drivers/acpi/button.c

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