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