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 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);