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