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