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 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 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 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 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 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 */ 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 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 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 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 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 471 static void acpi_button_notify_run(void *data) 472 { 473 acpi_button_notify(NULL, ACPI_BUTTON_NOTIFY_STATUS, data); 474 } 475 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 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 492 static int acpi_button_resume(struct device *dev) 493 { 494 struct acpi_device *device = to_acpi_device(dev); 495 struct acpi_button *button = acpi_driver_data(device); 496 497 button->suspended = false; 498 if (button->type == ACPI_BUTTON_TYPE_LID) { 499 button->last_state = !!acpi_lid_evaluate_state(device); 500 button->last_time = ktime_get(); 501 acpi_lid_initialize_state(device); 502 } 503 return 0; 504 } 505 #endif 506 507 static int acpi_lid_input_open(struct input_dev *input) 508 { 509 struct acpi_device *device = input_get_drvdata(input); 510 struct acpi_button *button = acpi_driver_data(device); 511 512 button->last_state = !!acpi_lid_evaluate_state(device); 513 button->last_time = ktime_get(); 514 acpi_lid_initialize_state(device); 515 516 return 0; 517 } 518 519 static int acpi_button_add(struct acpi_device *device) 520 { 521 acpi_notify_handler handler; 522 struct acpi_button *button; 523 struct input_dev *input; 524 const char *hid = acpi_device_hid(device); 525 acpi_status status; 526 char *name, *class; 527 int error = 0; 528 529 if (!strcmp(hid, ACPI_BUTTON_HID_LID) && 530 lid_init_state == ACPI_BUTTON_LID_INIT_DISABLED) 531 return -ENODEV; 532 533 button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL); 534 if (!button) 535 return -ENOMEM; 536 537 device->driver_data = button; 538 539 button->input = input = input_allocate_device(); 540 if (!input) { 541 error = -ENOMEM; 542 goto err_free_button; 543 } 544 545 name = acpi_device_name(device); 546 class = acpi_device_class(device); 547 548 if (!strcmp(hid, ACPI_BUTTON_HID_POWER) || 549 !strcmp(hid, ACPI_BUTTON_HID_POWERF)) { 550 button->type = ACPI_BUTTON_TYPE_POWER; 551 handler = acpi_button_notify; 552 strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER); 553 sprintf(class, "%s/%s", 554 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER); 555 } else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) || 556 !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) { 557 button->type = ACPI_BUTTON_TYPE_SLEEP; 558 handler = acpi_button_notify; 559 strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP); 560 sprintf(class, "%s/%s", 561 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP); 562 } else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) { 563 button->type = ACPI_BUTTON_TYPE_LID; 564 handler = acpi_lid_notify; 565 strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID); 566 sprintf(class, "%s/%s", 567 ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID); 568 input->open = acpi_lid_input_open; 569 } else { 570 pr_info("Unsupported hid [%s]\n", hid); 571 error = -ENODEV; 572 } 573 574 if (!error) 575 error = acpi_button_add_fs(device); 576 577 if (error) { 578 input_free_device(input); 579 goto err_free_button; 580 } 581 582 snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid); 583 584 input->name = name; 585 input->phys = button->phys; 586 input->id.bustype = BUS_HOST; 587 input->id.product = button->type; 588 input->dev.parent = &device->dev; 589 590 switch (button->type) { 591 case ACPI_BUTTON_TYPE_POWER: 592 input_set_capability(input, EV_KEY, KEY_POWER); 593 break; 594 595 case ACPI_BUTTON_TYPE_SLEEP: 596 input_set_capability(input, EV_KEY, KEY_SLEEP); 597 break; 598 599 case ACPI_BUTTON_TYPE_LID: 600 input_set_capability(input, EV_SW, SW_LID); 601 break; 602 } 603 604 input_set_drvdata(input, device); 605 error = input_register_device(input); 606 if (error) 607 goto err_remove_fs; 608 609 switch (device->device_type) { 610 case ACPI_BUS_TYPE_POWER_BUTTON: 611 status = acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON, 612 acpi_button_event, 613 device); 614 break; 615 case ACPI_BUS_TYPE_SLEEP_BUTTON: 616 status = acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON, 617 acpi_button_event, 618 device); 619 break; 620 default: 621 status = acpi_install_notify_handler(device->handle, 622 ACPI_DEVICE_NOTIFY, handler, 623 device); 624 break; 625 } 626 if (ACPI_FAILURE(status)) { 627 error = -ENODEV; 628 goto err_input_unregister; 629 } 630 631 if (button->type == ACPI_BUTTON_TYPE_LID) { 632 /* 633 * This assumes there's only one lid device, or if there are 634 * more we only care about the last one... 635 */ 636 lid_device = device; 637 } 638 639 device_init_wakeup(&device->dev, true); 640 pr_info("%s [%s]\n", name, acpi_device_bid(device)); 641 return 0; 642 643 err_input_unregister: 644 input_unregister_device(input); 645 err_remove_fs: 646 acpi_button_remove_fs(device); 647 err_free_button: 648 kfree(button); 649 return error; 650 } 651 652 static void acpi_button_remove(struct acpi_device *device) 653 { 654 struct acpi_button *button = acpi_driver_data(device); 655 656 switch (device->device_type) { 657 case ACPI_BUS_TYPE_POWER_BUTTON: 658 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON, 659 acpi_button_event); 660 break; 661 case ACPI_BUS_TYPE_SLEEP_BUTTON: 662 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON, 663 acpi_button_event); 664 break; 665 default: 666 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY, 667 button->type == ACPI_BUTTON_TYPE_LID ? 668 acpi_lid_notify : 669 acpi_button_notify); 670 break; 671 } 672 acpi_os_wait_events_complete(); 673 674 acpi_button_remove_fs(device); 675 input_unregister_device(button->input); 676 kfree(button); 677 } 678 679 static int param_set_lid_init_state(const char *val, 680 const struct kernel_param *kp) 681 { 682 int i; 683 684 i = sysfs_match_string(lid_init_state_str, val); 685 if (i < 0) 686 return i; 687 688 lid_init_state = i; 689 pr_info("Initial lid state set to '%s'\n", lid_init_state_str[i]); 690 return 0; 691 } 692 693 static int param_get_lid_init_state(char *buf, const struct kernel_param *kp) 694 { 695 int i, c = 0; 696 697 for (i = 0; i < ARRAY_SIZE(lid_init_state_str); i++) 698 if (i == lid_init_state) 699 c += sprintf(buf + c, "[%s] ", lid_init_state_str[i]); 700 else 701 c += sprintf(buf + c, "%s ", lid_init_state_str[i]); 702 703 buf[c - 1] = '\n'; /* Replace the final space with a newline */ 704 705 return c; 706 } 707 708 module_param_call(lid_init_state, 709 param_set_lid_init_state, param_get_lid_init_state, 710 NULL, 0644); 711 MODULE_PARM_DESC(lid_init_state, "Behavior for reporting LID initial state"); 712 713 static int acpi_button_register_driver(struct acpi_driver *driver) 714 { 715 const struct dmi_system_id *dmi_id; 716 717 if (lid_init_state == -1) { 718 dmi_id = dmi_first_match(dmi_lid_quirks); 719 if (dmi_id) 720 lid_init_state = (long)dmi_id->driver_data; 721 else 722 lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; 723 } 724 725 /* 726 * Modules such as nouveau.ko and i915.ko have a link time dependency 727 * on acpi_lid_open(), and would therefore not be loadable on ACPI 728 * capable kernels booted in non-ACPI mode if the return value of 729 * acpi_bus_register_driver() is returned from here with ACPI disabled 730 * when this driver is built as a module. 731 */ 732 if (acpi_disabled) 733 return 0; 734 735 return acpi_bus_register_driver(driver); 736 } 737 738 static void acpi_button_unregister_driver(struct acpi_driver *driver) 739 { 740 if (!acpi_disabled) 741 acpi_bus_unregister_driver(driver); 742 } 743 744 module_driver(acpi_button_driver, acpi_button_register_driver, 745 acpi_button_unregister_driver); 746