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