1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * button.c - ACPI Button Driver 4 * 5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 */ 8 9 #define pr_fmt(fmt) "ACPI: button: " fmt 10 11 #include <linux/compiler.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/types.h> 16 #include <linux/proc_fs.h> 17 #include <linux/seq_file.h> 18 #include <linux/input.h> 19 #include <linux/slab.h> 20 #include <linux/acpi.h> 21 #include <linux/dmi.h> 22 #include <acpi/button.h> 23 24 #define ACPI_BUTTON_CLASS "button" 25 #define ACPI_BUTTON_FILE_STATE "state" 26 #define ACPI_BUTTON_TYPE_UNKNOWN 0x00 27 #define ACPI_BUTTON_NOTIFY_STATUS 0x80 28 29 #define ACPI_BUTTON_SUBCLASS_POWER "power" 30 #define ACPI_BUTTON_DEVICE_NAME_POWER "Power Button" 31 #define ACPI_BUTTON_TYPE_POWER 0x01 32 33 #define ACPI_BUTTON_SUBCLASS_SLEEP "sleep" 34 #define ACPI_BUTTON_DEVICE_NAME_SLEEP "Sleep Button" 35 #define ACPI_BUTTON_TYPE_SLEEP 0x03 36 37 #define ACPI_BUTTON_SUBCLASS_LID "lid" 38 #define ACPI_BUTTON_DEVICE_NAME_LID "Lid Switch" 39 #define ACPI_BUTTON_TYPE_LID 0x05 40 41 enum { 42 ACPI_BUTTON_LID_INIT_IGNORE, 43 ACPI_BUTTON_LID_INIT_OPEN, 44 ACPI_BUTTON_LID_INIT_METHOD, 45 ACPI_BUTTON_LID_INIT_DISABLED, 46 }; 47 48 static const char * const lid_init_state_str[] = { 49 [ACPI_BUTTON_LID_INIT_IGNORE] = "ignore", 50 [ACPI_BUTTON_LID_INIT_OPEN] = "open", 51 [ACPI_BUTTON_LID_INIT_METHOD] = "method", 52 [ACPI_BUTTON_LID_INIT_DISABLED] = "disabled", 53 }; 54 55 MODULE_AUTHOR("Paul Diefenbaugh"); 56 MODULE_DESCRIPTION("ACPI Button Driver"); 57 MODULE_LICENSE("GPL"); 58 59 static const struct acpi_device_id button_device_ids[] = { 60 {ACPI_BUTTON_HID_LID, 0}, 61 {ACPI_BUTTON_HID_SLEEP, 0}, 62 {ACPI_BUTTON_HID_SLEEPF, 0}, 63 {ACPI_BUTTON_HID_POWER, 0}, 64 {ACPI_BUTTON_HID_POWERF, 0}, 65 {"", 0}, 66 }; 67 MODULE_DEVICE_TABLE(acpi, button_device_ids); 68 69 /* Please keep this list sorted alphabetically by vendor and model */ 70 static const struct dmi_system_id dmi_lid_quirks[] = { 71 { 72 /* GP-electronic T701, _LID method points to a floating GPIO */ 73 .matches = { 74 DMI_MATCH(DMI_SYS_VENDOR, "Insyde"), 75 DMI_MATCH(DMI_PRODUCT_NAME, "T701"), 76 DMI_MATCH(DMI_BIOS_VERSION, "BYT70A.YNCHENG.WIN.007"), 77 }, 78 .driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_DISABLED, 79 }, 80 { 81 /* Nextbook Ares 8A tablet, _LID device always reports lid closed */ 82 .matches = { 83 DMI_MATCH(DMI_SYS_VENDOR, "Insyde"), 84 DMI_MATCH(DMI_PRODUCT_NAME, "CherryTrail"), 85 DMI_MATCH(DMI_BIOS_VERSION, "M882"), 86 }, 87 .driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_DISABLED, 88 }, 89 { 90 /* 91 * Lenovo Yoga 9 14ITL5, initial notification of the LID device 92 * never happens. 93 */ 94 .matches = { 95 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 96 DMI_MATCH(DMI_PRODUCT_NAME, "82BG"), 97 }, 98 .driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_OPEN, 99 }, 100 { 101 /* 102 * Medion Akoya E2215T, notification of the LID device only 103 * happens on close, not on open and _LID always returns closed. 104 */ 105 .matches = { 106 DMI_MATCH(DMI_SYS_VENDOR, "MEDION"), 107 DMI_MATCH(DMI_PRODUCT_NAME, "E2215T"), 108 }, 109 .driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_OPEN, 110 }, 111 { 112 /* 113 * Medion Akoya E2228T, notification of the LID device only 114 * happens on close, not on open and _LID always returns closed. 115 */ 116 .matches = { 117 DMI_MATCH(DMI_SYS_VENDOR, "MEDION"), 118 DMI_MATCH(DMI_PRODUCT_NAME, "E2228T"), 119 }, 120 .driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_OPEN, 121 }, 122 { 123 /* 124 * Razer Blade Stealth 13 late 2019, notification of the LID device 125 * only happens on close, not on open and _LID always returns closed. 126 */ 127 .matches = { 128 DMI_MATCH(DMI_SYS_VENDOR, "Razer"), 129 DMI_MATCH(DMI_PRODUCT_NAME, "Razer Blade Stealth 13 Late 2019"), 130 }, 131 .driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_OPEN, 132 }, 133 { 134 /* 135 * Samsung galaxybook2 ,initial _LID device notification returns 136 * lid closed. 137 */ 138 .matches = { 139 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."), 140 DMI_MATCH(DMI_PRODUCT_NAME, "750XED"), 141 }, 142 .driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_OPEN, 143 }, 144 {} 145 }; 146 147 static int acpi_button_add(struct acpi_device *device); 148 static void acpi_button_remove(struct acpi_device *device); 149 150 #ifdef CONFIG_PM_SLEEP 151 static int acpi_button_suspend(struct device *dev); 152 static int acpi_button_resume(struct device *dev); 153 #else 154 #define acpi_button_suspend NULL 155 #define acpi_button_resume NULL 156 #endif 157 static SIMPLE_DEV_PM_OPS(acpi_button_pm, acpi_button_suspend, acpi_button_resume); 158 159 static struct acpi_driver acpi_button_driver = { 160 .name = "button", 161 .class = ACPI_BUTTON_CLASS, 162 .ids = button_device_ids, 163 .ops = { 164 .add = acpi_button_add, 165 .remove = acpi_button_remove, 166 }, 167 .drv.pm = &acpi_button_pm, 168 }; 169 170 struct acpi_button { 171 unsigned int type; 172 struct input_dev *input; 173 char phys[32]; /* for input device */ 174 unsigned long pushed; 175 int last_state; 176 ktime_t last_time; 177 bool suspended; 178 bool lid_state_initialized; 179 }; 180 181 static struct acpi_device *lid_device; 182 static long lid_init_state = -1; 183 184 static unsigned long lid_report_interval __read_mostly = 500; 185 module_param(lid_report_interval, ulong, 0644); 186 MODULE_PARM_DESC(lid_report_interval, "Interval (ms) between lid key events"); 187 188 /* FS Interface (/proc) */ 189 static struct proc_dir_entry *acpi_button_dir; 190 static struct proc_dir_entry *acpi_lid_dir; 191 acpi_lid_evaluate_state(struct acpi_device * device)192 static int acpi_lid_evaluate_state(struct acpi_device *device) 193 { 194 unsigned long long lid_state; 195 acpi_status status; 196 197 status = acpi_evaluate_integer(device->handle, "_LID", NULL, &lid_state); 198 if (ACPI_FAILURE(status)) 199 return -ENODEV; 200 201 return lid_state ? 1 : 0; 202 } 203 acpi_lid_notify_state(struct acpi_device * device,int state)204 static int acpi_lid_notify_state(struct acpi_device *device, int state) 205 { 206 struct acpi_button *button = acpi_driver_data(device); 207 ktime_t next_report; 208 bool do_update; 209 210 /* 211 * In lid_init_state=ignore mode, if user opens/closes lid 212 * frequently with "open" missing, and "last_time" is also updated 213 * frequently, "close" cannot be delivered to the userspace. 214 * So "last_time" is only updated after a timeout or an actual 215 * switch. 216 */ 217 if (lid_init_state != ACPI_BUTTON_LID_INIT_IGNORE || 218 button->last_state != !!state) 219 do_update = true; 220 else 221 do_update = false; 222 223 next_report = ktime_add(button->last_time, 224 ms_to_ktime(lid_report_interval)); 225 if (button->last_state == !!state && 226 ktime_after(ktime_get(), next_report)) { 227 /* Complain the buggy firmware */ 228 pr_warn_once("The lid device is not compliant to SW_LID.\n"); 229 230 /* 231 * Send the unreliable complement switch event: 232 * 233 * On most platforms, the lid device is reliable. However 234 * there are exceptions: 235 * 1. Platforms returning initial lid state as "close" by 236 * default after booting/resuming: 237 * https://bugzilla.kernel.org/show_bug.cgi?id=89211 238 * https://bugzilla.kernel.org/show_bug.cgi?id=106151 239 * 2. Platforms never reporting "open" events: 240 * https://bugzilla.kernel.org/show_bug.cgi?id=106941 241 * On these buggy platforms, the usage model of the ACPI 242 * lid device actually is: 243 * 1. The initial returning value of _LID may not be 244 * reliable. 245 * 2. The open event may not be reliable. 246 * 3. The close event is reliable. 247 * 248 * But SW_LID is typed as input switch event, the input 249 * layer checks if the event is redundant. Hence if the 250 * state is not switched, the userspace cannot see this 251 * platform triggered reliable event. By inserting a 252 * complement switch event, it then is guaranteed that the 253 * platform triggered reliable one can always be seen by 254 * the userspace. 255 */ 256 if (lid_init_state == ACPI_BUTTON_LID_INIT_IGNORE) { 257 do_update = true; 258 /* 259 * Do generate complement switch event for "close" 260 * as "close" is reliable and wrong "open" won't 261 * trigger unexpected behaviors. 262 * Do not generate complement switch event for 263 * "open" as "open" is not reliable and wrong 264 * "close" will trigger unexpected behaviors. 265 */ 266 if (!state) { 267 input_report_switch(button->input, 268 SW_LID, state); 269 input_sync(button->input); 270 } 271 } 272 } 273 /* Send the platform triggered reliable event */ 274 if (do_update) { 275 acpi_handle_debug(device->handle, "ACPI LID %s\n", 276 state ? "open" : "closed"); 277 input_report_switch(button->input, SW_LID, !state); 278 input_sync(button->input); 279 button->last_state = !!state; 280 button->last_time = ktime_get(); 281 } 282 283 return 0; 284 } 285 acpi_button_state_seq_show(struct seq_file * seq,void * offset)286 static int __maybe_unused acpi_button_state_seq_show(struct seq_file *seq, 287 void *offset) 288 { 289 struct acpi_device *device = seq->private; 290 int state; 291 292 state = acpi_lid_evaluate_state(device); 293 seq_printf(seq, "state: %s\n", 294 state < 0 ? "unsupported" : (state ? "open" : "closed")); 295 return 0; 296 } 297 acpi_button_add_fs(struct acpi_device * device)298 static int acpi_button_add_fs(struct acpi_device *device) 299 { 300 struct acpi_button *button = acpi_driver_data(device); 301 struct proc_dir_entry *entry = NULL; 302 int ret = 0; 303 304 /* procfs I/F for ACPI lid device only */ 305 if (button->type != ACPI_BUTTON_TYPE_LID) 306 return 0; 307 308 if (acpi_button_dir || acpi_lid_dir) { 309 pr_info("More than one Lid device found!\n"); 310 return -EEXIST; 311 } 312 313 /* create /proc/acpi/button */ 314 acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir); 315 if (!acpi_button_dir) 316 return -ENODEV; 317 318 /* create /proc/acpi/button/lid */ 319 acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir); 320 if (!acpi_lid_dir) { 321 ret = -ENODEV; 322 goto remove_button_dir; 323 } 324 325 /* create /proc/acpi/button/lid/LID/ */ 326 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), acpi_lid_dir); 327 if (!acpi_device_dir(device)) { 328 ret = -ENODEV; 329 goto remove_lid_dir; 330 } 331 332 /* create /proc/acpi/button/lid/LID/state */ 333 entry = proc_create_single_data(ACPI_BUTTON_FILE_STATE, S_IRUGO, 334 acpi_device_dir(device), acpi_button_state_seq_show, 335 device); 336 if (!entry) { 337 ret = -ENODEV; 338 goto remove_dev_dir; 339 } 340 341 done: 342 return ret; 343 344 remove_dev_dir: 345 remove_proc_entry(acpi_device_bid(device), 346 acpi_lid_dir); 347 acpi_device_dir(device) = NULL; 348 remove_lid_dir: 349 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir); 350 acpi_lid_dir = NULL; 351 remove_button_dir: 352 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir); 353 acpi_button_dir = NULL; 354 goto done; 355 } 356 acpi_button_remove_fs(struct acpi_device * device)357 static int acpi_button_remove_fs(struct acpi_device *device) 358 { 359 struct acpi_button *button = acpi_driver_data(device); 360 361 if (button->type != ACPI_BUTTON_TYPE_LID) 362 return 0; 363 364 remove_proc_entry(ACPI_BUTTON_FILE_STATE, 365 acpi_device_dir(device)); 366 remove_proc_entry(acpi_device_bid(device), 367 acpi_lid_dir); 368 acpi_device_dir(device) = NULL; 369 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir); 370 acpi_lid_dir = NULL; 371 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir); 372 acpi_button_dir = NULL; 373 374 return 0; 375 } 376 377 /* Driver Interface */ acpi_lid_open(void)378 int acpi_lid_open(void) 379 { 380 if (!lid_device) 381 return -ENODEV; 382 383 return acpi_lid_evaluate_state(lid_device); 384 } 385 EXPORT_SYMBOL(acpi_lid_open); 386 acpi_lid_update_state(struct acpi_device * device,bool signal_wakeup)387 static int acpi_lid_update_state(struct acpi_device *device, 388 bool signal_wakeup) 389 { 390 int state; 391 392 state = acpi_lid_evaluate_state(device); 393 if (state < 0) 394 return state; 395 396 if (state && signal_wakeup) 397 acpi_pm_wakeup_event(&device->dev); 398 399 return acpi_lid_notify_state(device, state); 400 } 401 acpi_lid_initialize_state(struct acpi_device * device)402 static void acpi_lid_initialize_state(struct acpi_device *device) 403 { 404 struct acpi_button *button = acpi_driver_data(device); 405 406 switch (lid_init_state) { 407 case ACPI_BUTTON_LID_INIT_OPEN: 408 (void)acpi_lid_notify_state(device, 1); 409 break; 410 case ACPI_BUTTON_LID_INIT_METHOD: 411 (void)acpi_lid_update_state(device, false); 412 break; 413 case ACPI_BUTTON_LID_INIT_IGNORE: 414 default: 415 break; 416 } 417 418 button->lid_state_initialized = true; 419 } 420 acpi_lid_notify(acpi_handle handle,u32 event,void * data)421 static void acpi_lid_notify(acpi_handle handle, u32 event, void *data) 422 { 423 struct acpi_device *device = data; 424 struct acpi_button *button; 425 426 if (event != ACPI_BUTTON_NOTIFY_STATUS) { 427 acpi_handle_debug(device->handle, "Unsupported event [0x%x]\n", 428 event); 429 return; 430 } 431 432 button = acpi_driver_data(device); 433 if (!button->lid_state_initialized) 434 return; 435 436 acpi_lid_update_state(device, true); 437 } 438 acpi_button_notify(acpi_handle handle,u32 event,void * data)439 static void acpi_button_notify(acpi_handle handle, u32 event, void *data) 440 { 441 struct acpi_device *device = data; 442 struct acpi_button *button; 443 struct input_dev *input; 444 int keycode; 445 446 if (event != ACPI_BUTTON_NOTIFY_STATUS) { 447 acpi_handle_debug(device->handle, "Unsupported event [0x%x]\n", 448 event); 449 return; 450 } 451 452 acpi_pm_wakeup_event(&device->dev); 453 454 button = acpi_driver_data(device); 455 if (button->suspended) 456 return; 457 458 input = button->input; 459 keycode = test_bit(KEY_SLEEP, input->keybit) ? KEY_SLEEP : KEY_POWER; 460 461 input_report_key(input, keycode, 1); 462 input_sync(input); 463 input_report_key(input, keycode, 0); 464 input_sync(input); 465 466 acpi_bus_generate_netlink_event(device->pnp.device_class, 467 dev_name(&device->dev), 468 event, ++button->pushed); 469 } 470 acpi_button_notify_run(void * data)471 static void acpi_button_notify_run(void *data) 472 { 473 acpi_button_notify(NULL, ACPI_BUTTON_NOTIFY_STATUS, data); 474 } 475 acpi_button_event(void * data)476 static u32 acpi_button_event(void *data) 477 { 478 acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_button_notify_run, data); 479 return ACPI_INTERRUPT_HANDLED; 480 } 481 482 #ifdef CONFIG_PM_SLEEP acpi_button_suspend(struct device * dev)483 static int acpi_button_suspend(struct device *dev) 484 { 485 struct acpi_device *device = to_acpi_device(dev); 486 struct acpi_button *button = acpi_driver_data(device); 487 488 button->suspended = true; 489 return 0; 490 } 491 acpi_button_resume(struct device * dev)492 static int acpi_button_resume(struct device *dev) 493 { 494 struct input_dev *input; 495 struct acpi_device *device = to_acpi_device(dev); 496 struct acpi_button *button = acpi_driver_data(device); 497 498 button->suspended = false; 499 if (button->type == ACPI_BUTTON_TYPE_LID) { 500 button->last_state = !!acpi_lid_evaluate_state(device); 501 button->last_time = ktime_get(); 502 acpi_lid_initialize_state(device); 503 } 504 505 if (button->type == ACPI_BUTTON_TYPE_POWER) { 506 input = button->input; 507 input_report_key(input, KEY_WAKEUP, 1); 508 input_sync(input); 509 input_report_key(input, KEY_WAKEUP, 0); 510 input_sync(input); 511 } 512 return 0; 513 } 514 #endif 515 acpi_lid_input_open(struct input_dev * input)516 static int acpi_lid_input_open(struct input_dev *input) 517 { 518 struct acpi_device *device = input_get_drvdata(input); 519 struct acpi_button *button = acpi_driver_data(device); 520 521 button->last_state = !!acpi_lid_evaluate_state(device); 522 button->last_time = ktime_get(); 523 acpi_lid_initialize_state(device); 524 525 return 0; 526 } 527 acpi_button_add(struct acpi_device * device)528 static int acpi_button_add(struct acpi_device *device) 529 { 530 acpi_notify_handler handler; 531 struct acpi_button *button; 532 struct input_dev *input; 533 const char *hid = acpi_device_hid(device); 534 acpi_status status; 535 char *name, *class; 536 int error = 0; 537 538 if (!strcmp(hid, ACPI_BUTTON_HID_LID) && 539 lid_init_state == ACPI_BUTTON_LID_INIT_DISABLED) 540 return -ENODEV; 541 542 button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL); 543 if (!button) 544 return -ENOMEM; 545 546 device->driver_data = button; 547 548 button->input = input = input_allocate_device(); 549 if (!input) { 550 error = -ENOMEM; 551 goto err_free_button; 552 } 553 554 name = acpi_device_name(device); 555 class = acpi_device_class(device); 556 557 if (!strcmp(hid, ACPI_BUTTON_HID_POWER) || 558 !strcmp(hid, ACPI_BUTTON_HID_POWERF)) { 559 button->type = ACPI_BUTTON_TYPE_POWER; 560 handler = acpi_button_notify; 561 strscpy(name, ACPI_BUTTON_DEVICE_NAME_POWER, MAX_ACPI_DEVICE_NAME_LEN); 562 sprintf(class, "%s/%s", 563 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER); 564 } else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) || 565 !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) { 566 button->type = ACPI_BUTTON_TYPE_SLEEP; 567 handler = acpi_button_notify; 568 strscpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP, MAX_ACPI_DEVICE_NAME_LEN); 569 sprintf(class, "%s/%s", 570 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP); 571 } else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) { 572 button->type = ACPI_BUTTON_TYPE_LID; 573 handler = acpi_lid_notify; 574 strscpy(name, ACPI_BUTTON_DEVICE_NAME_LID, MAX_ACPI_DEVICE_NAME_LEN); 575 sprintf(class, "%s/%s", 576 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID); 577 input->open = acpi_lid_input_open; 578 } else { 579 pr_info("Unsupported hid [%s]\n", hid); 580 error = -ENODEV; 581 } 582 583 if (!error) 584 error = acpi_button_add_fs(device); 585 586 if (error) { 587 input_free_device(input); 588 goto err_free_button; 589 } 590 591 snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid); 592 593 input->name = name; 594 input->phys = button->phys; 595 input->id.bustype = BUS_HOST; 596 input->id.product = button->type; 597 input->dev.parent = &device->dev; 598 599 switch (button->type) { 600 case ACPI_BUTTON_TYPE_POWER: 601 input_set_capability(input, EV_KEY, KEY_POWER); 602 input_set_capability(input, EV_KEY, KEY_WAKEUP); 603 break; 604 605 case ACPI_BUTTON_TYPE_SLEEP: 606 input_set_capability(input, EV_KEY, KEY_SLEEP); 607 break; 608 609 case ACPI_BUTTON_TYPE_LID: 610 input_set_capability(input, EV_SW, SW_LID); 611 break; 612 } 613 614 input_set_drvdata(input, device); 615 error = input_register_device(input); 616 if (error) 617 goto err_remove_fs; 618 619 switch (device->device_type) { 620 case ACPI_BUS_TYPE_POWER_BUTTON: 621 status = acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON, 622 acpi_button_event, 623 device); 624 break; 625 case ACPI_BUS_TYPE_SLEEP_BUTTON: 626 status = acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON, 627 acpi_button_event, 628 device); 629 break; 630 default: 631 status = acpi_install_notify_handler(device->handle, 632 ACPI_DEVICE_NOTIFY, handler, 633 device); 634 break; 635 } 636 if (ACPI_FAILURE(status)) { 637 error = -ENODEV; 638 goto err_input_unregister; 639 } 640 641 if (button->type == ACPI_BUTTON_TYPE_LID) { 642 /* 643 * This assumes there's only one lid device, or if there are 644 * more we only care about the last one... 645 */ 646 lid_device = device; 647 } 648 649 device_init_wakeup(&device->dev, true); 650 pr_info("%s [%s]\n", name, acpi_device_bid(device)); 651 return 0; 652 653 err_input_unregister: 654 input_unregister_device(input); 655 err_remove_fs: 656 acpi_button_remove_fs(device); 657 err_free_button: 658 kfree(button); 659 return error; 660 } 661 acpi_button_remove(struct acpi_device * device)662 static void acpi_button_remove(struct acpi_device *device) 663 { 664 struct acpi_button *button = acpi_driver_data(device); 665 666 switch (device->device_type) { 667 case ACPI_BUS_TYPE_POWER_BUTTON: 668 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON, 669 acpi_button_event); 670 break; 671 case ACPI_BUS_TYPE_SLEEP_BUTTON: 672 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON, 673 acpi_button_event); 674 break; 675 default: 676 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY, 677 button->type == ACPI_BUTTON_TYPE_LID ? 678 acpi_lid_notify : 679 acpi_button_notify); 680 break; 681 } 682 acpi_os_wait_events_complete(); 683 684 acpi_button_remove_fs(device); 685 input_unregister_device(button->input); 686 kfree(button); 687 } 688 param_set_lid_init_state(const char * val,const struct kernel_param * kp)689 static int param_set_lid_init_state(const char *val, 690 const struct kernel_param *kp) 691 { 692 int i; 693 694 i = sysfs_match_string(lid_init_state_str, val); 695 if (i < 0) 696 return i; 697 698 lid_init_state = i; 699 pr_info("Initial lid state set to '%s'\n", lid_init_state_str[i]); 700 return 0; 701 } 702 param_get_lid_init_state(char * buf,const struct kernel_param * kp)703 static int param_get_lid_init_state(char *buf, const struct kernel_param *kp) 704 { 705 int i, c = 0; 706 707 for (i = 0; i < ARRAY_SIZE(lid_init_state_str); i++) 708 if (i == lid_init_state) 709 c += sprintf(buf + c, "[%s] ", lid_init_state_str[i]); 710 else 711 c += sprintf(buf + c, "%s ", lid_init_state_str[i]); 712 713 buf[c - 1] = '\n'; /* Replace the final space with a newline */ 714 715 return c; 716 } 717 718 module_param_call(lid_init_state, 719 param_set_lid_init_state, param_get_lid_init_state, 720 NULL, 0644); 721 MODULE_PARM_DESC(lid_init_state, "Behavior for reporting LID initial state"); 722 acpi_button_register_driver(struct acpi_driver * driver)723 static int acpi_button_register_driver(struct acpi_driver *driver) 724 { 725 const struct dmi_system_id *dmi_id; 726 727 if (lid_init_state == -1) { 728 dmi_id = dmi_first_match(dmi_lid_quirks); 729 if (dmi_id) 730 lid_init_state = (long)dmi_id->driver_data; 731 else 732 lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; 733 } 734 735 /* 736 * Modules such as nouveau.ko and i915.ko have a link time dependency 737 * on acpi_lid_open(), and would therefore not be loadable on ACPI 738 * capable kernels booted in non-ACPI mode if the return value of 739 * acpi_bus_register_driver() is returned from here with ACPI disabled 740 * when this driver is built as a module. 741 */ 742 if (acpi_disabled) 743 return 0; 744 745 return acpi_bus_register_driver(driver); 746 } 747 acpi_button_unregister_driver(struct acpi_driver * driver)748 static void acpi_button_unregister_driver(struct acpi_driver *driver) 749 { 750 if (!acpi_disabled) 751 acpi_bus_unregister_driver(driver); 752 } 753 754 module_driver(acpi_button_driver, acpi_button_register_driver, 755 acpi_button_unregister_driver); 756