1
2
3
4
5
6
7
8
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11#define TPACPI_VERSION "0.26"
12#define TPACPI_SYSFS_VERSION 0x030000
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37#include <linux/kernel.h>
38#include <linux/module.h>
39#include <linux/init.h>
40#include <linux/types.h>
41#include <linux/string.h>
42#include <linux/list.h>
43#include <linux/mutex.h>
44#include <linux/sched.h>
45#include <linux/sched/signal.h>
46#include <linux/kthread.h>
47#include <linux/freezer.h>
48#include <linux/delay.h>
49#include <linux/slab.h>
50#include <linux/nvram.h>
51#include <linux/proc_fs.h>
52#include <linux/seq_file.h>
53#include <linux/sysfs.h>
54#include <linux/backlight.h>
55#include <linux/bitops.h>
56#include <linux/fb.h>
57#include <linux/platform_device.h>
58#include <linux/hwmon.h>
59#include <linux/hwmon-sysfs.h>
60#include <linux/input.h>
61#include <linux/leds.h>
62#include <linux/rfkill.h>
63#include <linux/dmi.h>
64#include <linux/jiffies.h>
65#include <linux/workqueue.h>
66#include <linux/acpi.h>
67#include <linux/pci.h>
68#include <linux/power_supply.h>
69#include <linux/platform_profile.h>
70#include <sound/core.h>
71#include <sound/control.h>
72#include <sound/initval.h>
73#include <linux/uaccess.h>
74#include <acpi/battery.h>
75#include <acpi/video.h>
76#include "dual_accel_detect.h"
77
78
79#define TP_CMOS_VOLUME_DOWN 0
80#define TP_CMOS_VOLUME_UP 1
81#define TP_CMOS_VOLUME_MUTE 2
82#define TP_CMOS_BRIGHTNESS_UP 4
83#define TP_CMOS_BRIGHTNESS_DOWN 5
84#define TP_CMOS_THINKLIGHT_ON 12
85#define TP_CMOS_THINKLIGHT_OFF 13
86
87
88enum tp_nvram_addr {
89 TP_NVRAM_ADDR_HK2 = 0x57,
90 TP_NVRAM_ADDR_THINKLIGHT = 0x58,
91 TP_NVRAM_ADDR_VIDEO = 0x59,
92 TP_NVRAM_ADDR_BRIGHTNESS = 0x5e,
93 TP_NVRAM_ADDR_MIXER = 0x60,
94};
95
96
97enum {
98 TP_NVRAM_MASK_HKT_THINKPAD = 0x08,
99 TP_NVRAM_MASK_HKT_ZOOM = 0x20,
100 TP_NVRAM_MASK_HKT_DISPLAY = 0x40,
101 TP_NVRAM_MASK_HKT_HIBERNATE = 0x80,
102 TP_NVRAM_MASK_THINKLIGHT = 0x10,
103 TP_NVRAM_MASK_HKT_DISPEXPND = 0x30,
104 TP_NVRAM_MASK_HKT_BRIGHTNESS = 0x20,
105 TP_NVRAM_MASK_LEVEL_BRIGHTNESS = 0x0f,
106 TP_NVRAM_POS_LEVEL_BRIGHTNESS = 0,
107 TP_NVRAM_MASK_MUTE = 0x40,
108 TP_NVRAM_MASK_HKT_VOLUME = 0x80,
109 TP_NVRAM_MASK_LEVEL_VOLUME = 0x0f,
110 TP_NVRAM_POS_LEVEL_VOLUME = 0,
111};
112
113
114enum {
115 TP_NVRAM_LEVEL_VOLUME_MAX = 14,
116};
117
118
119#define TPACPI_ACPI_IBM_HKEY_HID "IBM0068"
120#define TPACPI_ACPI_LENOVO_HKEY_HID "LEN0068"
121#define TPACPI_ACPI_LENOVO_HKEY_V2_HID "LEN0268"
122#define TPACPI_ACPI_EC_HID "PNP0C09"
123
124
125#define TPACPI_HKEY_INPUT_PRODUCT 0x5054
126#define TPACPI_HKEY_INPUT_VERSION 0x4101
127
128
129enum {
130 TP_ACPI_WGSV_GET_STATE = 0x01,
131 TP_ACPI_WGSV_PWR_ON_ON_RESUME = 0x02,
132 TP_ACPI_WGSV_PWR_OFF_ON_RESUME = 0x03,
133 TP_ACPI_WGSV_SAVE_STATE = 0x04,
134};
135
136
137enum {
138 TP_ACPI_WGSV_STATE_WWANEXIST = 0x0001,
139 TP_ACPI_WGSV_STATE_WWANPWR = 0x0002,
140 TP_ACPI_WGSV_STATE_WWANPWRRES = 0x0004,
141 TP_ACPI_WGSV_STATE_WWANBIOSOFF = 0x0008,
142 TP_ACPI_WGSV_STATE_BLTHEXIST = 0x0001,
143 TP_ACPI_WGSV_STATE_BLTHPWR = 0x0002,
144 TP_ACPI_WGSV_STATE_BLTHPWRRES = 0x0004,
145 TP_ACPI_WGSV_STATE_BLTHBIOSOFF = 0x0008,
146 TP_ACPI_WGSV_STATE_UWBEXIST = 0x0010,
147 TP_ACPI_WGSV_STATE_UWBPWR = 0x0020,
148};
149
150
151enum tpacpi_hkey_event_t {
152
153 TP_HKEY_EV_HOTKEY_BASE = 0x1001,
154 TP_HKEY_EV_BRGHT_UP = 0x1010,
155 TP_HKEY_EV_BRGHT_DOWN = 0x1011,
156 TP_HKEY_EV_KBD_LIGHT = 0x1012,
157 TP_HKEY_EV_VOL_UP = 0x1015,
158 TP_HKEY_EV_VOL_DOWN = 0x1016,
159 TP_HKEY_EV_VOL_MUTE = 0x1017,
160
161
162 TP_HKEY_EV_WKUP_S3_UNDOCK = 0x2304,
163 TP_HKEY_EV_WKUP_S4_UNDOCK = 0x2404,
164 TP_HKEY_EV_WKUP_S3_BAYEJ = 0x2305,
165 TP_HKEY_EV_WKUP_S4_BAYEJ = 0x2405,
166 TP_HKEY_EV_WKUP_S3_BATLOW = 0x2313,
167 TP_HKEY_EV_WKUP_S4_BATLOW = 0x2413,
168
169
170 TP_HKEY_EV_BAYEJ_ACK = 0x3003,
171 TP_HKEY_EV_UNDOCK_ACK = 0x4003,
172
173
174 TP_HKEY_EV_OPTDRV_EJ = 0x3006,
175 TP_HKEY_EV_HOTPLUG_DOCK = 0x4010,
176
177 TP_HKEY_EV_HOTPLUG_UNDOCK = 0x4011,
178
179
180
181
182
183 TP_HKEY_EV_KBD_COVER_ATTACH = 0x4012,
184 TP_HKEY_EV_KBD_COVER_DETACH = 0x4013,
185
186
187 TP_HKEY_EV_LID_CLOSE = 0x5001,
188 TP_HKEY_EV_LID_OPEN = 0x5002,
189 TP_HKEY_EV_TABLET_TABLET = 0x5009,
190 TP_HKEY_EV_TABLET_NOTEBOOK = 0x500a,
191 TP_HKEY_EV_TABLET_CHANGED = 0x60c0,
192
193
194 TP_HKEY_EV_PEN_INSERTED = 0x500b,
195 TP_HKEY_EV_PEN_REMOVED = 0x500c,
196 TP_HKEY_EV_BRGHT_CHANGED = 0x5010,
197
198
199 TP_HKEY_EV_KEY_NUMLOCK = 0x6000,
200 TP_HKEY_EV_KEY_FN = 0x6005,
201 TP_HKEY_EV_KEY_FN_ESC = 0x6060,
202
203
204 TP_HKEY_EV_ALARM_BAT_HOT = 0x6011,
205 TP_HKEY_EV_ALARM_BAT_XHOT = 0x6012,
206 TP_HKEY_EV_ALARM_SENSOR_HOT = 0x6021,
207 TP_HKEY_EV_ALARM_SENSOR_XHOT = 0x6022,
208 TP_HKEY_EV_THM_TABLE_CHANGED = 0x6030,
209 TP_HKEY_EV_THM_CSM_COMPLETED = 0x6032,
210
211
212 TP_HKEY_EV_THM_TRANSFM_CHANGED = 0x60F0,
213
214
215
216 TP_HKEY_EV_AC_CHANGED = 0x6040,
217
218
219 TP_HKEY_EV_PALM_DETECTED = 0x60b0,
220 TP_HKEY_EV_PALM_UNDETECTED = 0x60b1,
221
222
223 TP_HKEY_EV_RFKILL_CHANGED = 0x7000,
224};
225
226
227
228
229
230#define TPACPI_NAME "thinkpad"
231#define TPACPI_DESC "ThinkPad ACPI Extras"
232#define TPACPI_FILE TPACPI_NAME "_acpi"
233#define TPACPI_URL "http://ibm-acpi.sf.net/"
234#define TPACPI_MAIL "ibm-acpi-devel@lists.sourceforge.net"
235
236#define TPACPI_PROC_DIR "ibm"
237#define TPACPI_ACPI_EVENT_PREFIX "ibm"
238#define TPACPI_DRVR_NAME TPACPI_FILE
239#define TPACPI_DRVR_SHORTNAME "tpacpi"
240#define TPACPI_HWMON_DRVR_NAME TPACPI_NAME "_hwmon"
241
242#define TPACPI_NVRAM_KTHREAD_NAME "ktpacpi_nvramd"
243#define TPACPI_WORKQUEUE_NAME "ktpacpid"
244
245#define TPACPI_MAX_ACPI_ARGS 3
246
247
248#define TPACPI_DBG_ALL 0xffff
249#define TPACPI_DBG_DISCLOSETASK 0x8000
250#define TPACPI_DBG_INIT 0x0001
251#define TPACPI_DBG_EXIT 0x0002
252#define TPACPI_DBG_RFKILL 0x0004
253#define TPACPI_DBG_HKEY 0x0008
254#define TPACPI_DBG_FAN 0x0010
255#define TPACPI_DBG_BRGHT 0x0020
256#define TPACPI_DBG_MIXER 0x0040
257
258#define onoff(status, bit) ((status) & (1 << (bit)) ? "on" : "off")
259#define enabled(status, bit) ((status) & (1 << (bit)) ? "enabled" : "disabled")
260#define strlencmp(a, b) (strncmp((a), (b), strlen(b)))
261
262
263
264
265
266
267struct ibm_struct;
268
269struct tp_acpi_drv_struct {
270 const struct acpi_device_id *hid;
271 struct acpi_driver *driver;
272
273 void (*notify) (struct ibm_struct *, u32);
274 acpi_handle *handle;
275 u32 type;
276 struct acpi_device *device;
277};
278
279struct ibm_struct {
280 char *name;
281
282 int (*read) (struct seq_file *);
283 int (*write) (char *);
284 void (*exit) (void);
285 void (*resume) (void);
286 void (*suspend) (void);
287 void (*shutdown) (void);
288
289 struct list_head all_drivers;
290
291 struct tp_acpi_drv_struct *acpi;
292
293 struct {
294 u8 acpi_driver_registered:1;
295 u8 acpi_notify_installed:1;
296 u8 proc_created:1;
297 u8 init_called:1;
298 u8 experimental:1;
299 } flags;
300};
301
302struct ibm_init_struct {
303 char param[32];
304
305 int (*init) (struct ibm_init_struct *);
306 umode_t base_procfs_mode;
307 struct ibm_struct *data;
308};
309
310static struct {
311 u32 bluetooth:1;
312 u32 hotkey:1;
313 u32 hotkey_mask:1;
314 u32 hotkey_wlsw:1;
315 enum {
316 TP_HOTKEY_TABLET_NONE = 0,
317 TP_HOTKEY_TABLET_USES_MHKG,
318 TP_HOTKEY_TABLET_USES_GMMS,
319 } hotkey_tablet;
320 u32 kbdlight:1;
321 u32 light:1;
322 u32 light_status:1;
323 u32 bright_acpimode:1;
324 u32 bright_unkfw:1;
325 u32 wan:1;
326 u32 uwb:1;
327 u32 fan_ctrl_status_undef:1;
328 u32 second_fan:1;
329 u32 second_fan_ctl:1;
330 u32 beep_needs_two_args:1;
331 u32 mixer_no_level_control:1;
332 u32 battery_force_primary:1;
333 u32 input_device_registered:1;
334 u32 platform_drv_registered:1;
335 u32 platform_drv_attrs_registered:1;
336 u32 sensors_pdrv_registered:1;
337 u32 sensors_pdrv_attrs_registered:1;
338 u32 sensors_pdev_attrs_registered:1;
339 u32 hotkey_poll_active:1;
340 u32 has_adaptive_kbd:1;
341} tp_features;
342
343static struct {
344 u16 hotkey_mask_ff:1;
345 u16 volume_ctrl_forbidden:1;
346} tp_warned;
347
348struct thinkpad_id_data {
349 unsigned int vendor;
350
351
352 char *bios_version_str;
353 char *ec_version_str;
354
355 u32 bios_model;
356 u32 ec_model;
357 u16 bios_release;
358 u16 ec_release;
359
360 char *model_str;
361 char *nummodel_str;
362};
363static struct thinkpad_id_data thinkpad_id;
364
365static enum {
366 TPACPI_LIFE_INIT = 0,
367 TPACPI_LIFE_RUNNING,
368 TPACPI_LIFE_EXITING,
369} tpacpi_lifecycle;
370
371static int experimental;
372static u32 dbg_level;
373
374static struct workqueue_struct *tpacpi_wq;
375
376enum led_status_t {
377 TPACPI_LED_OFF = 0,
378 TPACPI_LED_ON,
379 TPACPI_LED_BLINK,
380};
381
382
383struct tpacpi_led_classdev {
384 struct led_classdev led_classdev;
385 int led;
386};
387
388
389static unsigned int bright_maxlvl;
390
391#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
392static int dbg_wlswemul;
393static bool tpacpi_wlsw_emulstate;
394static int dbg_bluetoothemul;
395static bool tpacpi_bluetooth_emulstate;
396static int dbg_wwanemul;
397static bool tpacpi_wwan_emulstate;
398static int dbg_uwbemul;
399static bool tpacpi_uwb_emulstate;
400#endif
401
402
403
404
405
406
407#define dbg_printk(a_dbg_level, format, arg...) \
408do { \
409 if (dbg_level & (a_dbg_level)) \
410 printk(KERN_DEBUG pr_fmt("%s: " format), \
411 __func__, ##arg); \
412} while (0)
413
414#ifdef CONFIG_THINKPAD_ACPI_DEBUG
415#define vdbg_printk dbg_printk
416static const char *str_supported(int is_supported);
417#else
418static inline const char *str_supported(int is_supported) { return ""; }
419#define vdbg_printk(a_dbg_level, format, arg...) \
420 do { if (0) no_printk(format, ##arg); } while (0)
421#endif
422
423static void tpacpi_log_usertask(const char * const what)
424{
425 printk(KERN_DEBUG pr_fmt("%s: access by process with PID %d\n"),
426 what, task_tgid_vnr(current));
427}
428
429#define tpacpi_disclose_usertask(what, format, arg...) \
430do { \
431 if (unlikely((dbg_level & TPACPI_DBG_DISCLOSETASK) && \
432 (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) { \
433 printk(KERN_DEBUG pr_fmt("%s: PID %d: " format), \
434 what, task_tgid_vnr(current), ## arg); \
435 } \
436} while (0)
437
438
439
440
441
442
443
444
445
446
447#define TPACPI_MATCH_ANY 0xffffffffU
448#define TPACPI_MATCH_ANY_VERSION 0xffffU
449#define TPACPI_MATCH_UNKNOWN 0U
450
451
452#define TPID(__c1, __c2) (((__c1) << 8) | (__c2))
453#define TPID3(__c1, __c2, __c3) (((__c1) << 16) | ((__c2) << 8) | (__c3))
454#define TPVER TPID
455
456#define TPACPI_Q_IBM(__id1, __id2, __quirk) \
457 { .vendor = PCI_VENDOR_ID_IBM, \
458 .bios = TPID(__id1, __id2), \
459 .ec = TPACPI_MATCH_ANY, \
460 .quirks = (__quirk) }
461
462#define TPACPI_Q_LNV(__id1, __id2, __quirk) \
463 { .vendor = PCI_VENDOR_ID_LENOVO, \
464 .bios = TPID(__id1, __id2), \
465 .ec = TPACPI_MATCH_ANY, \
466 .quirks = (__quirk) }
467
468#define TPACPI_Q_LNV3(__id1, __id2, __id3, __quirk) \
469 { .vendor = PCI_VENDOR_ID_LENOVO, \
470 .bios = TPID3(__id1, __id2, __id3), \
471 .ec = TPACPI_MATCH_ANY, \
472 .quirks = (__quirk) }
473
474#define TPACPI_QEC_IBM(__id1, __id2, __quirk) \
475 { .vendor = PCI_VENDOR_ID_IBM, \
476 .bios = TPACPI_MATCH_ANY, \
477 .ec = TPID(__id1, __id2), \
478 .quirks = (__quirk) }
479
480#define TPACPI_QEC_LNV(__id1, __id2, __quirk) \
481 { .vendor = PCI_VENDOR_ID_LENOVO, \
482 .bios = TPACPI_MATCH_ANY, \
483 .ec = TPID(__id1, __id2), \
484 .quirks = (__quirk) }
485
486struct tpacpi_quirk {
487 unsigned int vendor;
488 u32 bios;
489 u32 ec;
490 unsigned long quirks;
491};
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506static unsigned long __init tpacpi_check_quirks(
507 const struct tpacpi_quirk *qlist,
508 unsigned int qlist_size)
509{
510 while (qlist_size) {
511 if ((qlist->vendor == thinkpad_id.vendor ||
512 qlist->vendor == TPACPI_MATCH_ANY) &&
513 (qlist->bios == thinkpad_id.bios_model ||
514 qlist->bios == TPACPI_MATCH_ANY) &&
515 (qlist->ec == thinkpad_id.ec_model ||
516 qlist->ec == TPACPI_MATCH_ANY))
517 return qlist->quirks;
518
519 qlist_size--;
520 qlist++;
521 }
522 return 0;
523}
524
525static inline bool __pure __init tpacpi_is_lenovo(void)
526{
527 return thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO;
528}
529
530static inline bool __pure __init tpacpi_is_ibm(void)
531{
532 return thinkpad_id.vendor == PCI_VENDOR_ID_IBM;
533}
534
535
536
537
538
539
540
541
542
543
544
545
546
547static acpi_handle root_handle;
548static acpi_handle ec_handle;
549
550#define TPACPI_HANDLE(object, parent, paths...) \
551 static acpi_handle object##_handle; \
552 static const acpi_handle * const object##_parent __initconst = \
553 &parent##_handle; \
554 static char *object##_paths[] __initdata = { paths }
555
556TPACPI_HANDLE(ecrd, ec, "ECRD");
557TPACPI_HANDLE(ecwr, ec, "ECWR");
558
559TPACPI_HANDLE(cmos, root, "\\UCMS",
560
561 "\\CMOS",
562 "\\CMS",
563 );
564
565TPACPI_HANDLE(hkey, ec, "\\_SB.HKEY",
566 "^HKEY",
567 "HKEY",
568 );
569
570
571
572
573
574static int acpi_evalf(acpi_handle handle,
575 int *res, char *method, char *fmt, ...)
576{
577 char *fmt0 = fmt;
578 struct acpi_object_list params;
579 union acpi_object in_objs[TPACPI_MAX_ACPI_ARGS];
580 struct acpi_buffer result, *resultp;
581 union acpi_object out_obj;
582 acpi_status status;
583 va_list ap;
584 char res_type;
585 int success;
586 int quiet;
587
588 if (!*fmt) {
589 pr_err("acpi_evalf() called with empty format\n");
590 return 0;
591 }
592
593 if (*fmt == 'q') {
594 quiet = 1;
595 fmt++;
596 } else
597 quiet = 0;
598
599 res_type = *(fmt++);
600
601 params.count = 0;
602 params.pointer = &in_objs[0];
603
604 va_start(ap, fmt);
605 while (*fmt) {
606 char c = *(fmt++);
607 switch (c) {
608 case 'd':
609 in_objs[params.count].integer.value = va_arg(ap, int);
610 in_objs[params.count++].type = ACPI_TYPE_INTEGER;
611 break;
612
613 default:
614 pr_err("acpi_evalf() called with invalid format character '%c'\n",
615 c);
616 va_end(ap);
617 return 0;
618 }
619 }
620 va_end(ap);
621
622 if (res_type != 'v') {
623 result.length = sizeof(out_obj);
624 result.pointer = &out_obj;
625 resultp = &result;
626 } else
627 resultp = NULL;
628
629 status = acpi_evaluate_object(handle, method, ¶ms, resultp);
630
631 switch (res_type) {
632 case 'd':
633 success = (status == AE_OK &&
634 out_obj.type == ACPI_TYPE_INTEGER);
635 if (success && res)
636 *res = out_obj.integer.value;
637 break;
638 case 'v':
639 success = status == AE_OK;
640 break;
641
642 default:
643 pr_err("acpi_evalf() called with invalid format character '%c'\n",
644 res_type);
645 return 0;
646 }
647
648 if (!success && !quiet)
649 pr_err("acpi_evalf(%s, %s, ...) failed: %s\n",
650 method, fmt0, acpi_format_exception(status));
651
652 return success;
653}
654
655static int acpi_ec_read(int i, u8 *p)
656{
657 int v;
658
659 if (ecrd_handle) {
660 if (!acpi_evalf(ecrd_handle, &v, NULL, "dd", i))
661 return 0;
662 *p = v;
663 } else {
664 if (ec_read(i, p) < 0)
665 return 0;
666 }
667
668 return 1;
669}
670
671static int acpi_ec_write(int i, u8 v)
672{
673 if (ecwr_handle) {
674 if (!acpi_evalf(ecwr_handle, NULL, NULL, "vdd", i, v))
675 return 0;
676 } else {
677 if (ec_write(i, v) < 0)
678 return 0;
679 }
680
681 return 1;
682}
683
684static int issue_thinkpad_cmos_command(int cmos_cmd)
685{
686 if (!cmos_handle)
687 return -ENXIO;
688
689 if (!acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd))
690 return -EIO;
691
692 return 0;
693}
694
695
696
697
698
699#define TPACPI_ACPIHANDLE_INIT(object) \
700 drv_acpi_handle_init(#object, &object##_handle, *object##_parent, \
701 object##_paths, ARRAY_SIZE(object##_paths))
702
703static void __init drv_acpi_handle_init(const char *name,
704 acpi_handle *handle, const acpi_handle parent,
705 char **paths, const int num_paths)
706{
707 int i;
708 acpi_status status;
709
710 vdbg_printk(TPACPI_DBG_INIT, "trying to locate ACPI handle for %s\n",
711 name);
712
713 for (i = 0; i < num_paths; i++) {
714 status = acpi_get_handle(parent, paths[i], handle);
715 if (ACPI_SUCCESS(status)) {
716 dbg_printk(TPACPI_DBG_INIT,
717 "Found ACPI handle %s for %s\n",
718 paths[i], name);
719 return;
720 }
721 }
722
723 vdbg_printk(TPACPI_DBG_INIT, "ACPI handle for %s not found\n",
724 name);
725 *handle = NULL;
726}
727
728static acpi_status __init tpacpi_acpi_handle_locate_callback(acpi_handle handle,
729 u32 level, void *context, void **return_value)
730{
731 struct acpi_device *dev;
732 if (!strcmp(context, "video")) {
733 if (acpi_bus_get_device(handle, &dev))
734 return AE_OK;
735 if (strcmp(ACPI_VIDEO_HID, acpi_device_hid(dev)))
736 return AE_OK;
737 }
738
739 *(acpi_handle *)return_value = handle;
740
741 return AE_CTRL_TERMINATE;
742}
743
744static void __init tpacpi_acpi_handle_locate(const char *name,
745 const char *hid,
746 acpi_handle *handle)
747{
748 acpi_status status;
749 acpi_handle device_found;
750
751 BUG_ON(!name || !handle);
752 vdbg_printk(TPACPI_DBG_INIT,
753 "trying to locate ACPI handle for %s, using HID %s\n",
754 name, hid ? hid : "NULL");
755
756 memset(&device_found, 0, sizeof(device_found));
757 status = acpi_get_devices(hid, tpacpi_acpi_handle_locate_callback,
758 (void *)name, &device_found);
759
760 *handle = NULL;
761
762 if (ACPI_SUCCESS(status)) {
763 *handle = device_found;
764 dbg_printk(TPACPI_DBG_INIT,
765 "Found ACPI handle for %s\n", name);
766 } else {
767 vdbg_printk(TPACPI_DBG_INIT,
768 "Could not locate an ACPI handle for %s: %s\n",
769 name, acpi_format_exception(status));
770 }
771}
772
773static void dispatch_acpi_notify(acpi_handle handle, u32 event, void *data)
774{
775 struct ibm_struct *ibm = data;
776
777 if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
778 return;
779
780 if (!ibm || !ibm->acpi || !ibm->acpi->notify)
781 return;
782
783 ibm->acpi->notify(ibm, event);
784}
785
786static int __init setup_acpi_notify(struct ibm_struct *ibm)
787{
788 acpi_status status;
789 int rc;
790
791 BUG_ON(!ibm->acpi);
792
793 if (!*ibm->acpi->handle)
794 return 0;
795
796 vdbg_printk(TPACPI_DBG_INIT,
797 "setting up ACPI notify for %s\n", ibm->name);
798
799 rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
800 if (rc < 0) {
801 pr_err("acpi_bus_get_device(%s) failed: %d\n", ibm->name, rc);
802 return -ENODEV;
803 }
804
805 ibm->acpi->device->driver_data = ibm;
806 sprintf(acpi_device_class(ibm->acpi->device), "%s/%s",
807 TPACPI_ACPI_EVENT_PREFIX,
808 ibm->name);
809
810 status = acpi_install_notify_handler(*ibm->acpi->handle,
811 ibm->acpi->type, dispatch_acpi_notify, ibm);
812 if (ACPI_FAILURE(status)) {
813 if (status == AE_ALREADY_EXISTS) {
814 pr_notice("another device driver is already handling %s events\n",
815 ibm->name);
816 } else {
817 pr_err("acpi_install_notify_handler(%s) failed: %s\n",
818 ibm->name, acpi_format_exception(status));
819 }
820 return -ENODEV;
821 }
822 ibm->flags.acpi_notify_installed = 1;
823 return 0;
824}
825
826static int __init tpacpi_device_add(struct acpi_device *device)
827{
828 return 0;
829}
830
831static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
832{
833 int rc;
834
835 dbg_printk(TPACPI_DBG_INIT,
836 "registering %s as an ACPI driver\n", ibm->name);
837
838 BUG_ON(!ibm->acpi);
839
840 ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
841 if (!ibm->acpi->driver) {
842 pr_err("failed to allocate memory for ibm->acpi->driver\n");
843 return -ENOMEM;
844 }
845
846 sprintf(ibm->acpi->driver->name, "%s_%s", TPACPI_NAME, ibm->name);
847 ibm->acpi->driver->ids = ibm->acpi->hid;
848
849 ibm->acpi->driver->ops.add = &tpacpi_device_add;
850
851 rc = acpi_bus_register_driver(ibm->acpi->driver);
852 if (rc < 0) {
853 pr_err("acpi_bus_register_driver(%s) failed: %d\n",
854 ibm->name, rc);
855 kfree(ibm->acpi->driver);
856 ibm->acpi->driver = NULL;
857 } else if (!rc)
858 ibm->flags.acpi_driver_registered = 1;
859
860 return rc;
861}
862
863
864
865
866
867
868
869
870
871
872static int dispatch_proc_show(struct seq_file *m, void *v)
873{
874 struct ibm_struct *ibm = m->private;
875
876 if (!ibm || !ibm->read)
877 return -EINVAL;
878 return ibm->read(m);
879}
880
881static int dispatch_proc_open(struct inode *inode, struct file *file)
882{
883 return single_open(file, dispatch_proc_show, PDE_DATA(inode));
884}
885
886static ssize_t dispatch_proc_write(struct file *file,
887 const char __user *userbuf,
888 size_t count, loff_t *pos)
889{
890 struct ibm_struct *ibm = PDE_DATA(file_inode(file));
891 char *kernbuf;
892 int ret;
893
894 if (!ibm || !ibm->write)
895 return -EINVAL;
896 if (count > PAGE_SIZE - 1)
897 return -EINVAL;
898
899 kernbuf = kmalloc(count + 1, GFP_KERNEL);
900 if (!kernbuf)
901 return -ENOMEM;
902
903 if (copy_from_user(kernbuf, userbuf, count)) {
904 kfree(kernbuf);
905 return -EFAULT;
906 }
907
908 kernbuf[count] = 0;
909 ret = ibm->write(kernbuf);
910 if (ret == 0)
911 ret = count;
912
913 kfree(kernbuf);
914
915 return ret;
916}
917
918static const struct proc_ops dispatch_proc_ops = {
919 .proc_open = dispatch_proc_open,
920 .proc_read = seq_read,
921 .proc_lseek = seq_lseek,
922 .proc_release = single_release,
923 .proc_write = dispatch_proc_write,
924};
925
926
927
928
929
930
931
932
933
934static struct platform_device *tpacpi_pdev;
935static struct platform_device *tpacpi_sensors_pdev;
936static struct device *tpacpi_hwmon;
937static struct input_dev *tpacpi_inputdev;
938static struct mutex tpacpi_inputdev_send_mutex;
939static LIST_HEAD(tpacpi_all_drivers);
940
941#ifdef CONFIG_PM_SLEEP
942static int tpacpi_suspend_handler(struct device *dev)
943{
944 struct ibm_struct *ibm, *itmp;
945
946 list_for_each_entry_safe(ibm, itmp,
947 &tpacpi_all_drivers,
948 all_drivers) {
949 if (ibm->suspend)
950 (ibm->suspend)();
951 }
952
953 return 0;
954}
955
956static int tpacpi_resume_handler(struct device *dev)
957{
958 struct ibm_struct *ibm, *itmp;
959
960 list_for_each_entry_safe(ibm, itmp,
961 &tpacpi_all_drivers,
962 all_drivers) {
963 if (ibm->resume)
964 (ibm->resume)();
965 }
966
967 return 0;
968}
969#endif
970
971static SIMPLE_DEV_PM_OPS(tpacpi_pm,
972 tpacpi_suspend_handler, tpacpi_resume_handler);
973
974static void tpacpi_shutdown_handler(struct platform_device *pdev)
975{
976 struct ibm_struct *ibm, *itmp;
977
978 list_for_each_entry_safe(ibm, itmp,
979 &tpacpi_all_drivers,
980 all_drivers) {
981 if (ibm->shutdown)
982 (ibm->shutdown)();
983 }
984}
985
986static struct platform_driver tpacpi_pdriver = {
987 .driver = {
988 .name = TPACPI_DRVR_NAME,
989 .pm = &tpacpi_pm,
990 },
991 .shutdown = tpacpi_shutdown_handler,
992};
993
994static struct platform_driver tpacpi_hwmon_pdriver = {
995 .driver = {
996 .name = TPACPI_HWMON_DRVR_NAME,
997 },
998};
999
1000
1001
1002
1003
1004struct attribute_set {
1005 unsigned int members, max_members;
1006 struct attribute_group group;
1007};
1008
1009struct attribute_set_obj {
1010 struct attribute_set s;
1011 struct attribute *a;
1012} __attribute__((packed));
1013
1014static struct attribute_set *create_attr_set(unsigned int max_members,
1015 const char *name)
1016{
1017 struct attribute_set_obj *sobj;
1018
1019 if (max_members == 0)
1020 return NULL;
1021
1022
1023 sobj = kzalloc(sizeof(struct attribute_set_obj) +
1024 max_members * sizeof(struct attribute *),
1025 GFP_KERNEL);
1026 if (!sobj)
1027 return NULL;
1028 sobj->s.max_members = max_members;
1029 sobj->s.group.attrs = &sobj->a;
1030 sobj->s.group.name = name;
1031
1032 return &sobj->s;
1033}
1034
1035#define destroy_attr_set(_set) \
1036 kfree(_set)
1037
1038
1039static int add_to_attr_set(struct attribute_set *s, struct attribute *attr)
1040{
1041 if (!s || !attr)
1042 return -EINVAL;
1043
1044 if (s->members >= s->max_members)
1045 return -ENOMEM;
1046
1047 s->group.attrs[s->members] = attr;
1048 s->members++;
1049
1050 return 0;
1051}
1052
1053static int add_many_to_attr_set(struct attribute_set *s,
1054 struct attribute **attr,
1055 unsigned int count)
1056{
1057 int i, res;
1058
1059 for (i = 0; i < count; i++) {
1060 res = add_to_attr_set(s, attr[i]);
1061 if (res)
1062 return res;
1063 }
1064
1065 return 0;
1066}
1067
1068static void delete_attr_set(struct attribute_set *s, struct kobject *kobj)
1069{
1070 sysfs_remove_group(kobj, &s->group);
1071 destroy_attr_set(s);
1072}
1073
1074#define register_attr_set_with_sysfs(_attr_set, _kobj) \
1075 sysfs_create_group(_kobj, &_attr_set->group)
1076
1077static int parse_strtoul(const char *buf,
1078 unsigned long max, unsigned long *value)
1079{
1080 char *endp;
1081
1082 *value = simple_strtoul(skip_spaces(buf), &endp, 0);
1083 endp = skip_spaces(endp);
1084 if (*endp || *value > max)
1085 return -EINVAL;
1086
1087 return 0;
1088}
1089
1090static void tpacpi_disable_brightness_delay(void)
1091{
1092 if (acpi_evalf(hkey_handle, NULL, "PWMS", "qvd", 0))
1093 pr_notice("ACPI backlight control delay disabled\n");
1094}
1095
1096static void printk_deprecated_attribute(const char * const what,
1097 const char * const details)
1098{
1099 tpacpi_log_usertask("deprecated sysfs attribute");
1100 pr_warn("WARNING: sysfs attribute %s is deprecated and will be removed. %s\n",
1101 what, details);
1102}
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128enum tpacpi_rfkill_state {
1129 TPACPI_RFK_RADIO_OFF = 0,
1130 TPACPI_RFK_RADIO_ON
1131};
1132
1133
1134enum tpacpi_rfk_id {
1135 TPACPI_RFK_BLUETOOTH_SW_ID = 0,
1136 TPACPI_RFK_WWAN_SW_ID,
1137 TPACPI_RFK_UWB_SW_ID,
1138 TPACPI_RFK_SW_MAX
1139};
1140
1141static const char *tpacpi_rfkill_names[] = {
1142 [TPACPI_RFK_BLUETOOTH_SW_ID] = "bluetooth",
1143 [TPACPI_RFK_WWAN_SW_ID] = "wwan",
1144 [TPACPI_RFK_UWB_SW_ID] = "uwb",
1145 [TPACPI_RFK_SW_MAX] = NULL
1146};
1147
1148
1149struct tpacpi_rfk {
1150 struct rfkill *rfkill;
1151 enum tpacpi_rfk_id id;
1152 const struct tpacpi_rfk_ops *ops;
1153};
1154
1155struct tpacpi_rfk_ops {
1156
1157 int (*get_status)(void);
1158 int (*set_status)(const enum tpacpi_rfkill_state);
1159};
1160
1161static struct tpacpi_rfk *tpacpi_rfkill_switches[TPACPI_RFK_SW_MAX];
1162
1163
1164static int tpacpi_rfk_update_swstate(const struct tpacpi_rfk *tp_rfk)
1165{
1166 int status;
1167
1168 if (!tp_rfk)
1169 return -ENODEV;
1170
1171 status = (tp_rfk->ops->get_status)();
1172 if (status < 0)
1173 return status;
1174
1175 rfkill_set_sw_state(tp_rfk->rfkill,
1176 (status == TPACPI_RFK_RADIO_OFF));
1177
1178 return status;
1179}
1180
1181
1182static void tpacpi_rfk_update_swstate_all(void)
1183{
1184 unsigned int i;
1185
1186 for (i = 0; i < TPACPI_RFK_SW_MAX; i++)
1187 tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[i]);
1188}
1189
1190
1191
1192
1193
1194static void tpacpi_rfk_update_hwblock_state(bool blocked)
1195{
1196 unsigned int i;
1197 struct tpacpi_rfk *tp_rfk;
1198
1199 for (i = 0; i < TPACPI_RFK_SW_MAX; i++) {
1200 tp_rfk = tpacpi_rfkill_switches[i];
1201 if (tp_rfk) {
1202 if (rfkill_set_hw_state(tp_rfk->rfkill,
1203 blocked)) {
1204
1205 }
1206 }
1207 }
1208}
1209
1210
1211static int hotkey_get_wlsw(void);
1212
1213
1214static bool tpacpi_rfk_check_hwblock_state(void)
1215{
1216 int res = hotkey_get_wlsw();
1217 int hw_blocked;
1218
1219
1220 if (res < 0)
1221 return false;
1222
1223 hw_blocked = (res == TPACPI_RFK_RADIO_OFF);
1224 tpacpi_rfk_update_hwblock_state(hw_blocked);
1225
1226 return hw_blocked;
1227}
1228
1229static int tpacpi_rfk_hook_set_block(void *data, bool blocked)
1230{
1231 struct tpacpi_rfk *tp_rfk = data;
1232 int res;
1233
1234 dbg_printk(TPACPI_DBG_RFKILL,
1235 "request to change radio state to %s\n",
1236 blocked ? "blocked" : "unblocked");
1237
1238
1239 res = (tp_rfk->ops->set_status)(blocked ?
1240 TPACPI_RFK_RADIO_OFF : TPACPI_RFK_RADIO_ON);
1241
1242
1243 tpacpi_rfk_update_swstate(tp_rfk);
1244
1245 return (res < 0) ? res : 0;
1246}
1247
1248static const struct rfkill_ops tpacpi_rfk_rfkill_ops = {
1249 .set_block = tpacpi_rfk_hook_set_block,
1250};
1251
1252static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
1253 const struct tpacpi_rfk_ops *tp_rfkops,
1254 const enum rfkill_type rfktype,
1255 const char *name,
1256 const bool set_default)
1257{
1258 struct tpacpi_rfk *atp_rfk;
1259 int res;
1260 bool sw_state = false;
1261 bool hw_state;
1262 int sw_status;
1263
1264 BUG_ON(id >= TPACPI_RFK_SW_MAX || tpacpi_rfkill_switches[id]);
1265
1266 atp_rfk = kzalloc(sizeof(struct tpacpi_rfk), GFP_KERNEL);
1267 if (atp_rfk)
1268 atp_rfk->rfkill = rfkill_alloc(name,
1269 &tpacpi_pdev->dev,
1270 rfktype,
1271 &tpacpi_rfk_rfkill_ops,
1272 atp_rfk);
1273 if (!atp_rfk || !atp_rfk->rfkill) {
1274 pr_err("failed to allocate memory for rfkill class\n");
1275 kfree(atp_rfk);
1276 return -ENOMEM;
1277 }
1278
1279 atp_rfk->id = id;
1280 atp_rfk->ops = tp_rfkops;
1281
1282 sw_status = (tp_rfkops->get_status)();
1283 if (sw_status < 0) {
1284 pr_err("failed to read initial state for %s, error %d\n",
1285 name, sw_status);
1286 } else {
1287 sw_state = (sw_status == TPACPI_RFK_RADIO_OFF);
1288 if (set_default) {
1289
1290
1291 rfkill_init_sw_state(atp_rfk->rfkill, sw_state);
1292 }
1293 }
1294 hw_state = tpacpi_rfk_check_hwblock_state();
1295 rfkill_set_hw_state(atp_rfk->rfkill, hw_state);
1296
1297 res = rfkill_register(atp_rfk->rfkill);
1298 if (res < 0) {
1299 pr_err("failed to register %s rfkill switch: %d\n", name, res);
1300 rfkill_destroy(atp_rfk->rfkill);
1301 kfree(atp_rfk);
1302 return res;
1303 }
1304
1305 tpacpi_rfkill_switches[id] = atp_rfk;
1306
1307 pr_info("rfkill switch %s: radio is %sblocked\n",
1308 name, (sw_state || hw_state) ? "" : "un");
1309 return 0;
1310}
1311
1312static void tpacpi_destroy_rfkill(const enum tpacpi_rfk_id id)
1313{
1314 struct tpacpi_rfk *tp_rfk;
1315
1316 BUG_ON(id >= TPACPI_RFK_SW_MAX);
1317
1318 tp_rfk = tpacpi_rfkill_switches[id];
1319 if (tp_rfk) {
1320 rfkill_unregister(tp_rfk->rfkill);
1321 rfkill_destroy(tp_rfk->rfkill);
1322 tpacpi_rfkill_switches[id] = NULL;
1323 kfree(tp_rfk);
1324 }
1325}
1326
1327static void printk_deprecated_rfkill_attribute(const char * const what)
1328{
1329 printk_deprecated_attribute(what,
1330 "Please switch to generic rfkill before year 2010");
1331}
1332
1333
1334static ssize_t tpacpi_rfk_sysfs_enable_show(const enum tpacpi_rfk_id id,
1335 struct device_attribute *attr,
1336 char *buf)
1337{
1338 int status;
1339
1340 printk_deprecated_rfkill_attribute(attr->attr.name);
1341
1342
1343 if (tpacpi_rfk_check_hwblock_state()) {
1344 status = TPACPI_RFK_RADIO_OFF;
1345 } else {
1346 status = tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
1347 if (status < 0)
1348 return status;
1349 }
1350
1351 return snprintf(buf, PAGE_SIZE, "%d\n",
1352 (status == TPACPI_RFK_RADIO_ON) ? 1 : 0);
1353}
1354
1355static ssize_t tpacpi_rfk_sysfs_enable_store(const enum tpacpi_rfk_id id,
1356 struct device_attribute *attr,
1357 const char *buf, size_t count)
1358{
1359 unsigned long t;
1360 int res;
1361
1362 printk_deprecated_rfkill_attribute(attr->attr.name);
1363
1364 if (parse_strtoul(buf, 1, &t))
1365 return -EINVAL;
1366
1367 tpacpi_disclose_usertask(attr->attr.name, "set to %ld\n", t);
1368
1369
1370 if (tpacpi_rfk_check_hwblock_state() && !!t)
1371 return -EPERM;
1372
1373 res = tpacpi_rfkill_switches[id]->ops->set_status((!!t) ?
1374 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF);
1375 tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
1376
1377 return (res < 0) ? res : count;
1378}
1379
1380
1381static int tpacpi_rfk_procfs_read(const enum tpacpi_rfk_id id, struct seq_file *m)
1382{
1383 if (id >= TPACPI_RFK_SW_MAX)
1384 seq_printf(m, "status:\t\tnot supported\n");
1385 else {
1386 int status;
1387
1388
1389 if (tpacpi_rfk_check_hwblock_state()) {
1390 status = TPACPI_RFK_RADIO_OFF;
1391 } else {
1392 status = tpacpi_rfk_update_swstate(
1393 tpacpi_rfkill_switches[id]);
1394 if (status < 0)
1395 return status;
1396 }
1397
1398 seq_printf(m, "status:\t\t%s\n",
1399 (status == TPACPI_RFK_RADIO_ON) ?
1400 "enabled" : "disabled");
1401 seq_printf(m, "commands:\tenable, disable\n");
1402 }
1403
1404 return 0;
1405}
1406
1407static int tpacpi_rfk_procfs_write(const enum tpacpi_rfk_id id, char *buf)
1408{
1409 char *cmd;
1410 int status = -1;
1411 int res = 0;
1412
1413 if (id >= TPACPI_RFK_SW_MAX)
1414 return -ENODEV;
1415
1416 while ((cmd = strsep(&buf, ","))) {
1417 if (strlencmp(cmd, "enable") == 0)
1418 status = TPACPI_RFK_RADIO_ON;
1419 else if (strlencmp(cmd, "disable") == 0)
1420 status = TPACPI_RFK_RADIO_OFF;
1421 else
1422 return -EINVAL;
1423 }
1424
1425 if (status != -1) {
1426 tpacpi_disclose_usertask("procfs", "attempt to %s %s\n",
1427 (status == TPACPI_RFK_RADIO_ON) ?
1428 "enable" : "disable",
1429 tpacpi_rfkill_names[id]);
1430 res = (tpacpi_rfkill_switches[id]->ops->set_status)(status);
1431 tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
1432 }
1433
1434 return res;
1435}
1436
1437
1438
1439
1440
1441
1442static ssize_t interface_version_show(struct device_driver *drv, char *buf)
1443{
1444 return snprintf(buf, PAGE_SIZE, "0x%08x\n", TPACPI_SYSFS_VERSION);
1445}
1446static DRIVER_ATTR_RO(interface_version);
1447
1448
1449static ssize_t debug_level_show(struct device_driver *drv, char *buf)
1450{
1451 return snprintf(buf, PAGE_SIZE, "0x%04x\n", dbg_level);
1452}
1453
1454static ssize_t debug_level_store(struct device_driver *drv, const char *buf,
1455 size_t count)
1456{
1457 unsigned long t;
1458
1459 if (parse_strtoul(buf, 0xffff, &t))
1460 return -EINVAL;
1461
1462 dbg_level = t;
1463
1464 return count;
1465}
1466static DRIVER_ATTR_RW(debug_level);
1467
1468
1469static ssize_t version_show(struct device_driver *drv, char *buf)
1470{
1471 return snprintf(buf, PAGE_SIZE, "%s v%s\n",
1472 TPACPI_DESC, TPACPI_VERSION);
1473}
1474static DRIVER_ATTR_RO(version);
1475
1476
1477
1478#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
1479
1480
1481static ssize_t wlsw_emulstate_show(struct device_driver *drv, char *buf)
1482{
1483 return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wlsw_emulstate);
1484}
1485
1486static ssize_t wlsw_emulstate_store(struct device_driver *drv, const char *buf,
1487 size_t count)
1488{
1489 unsigned long t;
1490
1491 if (parse_strtoul(buf, 1, &t))
1492 return -EINVAL;
1493
1494 if (tpacpi_wlsw_emulstate != !!t) {
1495 tpacpi_wlsw_emulstate = !!t;
1496 tpacpi_rfk_update_hwblock_state(!t);
1497 }
1498
1499 return count;
1500}
1501static DRIVER_ATTR_RW(wlsw_emulstate);
1502
1503
1504static ssize_t bluetooth_emulstate_show(struct device_driver *drv, char *buf)
1505{
1506 return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_bluetooth_emulstate);
1507}
1508
1509static ssize_t bluetooth_emulstate_store(struct device_driver *drv,
1510 const char *buf, size_t count)
1511{
1512 unsigned long t;
1513
1514 if (parse_strtoul(buf, 1, &t))
1515 return -EINVAL;
1516
1517 tpacpi_bluetooth_emulstate = !!t;
1518
1519 return count;
1520}
1521static DRIVER_ATTR_RW(bluetooth_emulstate);
1522
1523
1524static ssize_t wwan_emulstate_show(struct device_driver *drv, char *buf)
1525{
1526 return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wwan_emulstate);
1527}
1528
1529static ssize_t wwan_emulstate_store(struct device_driver *drv, const char *buf,
1530 size_t count)
1531{
1532 unsigned long t;
1533
1534 if (parse_strtoul(buf, 1, &t))
1535 return -EINVAL;
1536
1537 tpacpi_wwan_emulstate = !!t;
1538
1539 return count;
1540}
1541static DRIVER_ATTR_RW(wwan_emulstate);
1542
1543
1544static ssize_t uwb_emulstate_show(struct device_driver *drv, char *buf)
1545{
1546 return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_uwb_emulstate);
1547}
1548
1549static ssize_t uwb_emulstate_store(struct device_driver *drv, const char *buf,
1550 size_t count)
1551{
1552 unsigned long t;
1553
1554 if (parse_strtoul(buf, 1, &t))
1555 return -EINVAL;
1556
1557 tpacpi_uwb_emulstate = !!t;
1558
1559 return count;
1560}
1561static DRIVER_ATTR_RW(uwb_emulstate);
1562#endif
1563
1564
1565
1566static struct driver_attribute *tpacpi_driver_attributes[] = {
1567 &driver_attr_debug_level, &driver_attr_version,
1568 &driver_attr_interface_version,
1569};
1570
1571static int __init tpacpi_create_driver_attributes(struct device_driver *drv)
1572{
1573 int i, res;
1574
1575 i = 0;
1576 res = 0;
1577 while (!res && i < ARRAY_SIZE(tpacpi_driver_attributes)) {
1578 res = driver_create_file(drv, tpacpi_driver_attributes[i]);
1579 i++;
1580 }
1581
1582#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
1583 if (!res && dbg_wlswemul)
1584 res = driver_create_file(drv, &driver_attr_wlsw_emulstate);
1585 if (!res && dbg_bluetoothemul)
1586 res = driver_create_file(drv, &driver_attr_bluetooth_emulstate);
1587 if (!res && dbg_wwanemul)
1588 res = driver_create_file(drv, &driver_attr_wwan_emulstate);
1589 if (!res && dbg_uwbemul)
1590 res = driver_create_file(drv, &driver_attr_uwb_emulstate);
1591#endif
1592
1593 return res;
1594}
1595
1596static void tpacpi_remove_driver_attributes(struct device_driver *drv)
1597{
1598 int i;
1599
1600 for (i = 0; i < ARRAY_SIZE(tpacpi_driver_attributes); i++)
1601 driver_remove_file(drv, tpacpi_driver_attributes[i]);
1602
1603#ifdef THINKPAD_ACPI_DEBUGFACILITIES
1604 driver_remove_file(drv, &driver_attr_wlsw_emulstate);
1605 driver_remove_file(drv, &driver_attr_bluetooth_emulstate);
1606 driver_remove_file(drv, &driver_attr_wwan_emulstate);
1607 driver_remove_file(drv, &driver_attr_uwb_emulstate);
1608#endif
1609}
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636#define TPV_Q(__v, __id1, __id2, __bv1, __bv2) \
1637 { .vendor = (__v), \
1638 .bios = TPID(__id1, __id2), \
1639 .ec = TPACPI_MATCH_ANY, \
1640 .quirks = TPACPI_MATCH_ANY_VERSION << 16 \
1641 | TPVER(__bv1, __bv2) }
1642
1643#define TPV_Q_X(__v, __bid1, __bid2, __bv1, __bv2, \
1644 __eid, __ev1, __ev2) \
1645 { .vendor = (__v), \
1646 .bios = TPID(__bid1, __bid2), \
1647 .ec = __eid, \
1648 .quirks = TPVER(__ev1, __ev2) << 16 \
1649 | TPVER(__bv1, __bv2) }
1650
1651#define TPV_QI0(__id1, __id2, __bv1, __bv2) \
1652 TPV_Q(PCI_VENDOR_ID_IBM, __id1, __id2, __bv1, __bv2)
1653
1654
1655#define TPV_QI1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
1656 TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2, \
1657 __bv1, __bv2, TPID(__id1, __id2), \
1658 __ev1, __ev2), \
1659 TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2, \
1660 __bv1, __bv2, TPACPI_MATCH_UNKNOWN, \
1661 __ev1, __ev2)
1662
1663
1664#define TPV_QI2(__bid1, __bid2, __bv1, __bv2, \
1665 __eid1, __eid2, __ev1, __ev2) \
1666 TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2, \
1667 __bv1, __bv2, TPID(__eid1, __eid2), \
1668 __ev1, __ev2), \
1669 TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2, \
1670 __bv1, __bv2, TPACPI_MATCH_UNKNOWN, \
1671 __ev1, __ev2)
1672
1673#define TPV_QL0(__id1, __id2, __bv1, __bv2) \
1674 TPV_Q(PCI_VENDOR_ID_LENOVO, __id1, __id2, __bv1, __bv2)
1675
1676#define TPV_QL1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
1677 TPV_Q_X(PCI_VENDOR_ID_LENOVO, __id1, __id2, \
1678 __bv1, __bv2, TPID(__id1, __id2), \
1679 __ev1, __ev2)
1680
1681#define TPV_QL2(__bid1, __bid2, __bv1, __bv2, \
1682 __eid1, __eid2, __ev1, __ev2) \
1683 TPV_Q_X(PCI_VENDOR_ID_LENOVO, __bid1, __bid2, \
1684 __bv1, __bv2, TPID(__eid1, __eid2), \
1685 __ev1, __ev2)
1686
1687static const struct tpacpi_quirk tpacpi_bios_version_qtable[] __initconst = {
1688
1689
1690 TPV_QI0('I', 'M', '6', '5'),
1691 TPV_QI0('I', 'U', '2', '6'),
1692 TPV_QI0('I', 'B', '5', '4'),
1693 TPV_QI0('I', 'H', '4', '7'),
1694 TPV_QI0('I', 'N', '3', '6'),
1695 TPV_QI0('I', 'T', '5', '5'),
1696 TPV_QI0('I', 'D', '4', '8'),
1697 TPV_QI0('I', 'I', '4', '2'),
1698 TPV_QI0('I', 'O', '2', '3'),
1699
1700
1701
1702 TPV_QI0('I', 'W', '5', '9'),
1703 TPV_QI0('I', 'V', '6', '9'),
1704 TPV_QI0('1', '0', '2', '6'),
1705 TPV_QI0('K', 'U', '3', '6'),
1706 TPV_QI0('K', 'X', '3', '6'),
1707 TPV_QI0('K', 'Y', '3', '8'),
1708 TPV_QI0('1', 'B', '1', '7'),
1709 TPV_QI0('1', '3', '2', '0'),
1710 TPV_QI0('1', 'E', '7', '3'),
1711 TPV_QI1('1', 'G', '4', '1', '1', '7'),
1712 TPV_QI1('1', 'N', '1', '6', '0', '7'),
1713
1714
1715
1716 TPV_QI0('1', 'T', 'A', '6'),
1717 TPV_QI0('1', 'X', '5', '7'),
1718
1719
1720
1721 TPV_QI0('1', 'C', 'F', '0'),
1722 TPV_QI0('1', 'F', 'F', '1'),
1723 TPV_QI0('1', 'M', '9', '7'),
1724 TPV_QI0('1', 'O', '6', '1'),
1725 TPV_QI0('1', 'P', '6', '5'),
1726 TPV_QI0('1', 'S', '7', '0'),
1727 TPV_QI1('1', 'R', 'D', 'R', '7', '1'),
1728
1729 TPV_QI1('1', 'V', '7', '1', '2', '8'),
1730 TPV_QI1('7', '8', '7', '1', '0', '6'),
1731 TPV_QI1('7', '6', '6', '9', '1', '6'),
1732 TPV_QI1('7', '0', '6', '9', '2', '8'),
1733
1734 TPV_QI0('I', 'Y', '6', '1'),
1735 TPV_QI0('K', 'Z', '3', '4'),
1736 TPV_QI0('1', '6', '3', '2'),
1737 TPV_QI1('1', 'A', '6', '4', '2', '3'),
1738 TPV_QI1('1', 'I', '7', '1', '2', '0'),
1739 TPV_QI1('1', 'Y', '6', '5', '2', '9'),
1740
1741 TPV_QL1('7', '9', 'E', '3', '5', '0'),
1742 TPV_QL1('7', 'C', 'D', '2', '2', '2'),
1743 TPV_QL1('7', 'E', 'D', '0', '1', '5'),
1744
1745
1746 TPV_QI2('1', 'W', '9', '0', '1', 'V', '2', '8'),
1747 TPV_QL2('7', 'I', '3', '4', '7', '9', '5', '0'),
1748
1749
1750
1751 TPV_QI0('I', 'Z', '9', 'D'),
1752 TPV_QI0('1', 'D', '7', '0'),
1753 TPV_QI1('1', 'K', '4', '8', '1', '8'),
1754 TPV_QI1('1', 'Q', '9', '7', '2', '3'),
1755 TPV_QI1('1', 'U', 'D', '3', 'B', '2'),
1756 TPV_QI1('7', '4', '6', '4', '2', '7'),
1757 TPV_QI1('7', '5', '6', '0', '2', '0'),
1758
1759 TPV_QL1('7', 'B', 'D', '7', '4', '0'),
1760 TPV_QL1('7', 'J', '3', '0', '1', '3'),
1761
1762
1763
1764};
1765
1766#undef TPV_QL1
1767#undef TPV_QL0
1768#undef TPV_QI2
1769#undef TPV_QI1
1770#undef TPV_QI0
1771#undef TPV_Q_X
1772#undef TPV_Q
1773
1774static void __init tpacpi_check_outdated_fw(void)
1775{
1776 unsigned long fwvers;
1777 u16 ec_version, bios_version;
1778
1779 fwvers = tpacpi_check_quirks(tpacpi_bios_version_qtable,
1780 ARRAY_SIZE(tpacpi_bios_version_qtable));
1781
1782 if (!fwvers)
1783 return;
1784
1785 bios_version = fwvers & 0xffffU;
1786 ec_version = (fwvers >> 16) & 0xffffU;
1787
1788
1789 if ((bios_version > thinkpad_id.bios_release) ||
1790 (ec_version > thinkpad_id.ec_release &&
1791 ec_version != TPACPI_MATCH_ANY_VERSION)) {
1792
1793
1794
1795
1796
1797
1798
1799 pr_warn("WARNING: Outdated ThinkPad BIOS/EC firmware\n");
1800 pr_warn("WARNING: This firmware may be missing critical bug fixes and/or important features\n");
1801 }
1802}
1803
1804static bool __init tpacpi_is_fw_known(void)
1805{
1806 return tpacpi_check_quirks(tpacpi_bios_version_qtable,
1807 ARRAY_SIZE(tpacpi_bios_version_qtable)) != 0;
1808}
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822static int thinkpad_acpi_driver_read(struct seq_file *m)
1823{
1824 seq_printf(m, "driver:\t\t%s\n", TPACPI_DESC);
1825 seq_printf(m, "version:\t%s\n", TPACPI_VERSION);
1826 return 0;
1827}
1828
1829static struct ibm_struct thinkpad_acpi_driver_data = {
1830 .name = "driver",
1831 .read = thinkpad_acpi_driver_read,
1832};
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859enum {
1860 TP_ACPI_HOTKEYSCAN_FNF1 = 0,
1861 TP_ACPI_HOTKEYSCAN_FNF2,
1862 TP_ACPI_HOTKEYSCAN_FNF3,
1863 TP_ACPI_HOTKEYSCAN_FNF4,
1864 TP_ACPI_HOTKEYSCAN_FNF5,
1865 TP_ACPI_HOTKEYSCAN_FNF6,
1866 TP_ACPI_HOTKEYSCAN_FNF7,
1867 TP_ACPI_HOTKEYSCAN_FNF8,
1868 TP_ACPI_HOTKEYSCAN_FNF9,
1869 TP_ACPI_HOTKEYSCAN_FNF10,
1870 TP_ACPI_HOTKEYSCAN_FNF11,
1871 TP_ACPI_HOTKEYSCAN_FNF12,
1872 TP_ACPI_HOTKEYSCAN_FNBACKSPACE,
1873 TP_ACPI_HOTKEYSCAN_FNINSERT,
1874 TP_ACPI_HOTKEYSCAN_FNDELETE,
1875 TP_ACPI_HOTKEYSCAN_FNHOME,
1876 TP_ACPI_HOTKEYSCAN_FNEND,
1877 TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1878 TP_ACPI_HOTKEYSCAN_FNPAGEDOWN,
1879 TP_ACPI_HOTKEYSCAN_FNSPACE,
1880 TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1881 TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1882 TP_ACPI_HOTKEYSCAN_MUTE,
1883 TP_ACPI_HOTKEYSCAN_THINKPAD,
1884 TP_ACPI_HOTKEYSCAN_UNK1,
1885 TP_ACPI_HOTKEYSCAN_UNK2,
1886 TP_ACPI_HOTKEYSCAN_UNK3,
1887 TP_ACPI_HOTKEYSCAN_UNK4,
1888 TP_ACPI_HOTKEYSCAN_UNK5,
1889 TP_ACPI_HOTKEYSCAN_UNK6,
1890 TP_ACPI_HOTKEYSCAN_UNK7,
1891 TP_ACPI_HOTKEYSCAN_UNK8,
1892
1893
1894 TP_ACPI_HOTKEYSCAN_ADAPTIVE_START,
1895 TP_ACPI_HOTKEYSCAN_MUTE2 = TP_ACPI_HOTKEYSCAN_ADAPTIVE_START,
1896 TP_ACPI_HOTKEYSCAN_BRIGHTNESS_ZERO,
1897 TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL,
1898 TP_ACPI_HOTKEYSCAN_CLOUD,
1899 TP_ACPI_HOTKEYSCAN_UNK9,
1900 TP_ACPI_HOTKEYSCAN_VOICE,
1901 TP_ACPI_HOTKEYSCAN_UNK10,
1902 TP_ACPI_HOTKEYSCAN_GESTURES,
1903 TP_ACPI_HOTKEYSCAN_UNK11,
1904 TP_ACPI_HOTKEYSCAN_UNK12,
1905 TP_ACPI_HOTKEYSCAN_UNK13,
1906 TP_ACPI_HOTKEYSCAN_CONFIG,
1907 TP_ACPI_HOTKEYSCAN_NEW_TAB,
1908 TP_ACPI_HOTKEYSCAN_RELOAD,
1909 TP_ACPI_HOTKEYSCAN_BACK,
1910 TP_ACPI_HOTKEYSCAN_MIC_DOWN,
1911 TP_ACPI_HOTKEYSCAN_MIC_UP,
1912 TP_ACPI_HOTKEYSCAN_MIC_CANCELLATION,
1913 TP_ACPI_HOTKEYSCAN_CAMERA_MODE,
1914 TP_ACPI_HOTKEYSCAN_ROTATE_DISPLAY,
1915
1916
1917 TP_ACPI_HOTKEYSCAN_EXTENDED_START,
1918
1919 TP_ACPI_HOTKEYSCAN_STAR = 69,
1920 TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL2,
1921 TP_ACPI_HOTKEYSCAN_CALCULATOR,
1922 TP_ACPI_HOTKEYSCAN_BLUETOOTH,
1923 TP_ACPI_HOTKEYSCAN_KEYBOARD,
1924 TP_ACPI_HOTKEYSCAN_FN_RIGHT_SHIFT,
1925 TP_ACPI_HOTKEYSCAN_NOTIFICATION_CENTER,
1926 TP_ACPI_HOTKEYSCAN_PICKUP_PHONE,
1927 TP_ACPI_HOTKEYSCAN_HANGUP_PHONE,
1928
1929
1930 TPACPI_HOTKEY_MAP_LEN
1931};
1932
1933enum {
1934 TPACPI_HKEY_NVRAM_KNOWN_MASK = 0x00fb88c0U,
1935 TPACPI_HKEY_NVRAM_GOOD_MASK = 0x00fb8000U,
1936};
1937
1938enum {
1939 TP_ACPI_HKEY_DISPSWTCH_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNF7,
1940 TP_ACPI_HKEY_DISPXPAND_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNF8,
1941 TP_ACPI_HKEY_HIBERNATE_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNF12,
1942 TP_ACPI_HKEY_BRGHTUP_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNHOME,
1943 TP_ACPI_HKEY_BRGHTDWN_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNEND,
1944 TP_ACPI_HKEY_KBD_LIGHT_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1945 TP_ACPI_HKEY_ZOOM_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNSPACE,
1946 TP_ACPI_HKEY_VOLUP_MASK = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1947 TP_ACPI_HKEY_VOLDWN_MASK = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1948 TP_ACPI_HKEY_MUTE_MASK = 1 << TP_ACPI_HOTKEYSCAN_MUTE,
1949 TP_ACPI_HKEY_THINKPAD_MASK = 1 << TP_ACPI_HOTKEYSCAN_THINKPAD,
1950};
1951
1952enum {
1953 TP_NVRAM_HKEY_GROUP_HK2 = TP_ACPI_HKEY_THINKPAD_MASK |
1954 TP_ACPI_HKEY_ZOOM_MASK |
1955 TP_ACPI_HKEY_DISPSWTCH_MASK |
1956 TP_ACPI_HKEY_HIBERNATE_MASK,
1957 TP_NVRAM_HKEY_GROUP_BRIGHTNESS = TP_ACPI_HKEY_BRGHTUP_MASK |
1958 TP_ACPI_HKEY_BRGHTDWN_MASK,
1959 TP_NVRAM_HKEY_GROUP_VOLUME = TP_ACPI_HKEY_VOLUP_MASK |
1960 TP_ACPI_HKEY_VOLDWN_MASK |
1961 TP_ACPI_HKEY_MUTE_MASK,
1962};
1963
1964#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1965struct tp_nvram_state {
1966 u16 thinkpad_toggle:1;
1967 u16 zoom_toggle:1;
1968 u16 display_toggle:1;
1969 u16 thinklight_toggle:1;
1970 u16 hibernate_toggle:1;
1971 u16 displayexp_toggle:1;
1972 u16 display_state:1;
1973 u16 brightness_toggle:1;
1974 u16 volume_toggle:1;
1975 u16 mute:1;
1976
1977 u8 brightness_level;
1978 u8 volume_level;
1979};
1980
1981
1982static struct task_struct *tpacpi_hotkey_task;
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993static struct mutex hotkey_thread_data_mutex;
1994static unsigned int hotkey_config_change;
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006static u32 hotkey_source_mask;
2007static unsigned int hotkey_poll_freq = 10;
2008
2009#define HOTKEY_CONFIG_CRITICAL_START \
2010 do { \
2011 mutex_lock(&hotkey_thread_data_mutex); \
2012 hotkey_config_change++; \
2013 } while (0);
2014#define HOTKEY_CONFIG_CRITICAL_END \
2015 mutex_unlock(&hotkey_thread_data_mutex);
2016
2017#else
2018
2019#define hotkey_source_mask 0U
2020#define HOTKEY_CONFIG_CRITICAL_START
2021#define HOTKEY_CONFIG_CRITICAL_END
2022
2023#endif
2024
2025static struct mutex hotkey_mutex;
2026
2027static enum {
2028 TP_ACPI_WAKEUP_NONE = 0,
2029 TP_ACPI_WAKEUP_BAYEJ,
2030 TP_ACPI_WAKEUP_UNDOCK,
2031} hotkey_wakeup_reason;
2032
2033static int hotkey_autosleep_ack;
2034
2035static u32 hotkey_orig_mask;
2036static u32 hotkey_all_mask;
2037static u32 hotkey_adaptive_all_mask;
2038static u32 hotkey_reserved_mask;
2039static u32 hotkey_driver_mask;
2040static u32 hotkey_user_mask;
2041static u32 hotkey_acpi_mask;
2042
2043static u16 *hotkey_keycode_map;
2044
2045static struct attribute_set *hotkey_dev_attributes;
2046
2047static void tpacpi_driver_event(const unsigned int hkey_event);
2048static void hotkey_driver_event(const unsigned int scancode);
2049static void hotkey_poll_setup(const bool may_warn);
2050
2051
2052#define TP_HOTKEY_TABLET_MASK (1 << 3)
2053enum {
2054 TP_ACPI_MULTI_MODE_INVALID = 0,
2055 TP_ACPI_MULTI_MODE_UNKNOWN = 1 << 0,
2056 TP_ACPI_MULTI_MODE_LAPTOP = 1 << 1,
2057 TP_ACPI_MULTI_MODE_TABLET = 1 << 2,
2058 TP_ACPI_MULTI_MODE_FLAT = 1 << 3,
2059 TP_ACPI_MULTI_MODE_STAND = 1 << 4,
2060 TP_ACPI_MULTI_MODE_TENT = 1 << 5,
2061 TP_ACPI_MULTI_MODE_STAND_TENT = 1 << 6,
2062};
2063
2064enum {
2065
2066
2067
2068
2069
2070 TP_ACPI_MULTI_MODE_TABLET_LIKE = TP_ACPI_MULTI_MODE_TABLET |
2071 TP_ACPI_MULTI_MODE_STAND |
2072 TP_ACPI_MULTI_MODE_TENT |
2073 TP_ACPI_MULTI_MODE_STAND_TENT,
2074};
2075
2076static int hotkey_get_wlsw(void)
2077{
2078 int status;
2079
2080 if (!tp_features.hotkey_wlsw)
2081 return -ENODEV;
2082
2083#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
2084 if (dbg_wlswemul)
2085 return (tpacpi_wlsw_emulstate) ?
2086 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
2087#endif
2088
2089 if (!acpi_evalf(hkey_handle, &status, "WLSW", "d"))
2090 return -EIO;
2091
2092 return (status) ? TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
2093}
2094
2095static int hotkey_gmms_get_tablet_mode(int s, int *has_tablet_mode)
2096{
2097 int type = (s >> 16) & 0xffff;
2098 int value = s & 0xffff;
2099 int mode = TP_ACPI_MULTI_MODE_INVALID;
2100 int valid_modes = 0;
2101
2102 if (has_tablet_mode)
2103 *has_tablet_mode = 0;
2104
2105 switch (type) {
2106 case 1:
2107 valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2108 TP_ACPI_MULTI_MODE_TABLET |
2109 TP_ACPI_MULTI_MODE_STAND_TENT;
2110 break;
2111 case 2:
2112 valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2113 TP_ACPI_MULTI_MODE_FLAT |
2114 TP_ACPI_MULTI_MODE_TABLET |
2115 TP_ACPI_MULTI_MODE_STAND |
2116 TP_ACPI_MULTI_MODE_TENT;
2117 break;
2118 case 3:
2119 valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2120 TP_ACPI_MULTI_MODE_FLAT;
2121 break;
2122 case 4:
2123 case 5:
2124
2125
2126
2127 valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2128 TP_ACPI_MULTI_MODE_FLAT |
2129 TP_ACPI_MULTI_MODE_TABLET |
2130 TP_ACPI_MULTI_MODE_STAND |
2131 TP_ACPI_MULTI_MODE_TENT;
2132 break;
2133 default:
2134 pr_err("Unknown multi mode status type %d with value 0x%04X, please report this to %s\n",
2135 type, value, TPACPI_MAIL);
2136 return 0;
2137 }
2138
2139 if (has_tablet_mode && (valid_modes & TP_ACPI_MULTI_MODE_TABLET_LIKE))
2140 *has_tablet_mode = 1;
2141
2142 switch (value) {
2143 case 1:
2144 mode = TP_ACPI_MULTI_MODE_LAPTOP;
2145 break;
2146 case 2:
2147 mode = TP_ACPI_MULTI_MODE_FLAT;
2148 break;
2149 case 3:
2150 mode = TP_ACPI_MULTI_MODE_TABLET;
2151 break;
2152 case 4:
2153 if (type == 1)
2154 mode = TP_ACPI_MULTI_MODE_STAND_TENT;
2155 else
2156 mode = TP_ACPI_MULTI_MODE_STAND;
2157 break;
2158 case 5:
2159 mode = TP_ACPI_MULTI_MODE_TENT;
2160 break;
2161 default:
2162 if (type == 5 && value == 0xffff) {
2163 pr_warn("Multi mode status is undetected, assuming laptop\n");
2164 return 0;
2165 }
2166 }
2167
2168 if (!(mode & valid_modes)) {
2169 pr_err("Unknown/reserved multi mode value 0x%04X for type %d, please report this to %s\n",
2170 value, type, TPACPI_MAIL);
2171 return 0;
2172 }
2173
2174 return !!(mode & TP_ACPI_MULTI_MODE_TABLET_LIKE);
2175}
2176
2177static int hotkey_get_tablet_mode(int *status)
2178{
2179 int s;
2180
2181 switch (tp_features.hotkey_tablet) {
2182 case TP_HOTKEY_TABLET_USES_MHKG:
2183 if (!acpi_evalf(hkey_handle, &s, "MHKG", "d"))
2184 return -EIO;
2185
2186 *status = ((s & TP_HOTKEY_TABLET_MASK) != 0);
2187 break;
2188 case TP_HOTKEY_TABLET_USES_GMMS:
2189 if (!acpi_evalf(hkey_handle, &s, "GMMS", "dd", 0))
2190 return -EIO;
2191
2192 *status = hotkey_gmms_get_tablet_mode(s, NULL);
2193 break;
2194 default:
2195 break;
2196 }
2197
2198 return 0;
2199}
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209static int hotkey_mask_get(void)
2210{
2211 if (tp_features.hotkey_mask) {
2212 u32 m = 0;
2213
2214 if (!acpi_evalf(hkey_handle, &m, "DHKN", "d"))
2215 return -EIO;
2216
2217 hotkey_acpi_mask = m;
2218 } else {
2219
2220 hotkey_acpi_mask = hotkey_all_mask;
2221 }
2222
2223
2224 hotkey_user_mask &= (hotkey_acpi_mask | hotkey_source_mask);
2225
2226 return 0;
2227}
2228
2229static void hotkey_mask_warn_incomplete_mask(void)
2230{
2231
2232 const u32 wantedmask = hotkey_driver_mask &
2233 ~(hotkey_acpi_mask | hotkey_source_mask) &
2234 (hotkey_all_mask | TPACPI_HKEY_NVRAM_KNOWN_MASK);
2235
2236 if (wantedmask)
2237 pr_notice("required events 0x%08x not enabled!\n", wantedmask);
2238}
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249static int hotkey_mask_set(u32 mask)
2250{
2251 int i;
2252 int rc = 0;
2253
2254 const u32 fwmask = mask & ~hotkey_source_mask;
2255
2256 if (tp_features.hotkey_mask) {
2257 for (i = 0; i < 32; i++) {
2258 if (!acpi_evalf(hkey_handle,
2259 NULL, "MHKM", "vdd", i + 1,
2260 !!(mask & (1 << i)))) {
2261 rc = -EIO;
2262 break;
2263 }
2264 }
2265 }
2266
2267
2268
2269
2270
2271
2272
2273
2274 if (!hotkey_mask_get() && !rc && (fwmask & ~hotkey_acpi_mask)) {
2275 pr_notice("asked for hotkey mask 0x%08x, but firmware forced it to 0x%08x\n",
2276 fwmask, hotkey_acpi_mask);
2277 }
2278
2279 if (tpacpi_lifecycle != TPACPI_LIFE_EXITING)
2280 hotkey_mask_warn_incomplete_mask();
2281
2282 return rc;
2283}
2284
2285
2286
2287
2288
2289
2290static int hotkey_user_mask_set(const u32 mask)
2291{
2292 int rc;
2293
2294
2295
2296 if (!tp_warned.hotkey_mask_ff &&
2297 (mask == 0xffff || mask == 0xffffff ||
2298 mask == 0xffffffff)) {
2299 tp_warned.hotkey_mask_ff = 1;
2300 pr_notice("setting the hotkey mask to 0x%08x is likely not the best way to go about it\n",
2301 mask);
2302 pr_notice("please consider using the driver defaults, and refer to up-to-date thinkpad-acpi documentation\n");
2303 }
2304
2305
2306
2307 rc = hotkey_mask_set((mask | hotkey_driver_mask) & ~hotkey_source_mask);
2308
2309
2310 hotkey_user_mask = mask & (hotkey_acpi_mask | hotkey_source_mask);
2311
2312 return rc;
2313}
2314
2315
2316
2317
2318
2319
2320static int tpacpi_hotkey_driver_mask_set(const u32 mask)
2321{
2322 int rc;
2323
2324
2325 if (!tp_features.hotkey) {
2326 hotkey_driver_mask = mask;
2327 return 0;
2328 }
2329
2330 mutex_lock(&hotkey_mutex);
2331
2332 HOTKEY_CONFIG_CRITICAL_START
2333 hotkey_driver_mask = mask;
2334#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2335 hotkey_source_mask |= (mask & ~hotkey_all_mask);
2336#endif
2337 HOTKEY_CONFIG_CRITICAL_END
2338
2339 rc = hotkey_mask_set((hotkey_acpi_mask | hotkey_driver_mask) &
2340 ~hotkey_source_mask);
2341 hotkey_poll_setup(true);
2342
2343 mutex_unlock(&hotkey_mutex);
2344
2345 return rc;
2346}
2347
2348static int hotkey_status_get(int *status)
2349{
2350 if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
2351 return -EIO;
2352
2353 return 0;
2354}
2355
2356static int hotkey_status_set(bool enable)
2357{
2358 if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", enable ? 1 : 0))
2359 return -EIO;
2360
2361 return 0;
2362}
2363
2364static void tpacpi_input_send_tabletsw(void)
2365{
2366 int state;
2367
2368 if (tp_features.hotkey_tablet &&
2369 !hotkey_get_tablet_mode(&state)) {
2370 mutex_lock(&tpacpi_inputdev_send_mutex);
2371
2372 input_report_switch(tpacpi_inputdev,
2373 SW_TABLET_MODE, !!state);
2374 input_sync(tpacpi_inputdev);
2375
2376 mutex_unlock(&tpacpi_inputdev_send_mutex);
2377 }
2378}
2379
2380
2381static void tpacpi_input_send_key(const unsigned int scancode)
2382{
2383 const unsigned int keycode = hotkey_keycode_map[scancode];
2384
2385 if (keycode != KEY_RESERVED) {
2386 mutex_lock(&tpacpi_inputdev_send_mutex);
2387
2388 input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
2389 input_report_key(tpacpi_inputdev, keycode, 1);
2390 input_sync(tpacpi_inputdev);
2391
2392 input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
2393 input_report_key(tpacpi_inputdev, keycode, 0);
2394 input_sync(tpacpi_inputdev);
2395
2396 mutex_unlock(&tpacpi_inputdev_send_mutex);
2397 }
2398}
2399
2400
2401static void tpacpi_input_send_key_masked(const unsigned int scancode)
2402{
2403 hotkey_driver_event(scancode);
2404 if (hotkey_user_mask & (1 << scancode))
2405 tpacpi_input_send_key(scancode);
2406}
2407
2408#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2409static struct tp_acpi_drv_struct ibm_hotkey_acpidriver;
2410
2411
2412static void tpacpi_hotkey_send_key(unsigned int scancode)
2413{
2414 tpacpi_input_send_key_masked(scancode);
2415}
2416
2417static void hotkey_read_nvram(struct tp_nvram_state *n, const u32 m)
2418{
2419 u8 d;
2420
2421 if (m & TP_NVRAM_HKEY_GROUP_HK2) {
2422 d = nvram_read_byte(TP_NVRAM_ADDR_HK2);
2423 n->thinkpad_toggle = !!(d & TP_NVRAM_MASK_HKT_THINKPAD);
2424 n->zoom_toggle = !!(d & TP_NVRAM_MASK_HKT_ZOOM);
2425 n->display_toggle = !!(d & TP_NVRAM_MASK_HKT_DISPLAY);
2426 n->hibernate_toggle = !!(d & TP_NVRAM_MASK_HKT_HIBERNATE);
2427 }
2428 if (m & TP_ACPI_HKEY_KBD_LIGHT_MASK) {
2429 d = nvram_read_byte(TP_NVRAM_ADDR_THINKLIGHT);
2430 n->thinklight_toggle = !!(d & TP_NVRAM_MASK_THINKLIGHT);
2431 }
2432 if (m & TP_ACPI_HKEY_DISPXPAND_MASK) {
2433 d = nvram_read_byte(TP_NVRAM_ADDR_VIDEO);
2434 n->displayexp_toggle =
2435 !!(d & TP_NVRAM_MASK_HKT_DISPEXPND);
2436 }
2437 if (m & TP_NVRAM_HKEY_GROUP_BRIGHTNESS) {
2438 d = nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS);
2439 n->brightness_level = (d & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
2440 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
2441 n->brightness_toggle =
2442 !!(d & TP_NVRAM_MASK_HKT_BRIGHTNESS);
2443 }
2444 if (m & TP_NVRAM_HKEY_GROUP_VOLUME) {
2445 d = nvram_read_byte(TP_NVRAM_ADDR_MIXER);
2446 n->volume_level = (d & TP_NVRAM_MASK_LEVEL_VOLUME)
2447 >> TP_NVRAM_POS_LEVEL_VOLUME;
2448 n->mute = !!(d & TP_NVRAM_MASK_MUTE);
2449 n->volume_toggle = !!(d & TP_NVRAM_MASK_HKT_VOLUME);
2450 }
2451}
2452
2453#define TPACPI_COMPARE_KEY(__scancode, __member) \
2454do { \
2455 if ((event_mask & (1 << __scancode)) && \
2456 oldn->__member != newn->__member) \
2457 tpacpi_hotkey_send_key(__scancode); \
2458} while (0)
2459
2460#define TPACPI_MAY_SEND_KEY(__scancode) \
2461do { \
2462 if (event_mask & (1 << __scancode)) \
2463 tpacpi_hotkey_send_key(__scancode); \
2464} while (0)
2465
2466static void issue_volchange(const unsigned int oldvol,
2467 const unsigned int newvol,
2468 const u32 event_mask)
2469{
2470 unsigned int i = oldvol;
2471
2472 while (i > newvol) {
2473 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
2474 i--;
2475 }
2476 while (i < newvol) {
2477 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2478 i++;
2479 }
2480}
2481
2482static void issue_brightnesschange(const unsigned int oldbrt,
2483 const unsigned int newbrt,
2484 const u32 event_mask)
2485{
2486 unsigned int i = oldbrt;
2487
2488 while (i > newbrt) {
2489 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
2490 i--;
2491 }
2492 while (i < newbrt) {
2493 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
2494 i++;
2495 }
2496}
2497
2498static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn,
2499 struct tp_nvram_state *newn,
2500 const u32 event_mask)
2501{
2502
2503 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_THINKPAD, thinkpad_toggle);
2504 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNSPACE, zoom_toggle);
2505 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF7, display_toggle);
2506 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF12, hibernate_toggle);
2507
2508 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNPAGEUP, thinklight_toggle);
2509
2510 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF8, displayexp_toggle);
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529 if (newn->mute) {
2530
2531 if (!oldn->mute ||
2532 oldn->volume_toggle != newn->volume_toggle ||
2533 oldn->volume_level != newn->volume_level) {
2534
2535
2536 issue_volchange(oldn->volume_level, newn->volume_level,
2537 event_mask);
2538 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE);
2539 }
2540 } else {
2541
2542 if (oldn->mute) {
2543
2544 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2545 }
2546 if (oldn->volume_level != newn->volume_level) {
2547 issue_volchange(oldn->volume_level, newn->volume_level,
2548 event_mask);
2549 } else if (oldn->volume_toggle != newn->volume_toggle) {
2550
2551 if (newn->volume_level == 0)
2552 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
2553 else if (newn->volume_level >= TP_NVRAM_LEVEL_VOLUME_MAX)
2554 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2555 }
2556 }
2557
2558
2559 if (oldn->brightness_level != newn->brightness_level) {
2560 issue_brightnesschange(oldn->brightness_level,
2561 newn->brightness_level, event_mask);
2562 } else if (oldn->brightness_toggle != newn->brightness_toggle) {
2563
2564 if (newn->brightness_level == 0)
2565 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
2566 else if (newn->brightness_level >= bright_maxlvl
2567 && !tp_features.bright_unkfw)
2568 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
2569 }
2570
2571#undef TPACPI_COMPARE_KEY
2572#undef TPACPI_MAY_SEND_KEY
2573}
2574
2575
2576
2577
2578
2579
2580
2581
2582static int hotkey_kthread(void *data)
2583{
2584 struct tp_nvram_state s[2] = { 0 };
2585 u32 poll_mask, event_mask;
2586 unsigned int si, so;
2587 unsigned long t;
2588 unsigned int change_detector;
2589 unsigned int poll_freq;
2590 bool was_frozen;
2591
2592 if (tpacpi_lifecycle == TPACPI_LIFE_EXITING)
2593 goto exit;
2594
2595 set_freezable();
2596
2597 so = 0;
2598 si = 1;
2599 t = 0;
2600
2601
2602 mutex_lock(&hotkey_thread_data_mutex);
2603 change_detector = hotkey_config_change;
2604 poll_mask = hotkey_source_mask;
2605 event_mask = hotkey_source_mask &
2606 (hotkey_driver_mask | hotkey_user_mask);
2607 poll_freq = hotkey_poll_freq;
2608 mutex_unlock(&hotkey_thread_data_mutex);
2609 hotkey_read_nvram(&s[so], poll_mask);
2610
2611 while (!kthread_should_stop()) {
2612 if (t == 0) {
2613 if (likely(poll_freq))
2614 t = 1000/poll_freq;
2615 else
2616 t = 100;
2617 }
2618 t = msleep_interruptible(t);
2619 if (unlikely(kthread_freezable_should_stop(&was_frozen)))
2620 break;
2621
2622 if (t > 0 && !was_frozen)
2623 continue;
2624
2625 mutex_lock(&hotkey_thread_data_mutex);
2626 if (was_frozen || hotkey_config_change != change_detector) {
2627
2628 si = so;
2629 t = 0;
2630 change_detector = hotkey_config_change;
2631 }
2632 poll_mask = hotkey_source_mask;
2633 event_mask = hotkey_source_mask &
2634 (hotkey_driver_mask | hotkey_user_mask);
2635 poll_freq = hotkey_poll_freq;
2636 mutex_unlock(&hotkey_thread_data_mutex);
2637
2638 if (likely(poll_mask)) {
2639 hotkey_read_nvram(&s[si], poll_mask);
2640 if (likely(si != so)) {
2641 hotkey_compare_and_issue_event(&s[so], &s[si],
2642 event_mask);
2643 }
2644 }
2645
2646 so = si;
2647 si ^= 1;
2648 }
2649
2650exit:
2651 return 0;
2652}
2653
2654
2655static void hotkey_poll_stop_sync(void)
2656{
2657 if (tpacpi_hotkey_task) {
2658 kthread_stop(tpacpi_hotkey_task);
2659 tpacpi_hotkey_task = NULL;
2660 }
2661}
2662
2663
2664static void hotkey_poll_setup(const bool may_warn)
2665{
2666 const u32 poll_driver_mask = hotkey_driver_mask & hotkey_source_mask;
2667 const u32 poll_user_mask = hotkey_user_mask & hotkey_source_mask;
2668
2669 if (hotkey_poll_freq > 0 &&
2670 (poll_driver_mask ||
2671 (poll_user_mask && tpacpi_inputdev->users > 0))) {
2672 if (!tpacpi_hotkey_task) {
2673 tpacpi_hotkey_task = kthread_run(hotkey_kthread,
2674 NULL, TPACPI_NVRAM_KTHREAD_NAME);
2675 if (IS_ERR(tpacpi_hotkey_task)) {
2676 tpacpi_hotkey_task = NULL;
2677 pr_err("could not create kernel thread for hotkey polling\n");
2678 }
2679 }
2680 } else {
2681 hotkey_poll_stop_sync();
2682 if (may_warn && (poll_driver_mask || poll_user_mask) &&
2683 hotkey_poll_freq == 0) {
2684 pr_notice("hot keys 0x%08x and/or events 0x%08x require polling, which is currently disabled\n",
2685 poll_user_mask, poll_driver_mask);
2686 }
2687 }
2688}
2689
2690static void hotkey_poll_setup_safe(const bool may_warn)
2691{
2692 mutex_lock(&hotkey_mutex);
2693 hotkey_poll_setup(may_warn);
2694 mutex_unlock(&hotkey_mutex);
2695}
2696
2697
2698static void hotkey_poll_set_freq(unsigned int freq)
2699{
2700 if (!freq)
2701 hotkey_poll_stop_sync();
2702
2703 hotkey_poll_freq = freq;
2704}
2705
2706#else
2707
2708static void hotkey_poll_setup(const bool __unused)
2709{
2710}
2711
2712static void hotkey_poll_setup_safe(const bool __unused)
2713{
2714}
2715
2716#endif
2717
2718static int hotkey_inputdev_open(struct input_dev *dev)
2719{
2720 switch (tpacpi_lifecycle) {
2721 case TPACPI_LIFE_INIT:
2722 case TPACPI_LIFE_RUNNING:
2723 hotkey_poll_setup_safe(false);
2724 return 0;
2725 case TPACPI_LIFE_EXITING:
2726 return -EBUSY;
2727 }
2728
2729
2730 BUG();
2731 return -EBUSY;
2732}
2733
2734static void hotkey_inputdev_close(struct input_dev *dev)
2735{
2736
2737 if (tpacpi_lifecycle != TPACPI_LIFE_EXITING &&
2738 !(hotkey_source_mask & hotkey_driver_mask))
2739 hotkey_poll_setup_safe(false);
2740}
2741
2742
2743static ssize_t hotkey_enable_show(struct device *dev,
2744 struct device_attribute *attr,
2745 char *buf)
2746{
2747 int res, status;
2748
2749 printk_deprecated_attribute("hotkey_enable",
2750 "Hotkey reporting is always enabled");
2751
2752 res = hotkey_status_get(&status);
2753 if (res)
2754 return res;
2755
2756 return snprintf(buf, PAGE_SIZE, "%d\n", status);
2757}
2758
2759static ssize_t hotkey_enable_store(struct device *dev,
2760 struct device_attribute *attr,
2761 const char *buf, size_t count)
2762{
2763 unsigned long t;
2764
2765 printk_deprecated_attribute("hotkey_enable",
2766 "Hotkeys can be disabled through hotkey_mask");
2767
2768 if (parse_strtoul(buf, 1, &t))
2769 return -EINVAL;
2770
2771 if (t == 0)
2772 return -EPERM;
2773
2774 return count;
2775}
2776
2777static DEVICE_ATTR_RW(hotkey_enable);
2778
2779
2780static ssize_t hotkey_mask_show(struct device *dev,
2781 struct device_attribute *attr,
2782 char *buf)
2783{
2784 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_user_mask);
2785}
2786
2787static ssize_t hotkey_mask_store(struct device *dev,
2788 struct device_attribute *attr,
2789 const char *buf, size_t count)
2790{
2791 unsigned long t;
2792 int res;
2793
2794 if (parse_strtoul(buf, 0xffffffffUL, &t))
2795 return -EINVAL;
2796
2797 if (mutex_lock_killable(&hotkey_mutex))
2798 return -ERESTARTSYS;
2799
2800 res = hotkey_user_mask_set(t);
2801
2802#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2803 hotkey_poll_setup(true);
2804#endif
2805
2806 mutex_unlock(&hotkey_mutex);
2807
2808 tpacpi_disclose_usertask("hotkey_mask", "set to 0x%08lx\n", t);
2809
2810 return (res) ? res : count;
2811}
2812
2813static DEVICE_ATTR_RW(hotkey_mask);
2814
2815
2816static ssize_t hotkey_bios_enabled_show(struct device *dev,
2817 struct device_attribute *attr,
2818 char *buf)
2819{
2820 return sprintf(buf, "0\n");
2821}
2822
2823static DEVICE_ATTR_RO(hotkey_bios_enabled);
2824
2825
2826static ssize_t hotkey_bios_mask_show(struct device *dev,
2827 struct device_attribute *attr,
2828 char *buf)
2829{
2830 printk_deprecated_attribute("hotkey_bios_mask",
2831 "This attribute is useless.");
2832 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask);
2833}
2834
2835static DEVICE_ATTR_RO(hotkey_bios_mask);
2836
2837
2838static ssize_t hotkey_all_mask_show(struct device *dev,
2839 struct device_attribute *attr,
2840 char *buf)
2841{
2842 return snprintf(buf, PAGE_SIZE, "0x%08x\n",
2843 hotkey_all_mask | hotkey_source_mask);
2844}
2845
2846static DEVICE_ATTR_RO(hotkey_all_mask);
2847
2848
2849static ssize_t hotkey_adaptive_all_mask_show(struct device *dev,
2850 struct device_attribute *attr,
2851 char *buf)
2852{
2853 return snprintf(buf, PAGE_SIZE, "0x%08x\n",
2854 hotkey_adaptive_all_mask | hotkey_source_mask);
2855}
2856
2857static DEVICE_ATTR_RO(hotkey_adaptive_all_mask);
2858
2859
2860static ssize_t hotkey_recommended_mask_show(struct device *dev,
2861 struct device_attribute *attr,
2862 char *buf)
2863{
2864 return snprintf(buf, PAGE_SIZE, "0x%08x\n",
2865 (hotkey_all_mask | hotkey_source_mask)
2866 & ~hotkey_reserved_mask);
2867}
2868
2869static DEVICE_ATTR_RO(hotkey_recommended_mask);
2870
2871#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2872
2873
2874static ssize_t hotkey_source_mask_show(struct device *dev,
2875 struct device_attribute *attr,
2876 char *buf)
2877{
2878 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_source_mask);
2879}
2880
2881static ssize_t hotkey_source_mask_store(struct device *dev,
2882 struct device_attribute *attr,
2883 const char *buf, size_t count)
2884{
2885 unsigned long t;
2886 u32 r_ev;
2887 int rc;
2888
2889 if (parse_strtoul(buf, 0xffffffffUL, &t) ||
2890 ((t & ~TPACPI_HKEY_NVRAM_KNOWN_MASK) != 0))
2891 return -EINVAL;
2892
2893 if (mutex_lock_killable(&hotkey_mutex))
2894 return -ERESTARTSYS;
2895
2896 HOTKEY_CONFIG_CRITICAL_START
2897 hotkey_source_mask = t;
2898 HOTKEY_CONFIG_CRITICAL_END
2899
2900 rc = hotkey_mask_set((hotkey_user_mask | hotkey_driver_mask) &
2901 ~hotkey_source_mask);
2902 hotkey_poll_setup(true);
2903
2904
2905 r_ev = hotkey_driver_mask & ~(hotkey_acpi_mask & hotkey_all_mask)
2906 & ~hotkey_source_mask & TPACPI_HKEY_NVRAM_KNOWN_MASK;
2907
2908 mutex_unlock(&hotkey_mutex);
2909
2910 if (rc < 0)
2911 pr_err("hotkey_source_mask: failed to update the firmware event mask!\n");
2912
2913 if (r_ev)
2914 pr_notice("hotkey_source_mask: some important events were disabled: 0x%04x\n",
2915 r_ev);
2916
2917 tpacpi_disclose_usertask("hotkey_source_mask", "set to 0x%08lx\n", t);
2918
2919 return (rc < 0) ? rc : count;
2920}
2921
2922static DEVICE_ATTR_RW(hotkey_source_mask);
2923
2924
2925static ssize_t hotkey_poll_freq_show(struct device *dev,
2926 struct device_attribute *attr,
2927 char *buf)
2928{
2929 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_poll_freq);
2930}
2931
2932static ssize_t hotkey_poll_freq_store(struct device *dev,
2933 struct device_attribute *attr,
2934 const char *buf, size_t count)
2935{
2936 unsigned long t;
2937
2938 if (parse_strtoul(buf, 25, &t))
2939 return -EINVAL;
2940
2941 if (mutex_lock_killable(&hotkey_mutex))
2942 return -ERESTARTSYS;
2943
2944 hotkey_poll_set_freq(t);
2945 hotkey_poll_setup(true);
2946
2947 mutex_unlock(&hotkey_mutex);
2948
2949 tpacpi_disclose_usertask("hotkey_poll_freq", "set to %lu\n", t);
2950
2951 return count;
2952}
2953
2954static DEVICE_ATTR_RW(hotkey_poll_freq);
2955
2956#endif
2957
2958
2959static ssize_t hotkey_radio_sw_show(struct device *dev,
2960 struct device_attribute *attr,
2961 char *buf)
2962{
2963 int res;
2964 res = hotkey_get_wlsw();
2965 if (res < 0)
2966 return res;
2967
2968
2969 tpacpi_rfk_update_hwblock_state((res == TPACPI_RFK_RADIO_OFF));
2970
2971 return snprintf(buf, PAGE_SIZE, "%d\n",
2972 (res == TPACPI_RFK_RADIO_OFF) ? 0 : 1);
2973}
2974
2975static DEVICE_ATTR_RO(hotkey_radio_sw);
2976
2977static void hotkey_radio_sw_notify_change(void)
2978{
2979 if (tp_features.hotkey_wlsw)
2980 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
2981 "hotkey_radio_sw");
2982}
2983
2984
2985static ssize_t hotkey_tablet_mode_show(struct device *dev,
2986 struct device_attribute *attr,
2987 char *buf)
2988{
2989 int res, s;
2990 res = hotkey_get_tablet_mode(&s);
2991 if (res < 0)
2992 return res;
2993
2994 return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
2995}
2996
2997static DEVICE_ATTR_RO(hotkey_tablet_mode);
2998
2999static void hotkey_tablet_mode_notify_change(void)
3000{
3001 if (tp_features.hotkey_tablet)
3002 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
3003 "hotkey_tablet_mode");
3004}
3005
3006
3007static ssize_t hotkey_wakeup_reason_show(struct device *dev,
3008 struct device_attribute *attr,
3009 char *buf)
3010{
3011 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_wakeup_reason);
3012}
3013
3014static DEVICE_ATTR(wakeup_reason, S_IRUGO, hotkey_wakeup_reason_show, NULL);
3015
3016static void hotkey_wakeup_reason_notify_change(void)
3017{
3018 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
3019 "wakeup_reason");
3020}
3021
3022
3023static ssize_t hotkey_wakeup_hotunplug_complete_show(struct device *dev,
3024 struct device_attribute *attr,
3025 char *buf)
3026{
3027 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_autosleep_ack);
3028}
3029
3030static DEVICE_ATTR(wakeup_hotunplug_complete, S_IRUGO,
3031 hotkey_wakeup_hotunplug_complete_show, NULL);
3032
3033static void hotkey_wakeup_hotunplug_complete_notify_change(void)
3034{
3035 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
3036 "wakeup_hotunplug_complete");
3037}
3038
3039
3040
3041static int adaptive_keyboard_get_mode(void);
3042static int adaptive_keyboard_set_mode(int new_mode);
3043
3044enum ADAPTIVE_KEY_MODE {
3045 HOME_MODE,
3046 WEB_BROWSER_MODE,
3047 WEB_CONFERENCE_MODE,
3048 FUNCTION_MODE,
3049 LAYFLAT_MODE
3050};
3051
3052static ssize_t adaptive_kbd_mode_show(struct device *dev,
3053 struct device_attribute *attr,
3054 char *buf)
3055{
3056 int current_mode;
3057
3058 current_mode = adaptive_keyboard_get_mode();
3059 if (current_mode < 0)
3060 return current_mode;
3061
3062 return snprintf(buf, PAGE_SIZE, "%d\n", current_mode);
3063}
3064
3065static ssize_t adaptive_kbd_mode_store(struct device *dev,
3066 struct device_attribute *attr,
3067 const char *buf, size_t count)
3068{
3069 unsigned long t;
3070 int res;
3071
3072 if (parse_strtoul(buf, LAYFLAT_MODE, &t))
3073 return -EINVAL;
3074
3075 res = adaptive_keyboard_set_mode(t);
3076 return (res < 0) ? res : count;
3077}
3078
3079static DEVICE_ATTR_RW(adaptive_kbd_mode);
3080
3081static struct attribute *adaptive_kbd_attributes[] = {
3082 &dev_attr_adaptive_kbd_mode.attr,
3083 NULL
3084};
3085
3086static const struct attribute_group adaptive_kbd_attr_group = {
3087 .attrs = adaptive_kbd_attributes,
3088};
3089
3090
3091
3092static struct attribute *hotkey_attributes[] __initdata = {
3093 &dev_attr_hotkey_enable.attr,
3094 &dev_attr_hotkey_bios_enabled.attr,
3095 &dev_attr_hotkey_bios_mask.attr,
3096 &dev_attr_wakeup_reason.attr,
3097 &dev_attr_wakeup_hotunplug_complete.attr,
3098 &dev_attr_hotkey_mask.attr,
3099 &dev_attr_hotkey_all_mask.attr,
3100 &dev_attr_hotkey_adaptive_all_mask.attr,
3101 &dev_attr_hotkey_recommended_mask.attr,
3102#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3103 &dev_attr_hotkey_source_mask.attr,
3104 &dev_attr_hotkey_poll_freq.attr,
3105#endif
3106};
3107
3108
3109
3110
3111static void tpacpi_send_radiosw_update(void)
3112{
3113 int wlsw;
3114
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126 wlsw = hotkey_get_wlsw();
3127
3128
3129 if (wlsw == TPACPI_RFK_RADIO_OFF)
3130 tpacpi_rfk_update_hwblock_state(true);
3131
3132
3133 tpacpi_rfk_update_swstate_all();
3134
3135
3136 if (wlsw == TPACPI_RFK_RADIO_ON)
3137 tpacpi_rfk_update_hwblock_state(false);
3138
3139
3140 if (!(wlsw < 0)) {
3141 mutex_lock(&tpacpi_inputdev_send_mutex);
3142
3143 input_report_switch(tpacpi_inputdev,
3144 SW_RFKILL_ALL, (wlsw > 0));
3145 input_sync(tpacpi_inputdev);
3146
3147 mutex_unlock(&tpacpi_inputdev_send_mutex);
3148 }
3149
3150
3151
3152
3153
3154 hotkey_radio_sw_notify_change();
3155}
3156
3157static void hotkey_exit(void)
3158{
3159#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3160 mutex_lock(&hotkey_mutex);
3161 hotkey_poll_stop_sync();
3162 mutex_unlock(&hotkey_mutex);
3163#endif
3164
3165 if (hotkey_dev_attributes)
3166 delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
3167
3168 dbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_HKEY,
3169 "restoring original HKEY status and mask\n");
3170
3171
3172 if (((tp_features.hotkey_mask &&
3173 hotkey_mask_set(hotkey_orig_mask)) |
3174 hotkey_status_set(false)) != 0)
3175 pr_err("failed to restore hot key mask to BIOS defaults\n");
3176}
3177
3178static void __init hotkey_unmap(const unsigned int scancode)
3179{
3180 if (hotkey_keycode_map[scancode] != KEY_RESERVED) {
3181 clear_bit(hotkey_keycode_map[scancode],
3182 tpacpi_inputdev->keybit);
3183 hotkey_keycode_map[scancode] = KEY_RESERVED;
3184 }
3185}
3186
3187
3188
3189
3190
3191
3192#define TPACPI_HK_Q_INIMASK 0x0001
3193
3194static const struct tpacpi_quirk tpacpi_hotkey_qtable[] __initconst = {
3195 TPACPI_Q_IBM('I', 'H', TPACPI_HK_Q_INIMASK),
3196 TPACPI_Q_IBM('I', 'N', TPACPI_HK_Q_INIMASK),
3197 TPACPI_Q_IBM('I', 'D', TPACPI_HK_Q_INIMASK),
3198 TPACPI_Q_IBM('I', 'W', TPACPI_HK_Q_INIMASK),
3199 TPACPI_Q_IBM('I', 'V', TPACPI_HK_Q_INIMASK),
3200 TPACPI_Q_IBM('1', '0', TPACPI_HK_Q_INIMASK),
3201 TPACPI_Q_IBM('K', 'U', TPACPI_HK_Q_INIMASK),
3202 TPACPI_Q_IBM('K', 'X', TPACPI_HK_Q_INIMASK),
3203 TPACPI_Q_IBM('K', 'Y', TPACPI_HK_Q_INIMASK),
3204 TPACPI_Q_IBM('1', 'B', TPACPI_HK_Q_INIMASK),
3205 TPACPI_Q_IBM('1', '3', TPACPI_HK_Q_INIMASK),
3206 TPACPI_Q_IBM('1', 'E', TPACPI_HK_Q_INIMASK),
3207 TPACPI_Q_IBM('1', 'C', TPACPI_HK_Q_INIMASK),
3208 TPACPI_Q_IBM('1', 'F', TPACPI_HK_Q_INIMASK),
3209 TPACPI_Q_IBM('I', 'Y', TPACPI_HK_Q_INIMASK),
3210 TPACPI_Q_IBM('K', 'Z', TPACPI_HK_Q_INIMASK),
3211 TPACPI_Q_IBM('1', '6', TPACPI_HK_Q_INIMASK),
3212 TPACPI_Q_IBM('I', 'Z', TPACPI_HK_Q_INIMASK),
3213 TPACPI_Q_IBM('1', 'D', TPACPI_HK_Q_INIMASK),
3214};
3215
3216typedef u16 tpacpi_keymap_entry_t;
3217typedef tpacpi_keymap_entry_t tpacpi_keymap_t[TPACPI_HOTKEY_MAP_LEN];
3218
3219static int hotkey_init_tablet_mode(void)
3220{
3221 int in_tablet_mode = 0, res;
3222 char *type = NULL;
3223
3224 if (acpi_evalf(hkey_handle, &res, "GMMS", "qdd", 0)) {
3225 int has_tablet_mode;
3226
3227 in_tablet_mode = hotkey_gmms_get_tablet_mode(res,
3228 &has_tablet_mode);
3229
3230
3231
3232
3233
3234
3235
3236 if (has_tablet_mode && !dual_accel_detect())
3237 tp_features.hotkey_tablet = TP_HOTKEY_TABLET_USES_GMMS;
3238 type = "GMMS";
3239 } else if (acpi_evalf(hkey_handle, &res, "MHKG", "qd")) {
3240
3241 tp_features.hotkey_tablet = TP_HOTKEY_TABLET_USES_MHKG;
3242 in_tablet_mode = !!(res & TP_HOTKEY_TABLET_MASK);
3243 type = "MHKG";
3244 }
3245
3246 if (!tp_features.hotkey_tablet)
3247 return 0;
3248
3249 pr_info("Tablet mode switch found (type: %s), currently in %s mode\n",
3250 type, in_tablet_mode ? "tablet" : "laptop");
3251
3252 res = add_to_attr_set(hotkey_dev_attributes,
3253 &dev_attr_hotkey_tablet_mode.attr);
3254 if (res)
3255 return -1;
3256
3257 return in_tablet_mode;
3258}
3259
3260static int __init hotkey_init(struct ibm_init_struct *iibm)
3261{
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292 enum keymap_index {
3293 TPACPI_KEYMAP_IBM_GENERIC = 0,
3294 TPACPI_KEYMAP_LENOVO_GENERIC,
3295 };
3296
3297 static const tpacpi_keymap_t tpacpi_keymaps[] __initconst = {
3298
3299 [TPACPI_KEYMAP_IBM_GENERIC] = {
3300
3301 KEY_FN_F1, KEY_BATTERY, KEY_COFFEE, KEY_SLEEP,
3302 KEY_WLAN, KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
3303 KEY_FN_F9, KEY_FN_F10, KEY_FN_F11, KEY_SUSPEND,
3304
3305
3306 KEY_UNKNOWN,
3307 KEY_UNKNOWN,
3308 KEY_UNKNOWN,
3309
3310
3311 KEY_RESERVED,
3312 KEY_RESERVED,
3313
3314
3315 KEY_RESERVED,
3316
3317 KEY_UNKNOWN,
3318 KEY_ZOOM,
3319
3320
3321
3322
3323 KEY_RESERVED,
3324 KEY_RESERVED,
3325 KEY_RESERVED,
3326
3327 KEY_VENDOR,
3328
3329
3330 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3331 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3332
3333
3334 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3335 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3336 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3337 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3338 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3339
3340
3341 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3342 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3343 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3344 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3345 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3346 KEY_UNKNOWN, KEY_UNKNOWN
3347
3348 },
3349
3350
3351 [TPACPI_KEYMAP_LENOVO_GENERIC] = {
3352
3353 KEY_FN_F1, KEY_COFFEE, KEY_BATTERY, KEY_SLEEP,
3354 KEY_WLAN, KEY_CAMERA, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
3355 KEY_FN_F9, KEY_FN_F10, KEY_FN_F11, KEY_SUSPEND,
3356
3357
3358 KEY_UNKNOWN,
3359 KEY_UNKNOWN,
3360 KEY_UNKNOWN,
3361
3362
3363
3364
3365 KEY_BRIGHTNESSUP,
3366 KEY_BRIGHTNESSDOWN,
3367
3368 KEY_RESERVED,
3369
3370 KEY_UNKNOWN,
3371 KEY_ZOOM,
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384 KEY_RESERVED,
3385 KEY_RESERVED,
3386 KEY_RESERVED,
3387
3388 KEY_VENDOR,
3389
3390
3391 KEY_UNKNOWN, KEY_UNKNOWN,
3392
3393
3394
3395
3396
3397 KEY_MICMUTE,
3398
3399
3400 KEY_UNKNOWN,
3401
3402
3403 KEY_CONFIG, KEY_SEARCH, KEY_SCALE, KEY_FILE,
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413 KEY_RESERVED,
3414 KEY_BRIGHTNESS_MIN,
3415 KEY_RESERVED,
3416 KEY_RESERVED,
3417 KEY_RESERVED,
3418 KEY_VOICECOMMAND,
3419 KEY_RESERVED,
3420 KEY_RESERVED,
3421 KEY_RESERVED,
3422 KEY_RESERVED,
3423 KEY_RESERVED,
3424 KEY_CONFIG,
3425 KEY_RESERVED,
3426 KEY_REFRESH,
3427 KEY_BACK,
3428 KEY_RESERVED,
3429 KEY_RESERVED,
3430 KEY_RESERVED,
3431 KEY_RESERVED,
3432 KEY_RESERVED,
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3446 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3447 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3448 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3449 KEY_UNKNOWN,
3450
3451 KEY_BOOKMARKS,
3452 KEY_SELECTIVE_SCREENSHOT,
3453 KEY_CALC,
3454 KEY_BLUETOOTH,
3455 KEY_KEYBOARD,
3456 KEY_FN_RIGHT_SHIFT,
3457 KEY_NOTIFICATION_CENTER,
3458 KEY_PICKUP_PHONE,
3459 KEY_HANGUP_PHONE,
3460 },
3461 };
3462
3463 static const struct tpacpi_quirk tpacpi_keymap_qtable[] __initconst = {
3464
3465 {
3466 .vendor = PCI_VENDOR_ID_IBM,
3467 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
3468 .quirks = TPACPI_KEYMAP_IBM_GENERIC,
3469 },
3470 {
3471 .vendor = PCI_VENDOR_ID_LENOVO,
3472 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
3473 .quirks = TPACPI_KEYMAP_LENOVO_GENERIC,
3474 },
3475 };
3476
3477#define TPACPI_HOTKEY_MAP_SIZE sizeof(tpacpi_keymap_t)
3478#define TPACPI_HOTKEY_MAP_TYPESIZE sizeof(tpacpi_keymap_entry_t)
3479
3480 int res, i;
3481 int status;
3482 int hkeyv;
3483 bool radiosw_state = false;
3484 bool tabletsw_state = false;
3485
3486 unsigned long quirks;
3487 unsigned long keymap_id;
3488
3489 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3490 "initializing hotkey subdriver\n");
3491
3492 BUG_ON(!tpacpi_inputdev);
3493 BUG_ON(tpacpi_inputdev->open != NULL ||
3494 tpacpi_inputdev->close != NULL);
3495
3496 TPACPI_ACPIHANDLE_INIT(hkey);
3497 mutex_init(&hotkey_mutex);
3498
3499#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3500 mutex_init(&hotkey_thread_data_mutex);
3501#endif
3502
3503
3504 tp_features.hotkey = hkey_handle != NULL;
3505
3506 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3507 "hotkeys are %s\n",
3508 str_supported(tp_features.hotkey));
3509
3510 if (!tp_features.hotkey)
3511 return 1;
3512
3513 quirks = tpacpi_check_quirks(tpacpi_hotkey_qtable,
3514 ARRAY_SIZE(tpacpi_hotkey_qtable));
3515
3516 tpacpi_disable_brightness_delay();
3517
3518
3519
3520 hotkey_dev_attributes = create_attr_set(
3521 ARRAY_SIZE(hotkey_attributes) + 2,
3522 NULL);
3523 if (!hotkey_dev_attributes)
3524 return -ENOMEM;
3525 res = add_many_to_attr_set(hotkey_dev_attributes,
3526 hotkey_attributes,
3527 ARRAY_SIZE(hotkey_attributes));
3528 if (res)
3529 goto err_exit;
3530
3531
3532
3533
3534 if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) {
3535 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3536 "firmware HKEY interface version: 0x%x\n",
3537 hkeyv);
3538
3539 switch (hkeyv >> 8) {
3540 case 1:
3541
3542
3543
3544
3545
3546
3547 if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
3548 "MHKA", "qd")) {
3549 pr_err("missing MHKA handler, please report this to %s\n",
3550 TPACPI_MAIL);
3551
3552 hotkey_all_mask = 0x080cU;
3553 } else {
3554 tp_features.hotkey_mask = 1;
3555 }
3556 break;
3557
3558 case 2:
3559
3560
3561
3562
3563
3564 if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
3565 "MHKA", "dd", 1)) {
3566 pr_err("missing MHKA handler, please report this to %s\n",
3567 TPACPI_MAIL);
3568
3569 hotkey_all_mask = 0x080cU;
3570 } else {
3571 tp_features.hotkey_mask = 1;
3572 }
3573
3574
3575
3576
3577
3578 if (acpi_evalf(hkey_handle, &hotkey_adaptive_all_mask,
3579 "MHKA", "dd", 2)) {
3580 if (hotkey_adaptive_all_mask != 0) {
3581 tp_features.has_adaptive_kbd = true;
3582 res = sysfs_create_group(
3583 &tpacpi_pdev->dev.kobj,
3584 &adaptive_kbd_attr_group);
3585 if (res)
3586 goto err_exit;
3587 }
3588 } else {
3589 tp_features.has_adaptive_kbd = false;
3590 hotkey_adaptive_all_mask = 0x0U;
3591 }
3592 break;
3593
3594 default:
3595 pr_err("unknown version of the HKEY interface: 0x%x\n",
3596 hkeyv);
3597 pr_err("please report this to %s\n", TPACPI_MAIL);
3598 break;
3599 }
3600 }
3601
3602 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3603 "hotkey masks are %s\n",
3604 str_supported(tp_features.hotkey_mask));
3605
3606
3607 if (!tp_features.hotkey_mask && !hotkey_all_mask &&
3608 (quirks & TPACPI_HK_Q_INIMASK))
3609 hotkey_all_mask = 0x080cU;
3610
3611
3612 if (tp_features.hotkey_mask) {
3613
3614
3615 res = hotkey_mask_get();
3616 if (res)
3617 goto err_exit;
3618
3619 hotkey_orig_mask = hotkey_acpi_mask;
3620 } else {
3621 hotkey_orig_mask = hotkey_all_mask;
3622 hotkey_acpi_mask = hotkey_all_mask;
3623 }
3624
3625#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
3626 if (dbg_wlswemul) {
3627 tp_features.hotkey_wlsw = 1;
3628 radiosw_state = !!tpacpi_wlsw_emulstate;
3629 pr_info("radio switch emulation enabled\n");
3630 } else
3631#endif
3632
3633 if (acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
3634 tp_features.hotkey_wlsw = 1;
3635 radiosw_state = !!status;
3636 pr_info("radio switch found; radios are %s\n",
3637 enabled(status, 0));
3638 }
3639 if (tp_features.hotkey_wlsw)
3640 res = add_to_attr_set(hotkey_dev_attributes,
3641 &dev_attr_hotkey_radio_sw.attr);
3642
3643 res = hotkey_init_tablet_mode();
3644 if (res < 0)
3645 goto err_exit;
3646
3647 tabletsw_state = res;
3648
3649 res = register_attr_set_with_sysfs(hotkey_dev_attributes,
3650 &tpacpi_pdev->dev.kobj);
3651 if (res)
3652 goto err_exit;
3653
3654
3655 keymap_id = tpacpi_check_quirks(tpacpi_keymap_qtable,
3656 ARRAY_SIZE(tpacpi_keymap_qtable));
3657 BUG_ON(keymap_id >= ARRAY_SIZE(tpacpi_keymaps));
3658 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3659 "using keymap number %lu\n", keymap_id);
3660
3661 hotkey_keycode_map = kmemdup(&tpacpi_keymaps[keymap_id],
3662 TPACPI_HOTKEY_MAP_SIZE, GFP_KERNEL);
3663 if (!hotkey_keycode_map) {
3664 pr_err("failed to allocate memory for key map\n");
3665 res = -ENOMEM;
3666 goto err_exit;
3667 }
3668
3669 input_set_capability(tpacpi_inputdev, EV_MSC, MSC_SCAN);
3670 tpacpi_inputdev->keycodesize = TPACPI_HOTKEY_MAP_TYPESIZE;
3671 tpacpi_inputdev->keycodemax = TPACPI_HOTKEY_MAP_LEN;
3672 tpacpi_inputdev->keycode = hotkey_keycode_map;
3673 for (i = 0; i < TPACPI_HOTKEY_MAP_LEN; i++) {
3674 if (hotkey_keycode_map[i] != KEY_RESERVED) {
3675 input_set_capability(tpacpi_inputdev, EV_KEY,
3676 hotkey_keycode_map[i]);
3677 } else {
3678 if (i < sizeof(hotkey_reserved_mask)*8)
3679 hotkey_reserved_mask |= 1 << i;
3680 }
3681 }
3682
3683 if (tp_features.hotkey_wlsw) {
3684 input_set_capability(tpacpi_inputdev, EV_SW, SW_RFKILL_ALL);
3685 input_report_switch(tpacpi_inputdev,
3686 SW_RFKILL_ALL, radiosw_state);
3687 }
3688 if (tp_features.hotkey_tablet) {
3689 input_set_capability(tpacpi_inputdev, EV_SW, SW_TABLET_MODE);
3690 input_report_switch(tpacpi_inputdev,
3691 SW_TABLET_MODE, tabletsw_state);
3692 }
3693
3694
3695
3696
3697 if (acpi_video_get_backlight_type() != acpi_backlight_vendor) {
3698 pr_info("This ThinkPad has standard ACPI backlight brightness control, supported by the ACPI video driver\n");
3699 pr_notice("Disabling thinkpad-acpi brightness events by default...\n");
3700
3701
3702
3703
3704 hotkey_reserved_mask |=
3705 (1 << TP_ACPI_HOTKEYSCAN_FNHOME)
3706 | (1 << TP_ACPI_HOTKEYSCAN_FNEND);
3707 hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNHOME);
3708 hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNEND);
3709 }
3710
3711#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3712 hotkey_source_mask = TPACPI_HKEY_NVRAM_GOOD_MASK
3713 & ~hotkey_all_mask
3714 & ~hotkey_reserved_mask;
3715
3716 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3717 "hotkey source mask 0x%08x, polling freq %u\n",
3718 hotkey_source_mask, hotkey_poll_freq);
3719#endif
3720
3721 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3722 "enabling firmware HKEY event interface...\n");
3723 res = hotkey_status_set(true);
3724 if (res) {
3725 hotkey_exit();
3726 return res;
3727 }
3728 res = hotkey_mask_set(((hotkey_all_mask & ~hotkey_reserved_mask)
3729 | hotkey_driver_mask)
3730 & ~hotkey_source_mask);
3731 if (res < 0 && res != -ENXIO) {
3732 hotkey_exit();
3733 return res;
3734 }
3735 hotkey_user_mask = (hotkey_acpi_mask | hotkey_source_mask)
3736 & ~hotkey_reserved_mask;
3737 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3738 "initial masks: user=0x%08x, fw=0x%08x, poll=0x%08x\n",
3739 hotkey_user_mask, hotkey_acpi_mask, hotkey_source_mask);
3740
3741 tpacpi_inputdev->open = &hotkey_inputdev_open;
3742 tpacpi_inputdev->close = &hotkey_inputdev_close;
3743
3744 hotkey_poll_setup_safe(true);
3745
3746 return 0;
3747
3748err_exit:
3749 delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
3750 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
3751 &adaptive_kbd_attr_group);
3752
3753 hotkey_dev_attributes = NULL;
3754
3755 return (res < 0) ? res : 1;
3756}
3757
3758
3759
3760
3761
3762
3763
3764
3765static const int adaptive_keyboard_modes[] = {
3766 HOME_MODE,
3767
3768
3769 FUNCTION_MODE
3770};
3771
3772#define DFR_CHANGE_ROW 0x101
3773#define DFR_SHOW_QUICKVIEW_ROW 0x102
3774#define FIRST_ADAPTIVE_KEY 0x103
3775
3776
3777
3778
3779static bool adaptive_keyboard_mode_is_saved;
3780static int adaptive_keyboard_prev_mode;
3781
3782static int adaptive_keyboard_get_mode(void)
3783{
3784 int mode = 0;
3785
3786 if (!acpi_evalf(hkey_handle, &mode, "GTRW", "dd", 0)) {
3787 pr_err("Cannot read adaptive keyboard mode\n");
3788 return -EIO;
3789 }
3790
3791 return mode;
3792}
3793
3794static int adaptive_keyboard_set_mode(int new_mode)
3795{
3796 if (new_mode < 0 ||
3797 new_mode > LAYFLAT_MODE)
3798 return -EINVAL;
3799
3800 if (!acpi_evalf(hkey_handle, NULL, "STRW", "vd", new_mode)) {
3801 pr_err("Cannot set adaptive keyboard mode\n");
3802 return -EIO;
3803 }
3804
3805 return 0;
3806}
3807
3808static int adaptive_keyboard_get_next_mode(int mode)
3809{
3810 size_t i;
3811 size_t max_mode = ARRAY_SIZE(adaptive_keyboard_modes) - 1;
3812
3813 for (i = 0; i <= max_mode; i++) {
3814 if (adaptive_keyboard_modes[i] == mode)
3815 break;
3816 }
3817
3818 if (i >= max_mode)
3819 i = 0;
3820 else
3821 i++;
3822
3823 return adaptive_keyboard_modes[i];
3824}
3825
3826static bool adaptive_keyboard_hotkey_notify_hotkey(unsigned int scancode)
3827{
3828 int current_mode = 0;
3829 int new_mode = 0;
3830 int keycode;
3831
3832 switch (scancode) {
3833 case DFR_CHANGE_ROW:
3834 if (adaptive_keyboard_mode_is_saved) {
3835 new_mode = adaptive_keyboard_prev_mode;
3836 adaptive_keyboard_mode_is_saved = false;
3837 } else {
3838 current_mode = adaptive_keyboard_get_mode();
3839 if (current_mode < 0)
3840 return false;
3841 new_mode = adaptive_keyboard_get_next_mode(
3842 current_mode);
3843 }
3844
3845 if (adaptive_keyboard_set_mode(new_mode) < 0)
3846 return false;
3847
3848 return true;
3849
3850 case DFR_SHOW_QUICKVIEW_ROW:
3851 current_mode = adaptive_keyboard_get_mode();
3852 if (current_mode < 0)
3853 return false;
3854
3855 adaptive_keyboard_prev_mode = current_mode;
3856 adaptive_keyboard_mode_is_saved = true;
3857
3858 if (adaptive_keyboard_set_mode (FUNCTION_MODE) < 0)
3859 return false;
3860 return true;
3861
3862 default:
3863 if (scancode < FIRST_ADAPTIVE_KEY ||
3864 scancode >= FIRST_ADAPTIVE_KEY +
3865 TP_ACPI_HOTKEYSCAN_EXTENDED_START -
3866 TP_ACPI_HOTKEYSCAN_ADAPTIVE_START) {
3867 pr_info("Unhandled adaptive keyboard key: 0x%x\n",
3868 scancode);
3869 return false;
3870 }
3871 keycode = hotkey_keycode_map[scancode - FIRST_ADAPTIVE_KEY +
3872 TP_ACPI_HOTKEYSCAN_ADAPTIVE_START];
3873 if (keycode != KEY_RESERVED) {
3874 mutex_lock(&tpacpi_inputdev_send_mutex);
3875
3876 input_report_key(tpacpi_inputdev, keycode, 1);
3877 input_sync(tpacpi_inputdev);
3878
3879 input_report_key(tpacpi_inputdev, keycode, 0);
3880 input_sync(tpacpi_inputdev);
3881
3882 mutex_unlock(&tpacpi_inputdev_send_mutex);
3883 }
3884 return true;
3885 }
3886}
3887
3888static bool hotkey_notify_hotkey(const u32 hkey,
3889 bool *send_acpi_ev,
3890 bool *ignore_acpi_ev)
3891{
3892
3893 unsigned int scancode = hkey & 0xfff;
3894 *send_acpi_ev = true;
3895 *ignore_acpi_ev = false;
3896
3897
3898
3899
3900
3901
3902 switch ((hkey >> 8) & 0xf) {
3903 case 0:
3904 if (scancode > 0 &&
3905 scancode <= TP_ACPI_HOTKEYSCAN_ADAPTIVE_START) {
3906
3907 scancode--;
3908 if (!(hotkey_source_mask & (1 << scancode))) {
3909 tpacpi_input_send_key_masked(scancode);
3910 *send_acpi_ev = false;
3911 } else {
3912 *ignore_acpi_ev = true;
3913 }
3914 return true;
3915 }
3916 break;
3917
3918 case 1:
3919 return adaptive_keyboard_hotkey_notify_hotkey(scancode);
3920
3921 case 3:
3922
3923
3924
3925
3926 scancode -= (0x300 - TP_ACPI_HOTKEYSCAN_EXTENDED_START);
3927 if (scancode >= TP_ACPI_HOTKEYSCAN_EXTENDED_START &&
3928 scancode < TPACPI_HOTKEY_MAP_LEN) {
3929 tpacpi_input_send_key(scancode);
3930 return true;
3931 }
3932 break;
3933 }
3934
3935 return false;
3936}
3937
3938static bool hotkey_notify_wakeup(const u32 hkey,
3939 bool *send_acpi_ev,
3940 bool *ignore_acpi_ev)
3941{
3942
3943 *send_acpi_ev = true;
3944 *ignore_acpi_ev = false;
3945
3946 switch (hkey) {
3947 case TP_HKEY_EV_WKUP_S3_UNDOCK:
3948 case TP_HKEY_EV_WKUP_S4_UNDOCK:
3949 hotkey_wakeup_reason = TP_ACPI_WAKEUP_UNDOCK;
3950 *ignore_acpi_ev = true;
3951 break;
3952
3953 case TP_HKEY_EV_WKUP_S3_BAYEJ:
3954 case TP_HKEY_EV_WKUP_S4_BAYEJ:
3955 hotkey_wakeup_reason = TP_ACPI_WAKEUP_BAYEJ;
3956 *ignore_acpi_ev = true;
3957 break;
3958
3959 case TP_HKEY_EV_WKUP_S3_BATLOW:
3960 case TP_HKEY_EV_WKUP_S4_BATLOW:
3961 pr_alert("EMERGENCY WAKEUP: battery almost empty\n");
3962
3963
3964
3965 break;
3966
3967 default:
3968 return false;
3969 }
3970
3971 if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
3972 pr_info("woke up due to a hot-unplug request...\n");
3973 hotkey_wakeup_reason_notify_change();
3974 }
3975 return true;
3976}
3977
3978static bool hotkey_notify_dockevent(const u32 hkey,
3979 bool *send_acpi_ev,
3980 bool *ignore_acpi_ev)
3981{
3982
3983 *send_acpi_ev = true;
3984 *ignore_acpi_ev = false;
3985
3986 switch (hkey) {
3987 case TP_HKEY_EV_UNDOCK_ACK:
3988
3989 hotkey_autosleep_ack = 1;
3990 pr_info("undocked\n");
3991 hotkey_wakeup_hotunplug_complete_notify_change();
3992 return true;
3993
3994 case TP_HKEY_EV_HOTPLUG_DOCK:
3995 pr_info("docked into hotplug port replicator\n");
3996 return true;
3997 case TP_HKEY_EV_HOTPLUG_UNDOCK:
3998 pr_info("undocked from hotplug port replicator\n");
3999 return true;
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012 case TP_HKEY_EV_KBD_COVER_ATTACH:
4013 case TP_HKEY_EV_KBD_COVER_DETACH:
4014 *send_acpi_ev = false;
4015 *ignore_acpi_ev = true;
4016 return true;
4017
4018 default:
4019 return false;
4020 }
4021}
4022
4023static bool hotkey_notify_usrevent(const u32 hkey,
4024 bool *send_acpi_ev,
4025 bool *ignore_acpi_ev)
4026{
4027
4028 *send_acpi_ev = true;
4029 *ignore_acpi_ev = false;
4030
4031 switch (hkey) {
4032 case TP_HKEY_EV_PEN_INSERTED:
4033 case TP_HKEY_EV_PEN_REMOVED:
4034 return true;
4035
4036 case TP_HKEY_EV_TABLET_TABLET:
4037 case TP_HKEY_EV_TABLET_NOTEBOOK:
4038 tpacpi_input_send_tabletsw();
4039 hotkey_tablet_mode_notify_change();
4040 *send_acpi_ev = false;
4041 return true;
4042
4043 case TP_HKEY_EV_LID_CLOSE:
4044 case TP_HKEY_EV_LID_OPEN:
4045 case TP_HKEY_EV_BRGHT_CHANGED:
4046
4047 *ignore_acpi_ev = true;
4048 return true;
4049
4050 default:
4051 return false;
4052 }
4053}
4054
4055static void thermal_dump_all_sensors(void);
4056static void palmsensor_refresh(void);
4057
4058static bool hotkey_notify_6xxx(const u32 hkey,
4059 bool *send_acpi_ev,
4060 bool *ignore_acpi_ev)
4061{
4062
4063 *send_acpi_ev = true;
4064 *ignore_acpi_ev = false;
4065
4066 switch (hkey) {
4067 case TP_HKEY_EV_THM_TABLE_CHANGED:
4068 pr_debug("EC reports: Thermal Table has changed\n");
4069
4070
4071 return true;
4072 case TP_HKEY_EV_THM_CSM_COMPLETED:
4073 pr_debug("EC reports: Thermal Control Command set completed (DYTC)\n");
4074
4075 tpacpi_driver_event(hkey);
4076 return true;
4077 case TP_HKEY_EV_THM_TRANSFM_CHANGED:
4078 pr_debug("EC reports: Thermal Transformation changed (GMTS)\n");
4079
4080
4081 return true;
4082 case TP_HKEY_EV_ALARM_BAT_HOT:
4083 pr_crit("THERMAL ALARM: battery is too hot!\n");
4084
4085 break;
4086 case TP_HKEY_EV_ALARM_BAT_XHOT:
4087 pr_alert("THERMAL EMERGENCY: battery is extremely hot!\n");
4088
4089 break;
4090 case TP_HKEY_EV_ALARM_SENSOR_HOT:
4091 pr_crit("THERMAL ALARM: a sensor reports something is too hot!\n");
4092
4093
4094 break;
4095 case TP_HKEY_EV_ALARM_SENSOR_XHOT:
4096 pr_alert("THERMAL EMERGENCY: a sensor reports something is extremely hot!\n");
4097
4098 break;
4099 case TP_HKEY_EV_AC_CHANGED:
4100
4101
4102
4103
4104 fallthrough;
4105
4106 case TP_HKEY_EV_KEY_NUMLOCK:
4107 case TP_HKEY_EV_KEY_FN:
4108
4109
4110 *send_acpi_ev = false;
4111 *ignore_acpi_ev = true;
4112 return true;
4113
4114 case TP_HKEY_EV_KEY_FN_ESC:
4115
4116 acpi_evalf(hkey_handle, NULL, "GMKS", "v");
4117 *send_acpi_ev = false;
4118 *ignore_acpi_ev = true;
4119 return true;
4120
4121 case TP_HKEY_EV_TABLET_CHANGED:
4122 tpacpi_input_send_tabletsw();
4123 hotkey_tablet_mode_notify_change();
4124 *send_acpi_ev = false;
4125 return true;
4126
4127 case TP_HKEY_EV_PALM_DETECTED:
4128 case TP_HKEY_EV_PALM_UNDETECTED:
4129
4130 palmsensor_refresh();
4131 return true;
4132
4133 default:
4134
4135 return false;
4136 }
4137
4138 thermal_dump_all_sensors();
4139 return true;
4140}
4141
4142static void hotkey_notify(struct ibm_struct *ibm, u32 event)
4143{
4144 u32 hkey;
4145 bool send_acpi_ev;
4146 bool ignore_acpi_ev;
4147 bool known_ev;
4148
4149 if (event != 0x80) {
4150 pr_err("unknown HKEY notification event %d\n", event);
4151
4152 acpi_bus_generate_netlink_event(
4153 ibm->acpi->device->pnp.device_class,
4154 dev_name(&ibm->acpi->device->dev),
4155 event, 0);
4156 return;
4157 }
4158
4159 while (1) {
4160 if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
4161 pr_err("failed to retrieve HKEY event\n");
4162 return;
4163 }
4164
4165 if (hkey == 0) {
4166
4167 return;
4168 }
4169
4170 send_acpi_ev = true;
4171 ignore_acpi_ev = false;
4172
4173 switch (hkey >> 12) {
4174 case 1:
4175
4176 known_ev = hotkey_notify_hotkey(hkey, &send_acpi_ev,
4177 &ignore_acpi_ev);
4178 break;
4179 case 2:
4180
4181 known_ev = hotkey_notify_wakeup(hkey, &send_acpi_ev,
4182 &ignore_acpi_ev);
4183 break;
4184 case 3:
4185
4186 switch (hkey) {
4187 case TP_HKEY_EV_BAYEJ_ACK:
4188 hotkey_autosleep_ack = 1;
4189 pr_info("bay ejected\n");
4190 hotkey_wakeup_hotunplug_complete_notify_change();
4191 known_ev = true;
4192 break;
4193 case TP_HKEY_EV_OPTDRV_EJ:
4194
4195 known_ev = true;
4196 break;
4197 default:
4198 known_ev = false;
4199 }
4200 break;
4201 case 4:
4202
4203 known_ev = hotkey_notify_dockevent(hkey, &send_acpi_ev,
4204 &ignore_acpi_ev);
4205 break;
4206 case 5:
4207
4208 known_ev = hotkey_notify_usrevent(hkey, &send_acpi_ev,
4209 &ignore_acpi_ev);
4210 break;
4211 case 6:
4212
4213
4214 known_ev = hotkey_notify_6xxx(hkey, &send_acpi_ev,
4215 &ignore_acpi_ev);
4216 break;
4217 case 7:
4218
4219 if (tp_features.hotkey_wlsw &&
4220 hkey == TP_HKEY_EV_RFKILL_CHANGED) {
4221 tpacpi_send_radiosw_update();
4222 send_acpi_ev = 0;
4223 known_ev = true;
4224 break;
4225 }
4226 fallthrough;
4227 default:
4228 known_ev = false;
4229 }
4230 if (!known_ev) {
4231 pr_notice("unhandled HKEY event 0x%04x\n", hkey);
4232 pr_notice("please report the conditions when this event happened to %s\n",
4233 TPACPI_MAIL);
4234 }
4235
4236
4237 if (!ignore_acpi_ev && send_acpi_ev) {
4238 acpi_bus_generate_netlink_event(
4239 ibm->acpi->device->pnp.device_class,
4240 dev_name(&ibm->acpi->device->dev),
4241 event, hkey);
4242 }
4243 }
4244}
4245
4246static void hotkey_suspend(void)
4247{
4248
4249 hotkey_wakeup_reason = TP_ACPI_WAKEUP_NONE;
4250 hotkey_autosleep_ack = 0;
4251
4252
4253 if (tp_features.has_adaptive_kbd) {
4254 if (!acpi_evalf(hkey_handle, &adaptive_keyboard_prev_mode,
4255 "GTRW", "dd", 0)) {
4256 pr_err("Cannot read adaptive keyboard mode.\n");
4257 }
4258 }
4259}
4260
4261static void hotkey_resume(void)
4262{
4263 tpacpi_disable_brightness_delay();
4264
4265 if (hotkey_status_set(true) < 0 ||
4266 hotkey_mask_set(hotkey_acpi_mask) < 0)
4267 pr_err("error while attempting to reset the event firmware interface\n");
4268
4269 tpacpi_send_radiosw_update();
4270 tpacpi_input_send_tabletsw();
4271 hotkey_tablet_mode_notify_change();
4272 hotkey_wakeup_reason_notify_change();
4273 hotkey_wakeup_hotunplug_complete_notify_change();
4274 hotkey_poll_setup_safe(false);
4275
4276
4277 if (tp_features.has_adaptive_kbd) {
4278 if (!acpi_evalf(hkey_handle, NULL, "STRW", "vd",
4279 adaptive_keyboard_prev_mode)) {
4280 pr_err("Cannot set adaptive keyboard mode.\n");
4281 }
4282 }
4283}
4284
4285
4286static int hotkey_read(struct seq_file *m)
4287{
4288 int res, status;
4289
4290 if (!tp_features.hotkey) {
4291 seq_printf(m, "status:\t\tnot supported\n");
4292 return 0;
4293 }
4294
4295 if (mutex_lock_killable(&hotkey_mutex))
4296 return -ERESTARTSYS;
4297 res = hotkey_status_get(&status);
4298 if (!res)
4299 res = hotkey_mask_get();
4300 mutex_unlock(&hotkey_mutex);
4301 if (res)
4302 return res;
4303
4304 seq_printf(m, "status:\t\t%s\n", enabled(status, 0));
4305 if (hotkey_all_mask) {
4306 seq_printf(m, "mask:\t\t0x%08x\n", hotkey_user_mask);
4307 seq_printf(m, "commands:\tenable, disable, reset, <mask>\n");
4308 } else {
4309 seq_printf(m, "mask:\t\tnot supported\n");
4310 seq_printf(m, "commands:\tenable, disable, reset\n");
4311 }
4312
4313 return 0;
4314}
4315
4316static void hotkey_enabledisable_warn(bool enable)
4317{
4318 tpacpi_log_usertask("procfs hotkey enable/disable");
4319 if (!WARN((tpacpi_lifecycle == TPACPI_LIFE_RUNNING || !enable),
4320 pr_fmt("hotkey enable/disable functionality has been removed from the driver. Hotkeys are always enabled.\n")))
4321 pr_err("Please remove the hotkey=enable module parameter, it is deprecated. Hotkeys are always enabled.\n");
4322}
4323
4324static int hotkey_write(char *buf)
4325{
4326 int res;
4327 u32 mask;
4328 char *cmd;
4329
4330 if (!tp_features.hotkey)
4331 return -ENODEV;
4332
4333 if (mutex_lock_killable(&hotkey_mutex))
4334 return -ERESTARTSYS;
4335
4336 mask = hotkey_user_mask;
4337
4338 res = 0;
4339 while ((cmd = strsep(&buf, ","))) {
4340 if (strlencmp(cmd, "enable") == 0) {
4341 hotkey_enabledisable_warn(1);
4342 } else if (strlencmp(cmd, "disable") == 0) {
4343 hotkey_enabledisable_warn(0);
4344 res = -EPERM;
4345 } else if (strlencmp(cmd, "reset") == 0) {
4346 mask = (hotkey_all_mask | hotkey_source_mask)
4347 & ~hotkey_reserved_mask;
4348 } else if (sscanf(cmd, "0x%x", &mask) == 1) {
4349
4350 } else if (sscanf(cmd, "%x", &mask) == 1) {
4351
4352 } else {
4353 res = -EINVAL;
4354 goto errexit;
4355 }
4356 }
4357
4358 if (!res) {
4359 tpacpi_disclose_usertask("procfs hotkey",
4360 "set mask to 0x%08x\n", mask);
4361 res = hotkey_user_mask_set(mask);
4362 }
4363
4364errexit:
4365 mutex_unlock(&hotkey_mutex);
4366 return res;
4367}
4368
4369static const struct acpi_device_id ibm_htk_device_ids[] = {
4370 {TPACPI_ACPI_IBM_HKEY_HID, 0},
4371 {TPACPI_ACPI_LENOVO_HKEY_HID, 0},
4372 {TPACPI_ACPI_LENOVO_HKEY_V2_HID, 0},
4373 {"", 0},
4374};
4375
4376static struct tp_acpi_drv_struct ibm_hotkey_acpidriver = {
4377 .hid = ibm_htk_device_ids,
4378 .notify = hotkey_notify,
4379 .handle = &hkey_handle,
4380 .type = ACPI_DEVICE_NOTIFY,
4381};
4382
4383static struct ibm_struct hotkey_driver_data = {
4384 .name = "hotkey",
4385 .read = hotkey_read,
4386 .write = hotkey_write,
4387 .exit = hotkey_exit,
4388 .resume = hotkey_resume,
4389 .suspend = hotkey_suspend,
4390 .acpi = &ibm_hotkey_acpidriver,
4391};
4392
4393
4394
4395
4396
4397enum {
4398
4399 TP_ACPI_BLUETOOTH_HWPRESENT = 0x01,
4400 TP_ACPI_BLUETOOTH_RADIOSSW = 0x02,
4401 TP_ACPI_BLUETOOTH_RESUMECTRL = 0x04,
4402
4403};
4404
4405enum {
4406
4407 TP_ACPI_BLTH_GET_ULTRAPORT_ID = 0x00,
4408 TP_ACPI_BLTH_GET_PWR_ON_RESUME = 0x01,
4409 TP_ACPI_BLTH_PWR_ON_ON_RESUME = 0x02,
4410 TP_ACPI_BLTH_PWR_OFF_ON_RESUME = 0x03,
4411 TP_ACPI_BLTH_SAVE_STATE = 0x05,
4412};
4413
4414#define TPACPI_RFK_BLUETOOTH_SW_NAME "tpacpi_bluetooth_sw"
4415
4416static int bluetooth_get_status(void)
4417{
4418 int status;
4419
4420#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4421 if (dbg_bluetoothemul)
4422 return (tpacpi_bluetooth_emulstate) ?
4423 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4424#endif
4425
4426 if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
4427 return -EIO;
4428
4429 return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0) ?
