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