1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * thinkpad_acpi.c - ThinkPad ACPI Extras
5 * Copyright (C) 2004-2005 Borislav Deianov <borislav@users.sf.net>
6 * Copyright (C) 2006-2009 Henrique de Moraes Holschuh <hmh@hmh.eng.br>
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #define TPACPI_VERSION "0.26"
12 #define TPACPI_SYSFS_VERSION 0x030000
16 * 2007-10-20 changelog trimmed down
18 * 2007-03-27 0.14 renamed to thinkpad_acpi and moved to
21 * 2006-11-22 0.13 new maintainer
22 * changelog now lives in git commit history, and will
23 * not be updated further in-file.
25 * 2005-03-17 0.11 support for 600e, 770x
26 * thanks to Jamie Lentin <lentinj@dial.pipex.com>
28 * 2005-01-16 0.9 use MODULE_VERSION
29 * thanks to Henrik Brix Andersen <brix@gentoo.org>
30 * fix parameter passing on module loading
31 * thanks to Rusty Russell <rusty@rustcorp.com.au>
32 * thanks to Jim Radford <radford@blackbean.org>
33 * 2004-11-08 0.8 fix init error case, don't return from a macro
34 * thanks to Chris Wright <chrisw@osdl.org>
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>
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 <sound/core.h>
70 #include <sound/control.h>
71 #include <sound/initval.h>
72 #include <linux/uaccess.h>
73 #include <acpi/battery.h>
74 #include <acpi/video.h>
76 /* ThinkPad CMOS commands */
77 #define TP_CMOS_VOLUME_DOWN 0
78 #define TP_CMOS_VOLUME_UP 1
79 #define TP_CMOS_VOLUME_MUTE 2
80 #define TP_CMOS_BRIGHTNESS_UP 4
81 #define TP_CMOS_BRIGHTNESS_DOWN 5
82 #define TP_CMOS_THINKLIGHT_ON 12
83 #define TP_CMOS_THINKLIGHT_OFF 13
87 TP_NVRAM_ADDR_HK2
= 0x57,
88 TP_NVRAM_ADDR_THINKLIGHT
= 0x58,
89 TP_NVRAM_ADDR_VIDEO
= 0x59,
90 TP_NVRAM_ADDR_BRIGHTNESS
= 0x5e,
91 TP_NVRAM_ADDR_MIXER
= 0x60,
96 TP_NVRAM_MASK_HKT_THINKPAD
= 0x08,
97 TP_NVRAM_MASK_HKT_ZOOM
= 0x20,
98 TP_NVRAM_MASK_HKT_DISPLAY
= 0x40,
99 TP_NVRAM_MASK_HKT_HIBERNATE
= 0x80,
100 TP_NVRAM_MASK_THINKLIGHT
= 0x10,
101 TP_NVRAM_MASK_HKT_DISPEXPND
= 0x30,
102 TP_NVRAM_MASK_HKT_BRIGHTNESS
= 0x20,
103 TP_NVRAM_MASK_LEVEL_BRIGHTNESS
= 0x0f,
104 TP_NVRAM_POS_LEVEL_BRIGHTNESS
= 0,
105 TP_NVRAM_MASK_MUTE
= 0x40,
106 TP_NVRAM_MASK_HKT_VOLUME
= 0x80,
107 TP_NVRAM_MASK_LEVEL_VOLUME
= 0x0f,
108 TP_NVRAM_POS_LEVEL_VOLUME
= 0,
111 /* Misc NVRAM-related */
113 TP_NVRAM_LEVEL_VOLUME_MAX
= 14,
117 #define TPACPI_ACPI_IBM_HKEY_HID "IBM0068"
118 #define TPACPI_ACPI_LENOVO_HKEY_HID "LEN0068"
119 #define TPACPI_ACPI_LENOVO_HKEY_V2_HID "LEN0268"
120 #define TPACPI_ACPI_EC_HID "PNP0C09"
123 #define TPACPI_HKEY_INPUT_PRODUCT 0x5054 /* "TP" */
124 #define TPACPI_HKEY_INPUT_VERSION 0x4101
126 /* ACPI \WGSV commands */
128 TP_ACPI_WGSV_GET_STATE
= 0x01, /* Get state information */
129 TP_ACPI_WGSV_PWR_ON_ON_RESUME
= 0x02, /* Resume WWAN powered on */
130 TP_ACPI_WGSV_PWR_OFF_ON_RESUME
= 0x03, /* Resume WWAN powered off */
131 TP_ACPI_WGSV_SAVE_STATE
= 0x04, /* Save state for S4/S5 */
134 /* TP_ACPI_WGSV_GET_STATE bits */
136 TP_ACPI_WGSV_STATE_WWANEXIST
= 0x0001, /* WWAN hw available */
137 TP_ACPI_WGSV_STATE_WWANPWR
= 0x0002, /* WWAN radio enabled */
138 TP_ACPI_WGSV_STATE_WWANPWRRES
= 0x0004, /* WWAN state at resume */
139 TP_ACPI_WGSV_STATE_WWANBIOSOFF
= 0x0008, /* WWAN disabled in BIOS */
140 TP_ACPI_WGSV_STATE_BLTHEXIST
= 0x0001, /* BLTH hw available */
141 TP_ACPI_WGSV_STATE_BLTHPWR
= 0x0002, /* BLTH radio enabled */
142 TP_ACPI_WGSV_STATE_BLTHPWRRES
= 0x0004, /* BLTH state at resume */
143 TP_ACPI_WGSV_STATE_BLTHBIOSOFF
= 0x0008, /* BLTH disabled in BIOS */
144 TP_ACPI_WGSV_STATE_UWBEXIST
= 0x0010, /* UWB hw available */
145 TP_ACPI_WGSV_STATE_UWBPWR
= 0x0020, /* UWB radio enabled */
149 enum tpacpi_hkey_event_t
{
151 TP_HKEY_EV_HOTKEY_BASE
= 0x1001, /* first hotkey (FN+F1) */
152 TP_HKEY_EV_BRGHT_UP
= 0x1010, /* Brightness up */
153 TP_HKEY_EV_BRGHT_DOWN
= 0x1011, /* Brightness down */
154 TP_HKEY_EV_KBD_LIGHT
= 0x1012, /* Thinklight/kbd backlight */
155 TP_HKEY_EV_VOL_UP
= 0x1015, /* Volume up or unmute */
156 TP_HKEY_EV_VOL_DOWN
= 0x1016, /* Volume down or unmute */
157 TP_HKEY_EV_VOL_MUTE
= 0x1017, /* Mixer output mute */
159 /* Reasons for waking up from S3/S4 */
160 TP_HKEY_EV_WKUP_S3_UNDOCK
= 0x2304, /* undock requested, S3 */
161 TP_HKEY_EV_WKUP_S4_UNDOCK
= 0x2404, /* undock requested, S4 */
162 TP_HKEY_EV_WKUP_S3_BAYEJ
= 0x2305, /* bay ejection req, S3 */
163 TP_HKEY_EV_WKUP_S4_BAYEJ
= 0x2405, /* bay ejection req, S4 */
164 TP_HKEY_EV_WKUP_S3_BATLOW
= 0x2313, /* battery empty, S3 */
165 TP_HKEY_EV_WKUP_S4_BATLOW
= 0x2413, /* battery empty, S4 */
167 /* Auto-sleep after eject request */
168 TP_HKEY_EV_BAYEJ_ACK
= 0x3003, /* bay ejection complete */
169 TP_HKEY_EV_UNDOCK_ACK
= 0x4003, /* undock complete */
171 /* Misc bay events */
172 TP_HKEY_EV_OPTDRV_EJ
= 0x3006, /* opt. drive tray ejected */
173 TP_HKEY_EV_HOTPLUG_DOCK
= 0x4010, /* docked into hotplug dock
174 or port replicator */
175 TP_HKEY_EV_HOTPLUG_UNDOCK
= 0x4011, /* undocked from hotplug
176 dock or port replicator */
178 /* User-interface events */
179 TP_HKEY_EV_LID_CLOSE
= 0x5001, /* laptop lid closed */
180 TP_HKEY_EV_LID_OPEN
= 0x5002, /* laptop lid opened */
181 TP_HKEY_EV_TABLET_TABLET
= 0x5009, /* tablet swivel up */
182 TP_HKEY_EV_TABLET_NOTEBOOK
= 0x500a, /* tablet swivel down */
183 TP_HKEY_EV_TABLET_CHANGED
= 0x60c0, /* X1 Yoga (2016):
184 * enter/leave tablet mode
186 TP_HKEY_EV_PEN_INSERTED
= 0x500b, /* tablet pen inserted */
187 TP_HKEY_EV_PEN_REMOVED
= 0x500c, /* tablet pen removed */
188 TP_HKEY_EV_BRGHT_CHANGED
= 0x5010, /* backlight control event */
190 /* Key-related user-interface events */
191 TP_HKEY_EV_KEY_NUMLOCK
= 0x6000, /* NumLock key pressed */
192 TP_HKEY_EV_KEY_FN
= 0x6005, /* Fn key pressed? E420 */
193 TP_HKEY_EV_KEY_FN_ESC
= 0x6060, /* Fn+Esc key pressed X240 */
196 TP_HKEY_EV_ALARM_BAT_HOT
= 0x6011, /* battery too hot */
197 TP_HKEY_EV_ALARM_BAT_XHOT
= 0x6012, /* battery critically hot */
198 TP_HKEY_EV_ALARM_SENSOR_HOT
= 0x6021, /* sensor too hot */
199 TP_HKEY_EV_ALARM_SENSOR_XHOT
= 0x6022, /* sensor critically hot */
200 TP_HKEY_EV_THM_TABLE_CHANGED
= 0x6030, /* windows; thermal table changed */
201 TP_HKEY_EV_THM_CSM_COMPLETED
= 0x6032, /* windows; thermal control set
202 * command completed. Related to
204 TP_HKEY_EV_THM_TRANSFM_CHANGED
= 0x60F0, /* windows; thermal transformation
205 * changed. Related to AML GMTS */
207 /* AC-related events */
208 TP_HKEY_EV_AC_CHANGED
= 0x6040, /* AC status changed */
210 /* Further user-interface events */
211 TP_HKEY_EV_PALM_DETECTED
= 0x60b0, /* palm hoveres keyboard */
212 TP_HKEY_EV_PALM_UNDETECTED
= 0x60b1, /* palm removed */
215 TP_HKEY_EV_RFKILL_CHANGED
= 0x7000, /* rfkill switch changed */
218 /****************************************************************************
222 #define TPACPI_NAME "thinkpad"
223 #define TPACPI_DESC "ThinkPad ACPI Extras"
224 #define TPACPI_FILE TPACPI_NAME "_acpi"
225 #define TPACPI_URL "http://ibm-acpi.sf.net/"
226 #define TPACPI_MAIL "ibm-acpi-devel@lists.sourceforge.net"
228 #define TPACPI_PROC_DIR "ibm"
229 #define TPACPI_ACPI_EVENT_PREFIX "ibm"
230 #define TPACPI_DRVR_NAME TPACPI_FILE
231 #define TPACPI_DRVR_SHORTNAME "tpacpi"
232 #define TPACPI_HWMON_DRVR_NAME TPACPI_NAME "_hwmon"
234 #define TPACPI_NVRAM_KTHREAD_NAME "ktpacpi_nvramd"
235 #define TPACPI_WORKQUEUE_NAME "ktpacpid"
237 #define TPACPI_MAX_ACPI_ARGS 3
239 /* Debugging printk groups */
240 #define TPACPI_DBG_ALL 0xffff
241 #define TPACPI_DBG_DISCLOSETASK 0x8000
242 #define TPACPI_DBG_INIT 0x0001
243 #define TPACPI_DBG_EXIT 0x0002
244 #define TPACPI_DBG_RFKILL 0x0004
245 #define TPACPI_DBG_HKEY 0x0008
246 #define TPACPI_DBG_FAN 0x0010
247 #define TPACPI_DBG_BRGHT 0x0020
248 #define TPACPI_DBG_MIXER 0x0040
250 #define onoff(status, bit) ((status) & (1 << (bit)) ? "on" : "off")
251 #define enabled(status, bit) ((status) & (1 << (bit)) ? "enabled" : "disabled")
252 #define strlencmp(a, b) (strncmp((a), (b), strlen(b)))
255 /****************************************************************************
256 * Driver-wide structs and misc. variables
261 struct tp_acpi_drv_struct
{
262 const struct acpi_device_id
*hid
;
263 struct acpi_driver
*driver
;
265 void (*notify
) (struct ibm_struct
*, u32
);
268 struct acpi_device
*device
;
274 int (*read
) (struct seq_file
*);
275 int (*write
) (char *);
277 void (*resume
) (void);
278 void (*suspend
) (void);
279 void (*shutdown
) (void);
281 struct list_head all_drivers
;
283 struct tp_acpi_drv_struct
*acpi
;
286 u8 acpi_driver_registered
:1;
287 u8 acpi_notify_installed
:1;
294 struct ibm_init_struct
{
297 int (*init
) (struct ibm_init_struct
*);
298 umode_t base_procfs_mode
;
299 struct ibm_struct
*data
;
308 TP_HOTKEY_TABLET_NONE
= 0,
309 TP_HOTKEY_TABLET_USES_MHKG
,
310 TP_HOTKEY_TABLET_USES_GMMS
,
315 u32 bright_acpimode
:1;
319 u32 fan_ctrl_status_undef
:1;
321 u32 second_fan_ctl
:1;
322 u32 beep_needs_two_args
:1;
323 u32 mixer_no_level_control
:1;
324 u32 battery_force_primary
:1;
325 u32 input_device_registered
:1;
326 u32 platform_drv_registered
:1;
327 u32 platform_drv_attrs_registered
:1;
328 u32 sensors_pdrv_registered
:1;
329 u32 sensors_pdrv_attrs_registered
:1;
330 u32 sensors_pdev_attrs_registered
:1;
331 u32 hotkey_poll_active
:1;
332 u32 has_adaptive_kbd
:1;
336 u16 hotkey_mask_ff
:1;
337 u16 volume_ctrl_forbidden
:1;
340 struct thinkpad_id_data
{
341 unsigned int vendor
; /* ThinkPad vendor:
342 * PCI_VENDOR_ID_IBM/PCI_VENDOR_ID_LENOVO */
344 char *bios_version_str
; /* Something like 1ZET51WW (1.03z) */
345 char *ec_version_str
; /* Something like 1ZHT51WW-1.04a */
347 u32 bios_model
; /* 1Y = 0x3159, 0 = unknown */
349 u16 bios_release
; /* 1ZETK1WW = 0x4b31, 0 = unknown */
352 char *model_str
; /* ThinkPad T43 */
353 char *nummodel_str
; /* 9384A9C for a 9384-A9C model */
355 static struct thinkpad_id_data thinkpad_id
;
358 TPACPI_LIFE_INIT
= 0,
363 static int experimental
;
364 static u32 dbg_level
;
366 static struct workqueue_struct
*tpacpi_wq
;
374 /* tpacpi LED class */
375 struct tpacpi_led_classdev
{
376 struct led_classdev led_classdev
;
380 /* brightness level capabilities */
381 static unsigned int bright_maxlvl
; /* 0 = unknown */
383 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
384 static int dbg_wlswemul
;
385 static bool tpacpi_wlsw_emulstate
;
386 static int dbg_bluetoothemul
;
387 static bool tpacpi_bluetooth_emulstate
;
388 static int dbg_wwanemul
;
389 static bool tpacpi_wwan_emulstate
;
390 static int dbg_uwbemul
;
391 static bool tpacpi_uwb_emulstate
;
395 /*************************************************************************
399 #define dbg_printk(a_dbg_level, format, arg...) \
401 if (dbg_level & (a_dbg_level)) \
402 printk(KERN_DEBUG pr_fmt("%s: " format), \
406 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
407 #define vdbg_printk dbg_printk
408 static const char *str_supported(int is_supported
);
410 static inline const char *str_supported(int is_supported
) { return ""; }
411 #define vdbg_printk(a_dbg_level, format, arg...) \
412 do { if (0) no_printk(format, ##arg); } while (0)
415 static void tpacpi_log_usertask(const char * const what
)
417 printk(KERN_DEBUG
pr_fmt("%s: access by process with PID %d\n"),
418 what
, task_tgid_vnr(current
));
421 #define tpacpi_disclose_usertask(what, format, arg...) \
423 if (unlikely((dbg_level & TPACPI_DBG_DISCLOSETASK) && \
424 (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) { \
425 printk(KERN_DEBUG pr_fmt("%s: PID %d: " format), \
426 what, task_tgid_vnr(current), ## arg); \
431 * Quirk handling helpers
433 * ThinkPad IDs and versions seen in the field so far are
434 * two or three characters from the set [0-9A-Z], i.e. base 36.
436 * We use values well outside that range as specials.
439 #define TPACPI_MATCH_ANY 0xffffffffU
440 #define TPACPI_MATCH_ANY_VERSION 0xffffU
441 #define TPACPI_MATCH_UNKNOWN 0U
443 /* TPID('1', 'Y') == 0x3159 */
444 #define TPID(__c1, __c2) (((__c1) << 8) | (__c2))
445 #define TPID3(__c1, __c2, __c3) (((__c1) << 16) | ((__c2) << 8) | (__c3))
448 #define TPACPI_Q_IBM(__id1, __id2, __quirk) \
449 { .vendor = PCI_VENDOR_ID_IBM, \
450 .bios = TPID(__id1, __id2), \
451 .ec = TPACPI_MATCH_ANY, \
452 .quirks = (__quirk) }
454 #define TPACPI_Q_LNV(__id1, __id2, __quirk) \
455 { .vendor = PCI_VENDOR_ID_LENOVO, \
456 .bios = TPID(__id1, __id2), \
457 .ec = TPACPI_MATCH_ANY, \
458 .quirks = (__quirk) }
460 #define TPACPI_Q_LNV3(__id1, __id2, __id3, __quirk) \
461 { .vendor = PCI_VENDOR_ID_LENOVO, \
462 .bios = TPID3(__id1, __id2, __id3), \
463 .ec = TPACPI_MATCH_ANY, \
464 .quirks = (__quirk) }
466 #define TPACPI_QEC_IBM(__id1, __id2, __quirk) \
467 { .vendor = PCI_VENDOR_ID_IBM, \
468 .bios = TPACPI_MATCH_ANY, \
469 .ec = TPID(__id1, __id2), \
470 .quirks = (__quirk) }
472 #define TPACPI_QEC_LNV(__id1, __id2, __quirk) \
473 { .vendor = PCI_VENDOR_ID_LENOVO, \
474 .bios = TPACPI_MATCH_ANY, \
475 .ec = TPID(__id1, __id2), \
476 .quirks = (__quirk) }
478 struct tpacpi_quirk
{
482 unsigned long quirks
;
486 * tpacpi_check_quirks() - search BIOS/EC version on a list
487 * @qlist: array of &struct tpacpi_quirk
488 * @qlist_size: number of elements in @qlist
490 * Iterates over a quirks list until one is found that matches the
491 * ThinkPad's vendor, BIOS and EC model.
493 * Returns 0 if nothing matches, otherwise returns the quirks field of
494 * the matching &struct tpacpi_quirk entry.
496 * The match criteria is: vendor, ec and bios much match.
498 static unsigned long __init
tpacpi_check_quirks(
499 const struct tpacpi_quirk
*qlist
,
500 unsigned int qlist_size
)
503 if ((qlist
->vendor
== thinkpad_id
.vendor
||
504 qlist
->vendor
== TPACPI_MATCH_ANY
) &&
505 (qlist
->bios
== thinkpad_id
.bios_model
||
506 qlist
->bios
== TPACPI_MATCH_ANY
) &&
507 (qlist
->ec
== thinkpad_id
.ec_model
||
508 qlist
->ec
== TPACPI_MATCH_ANY
))
509 return qlist
->quirks
;
517 static inline bool __pure __init
tpacpi_is_lenovo(void)
519 return thinkpad_id
.vendor
== PCI_VENDOR_ID_LENOVO
;
522 static inline bool __pure __init
tpacpi_is_ibm(void)
524 return thinkpad_id
.vendor
== PCI_VENDOR_ID_IBM
;
527 /****************************************************************************
528 ****************************************************************************
530 * ACPI Helpers and device model
532 ****************************************************************************
533 ****************************************************************************/
535 /*************************************************************************
539 static acpi_handle root_handle
;
540 static acpi_handle ec_handle
;
542 #define TPACPI_HANDLE(object, parent, paths...) \
543 static acpi_handle object##_handle; \
544 static const acpi_handle * const object##_parent __initconst = \
546 static char *object##_paths[] __initdata = { paths }
548 TPACPI_HANDLE(ecrd
, ec
, "ECRD"); /* 570 */
549 TPACPI_HANDLE(ecwr
, ec
, "ECWR"); /* 570 */
551 TPACPI_HANDLE(cmos
, root
, "\\UCMS", /* R50, R50e, R50p, R51, */
553 "\\CMOS", /* A3x, G4x, R32, T23, T30, X22-24, X30 */
554 "\\CMS", /* R40, R40e */
557 TPACPI_HANDLE(hkey
, ec
, "\\_SB.HKEY", /* 600e/x, 770e, 770x */
558 "^HKEY", /* R30, R31 */
559 "HKEY", /* all others */
562 /*************************************************************************
566 static int acpi_evalf(acpi_handle handle
,
567 int *res
, char *method
, char *fmt
, ...)
570 struct acpi_object_list params
;
571 union acpi_object in_objs
[TPACPI_MAX_ACPI_ARGS
];
572 struct acpi_buffer result
, *resultp
;
573 union acpi_object out_obj
;
581 pr_err("acpi_evalf() called with empty format\n");
594 params
.pointer
= &in_objs
[0];
601 in_objs
[params
.count
].integer
.value
= va_arg(ap
, int);
602 in_objs
[params
.count
++].type
= ACPI_TYPE_INTEGER
;
604 /* add more types as needed */
606 pr_err("acpi_evalf() called with invalid format character '%c'\n",
614 if (res_type
!= 'v') {
615 result
.length
= sizeof(out_obj
);
616 result
.pointer
= &out_obj
;
621 status
= acpi_evaluate_object(handle
, method
, ¶ms
, resultp
);
625 success
= (status
== AE_OK
&&
626 out_obj
.type
== ACPI_TYPE_INTEGER
);
628 *res
= out_obj
.integer
.value
;
631 success
= status
== AE_OK
;
633 /* add more types as needed */
635 pr_err("acpi_evalf() called with invalid format character '%c'\n",
640 if (!success
&& !quiet
)
641 pr_err("acpi_evalf(%s, %s, ...) failed: %s\n",
642 method
, fmt0
, acpi_format_exception(status
));
647 static int acpi_ec_read(int i
, u8
*p
)
652 if (!acpi_evalf(ecrd_handle
, &v
, NULL
, "dd", i
))
656 if (ec_read(i
, p
) < 0)
663 static int acpi_ec_write(int i
, u8 v
)
666 if (!acpi_evalf(ecwr_handle
, NULL
, NULL
, "vdd", i
, v
))
669 if (ec_write(i
, v
) < 0)
676 static int issue_thinkpad_cmos_command(int cmos_cmd
)
681 if (!acpi_evalf(cmos_handle
, NULL
, NULL
, "vd", cmos_cmd
))
687 /*************************************************************************
691 #define TPACPI_ACPIHANDLE_INIT(object) \
692 drv_acpi_handle_init(#object, &object##_handle, *object##_parent, \
693 object##_paths, ARRAY_SIZE(object##_paths))
695 static void __init
drv_acpi_handle_init(const char *name
,
696 acpi_handle
*handle
, const acpi_handle parent
,
697 char **paths
, const int num_paths
)
702 vdbg_printk(TPACPI_DBG_INIT
, "trying to locate ACPI handle for %s\n",
705 for (i
= 0; i
< num_paths
; i
++) {
706 status
= acpi_get_handle(parent
, paths
[i
], handle
);
707 if (ACPI_SUCCESS(status
)) {
708 dbg_printk(TPACPI_DBG_INIT
,
709 "Found ACPI handle %s for %s\n",
715 vdbg_printk(TPACPI_DBG_INIT
, "ACPI handle for %s not found\n",
720 static acpi_status __init
tpacpi_acpi_handle_locate_callback(acpi_handle handle
,
721 u32 level
, void *context
, void **return_value
)
723 struct acpi_device
*dev
;
724 if (!strcmp(context
, "video")) {
725 if (acpi_bus_get_device(handle
, &dev
))
727 if (strcmp(ACPI_VIDEO_HID
, acpi_device_hid(dev
)))
731 *(acpi_handle
*)return_value
= handle
;
733 return AE_CTRL_TERMINATE
;
736 static void __init
tpacpi_acpi_handle_locate(const char *name
,
741 acpi_handle device_found
;
743 BUG_ON(!name
|| !handle
);
744 vdbg_printk(TPACPI_DBG_INIT
,
745 "trying to locate ACPI handle for %s, using HID %s\n",
746 name
, hid
? hid
: "NULL");
748 memset(&device_found
, 0, sizeof(device_found
));
749 status
= acpi_get_devices(hid
, tpacpi_acpi_handle_locate_callback
,
750 (void *)name
, &device_found
);
754 if (ACPI_SUCCESS(status
)) {
755 *handle
= device_found
;
756 dbg_printk(TPACPI_DBG_INIT
,
757 "Found ACPI handle for %s\n", name
);
759 vdbg_printk(TPACPI_DBG_INIT
,
760 "Could not locate an ACPI handle for %s: %s\n",
761 name
, acpi_format_exception(status
));
765 static void dispatch_acpi_notify(acpi_handle handle
, u32 event
, void *data
)
767 struct ibm_struct
*ibm
= data
;
769 if (tpacpi_lifecycle
!= TPACPI_LIFE_RUNNING
)
772 if (!ibm
|| !ibm
->acpi
|| !ibm
->acpi
->notify
)
775 ibm
->acpi
->notify(ibm
, event
);
778 static int __init
setup_acpi_notify(struct ibm_struct
*ibm
)
785 if (!*ibm
->acpi
->handle
)
788 vdbg_printk(TPACPI_DBG_INIT
,
789 "setting up ACPI notify for %s\n", ibm
->name
);
791 rc
= acpi_bus_get_device(*ibm
->acpi
->handle
, &ibm
->acpi
->device
);
793 pr_err("acpi_bus_get_device(%s) failed: %d\n", ibm
->name
, rc
);
797 ibm
->acpi
->device
->driver_data
= ibm
;
798 sprintf(acpi_device_class(ibm
->acpi
->device
), "%s/%s",
799 TPACPI_ACPI_EVENT_PREFIX
,
802 status
= acpi_install_notify_handler(*ibm
->acpi
->handle
,
803 ibm
->acpi
->type
, dispatch_acpi_notify
, ibm
);
804 if (ACPI_FAILURE(status
)) {
805 if (status
== AE_ALREADY_EXISTS
) {
806 pr_notice("another device driver is already handling %s events\n",
809 pr_err("acpi_install_notify_handler(%s) failed: %s\n",
810 ibm
->name
, acpi_format_exception(status
));
814 ibm
->flags
.acpi_notify_installed
= 1;
818 static int __init
tpacpi_device_add(struct acpi_device
*device
)
823 static int __init
register_tpacpi_subdriver(struct ibm_struct
*ibm
)
827 dbg_printk(TPACPI_DBG_INIT
,
828 "registering %s as an ACPI driver\n", ibm
->name
);
832 ibm
->acpi
->driver
= kzalloc(sizeof(struct acpi_driver
), GFP_KERNEL
);
833 if (!ibm
->acpi
->driver
) {
834 pr_err("failed to allocate memory for ibm->acpi->driver\n");
838 sprintf(ibm
->acpi
->driver
->name
, "%s_%s", TPACPI_NAME
, ibm
->name
);
839 ibm
->acpi
->driver
->ids
= ibm
->acpi
->hid
;
841 ibm
->acpi
->driver
->ops
.add
= &tpacpi_device_add
;
843 rc
= acpi_bus_register_driver(ibm
->acpi
->driver
);
845 pr_err("acpi_bus_register_driver(%s) failed: %d\n",
847 kfree(ibm
->acpi
->driver
);
848 ibm
->acpi
->driver
= NULL
;
850 ibm
->flags
.acpi_driver_registered
= 1;
856 /****************************************************************************
857 ****************************************************************************
861 ****************************************************************************
862 ****************************************************************************/
864 static int dispatch_proc_show(struct seq_file
*m
, void *v
)
866 struct ibm_struct
*ibm
= m
->private;
868 if (!ibm
|| !ibm
->read
)
873 static int dispatch_proc_open(struct inode
*inode
, struct file
*file
)
875 return single_open(file
, dispatch_proc_show
, PDE_DATA(inode
));
878 static ssize_t
dispatch_proc_write(struct file
*file
,
879 const char __user
*userbuf
,
880 size_t count
, loff_t
*pos
)
882 struct ibm_struct
*ibm
= PDE_DATA(file_inode(file
));
886 if (!ibm
|| !ibm
->write
)
889 kernbuf
= strndup_user(userbuf
, PAGE_SIZE
);
891 return PTR_ERR(kernbuf
);
893 ret
= ibm
->write(kernbuf
);
902 static const struct proc_ops dispatch_proc_ops
= {
903 .proc_open
= dispatch_proc_open
,
904 .proc_read
= seq_read
,
905 .proc_lseek
= seq_lseek
,
906 .proc_release
= single_release
,
907 .proc_write
= dispatch_proc_write
,
910 /****************************************************************************
911 ****************************************************************************
913 * Device model: input, hwmon and platform
915 ****************************************************************************
916 ****************************************************************************/
918 static struct platform_device
*tpacpi_pdev
;
919 static struct platform_device
*tpacpi_sensors_pdev
;
920 static struct device
*tpacpi_hwmon
;
921 static struct input_dev
*tpacpi_inputdev
;
922 static struct mutex tpacpi_inputdev_send_mutex
;
923 static LIST_HEAD(tpacpi_all_drivers
);
925 #ifdef CONFIG_PM_SLEEP
926 static int tpacpi_suspend_handler(struct device
*dev
)
928 struct ibm_struct
*ibm
, *itmp
;
930 list_for_each_entry_safe(ibm
, itmp
,
940 static int tpacpi_resume_handler(struct device
*dev
)
942 struct ibm_struct
*ibm
, *itmp
;
944 list_for_each_entry_safe(ibm
, itmp
,
955 static SIMPLE_DEV_PM_OPS(tpacpi_pm
,
956 tpacpi_suspend_handler
, tpacpi_resume_handler
);
958 static void tpacpi_shutdown_handler(struct platform_device
*pdev
)
960 struct ibm_struct
*ibm
, *itmp
;
962 list_for_each_entry_safe(ibm
, itmp
,
970 static struct platform_driver tpacpi_pdriver
= {
972 .name
= TPACPI_DRVR_NAME
,
975 .shutdown
= tpacpi_shutdown_handler
,
978 static struct platform_driver tpacpi_hwmon_pdriver
= {
980 .name
= TPACPI_HWMON_DRVR_NAME
,
984 /*************************************************************************
985 * sysfs support helpers
988 struct attribute_set
{
989 unsigned int members
, max_members
;
990 struct attribute_group group
;
993 struct attribute_set_obj
{
994 struct attribute_set s
;
996 } __attribute__((packed
));
998 static struct attribute_set
*create_attr_set(unsigned int max_members
,
1001 struct attribute_set_obj
*sobj
;
1003 if (max_members
== 0)
1006 /* Allocates space for implicit NULL at the end too */
1007 sobj
= kzalloc(sizeof(struct attribute_set_obj
) +
1008 max_members
* sizeof(struct attribute
*),
1012 sobj
->s
.max_members
= max_members
;
1013 sobj
->s
.group
.attrs
= &sobj
->a
;
1014 sobj
->s
.group
.name
= name
;
1019 #define destroy_attr_set(_set) \
1022 /* not multi-threaded safe, use it in a single thread per set */
1023 static int add_to_attr_set(struct attribute_set
*s
, struct attribute
*attr
)
1028 if (s
->members
>= s
->max_members
)
1031 s
->group
.attrs
[s
->members
] = attr
;
1037 static int add_many_to_attr_set(struct attribute_set
*s
,
1038 struct attribute
**attr
,
1043 for (i
= 0; i
< count
; i
++) {
1044 res
= add_to_attr_set(s
, attr
[i
]);
1052 static void delete_attr_set(struct attribute_set
*s
, struct kobject
*kobj
)
1054 sysfs_remove_group(kobj
, &s
->group
);
1055 destroy_attr_set(s
);
1058 #define register_attr_set_with_sysfs(_attr_set, _kobj) \
1059 sysfs_create_group(_kobj, &_attr_set->group)
1061 static int parse_strtoul(const char *buf
,
1062 unsigned long max
, unsigned long *value
)
1066 *value
= simple_strtoul(skip_spaces(buf
), &endp
, 0);
1067 endp
= skip_spaces(endp
);
1068 if (*endp
|| *value
> max
)
1074 static void tpacpi_disable_brightness_delay(void)
1076 if (acpi_evalf(hkey_handle
, NULL
, "PWMS", "qvd", 0))
1077 pr_notice("ACPI backlight control delay disabled\n");
1080 static void printk_deprecated_attribute(const char * const what
,
1081 const char * const details
)
1083 tpacpi_log_usertask("deprecated sysfs attribute");
1084 pr_warn("WARNING: sysfs attribute %s is deprecated and will be removed. %s\n",
1088 /*************************************************************************
1089 * rfkill and radio control support helpers
1093 * ThinkPad-ACPI firmware handling model:
1095 * WLSW (master wireless switch) is event-driven, and is common to all
1096 * firmware-controlled radios. It cannot be controlled, just monitored,
1097 * as expected. It overrides all radio state in firmware
1099 * The kernel, a masked-off hotkey, and WLSW can change the radio state
1100 * (TODO: verify how WLSW interacts with the returned radio state).
1102 * The only time there are shadow radio state changes, is when
1103 * masked-off hotkeys are used.
1107 * Internal driver API for radio state:
1109 * int: < 0 = error, otherwise enum tpacpi_rfkill_state
1110 * bool: true means radio blocked (off)
1112 enum tpacpi_rfkill_state
{
1113 TPACPI_RFK_RADIO_OFF
= 0,
1117 /* rfkill switches */
1118 enum tpacpi_rfk_id
{
1119 TPACPI_RFK_BLUETOOTH_SW_ID
= 0,
1120 TPACPI_RFK_WWAN_SW_ID
,
1121 TPACPI_RFK_UWB_SW_ID
,
1125 static const char *tpacpi_rfkill_names
[] = {
1126 [TPACPI_RFK_BLUETOOTH_SW_ID
] = "bluetooth",
1127 [TPACPI_RFK_WWAN_SW_ID
] = "wwan",
1128 [TPACPI_RFK_UWB_SW_ID
] = "uwb",
1129 [TPACPI_RFK_SW_MAX
] = NULL
1132 /* ThinkPad-ACPI rfkill subdriver */
1134 struct rfkill
*rfkill
;
1135 enum tpacpi_rfk_id id
;
1136 const struct tpacpi_rfk_ops
*ops
;
1139 struct tpacpi_rfk_ops
{
1140 /* firmware interface */
1141 int (*get_status
)(void);
1142 int (*set_status
)(const enum tpacpi_rfkill_state
);
1145 static struct tpacpi_rfk
*tpacpi_rfkill_switches
[TPACPI_RFK_SW_MAX
];
1147 /* Query FW and update rfkill sw state for a given rfkill switch */
1148 static int tpacpi_rfk_update_swstate(const struct tpacpi_rfk
*tp_rfk
)
1155 status
= (tp_rfk
->ops
->get_status
)();
1159 rfkill_set_sw_state(tp_rfk
->rfkill
,
1160 (status
== TPACPI_RFK_RADIO_OFF
));
1165 /* Query FW and update rfkill sw state for all rfkill switches */
1166 static void tpacpi_rfk_update_swstate_all(void)
1170 for (i
= 0; i
< TPACPI_RFK_SW_MAX
; i
++)
1171 tpacpi_rfk_update_swstate(tpacpi_rfkill_switches
[i
]);
1175 * Sync the HW-blocking state of all rfkill switches,
1176 * do notice it causes the rfkill core to schedule uevents
1178 static void tpacpi_rfk_update_hwblock_state(bool blocked
)
1181 struct tpacpi_rfk
*tp_rfk
;
1183 for (i
= 0; i
< TPACPI_RFK_SW_MAX
; i
++) {
1184 tp_rfk
= tpacpi_rfkill_switches
[i
];
1186 if (rfkill_set_hw_state(tp_rfk
->rfkill
,
1188 /* ignore -- we track sw block */
1194 /* Call to get the WLSW state from the firmware */
1195 static int hotkey_get_wlsw(void);
1197 /* Call to query WLSW state and update all rfkill switches */
1198 static bool tpacpi_rfk_check_hwblock_state(void)
1200 int res
= hotkey_get_wlsw();
1203 /* When unknown or unsupported, we have to assume it is unblocked */
1207 hw_blocked
= (res
== TPACPI_RFK_RADIO_OFF
);
1208 tpacpi_rfk_update_hwblock_state(hw_blocked
);
1213 static int tpacpi_rfk_hook_set_block(void *data
, bool blocked
)
1215 struct tpacpi_rfk
*tp_rfk
= data
;
1218 dbg_printk(TPACPI_DBG_RFKILL
,
1219 "request to change radio state to %s\n",
1220 blocked
? "blocked" : "unblocked");
1222 /* try to set radio state */
1223 res
= (tp_rfk
->ops
->set_status
)(blocked
?
1224 TPACPI_RFK_RADIO_OFF
: TPACPI_RFK_RADIO_ON
);
1226 /* and update the rfkill core with whatever the FW really did */
1227 tpacpi_rfk_update_swstate(tp_rfk
);
1229 return (res
< 0) ? res
: 0;
1232 static const struct rfkill_ops tpacpi_rfk_rfkill_ops
= {
1233 .set_block
= tpacpi_rfk_hook_set_block
,
1236 static int __init
tpacpi_new_rfkill(const enum tpacpi_rfk_id id
,
1237 const struct tpacpi_rfk_ops
*tp_rfkops
,
1238 const enum rfkill_type rfktype
,
1240 const bool set_default
)
1242 struct tpacpi_rfk
*atp_rfk
;
1244 bool sw_state
= false;
1248 BUG_ON(id
>= TPACPI_RFK_SW_MAX
|| tpacpi_rfkill_switches
[id
]);
1250 atp_rfk
= kzalloc(sizeof(struct tpacpi_rfk
), GFP_KERNEL
);
1252 atp_rfk
->rfkill
= rfkill_alloc(name
,
1255 &tpacpi_rfk_rfkill_ops
,
1257 if (!atp_rfk
|| !atp_rfk
->rfkill
) {
1258 pr_err("failed to allocate memory for rfkill class\n");
1264 atp_rfk
->ops
= tp_rfkops
;
1266 sw_status
= (tp_rfkops
->get_status
)();
1267 if (sw_status
< 0) {
1268 pr_err("failed to read initial state for %s, error %d\n",
1271 sw_state
= (sw_status
== TPACPI_RFK_RADIO_OFF
);
1273 /* try to keep the initial state, since we ask the
1274 * firmware to preserve it across S5 in NVRAM */
1275 rfkill_init_sw_state(atp_rfk
->rfkill
, sw_state
);
1278 hw_state
= tpacpi_rfk_check_hwblock_state();
1279 rfkill_set_hw_state(atp_rfk
->rfkill
, hw_state
);
1281 res
= rfkill_register(atp_rfk
->rfkill
);
1283 pr_err("failed to register %s rfkill switch: %d\n", name
, res
);
1284 rfkill_destroy(atp_rfk
->rfkill
);
1289 tpacpi_rfkill_switches
[id
] = atp_rfk
;
1291 pr_info("rfkill switch %s: radio is %sblocked\n",
1292 name
, (sw_state
|| hw_state
) ? "" : "un");
1296 static void tpacpi_destroy_rfkill(const enum tpacpi_rfk_id id
)
1298 struct tpacpi_rfk
*tp_rfk
;
1300 BUG_ON(id
>= TPACPI_RFK_SW_MAX
);
1302 tp_rfk
= tpacpi_rfkill_switches
[id
];
1304 rfkill_unregister(tp_rfk
->rfkill
);
1305 rfkill_destroy(tp_rfk
->rfkill
);
1306 tpacpi_rfkill_switches
[id
] = NULL
;
1311 static void printk_deprecated_rfkill_attribute(const char * const what
)
1313 printk_deprecated_attribute(what
,
1314 "Please switch to generic rfkill before year 2010");
1317 /* sysfs <radio> enable ------------------------------------------------ */
1318 static ssize_t
tpacpi_rfk_sysfs_enable_show(const enum tpacpi_rfk_id id
,
1319 struct device_attribute
*attr
,
1324 printk_deprecated_rfkill_attribute(attr
->attr
.name
);
1326 /* This is in the ABI... */
1327 if (tpacpi_rfk_check_hwblock_state()) {
1328 status
= TPACPI_RFK_RADIO_OFF
;
1330 status
= tpacpi_rfk_update_swstate(tpacpi_rfkill_switches
[id
]);
1335 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1336 (status
== TPACPI_RFK_RADIO_ON
) ? 1 : 0);
1339 static ssize_t
tpacpi_rfk_sysfs_enable_store(const enum tpacpi_rfk_id id
,
1340 struct device_attribute
*attr
,
1341 const char *buf
, size_t count
)
1346 printk_deprecated_rfkill_attribute(attr
->attr
.name
);
1348 if (parse_strtoul(buf
, 1, &t
))
1351 tpacpi_disclose_usertask(attr
->attr
.name
, "set to %ld\n", t
);
1353 /* This is in the ABI... */
1354 if (tpacpi_rfk_check_hwblock_state() && !!t
)
1357 res
= tpacpi_rfkill_switches
[id
]->ops
->set_status((!!t
) ?
1358 TPACPI_RFK_RADIO_ON
: TPACPI_RFK_RADIO_OFF
);
1359 tpacpi_rfk_update_swstate(tpacpi_rfkill_switches
[id
]);
1361 return (res
< 0) ? res
: count
;
1364 /* procfs -------------------------------------------------------------- */
1365 static int tpacpi_rfk_procfs_read(const enum tpacpi_rfk_id id
, struct seq_file
*m
)
1367 if (id
>= TPACPI_RFK_SW_MAX
)
1368 seq_printf(m
, "status:\t\tnot supported\n");
1372 /* This is in the ABI... */
1373 if (tpacpi_rfk_check_hwblock_state()) {
1374 status
= TPACPI_RFK_RADIO_OFF
;
1376 status
= tpacpi_rfk_update_swstate(
1377 tpacpi_rfkill_switches
[id
]);
1382 seq_printf(m
, "status:\t\t%s\n",
1383 (status
== TPACPI_RFK_RADIO_ON
) ?
1384 "enabled" : "disabled");
1385 seq_printf(m
, "commands:\tenable, disable\n");
1391 static int tpacpi_rfk_procfs_write(const enum tpacpi_rfk_id id
, char *buf
)
1397 if (id
>= TPACPI_RFK_SW_MAX
)
1400 while ((cmd
= strsep(&buf
, ","))) {
1401 if (strlencmp(cmd
, "enable") == 0)
1402 status
= TPACPI_RFK_RADIO_ON
;
1403 else if (strlencmp(cmd
, "disable") == 0)
1404 status
= TPACPI_RFK_RADIO_OFF
;
1410 tpacpi_disclose_usertask("procfs", "attempt to %s %s\n",
1411 (status
== TPACPI_RFK_RADIO_ON
) ?
1412 "enable" : "disable",
1413 tpacpi_rfkill_names
[id
]);
1414 res
= (tpacpi_rfkill_switches
[id
]->ops
->set_status
)(status
);
1415 tpacpi_rfk_update_swstate(tpacpi_rfkill_switches
[id
]);
1421 /*************************************************************************
1422 * thinkpad-acpi driver attributes
1425 /* interface_version --------------------------------------------------- */
1426 static ssize_t
interface_version_show(struct device_driver
*drv
, char *buf
)
1428 return snprintf(buf
, PAGE_SIZE
, "0x%08x\n", TPACPI_SYSFS_VERSION
);
1430 static DRIVER_ATTR_RO(interface_version
);
1432 /* debug_level --------------------------------------------------------- */
1433 static ssize_t
debug_level_show(struct device_driver
*drv
, char *buf
)
1435 return snprintf(buf
, PAGE_SIZE
, "0x%04x\n", dbg_level
);
1438 static ssize_t
debug_level_store(struct device_driver
*drv
, const char *buf
,
1443 if (parse_strtoul(buf
, 0xffff, &t
))
1450 static DRIVER_ATTR_RW(debug_level
);
1452 /* version ------------------------------------------------------------- */
1453 static ssize_t
version_show(struct device_driver
*drv
, char *buf
)
1455 return snprintf(buf
, PAGE_SIZE
, "%s v%s\n",
1456 TPACPI_DESC
, TPACPI_VERSION
);
1458 static DRIVER_ATTR_RO(version
);
1460 /* --------------------------------------------------------------------- */
1462 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
1464 /* wlsw_emulstate ------------------------------------------------------ */
1465 static ssize_t
wlsw_emulstate_show(struct device_driver
*drv
, char *buf
)
1467 return snprintf(buf
, PAGE_SIZE
, "%d\n", !!tpacpi_wlsw_emulstate
);
1470 static ssize_t
wlsw_emulstate_store(struct device_driver
*drv
, const char *buf
,
1475 if (parse_strtoul(buf
, 1, &t
))
1478 if (tpacpi_wlsw_emulstate
!= !!t
) {
1479 tpacpi_wlsw_emulstate
= !!t
;
1480 tpacpi_rfk_update_hwblock_state(!t
); /* negative logic */
1485 static DRIVER_ATTR_RW(wlsw_emulstate
);
1487 /* bluetooth_emulstate ------------------------------------------------- */
1488 static ssize_t
bluetooth_emulstate_show(struct device_driver
*drv
, char *buf
)
1490 return snprintf(buf
, PAGE_SIZE
, "%d\n", !!tpacpi_bluetooth_emulstate
);
1493 static ssize_t
bluetooth_emulstate_store(struct device_driver
*drv
,
1494 const char *buf
, size_t count
)
1498 if (parse_strtoul(buf
, 1, &t
))
1501 tpacpi_bluetooth_emulstate
= !!t
;
1505 static DRIVER_ATTR_RW(bluetooth_emulstate
);
1507 /* wwan_emulstate ------------------------------------------------- */
1508 static ssize_t
wwan_emulstate_show(struct device_driver
*drv
, char *buf
)
1510 return snprintf(buf
, PAGE_SIZE
, "%d\n", !!tpacpi_wwan_emulstate
);
1513 static ssize_t
wwan_emulstate_store(struct device_driver
*drv
, const char *buf
,
1518 if (parse_strtoul(buf
, 1, &t
))
1521 tpacpi_wwan_emulstate
= !!t
;
1525 static DRIVER_ATTR_RW(wwan_emulstate
);
1527 /* uwb_emulstate ------------------------------------------------- */
1528 static ssize_t
uwb_emulstate_show(struct device_driver
*drv
, char *buf
)
1530 return snprintf(buf
, PAGE_SIZE
, "%d\n", !!tpacpi_uwb_emulstate
);
1533 static ssize_t
uwb_emulstate_store(struct device_driver
*drv
, const char *buf
,
1538 if (parse_strtoul(buf
, 1, &t
))
1541 tpacpi_uwb_emulstate
= !!t
;
1545 static DRIVER_ATTR_RW(uwb_emulstate
);
1548 /* --------------------------------------------------------------------- */
1550 static struct driver_attribute
*tpacpi_driver_attributes
[] = {
1551 &driver_attr_debug_level
, &driver_attr_version
,
1552 &driver_attr_interface_version
,
1555 static int __init
tpacpi_create_driver_attributes(struct device_driver
*drv
)
1561 while (!res
&& i
< ARRAY_SIZE(tpacpi_driver_attributes
)) {
1562 res
= driver_create_file(drv
, tpacpi_driver_attributes
[i
]);
1566 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
1567 if (!res
&& dbg_wlswemul
)
1568 res
= driver_create_file(drv
, &driver_attr_wlsw_emulstate
);
1569 if (!res
&& dbg_bluetoothemul
)
1570 res
= driver_create_file(drv
, &driver_attr_bluetooth_emulstate
);
1571 if (!res
&& dbg_wwanemul
)
1572 res
= driver_create_file(drv
, &driver_attr_wwan_emulstate
);
1573 if (!res
&& dbg_uwbemul
)
1574 res
= driver_create_file(drv
, &driver_attr_uwb_emulstate
);
1580 static void tpacpi_remove_driver_attributes(struct device_driver
*drv
)
1584 for (i
= 0; i
< ARRAY_SIZE(tpacpi_driver_attributes
); i
++)
1585 driver_remove_file(drv
, tpacpi_driver_attributes
[i
]);
1587 #ifdef THINKPAD_ACPI_DEBUGFACILITIES
1588 driver_remove_file(drv
, &driver_attr_wlsw_emulstate
);
1589 driver_remove_file(drv
, &driver_attr_bluetooth_emulstate
);
1590 driver_remove_file(drv
, &driver_attr_wwan_emulstate
);
1591 driver_remove_file(drv
, &driver_attr_uwb_emulstate
);
1595 /*************************************************************************
1600 * Table of recommended minimum BIOS versions
1602 * Reasons for listing:
1603 * 1. Stable BIOS, listed because the unknown amount of
1604 * bugs and bad ACPI behaviour on older versions
1606 * 2. BIOS or EC fw with known bugs that trigger on Linux
1608 * 3. BIOS with known reduced functionality in older versions
1610 * We recommend the latest BIOS and EC version.
1611 * We only support the latest BIOS and EC fw version as a rule.
1613 * Sources: IBM ThinkPad Public Web Documents (update changelogs),
1614 * Information from users in ThinkWiki
1616 * WARNING: we use this table also to detect that the machine is
1617 * a ThinkPad in some cases, so don't remove entries lightly.
1620 #define TPV_Q(__v, __id1, __id2, __bv1, __bv2) \
1621 { .vendor = (__v), \
1622 .bios = TPID(__id1, __id2), \
1623 .ec = TPACPI_MATCH_ANY, \
1624 .quirks = TPACPI_MATCH_ANY_VERSION << 16 \
1625 | TPVER(__bv1, __bv2) }
1627 #define TPV_Q_X(__v, __bid1, __bid2, __bv1, __bv2, \
1628 __eid, __ev1, __ev2) \
1629 { .vendor = (__v), \
1630 .bios = TPID(__bid1, __bid2), \
1632 .quirks = TPVER(__ev1, __ev2) << 16 \
1633 | TPVER(__bv1, __bv2) }
1635 #define TPV_QI0(__id1, __id2, __bv1, __bv2) \
1636 TPV_Q(PCI_VENDOR_ID_IBM, __id1, __id2, __bv1, __bv2)
1638 /* Outdated IBM BIOSes often lack the EC id string */
1639 #define TPV_QI1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
1640 TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2, \
1641 __bv1, __bv2, TPID(__id1, __id2), \
1643 TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2, \
1644 __bv1, __bv2, TPACPI_MATCH_UNKNOWN, \
1647 /* Outdated IBM BIOSes often lack the EC id string */
1648 #define TPV_QI2(__bid1, __bid2, __bv1, __bv2, \
1649 __eid1, __eid2, __ev1, __ev2) \
1650 TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2, \
1651 __bv1, __bv2, TPID(__eid1, __eid2), \
1653 TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2, \
1654 __bv1, __bv2, TPACPI_MATCH_UNKNOWN, \
1657 #define TPV_QL0(__id1, __id2, __bv1, __bv2) \
1658 TPV_Q(PCI_VENDOR_ID_LENOVO, __id1, __id2, __bv1, __bv2)
1660 #define TPV_QL1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
1661 TPV_Q_X(PCI_VENDOR_ID_LENOVO, __id1, __id2, \
1662 __bv1, __bv2, TPID(__id1, __id2), \
1665 #define TPV_QL2(__bid1, __bid2, __bv1, __bv2, \
1666 __eid1, __eid2, __ev1, __ev2) \
1667 TPV_Q_X(PCI_VENDOR_ID_LENOVO, __bid1, __bid2, \
1668 __bv1, __bv2, TPID(__eid1, __eid2), \
1671 static const struct tpacpi_quirk tpacpi_bios_version_qtable
[] __initconst
= {
1672 /* Numeric models ------------------ */
1673 /* FW MODEL BIOS VERS */
1674 TPV_QI0('I', 'M', '6', '5'), /* 570 */
1675 TPV_QI0('I', 'U', '2', '6'), /* 570E */
1676 TPV_QI0('I', 'B', '5', '4'), /* 600 */
1677 TPV_QI0('I', 'H', '4', '7'), /* 600E */
1678 TPV_QI0('I', 'N', '3', '6'), /* 600E */
1679 TPV_QI0('I', 'T', '5', '5'), /* 600X */
1680 TPV_QI0('I', 'D', '4', '8'), /* 770, 770E, 770ED */
1681 TPV_QI0('I', 'I', '4', '2'), /* 770X */
1682 TPV_QI0('I', 'O', '2', '3'), /* 770Z */
1684 /* A-series ------------------------- */
1685 /* FW MODEL BIOS VERS EC VERS */
1686 TPV_QI0('I', 'W', '5', '9'), /* A20m */
1687 TPV_QI0('I', 'V', '6', '9'), /* A20p */
1688 TPV_QI0('1', '0', '2', '6'), /* A21e, A22e */
1689 TPV_QI0('K', 'U', '3', '6'), /* A21e */
1690 TPV_QI0('K', 'X', '3', '6'), /* A21m, A22m */
1691 TPV_QI0('K', 'Y', '3', '8'), /* A21p, A22p */
1692 TPV_QI0('1', 'B', '1', '7'), /* A22e */
1693 TPV_QI0('1', '3', '2', '0'), /* A22m */
1694 TPV_QI0('1', 'E', '7', '3'), /* A30/p (0) */
1695 TPV_QI1('1', 'G', '4', '1', '1', '7'), /* A31/p (0) */
1696 TPV_QI1('1', 'N', '1', '6', '0', '7'), /* A31/p (0) */
1698 /* G-series ------------------------- */
1699 /* FW MODEL BIOS VERS */
1700 TPV_QI0('1', 'T', 'A', '6'), /* G40 */
1701 TPV_QI0('1', 'X', '5', '7'), /* G41 */
1703 /* R-series, T-series --------------- */
1704 /* FW MODEL BIOS VERS EC VERS */
1705 TPV_QI0('1', 'C', 'F', '0'), /* R30 */
1706 TPV_QI0('1', 'F', 'F', '1'), /* R31 */
1707 TPV_QI0('1', 'M', '9', '7'), /* R32 */
1708 TPV_QI0('1', 'O', '6', '1'), /* R40 */
1709 TPV_QI0('1', 'P', '6', '5'), /* R40 */
1710 TPV_QI0('1', 'S', '7', '0'), /* R40e */
1711 TPV_QI1('1', 'R', 'D', 'R', '7', '1'), /* R50/p, R51,
1712 T40/p, T41/p, T42/p (1) */
1713 TPV_QI1('1', 'V', '7', '1', '2', '8'), /* R50e, R51 (1) */
1714 TPV_QI1('7', '8', '7', '1', '0', '6'), /* R51e (1) */
1715 TPV_QI1('7', '6', '6', '9', '1', '6'), /* R52 (1) */
1716 TPV_QI1('7', '0', '6', '9', '2', '8'), /* R52, T43 (1) */
1718 TPV_QI0('I', 'Y', '6', '1'), /* T20 */
1719 TPV_QI0('K', 'Z', '3', '4'), /* T21 */
1720 TPV_QI0('1', '6', '3', '2'), /* T22 */
1721 TPV_QI1('1', 'A', '6', '4', '2', '3'), /* T23 (0) */
1722 TPV_QI1('1', 'I', '7', '1', '2', '0'), /* T30 (0) */
1723 TPV_QI1('1', 'Y', '6', '5', '2', '9'), /* T43/p (1) */
1725 TPV_QL1('7', '9', 'E', '3', '5', '0'), /* T60/p */
1726 TPV_QL1('7', 'C', 'D', '2', '2', '2'), /* R60, R60i */
1727 TPV_QL1('7', 'E', 'D', '0', '1', '5'), /* R60e, R60i */
1729 /* BIOS FW BIOS VERS EC FW EC VERS */
1730 TPV_QI2('1', 'W', '9', '0', '1', 'V', '2', '8'), /* R50e (1) */
1731 TPV_QL2('7', 'I', '3', '4', '7', '9', '5', '0'), /* T60/p wide */
1733 /* X-series ------------------------- */
1734 /* FW MODEL BIOS VERS EC VERS */
1735 TPV_QI0('I', 'Z', '9', 'D'), /* X20, X21 */
1736 TPV_QI0('1', 'D', '7', '0'), /* X22, X23, X24 */
1737 TPV_QI1('1', 'K', '4', '8', '1', '8'), /* X30 (0) */
1738 TPV_QI1('1', 'Q', '9', '7', '2', '3'), /* X31, X32 (0) */
1739 TPV_QI1('1', 'U', 'D', '3', 'B', '2'), /* X40 (0) */
1740 TPV_QI1('7', '4', '6', '4', '2', '7'), /* X41 (0) */
1741 TPV_QI1('7', '5', '6', '0', '2', '0'), /* X41t (0) */
1743 TPV_QL1('7', 'B', 'D', '7', '4', '0'), /* X60/s */
1744 TPV_QL1('7', 'J', '3', '0', '1', '3'), /* X60t */
1746 /* (0) - older versions lack DMI EC fw string and functionality */
1747 /* (1) - older versions known to lack functionality */
1758 static void __init
tpacpi_check_outdated_fw(void)
1760 unsigned long fwvers
;
1761 u16 ec_version
, bios_version
;
1763 fwvers
= tpacpi_check_quirks(tpacpi_bios_version_qtable
,
1764 ARRAY_SIZE(tpacpi_bios_version_qtable
));
1769 bios_version
= fwvers
& 0xffffU
;
1770 ec_version
= (fwvers
>> 16) & 0xffffU
;
1772 /* note that unknown versions are set to 0x0000 and we use that */
1773 if ((bios_version
> thinkpad_id
.bios_release
) ||
1774 (ec_version
> thinkpad_id
.ec_release
&&
1775 ec_version
!= TPACPI_MATCH_ANY_VERSION
)) {
1777 * The changelogs would let us track down the exact
1778 * reason, but it is just too much of a pain to track
1779 * it. We only list BIOSes that are either really
1780 * broken, or really stable to begin with, so it is
1781 * best if the user upgrades the firmware anyway.
1783 pr_warn("WARNING: Outdated ThinkPad BIOS/EC firmware\n");
1784 pr_warn("WARNING: This firmware may be missing critical bug fixes and/or important features\n");
1788 static bool __init
tpacpi_is_fw_known(void)
1790 return tpacpi_check_quirks(tpacpi_bios_version_qtable
,
1791 ARRAY_SIZE(tpacpi_bios_version_qtable
)) != 0;
1794 /****************************************************************************
1795 ****************************************************************************
1799 ****************************************************************************
1800 ****************************************************************************/
1802 /*************************************************************************
1803 * thinkpad-acpi metadata subdriver
1806 static int thinkpad_acpi_driver_read(struct seq_file
*m
)
1808 seq_printf(m
, "driver:\t\t%s\n", TPACPI_DESC
);
1809 seq_printf(m
, "version:\t%s\n", TPACPI_VERSION
);
1813 static struct ibm_struct thinkpad_acpi_driver_data
= {
1815 .read
= thinkpad_acpi_driver_read
,
1818 /*************************************************************************
1823 * ThinkPad firmware event model
1825 * The ThinkPad firmware has two main event interfaces: normal ACPI
1826 * notifications (which follow the ACPI standard), and a private event
1829 * The private event interface also issues events for the hotkeys. As
1830 * the driver gained features, the event handling code ended up being
1831 * built around the hotkey subdriver. This will need to be refactored
1832 * to a more formal event API eventually.
1834 * Some "hotkeys" are actually supposed to be used as event reports,
1835 * such as "brightness has changed", "volume has changed", depending on
1836 * the ThinkPad model and how the firmware is operating.
1838 * Unlike other classes, hotkey-class events have mask/unmask control on
1839 * non-ancient firmware. However, how it behaves changes a lot with the
1840 * firmware model and version.
1843 enum { /* hot key scan codes (derived from ACPI DSDT) */
1844 TP_ACPI_HOTKEYSCAN_FNF1
= 0,
1845 TP_ACPI_HOTKEYSCAN_FNF2
,
1846 TP_ACPI_HOTKEYSCAN_FNF3
,
1847 TP_ACPI_HOTKEYSCAN_FNF4
,
1848 TP_ACPI_HOTKEYSCAN_FNF5
,
1849 TP_ACPI_HOTKEYSCAN_FNF6
,
1850 TP_ACPI_HOTKEYSCAN_FNF7
,
1851 TP_ACPI_HOTKEYSCAN_FNF8
,
1852 TP_ACPI_HOTKEYSCAN_FNF9
,
1853 TP_ACPI_HOTKEYSCAN_FNF10
,
1854 TP_ACPI_HOTKEYSCAN_FNF11
,
1855 TP_ACPI_HOTKEYSCAN_FNF12
,
1856 TP_ACPI_HOTKEYSCAN_FNBACKSPACE
,
1857 TP_ACPI_HOTKEYSCAN_FNINSERT
,
1858 TP_ACPI_HOTKEYSCAN_FNDELETE
,
1859 TP_ACPI_HOTKEYSCAN_FNHOME
,
1860 TP_ACPI_HOTKEYSCAN_FNEND
,
1861 TP_ACPI_HOTKEYSCAN_FNPAGEUP
,
1862 TP_ACPI_HOTKEYSCAN_FNPAGEDOWN
,
1863 TP_ACPI_HOTKEYSCAN_FNSPACE
,
1864 TP_ACPI_HOTKEYSCAN_VOLUMEUP
,
1865 TP_ACPI_HOTKEYSCAN_VOLUMEDOWN
,
1866 TP_ACPI_HOTKEYSCAN_MUTE
,
1867 TP_ACPI_HOTKEYSCAN_THINKPAD
,
1868 TP_ACPI_HOTKEYSCAN_UNK1
,
1869 TP_ACPI_HOTKEYSCAN_UNK2
,
1870 TP_ACPI_HOTKEYSCAN_UNK3
,
1871 TP_ACPI_HOTKEYSCAN_UNK4
,
1872 TP_ACPI_HOTKEYSCAN_UNK5
,
1873 TP_ACPI_HOTKEYSCAN_UNK6
,
1874 TP_ACPI_HOTKEYSCAN_UNK7
,
1875 TP_ACPI_HOTKEYSCAN_UNK8
,
1877 /* Adaptive keyboard keycodes */
1878 TP_ACPI_HOTKEYSCAN_ADAPTIVE_START
,
1879 TP_ACPI_HOTKEYSCAN_MUTE2
= TP_ACPI_HOTKEYSCAN_ADAPTIVE_START
,
1880 TP_ACPI_HOTKEYSCAN_BRIGHTNESS_ZERO
,
1881 TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL
,
1882 TP_ACPI_HOTKEYSCAN_CLOUD
,
1883 TP_ACPI_HOTKEYSCAN_UNK9
,
1884 TP_ACPI_HOTKEYSCAN_VOICE
,
1885 TP_ACPI_HOTKEYSCAN_UNK10
,
1886 TP_ACPI_HOTKEYSCAN_GESTURES
,
1887 TP_ACPI_HOTKEYSCAN_UNK11
,
1888 TP_ACPI_HOTKEYSCAN_UNK12
,
1889 TP_ACPI_HOTKEYSCAN_UNK13
,
1890 TP_ACPI_HOTKEYSCAN_CONFIG
,
1891 TP_ACPI_HOTKEYSCAN_NEW_TAB
,
1892 TP_ACPI_HOTKEYSCAN_RELOAD
,
1893 TP_ACPI_HOTKEYSCAN_BACK
,
1894 TP_ACPI_HOTKEYSCAN_MIC_DOWN
,
1895 TP_ACPI_HOTKEYSCAN_MIC_UP
,
1896 TP_ACPI_HOTKEYSCAN_MIC_CANCELLATION
,
1897 TP_ACPI_HOTKEYSCAN_CAMERA_MODE
,
1898 TP_ACPI_HOTKEYSCAN_ROTATE_DISPLAY
,
1900 /* Lenovo extended keymap, starting at 0x1300 */
1901 TP_ACPI_HOTKEYSCAN_EXTENDED_START
,
1902 /* first new observed key (star, favorites) is 0x1311 */
1903 TP_ACPI_HOTKEYSCAN_STAR
= 69,
1904 TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL2
,
1905 TP_ACPI_HOTKEYSCAN_CALCULATOR
,
1906 TP_ACPI_HOTKEYSCAN_BLUETOOTH
,
1907 TP_ACPI_HOTKEYSCAN_KEYBOARD
,
1909 /* Hotkey keymap size */
1910 TPACPI_HOTKEY_MAP_LEN
1913 enum { /* Keys/events available through NVRAM polling */
1914 TPACPI_HKEY_NVRAM_KNOWN_MASK
= 0x00fb88c0U
,
1915 TPACPI_HKEY_NVRAM_GOOD_MASK
= 0x00fb8000U
,
1918 enum { /* Positions of some of the keys in hotkey masks */
1919 TP_ACPI_HKEY_DISPSWTCH_MASK
= 1 << TP_ACPI_HOTKEYSCAN_FNF7
,
1920 TP_ACPI_HKEY_DISPXPAND_MASK
= 1 << TP_ACPI_HOTKEYSCAN_FNF8
,
1921 TP_ACPI_HKEY_HIBERNATE_MASK
= 1 << TP_ACPI_HOTKEYSCAN_FNF12
,
1922 TP_ACPI_HKEY_BRGHTUP_MASK
= 1 << TP_ACPI_HOTKEYSCAN_FNHOME
,
1923 TP_ACPI_HKEY_BRGHTDWN_MASK
= 1 << TP_ACPI_HOTKEYSCAN_FNEND
,
1924 TP_ACPI_HKEY_KBD_LIGHT_MASK
= 1 << TP_ACPI_HOTKEYSCAN_FNPAGEUP
,
1925 TP_ACPI_HKEY_ZOOM_MASK
= 1 << TP_ACPI_HOTKEYSCAN_FNSPACE
,
1926 TP_ACPI_HKEY_VOLUP_MASK
= 1 << TP_ACPI_HOTKEYSCAN_VOLUMEUP
,
1927 TP_ACPI_HKEY_VOLDWN_MASK
= 1 << TP_ACPI_HOTKEYSCAN_VOLUMEDOWN
,
1928 TP_ACPI_HKEY_MUTE_MASK
= 1 << TP_ACPI_HOTKEYSCAN_MUTE
,
1929 TP_ACPI_HKEY_THINKPAD_MASK
= 1 << TP_ACPI_HOTKEYSCAN_THINKPAD
,
1932 enum { /* NVRAM to ACPI HKEY group map */
1933 TP_NVRAM_HKEY_GROUP_HK2
= TP_ACPI_HKEY_THINKPAD_MASK
|
1934 TP_ACPI_HKEY_ZOOM_MASK
|
1935 TP_ACPI_HKEY_DISPSWTCH_MASK
|
1936 TP_ACPI_HKEY_HIBERNATE_MASK
,
1937 TP_NVRAM_HKEY_GROUP_BRIGHTNESS
= TP_ACPI_HKEY_BRGHTUP_MASK
|
1938 TP_ACPI_HKEY_BRGHTDWN_MASK
,
1939 TP_NVRAM_HKEY_GROUP_VOLUME
= TP_ACPI_HKEY_VOLUP_MASK
|
1940 TP_ACPI_HKEY_VOLDWN_MASK
|
1941 TP_ACPI_HKEY_MUTE_MASK
,
1944 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1945 struct tp_nvram_state
{
1946 u16 thinkpad_toggle
:1;
1948 u16 display_toggle
:1;
1949 u16 thinklight_toggle
:1;
1950 u16 hibernate_toggle
:1;
1951 u16 displayexp_toggle
:1;
1952 u16 display_state
:1;
1953 u16 brightness_toggle
:1;
1954 u16 volume_toggle
:1;
1957 u8 brightness_level
;
1961 /* kthread for the hotkey poller */
1962 static struct task_struct
*tpacpi_hotkey_task
;
1965 * Acquire mutex to write poller control variables as an
1968 * Increment hotkey_config_change when changing them if you
1969 * want the kthread to forget old state.
1971 * See HOTKEY_CONFIG_CRITICAL_START/HOTKEY_CONFIG_CRITICAL_END
1973 static struct mutex hotkey_thread_data_mutex
;
1974 static unsigned int hotkey_config_change
;
1977 * hotkey poller control variables
1979 * Must be atomic or readers will also need to acquire mutex
1981 * HOTKEY_CONFIG_CRITICAL_START/HOTKEY_CONFIG_CRITICAL_END
1982 * should be used only when the changes need to be taken as
1983 * a block, OR when one needs to force the kthread to forget
1986 static u32 hotkey_source_mask
; /* bit mask 0=ACPI,1=NVRAM */
1987 static unsigned int hotkey_poll_freq
= 10; /* Hz */
1989 #define HOTKEY_CONFIG_CRITICAL_START \
1991 mutex_lock(&hotkey_thread_data_mutex); \
1992 hotkey_config_change++; \
1994 #define HOTKEY_CONFIG_CRITICAL_END \
1995 mutex_unlock(&hotkey_thread_data_mutex);
1997 #else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1999 #define hotkey_source_mask 0U
2000 #define HOTKEY_CONFIG_CRITICAL_START
2001 #define HOTKEY_CONFIG_CRITICAL_END
2003 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
2005 static struct mutex hotkey_mutex
;
2007 static enum { /* Reasons for waking up */
2008 TP_ACPI_WAKEUP_NONE
= 0, /* None or unknown */
2009 TP_ACPI_WAKEUP_BAYEJ
, /* Bay ejection request */
2010 TP_ACPI_WAKEUP_UNDOCK
, /* Undock request */
2011 } hotkey_wakeup_reason
;
2013 static int hotkey_autosleep_ack
;
2015 static u32 hotkey_orig_mask
; /* events the BIOS had enabled */
2016 static u32 hotkey_all_mask
; /* all events supported in fw */
2017 static u32 hotkey_adaptive_all_mask
; /* all adaptive events supported in fw */
2018 static u32 hotkey_reserved_mask
; /* events better left disabled */
2019 static u32 hotkey_driver_mask
; /* events needed by the driver */
2020 static u32 hotkey_user_mask
; /* events visible to userspace */
2021 static u32 hotkey_acpi_mask
; /* events enabled in firmware */
2023 static u16
*hotkey_keycode_map
;
2025 static struct attribute_set
*hotkey_dev_attributes
;
2027 static void tpacpi_driver_event(const unsigned int hkey_event
);
2028 static void hotkey_driver_event(const unsigned int scancode
);
2029 static void hotkey_poll_setup(const bool may_warn
);
2031 /* HKEY.MHKG() return bits */
2032 #define TP_HOTKEY_TABLET_MASK (1 << 3)
2034 TP_ACPI_MULTI_MODE_INVALID
= 0,
2035 TP_ACPI_MULTI_MODE_UNKNOWN
= 1 << 0,
2036 TP_ACPI_MULTI_MODE_LAPTOP
= 1 << 1,
2037 TP_ACPI_MULTI_MODE_TABLET
= 1 << 2,
2038 TP_ACPI_MULTI_MODE_FLAT
= 1 << 3,
2039 TP_ACPI_MULTI_MODE_STAND
= 1 << 4,
2040 TP_ACPI_MULTI_MODE_TENT
= 1 << 5,
2041 TP_ACPI_MULTI_MODE_STAND_TENT
= 1 << 6,
2045 /* The following modes are considered tablet mode for the purpose of
2046 * reporting the status to userspace. i.e. in all these modes it makes
2047 * sense to disable the laptop input devices such as touchpad and
2050 TP_ACPI_MULTI_MODE_TABLET_LIKE
= TP_ACPI_MULTI_MODE_TABLET
|
2051 TP_ACPI_MULTI_MODE_STAND
|
2052 TP_ACPI_MULTI_MODE_TENT
|
2053 TP_ACPI_MULTI_MODE_STAND_TENT
,
2056 static int hotkey_get_wlsw(void)
2060 if (!tp_features
.hotkey_wlsw
)
2063 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
2065 return (tpacpi_wlsw_emulstate
) ?
2066 TPACPI_RFK_RADIO_ON
: TPACPI_RFK_RADIO_OFF
;
2069 if (!acpi_evalf(hkey_handle
, &status
, "WLSW", "d"))
2072 return (status
) ? TPACPI_RFK_RADIO_ON
: TPACPI_RFK_RADIO_OFF
;
2075 static int hotkey_gmms_get_tablet_mode(int s
, int *has_tablet_mode
)
2077 int type
= (s
>> 16) & 0xffff;
2078 int value
= s
& 0xffff;
2079 int mode
= TP_ACPI_MULTI_MODE_INVALID
;
2080 int valid_modes
= 0;
2082 if (has_tablet_mode
)
2083 *has_tablet_mode
= 0;
2087 valid_modes
= TP_ACPI_MULTI_MODE_LAPTOP
|
2088 TP_ACPI_MULTI_MODE_TABLET
|
2089 TP_ACPI_MULTI_MODE_STAND_TENT
;
2092 valid_modes
= TP_ACPI_MULTI_MODE_LAPTOP
|
2093 TP_ACPI_MULTI_MODE_FLAT
|
2094 TP_ACPI_MULTI_MODE_TABLET
|
2095 TP_ACPI_MULTI_MODE_STAND
|
2096 TP_ACPI_MULTI_MODE_TENT
;
2099 valid_modes
= TP_ACPI_MULTI_MODE_LAPTOP
|
2100 TP_ACPI_MULTI_MODE_FLAT
;
2104 /* In mode 4, FLAT is not specified as a valid mode. However,
2105 * it can be seen at least on the X1 Yoga 2nd Generation.
2107 valid_modes
= TP_ACPI_MULTI_MODE_LAPTOP
|
2108 TP_ACPI_MULTI_MODE_FLAT
|
2109 TP_ACPI_MULTI_MODE_TABLET
|
2110 TP_ACPI_MULTI_MODE_STAND
|
2111 TP_ACPI_MULTI_MODE_TENT
;
2114 pr_err("Unknown multi mode status type %d with value 0x%04X, please report this to %s\n",
2115 type
, value
, TPACPI_MAIL
);
2119 if (has_tablet_mode
&& (valid_modes
& TP_ACPI_MULTI_MODE_TABLET_LIKE
))
2120 *has_tablet_mode
= 1;
2124 mode
= TP_ACPI_MULTI_MODE_LAPTOP
;
2127 mode
= TP_ACPI_MULTI_MODE_FLAT
;
2130 mode
= TP_ACPI_MULTI_MODE_TABLET
;
2134 mode
= TP_ACPI_MULTI_MODE_STAND_TENT
;
2136 mode
= TP_ACPI_MULTI_MODE_STAND
;
2139 mode
= TP_ACPI_MULTI_MODE_TENT
;
2142 if (type
== 5 && value
== 0xffff) {
2143 pr_warn("Multi mode status is undetected, assuming laptop\n");
2148 if (!(mode
& valid_modes
)) {
2149 pr_err("Unknown/reserved multi mode value 0x%04X for type %d, please report this to %s\n",
2150 value
, type
, TPACPI_MAIL
);
2154 return !!(mode
& TP_ACPI_MULTI_MODE_TABLET_LIKE
);
2157 static int hotkey_get_tablet_mode(int *status
)
2161 switch (tp_features
.hotkey_tablet
) {
2162 case TP_HOTKEY_TABLET_USES_MHKG
:
2163 if (!acpi_evalf(hkey_handle
, &s
, "MHKG", "d"))
2166 *status
= ((s
& TP_HOTKEY_TABLET_MASK
) != 0);
2168 case TP_HOTKEY_TABLET_USES_GMMS
:
2169 if (!acpi_evalf(hkey_handle
, &s
, "GMMS", "dd", 0))
2172 *status
= hotkey_gmms_get_tablet_mode(s
, NULL
);
2182 * Reads current event mask from firmware, and updates
2183 * hotkey_acpi_mask accordingly. Also resets any bits
2184 * from hotkey_user_mask that are unavailable to be
2185 * delivered (shadow requirement of the userspace ABI).
2187 * Call with hotkey_mutex held
2189 static int hotkey_mask_get(void)
2191 if (tp_features
.hotkey_mask
) {
2194 if (!acpi_evalf(hkey_handle
, &m
, "DHKN", "d"))
2197 hotkey_acpi_mask
= m
;
2199 /* no mask support doesn't mean no event support... */
2200 hotkey_acpi_mask
= hotkey_all_mask
;
2203 /* sync userspace-visible mask */
2204 hotkey_user_mask
&= (hotkey_acpi_mask
| hotkey_source_mask
);
2209 static void hotkey_mask_warn_incomplete_mask(void)
2211 /* log only what the user can fix... */
2212 const u32 wantedmask
= hotkey_driver_mask
&
2213 ~(hotkey_acpi_mask
| hotkey_source_mask
) &
2214 (hotkey_all_mask
| TPACPI_HKEY_NVRAM_KNOWN_MASK
);
2217 pr_notice("required events 0x%08x not enabled!\n", wantedmask
);
2221 * Set the firmware mask when supported
2223 * Also calls hotkey_mask_get to update hotkey_acpi_mask.
2225 * NOTE: does not set bits in hotkey_user_mask, but may reset them.
2227 * Call with hotkey_mutex held
2229 static int hotkey_mask_set(u32 mask
)
2234 const u32 fwmask
= mask
& ~hotkey_source_mask
;
2236 if (tp_features
.hotkey_mask
) {
2237 for (i
= 0; i
< 32; i
++) {
2238 if (!acpi_evalf(hkey_handle
,
2239 NULL
, "MHKM", "vdd", i
+ 1,
2240 !!(mask
& (1 << i
)))) {
2248 * We *must* make an inconditional call to hotkey_mask_get to
2249 * refresh hotkey_acpi_mask and update hotkey_user_mask
2251 * Take the opportunity to also log when we cannot _enable_
2254 if (!hotkey_mask_get() && !rc
&& (fwmask
& ~hotkey_acpi_mask
)) {
2255 pr_notice("asked for hotkey mask 0x%08x, but firmware forced it to 0x%08x\n",
2256 fwmask
, hotkey_acpi_mask
);
2259 if (tpacpi_lifecycle
!= TPACPI_LIFE_EXITING
)
2260 hotkey_mask_warn_incomplete_mask();
2266 * Sets hotkey_user_mask and tries to set the firmware mask
2268 * Call with hotkey_mutex held
2270 static int hotkey_user_mask_set(const u32 mask
)
2274 /* Give people a chance to notice they are doing something that
2275 * is bound to go boom on their users sooner or later */
2276 if (!tp_warned
.hotkey_mask_ff
&&
2277 (mask
== 0xffff || mask
== 0xffffff ||
2278 mask
== 0xffffffff)) {
2279 tp_warned
.hotkey_mask_ff
= 1;
2280 pr_notice("setting the hotkey mask to 0x%08x is likely not the best way to go about it\n",
2282 pr_notice("please consider using the driver defaults, and refer to up-to-date thinkpad-acpi documentation\n");
2285 /* Try to enable what the user asked for, plus whatever we need.
2286 * this syncs everything but won't enable bits in hotkey_user_mask */
2287 rc
= hotkey_mask_set((mask
| hotkey_driver_mask
) & ~hotkey_source_mask
);
2289 /* Enable the available bits in hotkey_user_mask */
2290 hotkey_user_mask
= mask
& (hotkey_acpi_mask
| hotkey_source_mask
);
2296 * Sets the driver hotkey mask.
2298 * Can be called even if the hotkey subdriver is inactive
2300 static int tpacpi_hotkey_driver_mask_set(const u32 mask
)
2304 /* Do the right thing if hotkey_init has not been called yet */
2305 if (!tp_features
.hotkey
) {
2306 hotkey_driver_mask
= mask
;
2310 mutex_lock(&hotkey_mutex
);
2312 HOTKEY_CONFIG_CRITICAL_START
2313 hotkey_driver_mask
= mask
;
2314 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2315 hotkey_source_mask
|= (mask
& ~hotkey_all_mask
);
2317 HOTKEY_CONFIG_CRITICAL_END
2319 rc
= hotkey_mask_set((hotkey_acpi_mask
| hotkey_driver_mask
) &
2320 ~hotkey_source_mask
);
2321 hotkey_poll_setup(true);
2323 mutex_unlock(&hotkey_mutex
);
2328 static int hotkey_status_get(int *status
)
2330 if (!acpi_evalf(hkey_handle
, status
, "DHKC", "d"))
2336 static int hotkey_status_set(bool enable
)
2338 if (!acpi_evalf(hkey_handle
, NULL
, "MHKC", "vd", enable
? 1 : 0))
2344 static void tpacpi_input_send_tabletsw(void)
2348 if (tp_features
.hotkey_tablet
&&
2349 !hotkey_get_tablet_mode(&state
)) {
2350 mutex_lock(&tpacpi_inputdev_send_mutex
);
2352 input_report_switch(tpacpi_inputdev
,
2353 SW_TABLET_MODE
, !!state
);
2354 input_sync(tpacpi_inputdev
);
2356 mutex_unlock(&tpacpi_inputdev_send_mutex
);
2360 /* Do NOT call without validating scancode first */
2361 static void tpacpi_input_send_key(const unsigned int scancode
)
2363 const unsigned int keycode
= hotkey_keycode_map
[scancode
];
2365 if (keycode
!= KEY_RESERVED
) {
2366 mutex_lock(&tpacpi_inputdev_send_mutex
);
2368 input_event(tpacpi_inputdev
, EV_MSC
, MSC_SCAN
, scancode
);
2369 input_report_key(tpacpi_inputdev
, keycode
, 1);
2370 input_sync(tpacpi_inputdev
);
2372 input_event(tpacpi_inputdev
, EV_MSC
, MSC_SCAN
, scancode
);
2373 input_report_key(tpacpi_inputdev
, keycode
, 0);
2374 input_sync(tpacpi_inputdev
);
2376 mutex_unlock(&tpacpi_inputdev_send_mutex
);
2380 /* Do NOT call without validating scancode first */
2381 static void tpacpi_input_send_key_masked(const unsigned int scancode
)
2383 hotkey_driver_event(scancode
);
2384 if (hotkey_user_mask
& (1 << scancode
))
2385 tpacpi_input_send_key(scancode
);
2388 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2389 static struct tp_acpi_drv_struct ibm_hotkey_acpidriver
;
2391 /* Do NOT call without validating scancode first */
2392 static void tpacpi_hotkey_send_key(unsigned int scancode
)
2394 tpacpi_input_send_key_masked(scancode
);
2397 static void hotkey_read_nvram(struct tp_nvram_state
*n
, const u32 m
)
2401 if (m
& TP_NVRAM_HKEY_GROUP_HK2
) {
2402 d
= nvram_read_byte(TP_NVRAM_ADDR_HK2
);
2403 n
->thinkpad_toggle
= !!(d
& TP_NVRAM_MASK_HKT_THINKPAD
);
2404 n
->zoom_toggle
= !!(d
& TP_NVRAM_MASK_HKT_ZOOM
);
2405 n
->display_toggle
= !!(d
& TP_NVRAM_MASK_HKT_DISPLAY
);
2406 n
->hibernate_toggle
= !!(d
& TP_NVRAM_MASK_HKT_HIBERNATE
);
2408 if (m
& TP_ACPI_HKEY_KBD_LIGHT_MASK
) {
2409 d
= nvram_read_byte(TP_NVRAM_ADDR_THINKLIGHT
);
2410 n
->thinklight_toggle
= !!(d
& TP_NVRAM_MASK_THINKLIGHT
);
2412 if (m
& TP_ACPI_HKEY_DISPXPAND_MASK
) {
2413 d
= nvram_read_byte(TP_NVRAM_ADDR_VIDEO
);
2414 n
->displayexp_toggle
=
2415 !!(d
& TP_NVRAM_MASK_HKT_DISPEXPND
);
2417 if (m
& TP_NVRAM_HKEY_GROUP_BRIGHTNESS
) {
2418 d
= nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS
);
2419 n
->brightness_level
= (d
& TP_NVRAM_MASK_LEVEL_BRIGHTNESS
)
2420 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS
;
2421 n
->brightness_toggle
=
2422 !!(d
& TP_NVRAM_MASK_HKT_BRIGHTNESS
);
2424 if (m
& TP_NVRAM_HKEY_GROUP_VOLUME
) {
2425 d
= nvram_read_byte(TP_NVRAM_ADDR_MIXER
);
2426 n
->volume_level
= (d
& TP_NVRAM_MASK_LEVEL_VOLUME
)
2427 >> TP_NVRAM_POS_LEVEL_VOLUME
;
2428 n
->mute
= !!(d
& TP_NVRAM_MASK_MUTE
);
2429 n
->volume_toggle
= !!(d
& TP_NVRAM_MASK_HKT_VOLUME
);
2433 #define TPACPI_COMPARE_KEY(__scancode, __member) \
2435 if ((event_mask & (1 << __scancode)) && \
2436 oldn->__member != newn->__member) \
2437 tpacpi_hotkey_send_key(__scancode); \
2440 #define TPACPI_MAY_SEND_KEY(__scancode) \
2442 if (event_mask & (1 << __scancode)) \
2443 tpacpi_hotkey_send_key(__scancode); \
2446 static void issue_volchange(const unsigned int oldvol
,
2447 const unsigned int newvol
,
2448 const u32 event_mask
)
2450 unsigned int i
= oldvol
;
2452 while (i
> newvol
) {
2453 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN
);
2456 while (i
< newvol
) {
2457 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP
);
2462 static void issue_brightnesschange(const unsigned int oldbrt
,
2463 const unsigned int newbrt
,
2464 const u32 event_mask
)
2466 unsigned int i
= oldbrt
;
2468 while (i
> newbrt
) {
2469 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND
);
2472 while (i
< newbrt
) {
2473 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME
);
2478 static void hotkey_compare_and_issue_event(struct tp_nvram_state
*oldn
,
2479 struct tp_nvram_state
*newn
,
2480 const u32 event_mask
)
2483 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_THINKPAD
, thinkpad_toggle
);
2484 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNSPACE
, zoom_toggle
);
2485 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF7
, display_toggle
);
2486 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF12
, hibernate_toggle
);
2488 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNPAGEUP
, thinklight_toggle
);
2490 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF8
, displayexp_toggle
);
2495 * This code is supposed to duplicate the IBM firmware behaviour:
2496 * - Pressing MUTE issues mute hotkey message, even when already mute
2497 * - Pressing Volume up/down issues volume up/down hotkey messages,
2498 * even when already at maximum or minimum volume
2499 * - The act of unmuting issues volume up/down notification,
2500 * depending which key was used to unmute
2502 * We are constrained to what the NVRAM can tell us, which is not much
2503 * and certainly not enough if more than one volume hotkey was pressed
2504 * since the last poll cycle.
2506 * Just to make our life interesting, some newer Lenovo ThinkPads have
2507 * bugs in the BIOS and may fail to update volume_toggle properly.
2512 oldn
->volume_toggle
!= newn
->volume_toggle
||
2513 oldn
->volume_level
!= newn
->volume_level
) {
2514 /* recently muted, or repeated mute keypress, or
2515 * multiple presses ending in mute */
2516 issue_volchange(oldn
->volume_level
, newn
->volume_level
,
2518 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE
);
2523 /* recently unmuted, issue 'unmute' keypress */
2524 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP
);
2526 if (oldn
->volume_level
!= newn
->volume_level
) {
2527 issue_volchange(oldn
->volume_level
, newn
->volume_level
,
2529 } else if (oldn
->volume_toggle
!= newn
->volume_toggle
) {
2530 /* repeated vol up/down keypress at end of scale ? */
2531 if (newn
->volume_level
== 0)
2532 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN
);
2533 else if (newn
->volume_level
>= TP_NVRAM_LEVEL_VOLUME_MAX
)
2534 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP
);
2538 /* handle brightness */
2539 if (oldn
->brightness_level
!= newn
->brightness_level
) {
2540 issue_brightnesschange(oldn
->brightness_level
,
2541 newn
->brightness_level
, event_mask
);
2542 } else if (oldn
->brightness_toggle
!= newn
->brightness_toggle
) {
2543 /* repeated key presses that didn't change state */
2544 if (newn
->brightness_level
== 0)
2545 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND
);
2546 else if (newn
->brightness_level
>= bright_maxlvl
2547 && !tp_features
.bright_unkfw
)
2548 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME
);
2551 #undef TPACPI_COMPARE_KEY
2552 #undef TPACPI_MAY_SEND_KEY
2558 * We track all events in hotkey_source_mask all the time, since
2559 * most of them are edge-based. We only issue those requested by
2560 * hotkey_user_mask or hotkey_driver_mask, though.
2562 static int hotkey_kthread(void *data
)
2564 struct tp_nvram_state s
[2];
2565 u32 poll_mask
, event_mask
;
2566 unsigned int si
, so
;
2568 unsigned int change_detector
;
2569 unsigned int poll_freq
;
2572 if (tpacpi_lifecycle
== TPACPI_LIFE_EXITING
)
2581 /* Initial state for compares */
2582 mutex_lock(&hotkey_thread_data_mutex
);
2583 change_detector
= hotkey_config_change
;
2584 poll_mask
= hotkey_source_mask
;
2585 event_mask
= hotkey_source_mask
&
2586 (hotkey_driver_mask
| hotkey_user_mask
);
2587 poll_freq
= hotkey_poll_freq
;
2588 mutex_unlock(&hotkey_thread_data_mutex
);
2589 hotkey_read_nvram(&s
[so
], poll_mask
);
2591 while (!kthread_should_stop()) {
2593 if (likely(poll_freq
))
2596 t
= 100; /* should never happen... */
2598 t
= msleep_interruptible(t
);
2599 if (unlikely(kthread_freezable_should_stop(&was_frozen
)))
2602 if (t
> 0 && !was_frozen
)
2605 mutex_lock(&hotkey_thread_data_mutex
);
2606 if (was_frozen
|| hotkey_config_change
!= change_detector
) {
2607 /* forget old state on thaw or config change */
2610 change_detector
= hotkey_config_change
;
2612 poll_mask
= hotkey_source_mask
;
2613 event_mask
= hotkey_source_mask
&
2614 (hotkey_driver_mask
| hotkey_user_mask
);
2615 poll_freq
= hotkey_poll_freq
;
2616 mutex_unlock(&hotkey_thread_data_mutex
);
2618 if (likely(poll_mask
)) {
2619 hotkey_read_nvram(&s
[si
], poll_mask
);
2620 if (likely(si
!= so
)) {
2621 hotkey_compare_and_issue_event(&s
[so
], &s
[si
],
2634 /* call with hotkey_mutex held */
2635 static void hotkey_poll_stop_sync(void)
2637 if (tpacpi_hotkey_task
) {
2638 kthread_stop(tpacpi_hotkey_task
);
2639 tpacpi_hotkey_task
= NULL
;
2643 /* call with hotkey_mutex held */
2644 static void hotkey_poll_setup(const bool may_warn
)
2646 const u32 poll_driver_mask
= hotkey_driver_mask
& hotkey_source_mask
;
2647 const u32 poll_user_mask
= hotkey_user_mask
& hotkey_source_mask
;
2649 if (hotkey_poll_freq
> 0 &&
2650 (poll_driver_mask
||
2651 (poll_user_mask
&& tpacpi_inputdev
->users
> 0))) {
2652 if (!tpacpi_hotkey_task
) {
2653 tpacpi_hotkey_task
= kthread_run(hotkey_kthread
,
2654 NULL
, TPACPI_NVRAM_KTHREAD_NAME
);
2655 if (IS_ERR(tpacpi_hotkey_task
)) {
2656 tpacpi_hotkey_task
= NULL
;
2657 pr_err("could not create kernel thread for hotkey polling\n");
2661 hotkey_poll_stop_sync();
2662 if (may_warn
&& (poll_driver_mask
|| poll_user_mask
) &&
2663 hotkey_poll_freq
== 0) {
2664 pr_notice("hot keys 0x%08x and/or events 0x%08x require polling, which is currently disabled\n",
2665 poll_user_mask
, poll_driver_mask
);
2670 static void hotkey_poll_setup_safe(const bool may_warn
)
2672 mutex_lock(&hotkey_mutex
);
2673 hotkey_poll_setup(may_warn
);
2674 mutex_unlock(&hotkey_mutex
);
2677 /* call with hotkey_mutex held */
2678 static void hotkey_poll_set_freq(unsigned int freq
)
2681 hotkey_poll_stop_sync();
2683 hotkey_poll_freq
= freq
;
2686 #else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
2688 static void hotkey_poll_setup(const bool __unused
)
2692 static void hotkey_poll_setup_safe(const bool __unused
)
2696 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
2698 static int hotkey_inputdev_open(struct input_dev
*dev
)
2700 switch (tpacpi_lifecycle
) {
2701 case TPACPI_LIFE_INIT
:
2702 case TPACPI_LIFE_RUNNING
:
2703 hotkey_poll_setup_safe(false);
2705 case TPACPI_LIFE_EXITING
:
2709 /* Should only happen if tpacpi_lifecycle is corrupt */
2714 static void hotkey_inputdev_close(struct input_dev
*dev
)
2716 /* disable hotkey polling when possible */
2717 if (tpacpi_lifecycle
!= TPACPI_LIFE_EXITING
&&
2718 !(hotkey_source_mask
& hotkey_driver_mask
))
2719 hotkey_poll_setup_safe(false);
2722 /* sysfs hotkey enable ------------------------------------------------- */
2723 static ssize_t
hotkey_enable_show(struct device
*dev
,
2724 struct device_attribute
*attr
,
2729 printk_deprecated_attribute("hotkey_enable",
2730 "Hotkey reporting is always enabled");
2732 res
= hotkey_status_get(&status
);
2736 return snprintf(buf
, PAGE_SIZE
, "%d\n", status
);
2739 static ssize_t
hotkey_enable_store(struct device
*dev
,
2740 struct device_attribute
*attr
,
2741 const char *buf
, size_t count
)
2745 printk_deprecated_attribute("hotkey_enable",
2746 "Hotkeys can be disabled through hotkey_mask");
2748 if (parse_strtoul(buf
, 1, &t
))
2757 static DEVICE_ATTR_RW(hotkey_enable
);
2759 /* sysfs hotkey mask --------------------------------------------------- */
2760 static ssize_t
hotkey_mask_show(struct device
*dev
,
2761 struct device_attribute
*attr
,
2764 return snprintf(buf
, PAGE_SIZE
, "0x%08x\n", hotkey_user_mask
);
2767 static ssize_t
hotkey_mask_store(struct device
*dev
,
2768 struct device_attribute
*attr
,
2769 const char *buf
, size_t count
)
2774 if (parse_strtoul(buf
, 0xffffffffUL
, &t
))
2777 if (mutex_lock_killable(&hotkey_mutex
))
2778 return -ERESTARTSYS
;
2780 res
= hotkey_user_mask_set(t
);
2782 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2783 hotkey_poll_setup(true);
2786 mutex_unlock(&hotkey_mutex
);
2788 tpacpi_disclose_usertask("hotkey_mask", "set to 0x%08lx\n", t
);
2790 return (res
) ? res
: count
;
2793 static DEVICE_ATTR_RW(hotkey_mask
);
2795 /* sysfs hotkey bios_enabled ------------------------------------------- */
2796 static ssize_t
hotkey_bios_enabled_show(struct device
*dev
,
2797 struct device_attribute
*attr
,
2800 return sprintf(buf
, "0\n");
2803 static DEVICE_ATTR_RO(hotkey_bios_enabled
);
2805 /* sysfs hotkey bios_mask ---------------------------------------------- */
2806 static ssize_t
hotkey_bios_mask_show(struct device
*dev
,
2807 struct device_attribute
*attr
,
2810 printk_deprecated_attribute("hotkey_bios_mask",
2811 "This attribute is useless.");
2812 return snprintf(buf
, PAGE_SIZE
, "0x%08x\n", hotkey_orig_mask
);
2815 static DEVICE_ATTR_RO(hotkey_bios_mask
);
2817 /* sysfs hotkey all_mask ----------------------------------------------- */
2818 static ssize_t
hotkey_all_mask_show(struct device
*dev
,
2819 struct device_attribute
*attr
,
2822 return snprintf(buf
, PAGE_SIZE
, "0x%08x\n",
2823 hotkey_all_mask
| hotkey_source_mask
);
2826 static DEVICE_ATTR_RO(hotkey_all_mask
);
2828 /* sysfs hotkey all_mask ----------------------------------------------- */
2829 static ssize_t
hotkey_adaptive_all_mask_show(struct device
*dev
,
2830 struct device_attribute
*attr
,
2833 return snprintf(buf
, PAGE_SIZE
, "0x%08x\n",
2834 hotkey_adaptive_all_mask
| hotkey_source_mask
);
2837 static DEVICE_ATTR_RO(hotkey_adaptive_all_mask
);
2839 /* sysfs hotkey recommended_mask --------------------------------------- */
2840 static ssize_t
hotkey_recommended_mask_show(struct device
*dev
,
2841 struct device_attribute
*attr
,
2844 return snprintf(buf
, PAGE_SIZE
, "0x%08x\n",
2845 (hotkey_all_mask
| hotkey_source_mask
)
2846 & ~hotkey_reserved_mask
);
2849 static DEVICE_ATTR_RO(hotkey_recommended_mask
);
2851 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2853 /* sysfs hotkey hotkey_source_mask ------------------------------------- */
2854 static ssize_t
hotkey_source_mask_show(struct device
*dev
,
2855 struct device_attribute
*attr
,
2858 return snprintf(buf
, PAGE_SIZE
, "0x%08x\n", hotkey_source_mask
);
2861 static ssize_t
hotkey_source_mask_store(struct device
*dev
,
2862 struct device_attribute
*attr
,
2863 const char *buf
, size_t count
)
2869 if (parse_strtoul(buf
, 0xffffffffUL
, &t
) ||
2870 ((t
& ~TPACPI_HKEY_NVRAM_KNOWN_MASK
) != 0))
2873 if (mutex_lock_killable(&hotkey_mutex
))
2874 return -ERESTARTSYS
;
2876 HOTKEY_CONFIG_CRITICAL_START
2877 hotkey_source_mask
= t
;
2878 HOTKEY_CONFIG_CRITICAL_END
2880 rc
= hotkey_mask_set((hotkey_user_mask
| hotkey_driver_mask
) &
2881 ~hotkey_source_mask
);
2882 hotkey_poll_setup(true);
2884 /* check if events needed by the driver got disabled */
2885 r_ev
= hotkey_driver_mask
& ~(hotkey_acpi_mask
& hotkey_all_mask
)
2886 & ~hotkey_source_mask
& TPACPI_HKEY_NVRAM_KNOWN_MASK
;
2888 mutex_unlock(&hotkey_mutex
);
2891 pr_err("hotkey_source_mask: failed to update the firmware event mask!\n");
2894 pr_notice("hotkey_source_mask: some important events were disabled: 0x%04x\n",
2897 tpacpi_disclose_usertask("hotkey_source_mask", "set to 0x%08lx\n", t
);
2899 return (rc
< 0) ? rc
: count
;
2902 static DEVICE_ATTR_RW(hotkey_source_mask
);
2904 /* sysfs hotkey hotkey_poll_freq --------------------------------------- */
2905 static ssize_t
hotkey_poll_freq_show(struct device
*dev
,
2906 struct device_attribute
*attr
,
2909 return snprintf(buf
, PAGE_SIZE
, "%d\n", hotkey_poll_freq
);
2912 static ssize_t
hotkey_poll_freq_store(struct device
*dev
,
2913 struct device_attribute
*attr
,
2914 const char *buf
, size_t count
)
2918 if (parse_strtoul(buf
, 25, &t
))
2921 if (mutex_lock_killable(&hotkey_mutex
))
2922 return -ERESTARTSYS
;
2924 hotkey_poll_set_freq(t
);
2925 hotkey_poll_setup(true);
2927 mutex_unlock(&hotkey_mutex
);
2929 tpacpi_disclose_usertask("hotkey_poll_freq", "set to %lu\n", t
);
2934 static DEVICE_ATTR_RW(hotkey_poll_freq
);
2936 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
2938 /* sysfs hotkey radio_sw (pollable) ------------------------------------ */
2939 static ssize_t
hotkey_radio_sw_show(struct device
*dev
,
2940 struct device_attribute
*attr
,
2944 res
= hotkey_get_wlsw();
2948 /* Opportunistic update */
2949 tpacpi_rfk_update_hwblock_state((res
== TPACPI_RFK_RADIO_OFF
));
2951 return snprintf(buf
, PAGE_SIZE
, "%d\n",
2952 (res
== TPACPI_RFK_RADIO_OFF
) ? 0 : 1);
2955 static DEVICE_ATTR_RO(hotkey_radio_sw
);
2957 static void hotkey_radio_sw_notify_change(void)
2959 if (tp_features
.hotkey_wlsw
)
2960 sysfs_notify(&tpacpi_pdev
->dev
.kobj
, NULL
,
2964 /* sysfs hotkey tablet mode (pollable) --------------------------------- */
2965 static ssize_t
hotkey_tablet_mode_show(struct device
*dev
,
2966 struct device_attribute
*attr
,
2970 res
= hotkey_get_tablet_mode(&s
);
2974 return snprintf(buf
, PAGE_SIZE
, "%d\n", !!s
);
2977 static DEVICE_ATTR_RO(hotkey_tablet_mode
);
2979 static void hotkey_tablet_mode_notify_change(void)
2981 if (tp_features
.hotkey_tablet
)
2982 sysfs_notify(&tpacpi_pdev
->dev
.kobj
, NULL
,
2983 "hotkey_tablet_mode");
2986 /* sysfs wakeup reason (pollable) -------------------------------------- */
2987 static ssize_t
hotkey_wakeup_reason_show(struct device
*dev
,
2988 struct device_attribute
*attr
,
2991 return snprintf(buf
, PAGE_SIZE
, "%d\n", hotkey_wakeup_reason
);
2994 static DEVICE_ATTR(wakeup_reason
, S_IRUGO
, hotkey_wakeup_reason_show
, NULL
);
2996 static void hotkey_wakeup_reason_notify_change(void)
2998 sysfs_notify(&tpacpi_pdev
->dev
.kobj
, NULL
,
3002 /* sysfs wakeup hotunplug_complete (pollable) -------------------------- */
3003 static ssize_t
hotkey_wakeup_hotunplug_complete_show(struct device
*dev
,
3004 struct device_attribute
*attr
,
3007 return snprintf(buf
, PAGE_SIZE
, "%d\n", hotkey_autosleep_ack
);
3010 static DEVICE_ATTR(wakeup_hotunplug_complete
, S_IRUGO
,
3011 hotkey_wakeup_hotunplug_complete_show
, NULL
);
3013 static void hotkey_wakeup_hotunplug_complete_notify_change(void)
3015 sysfs_notify(&tpacpi_pdev
->dev
.kobj
, NULL
,
3016 "wakeup_hotunplug_complete");
3019 /* sysfs adaptive kbd mode --------------------------------------------- */
3021 static int adaptive_keyboard_get_mode(void);
3022 static int adaptive_keyboard_set_mode(int new_mode
);
3024 enum ADAPTIVE_KEY_MODE
{
3027 WEB_CONFERENCE_MODE
,
3032 static ssize_t
adaptive_kbd_mode_show(struct device
*dev
,
3033 struct device_attribute
*attr
,
3038 current_mode
= adaptive_keyboard_get_mode();
3039 if (current_mode
< 0)
3040 return current_mode
;
3042 return snprintf(buf
, PAGE_SIZE
, "%d\n", current_mode
);
3045 static ssize_t
adaptive_kbd_mode_store(struct device
*dev
,
3046 struct device_attribute
*attr
,
3047 const char *buf
, size_t count
)
3052 if (parse_strtoul(buf
, LAYFLAT_MODE
, &t
))
3055 res
= adaptive_keyboard_set_mode(t
);
3056 return (res
< 0) ? res
: count
;
3059 static DEVICE_ATTR_RW(adaptive_kbd_mode
);
3061 static struct attribute
*adaptive_kbd_attributes
[] = {
3062 &dev_attr_adaptive_kbd_mode
.attr
,
3066 static const struct attribute_group adaptive_kbd_attr_group
= {
3067 .attrs
= adaptive_kbd_attributes
,
3070 /* --------------------------------------------------------------------- */
3072 static struct attribute
*hotkey_attributes
[] __initdata
= {
3073 &dev_attr_hotkey_enable
.attr
,
3074 &dev_attr_hotkey_bios_enabled
.attr
,
3075 &dev_attr_hotkey_bios_mask
.attr
,
3076 &dev_attr_wakeup_reason
.attr
,
3077 &dev_attr_wakeup_hotunplug_complete
.attr
,
3078 &dev_attr_hotkey_mask
.attr
,
3079 &dev_attr_hotkey_all_mask
.attr
,
3080 &dev_attr_hotkey_adaptive_all_mask
.attr
,
3081 &dev_attr_hotkey_recommended_mask
.attr
,
3082 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3083 &dev_attr_hotkey_source_mask
.attr
,
3084 &dev_attr_hotkey_poll_freq
.attr
,
3089 * Sync both the hw and sw blocking state of all switches
3091 static void tpacpi_send_radiosw_update(void)
3096 * We must sync all rfkill controllers *before* issuing any
3097 * rfkill input events, or we will race the rfkill core input
3100 * tpacpi_inputdev_send_mutex works as a synchronization point
3103 * We optimize to avoid numerous calls to hotkey_get_wlsw.
3106 wlsw
= hotkey_get_wlsw();
3108 /* Sync hw blocking state first if it is hw-blocked */
3109 if (wlsw
== TPACPI_RFK_RADIO_OFF
)
3110 tpacpi_rfk_update_hwblock_state(true);
3112 /* Sync sw blocking state */
3113 tpacpi_rfk_update_swstate_all();
3115 /* Sync hw blocking state last if it is hw-unblocked */
3116 if (wlsw
== TPACPI_RFK_RADIO_ON
)
3117 tpacpi_rfk_update_hwblock_state(false);
3119 /* Issue rfkill input event for WLSW switch */
3121 mutex_lock(&tpacpi_inputdev_send_mutex
);
3123 input_report_switch(tpacpi_inputdev
,
3124 SW_RFKILL_ALL
, (wlsw
> 0));
3125 input_sync(tpacpi_inputdev
);
3127 mutex_unlock(&tpacpi_inputdev_send_mutex
);
3131 * this can be unconditional, as we will poll state again
3132 * if userspace uses the notify to read data
3134 hotkey_radio_sw_notify_change();
3137 static void hotkey_exit(void)
3139 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3140 mutex_lock(&hotkey_mutex
);
3141 hotkey_poll_stop_sync();
3142 mutex_unlock(&hotkey_mutex
);
3145 if (hotkey_dev_attributes
)
3146 delete_attr_set(hotkey_dev_attributes
, &tpacpi_pdev
->dev
.kobj
);
3148 dbg_printk(TPACPI_DBG_EXIT
| TPACPI_DBG_HKEY
,
3149 "restoring original HKEY status and mask\n");
3150 /* yes, there is a bitwise or below, we want the
3151 * functions to be called even if one of them fail */
3152 if (((tp_features
.hotkey_mask
&&
3153 hotkey_mask_set(hotkey_orig_mask
)) |
3154 hotkey_status_set(false)) != 0)
3155 pr_err("failed to restore hot key mask to BIOS defaults\n");
3158 static void __init
hotkey_unmap(const unsigned int scancode
)
3160 if (hotkey_keycode_map
[scancode
] != KEY_RESERVED
) {
3161 clear_bit(hotkey_keycode_map
[scancode
],
3162 tpacpi_inputdev
->keybit
);
3163 hotkey_keycode_map
[scancode
] = KEY_RESERVED
;
3169 * TPACPI_HK_Q_INIMASK: Supports FN+F3,FN+F4,FN+F12
3172 #define TPACPI_HK_Q_INIMASK 0x0001
3174 static const struct tpacpi_quirk tpacpi_hotkey_qtable
[] __initconst
= {
3175 TPACPI_Q_IBM('I', 'H', TPACPI_HK_Q_INIMASK
), /* 600E */
3176 TPACPI_Q_IBM('I', 'N', TPACPI_HK_Q_INIMASK
), /* 600E */
3177 TPACPI_Q_IBM('I', 'D', TPACPI_HK_Q_INIMASK
), /* 770, 770E, 770ED */
3178 TPACPI_Q_IBM('I', 'W', TPACPI_HK_Q_INIMASK
), /* A20m */
3179 TPACPI_Q_IBM('I', 'V', TPACPI_HK_Q_INIMASK
), /* A20p */
3180 TPACPI_Q_IBM('1', '0', TPACPI_HK_Q_INIMASK
), /* A21e, A22e */
3181 TPACPI_Q_IBM('K', 'U', TPACPI_HK_Q_INIMASK
), /* A21e */
3182 TPACPI_Q_IBM('K', 'X', TPACPI_HK_Q_INIMASK
), /* A21m, A22m */
3183 TPACPI_Q_IBM('K', 'Y', TPACPI_HK_Q_INIMASK
), /* A21p, A22p */
3184 TPACPI_Q_IBM('1', 'B', TPACPI_HK_Q_INIMASK
), /* A22e */
3185 TPACPI_Q_IBM('1', '3', TPACPI_HK_Q_INIMASK
), /* A22m */
3186 TPACPI_Q_IBM('1', 'E', TPACPI_HK_Q_INIMASK
), /* A30/p (0) */
3187 TPACPI_Q_IBM('1', 'C', TPACPI_HK_Q_INIMASK
), /* R30 */
3188 TPACPI_Q_IBM('1', 'F', TPACPI_HK_Q_INIMASK
), /* R31 */
3189 TPACPI_Q_IBM('I', 'Y', TPACPI_HK_Q_INIMASK
), /* T20 */
3190 TPACPI_Q_IBM('K', 'Z', TPACPI_HK_Q_INIMASK
), /* T21 */
3191 TPACPI_Q_IBM('1', '6', TPACPI_HK_Q_INIMASK
), /* T22 */
3192 TPACPI_Q_IBM('I', 'Z', TPACPI_HK_Q_INIMASK
), /* X20, X21 */
3193 TPACPI_Q_IBM('1', 'D', TPACPI_HK_Q_INIMASK
), /* X22, X23, X24 */
3196 typedef u16 tpacpi_keymap_entry_t
;
3197 typedef tpacpi_keymap_entry_t tpacpi_keymap_t
[TPACPI_HOTKEY_MAP_LEN
];
3199 static int hotkey_init_tablet_mode(void)
3201 int in_tablet_mode
= 0, res
;
3204 if (acpi_evalf(hkey_handle
, &res
, "GMMS", "qdd", 0)) {
3205 int has_tablet_mode
;
3207 in_tablet_mode
= hotkey_gmms_get_tablet_mode(res
,
3209 if (has_tablet_mode
)
3210 tp_features
.hotkey_tablet
= TP_HOTKEY_TABLET_USES_GMMS
;
3212 } else if (acpi_evalf(hkey_handle
, &res
, "MHKG", "qd")) {
3213 /* For X41t, X60t, X61t Tablets... */
3214 tp_features
.hotkey_tablet
= TP_HOTKEY_TABLET_USES_MHKG
;
3215 in_tablet_mode
= !!(res
& TP_HOTKEY_TABLET_MASK
);
3219 if (!tp_features
.hotkey_tablet
)
3222 pr_info("Tablet mode switch found (type: %s), currently in %s mode\n",
3223 type
, in_tablet_mode
? "tablet" : "laptop");
3225 res
= add_to_attr_set(hotkey_dev_attributes
,
3226 &dev_attr_hotkey_tablet_mode
.attr
);
3230 return in_tablet_mode
;
3233 static int __init
hotkey_init(struct ibm_init_struct
*iibm
)
3235 /* Requirements for changing the default keymaps:
3237 * 1. Many of the keys are mapped to KEY_RESERVED for very
3238 * good reasons. Do not change them unless you have deep
3239 * knowledge on the IBM and Lenovo ThinkPad firmware for
3240 * the various ThinkPad models. The driver behaves
3241 * differently for KEY_RESERVED: such keys have their
3242 * hot key mask *unset* in mask_recommended, and also
3243 * in the initial hot key mask programmed into the
3244 * firmware at driver load time, which means the firm-
3245 * ware may react very differently if you change them to
3248 * 2. You must be subscribed to the linux-thinkpad and
3249 * ibm-acpi-devel mailing lists, and you should read the
3250 * list archives since 2007 if you want to change the
3251 * keymaps. This requirement exists so that you will
3252 * know the past history of problems with the thinkpad-
3253 * acpi driver keymaps, and also that you will be
3254 * listening to any bug reports;
3256 * 3. Do not send thinkpad-acpi specific patches directly to
3257 * for merging, *ever*. Send them to the linux-acpi
3258 * mailinglist for comments. Merging is to be done only
3259 * through acpi-test and the ACPI maintainer.
3261 * If the above is too much to ask, don't change the keymap.
3262 * Ask the thinkpad-acpi maintainer to do it, instead.
3266 TPACPI_KEYMAP_IBM_GENERIC
= 0,
3267 TPACPI_KEYMAP_LENOVO_GENERIC
,
3270 static const tpacpi_keymap_t tpacpi_keymaps
[] __initconst
= {
3271 /* Generic keymap for IBM ThinkPads */
3272 [TPACPI_KEYMAP_IBM_GENERIC
] = {
3273 /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
3274 KEY_FN_F1
, KEY_BATTERY
, KEY_COFFEE
, KEY_SLEEP
,
3275 KEY_WLAN
, KEY_FN_F6
, KEY_SWITCHVIDEOMODE
, KEY_FN_F8
,
3276 KEY_FN_F9
, KEY_FN_F10
, KEY_FN_F11
, KEY_SUSPEND
,
3278 /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
3279 KEY_UNKNOWN
, /* 0x0C: FN+BACKSPACE */
3280 KEY_UNKNOWN
, /* 0x0D: FN+INSERT */
3281 KEY_UNKNOWN
, /* 0x0E: FN+DELETE */
3283 /* brightness: firmware always reacts to them */
3284 KEY_RESERVED
, /* 0x0F: FN+HOME (brightness up) */
3285 KEY_RESERVED
, /* 0x10: FN+END (brightness down) */
3287 /* Thinklight: firmware always react to it */
3288 KEY_RESERVED
, /* 0x11: FN+PGUP (thinklight toggle) */
3290 KEY_UNKNOWN
, /* 0x12: FN+PGDOWN */
3291 KEY_ZOOM
, /* 0x13: FN+SPACE (zoom) */
3293 /* Volume: firmware always react to it and reprograms
3294 * the built-in *extra* mixer. Never map it to control
3295 * another mixer by default. */
3296 KEY_RESERVED
, /* 0x14: VOLUME UP */
3297 KEY_RESERVED
, /* 0x15: VOLUME DOWN */
3298 KEY_RESERVED
, /* 0x16: MUTE */
3300 KEY_VENDOR
, /* 0x17: Thinkpad/AccessIBM/Lenovo */
3302 /* (assignments unknown, please report if found) */
3303 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3304 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3306 /* No assignments, only used for Adaptive keyboards. */
3307 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3308 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3309 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3310 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3311 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3313 /* No assignment, used for newer Lenovo models */
3314 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3315 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3316 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3317 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3318 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3319 KEY_UNKNOWN
, KEY_UNKNOWN
3323 /* Generic keymap for Lenovo ThinkPads */
3324 [TPACPI_KEYMAP_LENOVO_GENERIC
] = {
3325 /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
3326 KEY_FN_F1
, KEY_COFFEE
, KEY_BATTERY
, KEY_SLEEP
,
3327 KEY_WLAN
, KEY_CAMERA
, KEY_SWITCHVIDEOMODE
, KEY_FN_F8
,
3328 KEY_FN_F9
, KEY_FN_F10
, KEY_FN_F11
, KEY_SUSPEND
,
3330 /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
3331 KEY_UNKNOWN
, /* 0x0C: FN+BACKSPACE */
3332 KEY_UNKNOWN
, /* 0x0D: FN+INSERT */
3333 KEY_UNKNOWN
, /* 0x0E: FN+DELETE */
3335 /* These should be enabled --only-- when ACPI video
3336 * is disabled (i.e. in "vendor" mode), and are handled
3337 * in a special way by the init code */
3338 KEY_BRIGHTNESSUP
, /* 0x0F: FN+HOME (brightness up) */
3339 KEY_BRIGHTNESSDOWN
, /* 0x10: FN+END (brightness down) */
3341 KEY_RESERVED
, /* 0x11: FN+PGUP (thinklight toggle) */
3343 KEY_UNKNOWN
, /* 0x12: FN+PGDOWN */
3344 KEY_ZOOM
, /* 0x13: FN+SPACE (zoom) */
3346 /* Volume: z60/z61, T60 (BIOS version?): firmware always
3347 * react to it and reprograms the built-in *extra* mixer.
3348 * Never map it to control another mixer by default.
3350 * T60?, T61, R60?, R61: firmware and EC tries to send
3351 * these over the regular keyboard, so these are no-ops,
3352 * but there are still weird bugs re. MUTE, so do not
3353 * change unless you get test reports from all Lenovo
3354 * models. May cause the BIOS to interfere with the
3357 KEY_RESERVED
, /* 0x14: VOLUME UP */
3358 KEY_RESERVED
, /* 0x15: VOLUME DOWN */
3359 KEY_RESERVED
, /* 0x16: MUTE */
3361 KEY_VENDOR
, /* 0x17: Thinkpad/AccessIBM/Lenovo */
3363 /* (assignments unknown, please report if found) */
3364 KEY_UNKNOWN
, KEY_UNKNOWN
,
3367 * The mic mute button only sends 0x1a. It does not
3368 * automatically mute the mic or change the mute light.
3370 KEY_MICMUTE
, /* 0x1a: Mic mute (since ?400 or so) */
3372 /* (assignments unknown, please report if found) */
3375 /* Extra keys in use since the X240 / T440 / T540 */
3376 KEY_CONFIG
, KEY_SEARCH
, KEY_SCALE
, KEY_FILE
,
3379 * These are the adaptive keyboard keycodes for Carbon X1 2014.
3380 * The first item in this list is the Mute button which is
3381 * emitted with 0x103 through
3382 * adaptive_keyboard_hotkey_notify_hotkey() when the sound
3384 * We'll need to offset those by 0x20.
3386 KEY_RESERVED
, /* Mute held, 0x103 */
3387 KEY_BRIGHTNESS_MIN
, /* Backlight off */
3388 KEY_RESERVED
, /* Clipping tool */
3389 KEY_RESERVED
, /* Cloud */
3391 KEY_VOICECOMMAND
, /* Voice */
3393 KEY_RESERVED
, /* Gestures */
3397 KEY_CONFIG
, /* Settings */
3398 KEY_RESERVED
, /* New tab */
3399 KEY_REFRESH
, /* Reload */
3400 KEY_BACK
, /* Back */
3401 KEY_RESERVED
, /* Microphone down */
3402 KEY_RESERVED
, /* Microphone up */
3403 KEY_RESERVED
, /* Microphone cancellation */
3404 KEY_RESERVED
, /* Camera mode */
3405 KEY_RESERVED
, /* Rotate display, 0x116 */
3408 * These are found in 2017 models (e.g. T470s, X270).
3409 * The lowest known value is 0x311, which according to
3410 * the manual should launch a user defined favorite
3413 * The offset for these is TP_ACPI_HOTKEYSCAN_EXTENDED_START,
3414 * corresponding to 0x34.
3417 /* (assignments unknown, please report if found) */
3418 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3419 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3420 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3421 KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
, KEY_UNKNOWN
,
3424 KEY_BOOKMARKS
, /* Favorite app, 0x311 */
3425 KEY_RESERVED
, /* Clipping tool */
3426 KEY_CALC
, /* Calculator (above numpad, P52) */
3427 KEY_BLUETOOTH
, /* Bluetooth */
3428 KEY_KEYBOARD
/* Keyboard, 0x315 */
3432 static const struct tpacpi_quirk tpacpi_keymap_qtable
[] __initconst
= {
3433 /* Generic maps (fallback) */
3435 .vendor
= PCI_VENDOR_ID_IBM
,
3436 .bios
= TPACPI_MATCH_ANY
, .ec
= TPACPI_MATCH_ANY
,
3437 .quirks
= TPACPI_KEYMAP_IBM_GENERIC
,
3440 .vendor
= PCI_VENDOR_ID_LENOVO
,
3441 .bios
= TPACPI_MATCH_ANY
, .ec
= TPACPI_MATCH_ANY
,
3442 .quirks
= TPACPI_KEYMAP_LENOVO_GENERIC
,
3446 #define TPACPI_HOTKEY_MAP_SIZE sizeof(tpacpi_keymap_t)
3447 #define TPACPI_HOTKEY_MAP_TYPESIZE sizeof(tpacpi_keymap_entry_t)
3452 bool radiosw_state
= false;
3453 bool tabletsw_state
= false;
3455 unsigned long quirks
;
3456 unsigned long keymap_id
;
3458 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_HKEY
,
3459 "initializing hotkey subdriver\n");
3461 BUG_ON(!tpacpi_inputdev
);
3462 BUG_ON(tpacpi_inputdev
->open
!= NULL
||
3463 tpacpi_inputdev
->close
!= NULL
);
3465 TPACPI_ACPIHANDLE_INIT(hkey
);
3466 mutex_init(&hotkey_mutex
);
3468 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3469 mutex_init(&hotkey_thread_data_mutex
);
3472 /* hotkey not supported on 570 */
3473 tp_features
.hotkey
= hkey_handle
!= NULL
;
3475 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_HKEY
,
3477 str_supported(tp_features
.hotkey
));
3479 if (!tp_features
.hotkey
)
3482 quirks
= tpacpi_check_quirks(tpacpi_hotkey_qtable
,
3483 ARRAY_SIZE(tpacpi_hotkey_qtable
));
3485 tpacpi_disable_brightness_delay();
3487 /* MUST have enough space for all attributes to be added to
3488 * hotkey_dev_attributes */
3489 hotkey_dev_attributes
= create_attr_set(
3490 ARRAY_SIZE(hotkey_attributes
) + 2,
3492 if (!hotkey_dev_attributes
)
3494 res
= add_many_to_attr_set(hotkey_dev_attributes
,
3496 ARRAY_SIZE(hotkey_attributes
));
3500 /* mask not supported on 600e/x, 770e, 770x, A21e, A2xm/p,
3501 A30, R30, R31, T20-22, X20-21, X22-24. Detected by checking
3502 for HKEY interface version 0x100 */
3503 if (acpi_evalf(hkey_handle
, &hkeyv
, "MHKV", "qd")) {
3504 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_HKEY
,
3505 "firmware HKEY interface version: 0x%x\n",
3508 switch (hkeyv
>> 8) {
3511 * MHKV 0x100 in A31, R40, R40e,
3512 * T4x, X31, and later
3515 /* Paranoia check AND init hotkey_all_mask */
3516 if (!acpi_evalf(hkey_handle
, &hotkey_all_mask
,
3518 pr_err("missing MHKA handler, please report this to %s\n",
3520 /* Fallback: pre-init for FN+F3,F4,F12 */
3521 hotkey_all_mask
= 0x080cU
;
3523 tp_features
.hotkey_mask
= 1;
3529 * MHKV 0x200 in X1, T460s, X260, T560, X1 Tablet (2016)
3532 /* Paranoia check AND init hotkey_all_mask */
3533 if (!acpi_evalf(hkey_handle
, &hotkey_all_mask
,
3535 pr_err("missing MHKA handler, please report this to %s\n",
3537 /* Fallback: pre-init for FN+F3,F4,F12 */
3538 hotkey_all_mask
= 0x080cU
;
3540 tp_features
.hotkey_mask
= 1;
3544 * Check if we have an adaptive keyboard, like on the
3545 * Lenovo Carbon X1 2014 (2nd Gen).
3547 if (acpi_evalf(hkey_handle
, &hotkey_adaptive_all_mask
,
3549 if (hotkey_adaptive_all_mask
!= 0) {
3550 tp_features
.has_adaptive_kbd
= true;
3551 res
= sysfs_create_group(
3552 &tpacpi_pdev
->dev
.kobj
,
3553 &adaptive_kbd_attr_group
);
3558 tp_features
.has_adaptive_kbd
= false;
3559 hotkey_adaptive_all_mask
= 0x0U
;
3564 pr_err("unknown version of the HKEY interface: 0x%x\n",
3566 pr_err("please report this to %s\n", TPACPI_MAIL
);
3571 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_HKEY
,
3572 "hotkey masks are %s\n",
3573 str_supported(tp_features
.hotkey_mask
));
3575 /* Init hotkey_all_mask if not initialized yet */
3576 if (!tp_features
.hotkey_mask
&& !hotkey_all_mask
&&
3577 (quirks
& TPACPI_HK_Q_INIMASK
))
3578 hotkey_all_mask
= 0x080cU
; /* FN+F12, FN+F4, FN+F3 */
3580 /* Init hotkey_acpi_mask and hotkey_orig_mask */
3581 if (tp_features
.hotkey_mask
) {
3582 /* hotkey_source_mask *must* be zero for
3583 * the first hotkey_mask_get to return hotkey_orig_mask */
3584 res
= hotkey_mask_get();
3588 hotkey_orig_mask
= hotkey_acpi_mask
;
3590 hotkey_orig_mask
= hotkey_all_mask
;
3591 hotkey_acpi_mask
= hotkey_all_mask
;
3594 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
3596 tp_features
.hotkey_wlsw
= 1;
3597 radiosw_state
= !!tpacpi_wlsw_emulstate
;
3598 pr_info("radio switch emulation enabled\n");
3601 /* Not all thinkpads have a hardware radio switch */
3602 if (acpi_evalf(hkey_handle
, &status
, "WLSW", "qd")) {
3603 tp_features
.hotkey_wlsw
= 1;
3604 radiosw_state
= !!status
;
3605 pr_info("radio switch found; radios are %s\n",
3606 enabled(status
, 0));
3608 if (tp_features
.hotkey_wlsw
)
3609 res
= add_to_attr_set(hotkey_dev_attributes
,
3610 &dev_attr_hotkey_radio_sw
.attr
);
3612 res
= hotkey_init_tablet_mode();
3616 tabletsw_state
= res
;
3618 res
= register_attr_set_with_sysfs(hotkey_dev_attributes
,
3619 &tpacpi_pdev
->dev
.kobj
);
3623 /* Set up key map */
3624 keymap_id
= tpacpi_check_quirks(tpacpi_keymap_qtable
,
3625 ARRAY_SIZE(tpacpi_keymap_qtable
));
3626 BUG_ON(keymap_id
>= ARRAY_SIZE(tpacpi_keymaps
));
3627 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_HKEY
,
3628 "using keymap number %lu\n", keymap_id
);
3630 hotkey_keycode_map
= kmemdup(&tpacpi_keymaps
[keymap_id
],
3631 TPACPI_HOTKEY_MAP_SIZE
, GFP_KERNEL
);
3632 if (!hotkey_keycode_map
) {
3633 pr_err("failed to allocate memory for key map\n");
3638 input_set_capability(tpacpi_inputdev
, EV_MSC
, MSC_SCAN
);
3639 tpacpi_inputdev
->keycodesize
= TPACPI_HOTKEY_MAP_TYPESIZE
;
3640 tpacpi_inputdev
->keycodemax
= TPACPI_HOTKEY_MAP_LEN
;
3641 tpacpi_inputdev
->keycode
= hotkey_keycode_map
;
3642 for (i
= 0; i
< TPACPI_HOTKEY_MAP_LEN
; i
++) {
3643 if (hotkey_keycode_map
[i
] != KEY_RESERVED
) {
3644 input_set_capability(tpacpi_inputdev
, EV_KEY
,
3645 hotkey_keycode_map
[i
]);
3647 if (i
< sizeof(hotkey_reserved_mask
)*8)
3648 hotkey_reserved_mask
|= 1 << i
;
3652 if (tp_features
.hotkey_wlsw
) {
3653 input_set_capability(tpacpi_inputdev
, EV_SW
, SW_RFKILL_ALL
);
3654 input_report_switch(tpacpi_inputdev
,
3655 SW_RFKILL_ALL
, radiosw_state
);
3657 if (tp_features
.hotkey_tablet
) {
3658 input_set_capability(tpacpi_inputdev
, EV_SW
, SW_TABLET_MODE
);
3659 input_report_switch(tpacpi_inputdev
,
3660 SW_TABLET_MODE
, tabletsw_state
);
3663 /* Do not issue duplicate brightness change events to
3664 * userspace. tpacpi_detect_brightness_capabilities() must have
3665 * been called before this point */
3666 if (acpi_video_get_backlight_type() != acpi_backlight_vendor
) {
3667 pr_info("This ThinkPad has standard ACPI backlight brightness control, supported by the ACPI video driver\n");
3668 pr_notice("Disabling thinkpad-acpi brightness events by default...\n");
3670 /* Disable brightness up/down on Lenovo thinkpads when
3671 * ACPI is handling them, otherwise it is plain impossible
3672 * for userspace to do something even remotely sane */
3673 hotkey_reserved_mask
|=
3674 (1 << TP_ACPI_HOTKEYSCAN_FNHOME
)
3675 | (1 << TP_ACPI_HOTKEYSCAN_FNEND
);
3676 hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNHOME
);
3677 hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNEND
);
3680 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3681 hotkey_source_mask
= TPACPI_HKEY_NVRAM_GOOD_MASK
3683 & ~hotkey_reserved_mask
;
3685 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_HKEY
,
3686 "hotkey source mask 0x%08x, polling freq %u\n",
3687 hotkey_source_mask
, hotkey_poll_freq
);
3690 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_HKEY
,
3691 "enabling firmware HKEY event interface...\n");
3692 res
= hotkey_status_set(true);
3697 res
= hotkey_mask_set(((hotkey_all_mask
& ~hotkey_reserved_mask
)
3698 | hotkey_driver_mask
)
3699 & ~hotkey_source_mask
);
3700 if (res
< 0 && res
!= -ENXIO
) {
3704 hotkey_user_mask
= (hotkey_acpi_mask
| hotkey_source_mask
)
3705 & ~hotkey_reserved_mask
;
3706 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_HKEY
,
3707 "initial masks: user=0x%08x, fw=0x%08x, poll=0x%08x\n",
3708 hotkey_user_mask
, hotkey_acpi_mask
, hotkey_source_mask
);
3710 tpacpi_inputdev
->open
= &hotkey_inputdev_open
;
3711 tpacpi_inputdev
->close
= &hotkey_inputdev_close
;
3713 hotkey_poll_setup_safe(true);
3718 delete_attr_set(hotkey_dev_attributes
, &tpacpi_pdev
->dev
.kobj
);
3719 sysfs_remove_group(&tpacpi_pdev
->dev
.kobj
,
3720 &adaptive_kbd_attr_group
);
3722 hotkey_dev_attributes
= NULL
;
3724 return (res
< 0) ? res
: 1;
3727 /* Thinkpad X1 Carbon support 5 modes including Home mode, Web browser
3728 * mode, Web conference mode, Function mode and Lay-flat mode.
3729 * We support Home mode and Function mode currently.
3731 * Will consider support rest of modes in future.
3734 static const int adaptive_keyboard_modes
[] = {
3736 /* WEB_BROWSER_MODE = 2,
3737 WEB_CONFERENCE_MODE = 3, */
3741 #define DFR_CHANGE_ROW 0x101
3742 #define DFR_SHOW_QUICKVIEW_ROW 0x102
3743 #define FIRST_ADAPTIVE_KEY 0x103
3745 /* press Fn key a while second, it will switch to Function Mode. Then
3746 * release Fn key, previous mode be restored.
3748 static bool adaptive_keyboard_mode_is_saved
;
3749 static int adaptive_keyboard_prev_mode
;
3751 static int adaptive_keyboard_get_mode(void)
3755 if (!acpi_evalf(hkey_handle
, &mode
, "GTRW", "dd", 0)) {
3756 pr_err("Cannot read adaptive keyboard mode\n");
3763 static int adaptive_keyboard_set_mode(int new_mode
)
3766 new_mode
> LAYFLAT_MODE
)
3769 if (!acpi_evalf(hkey_handle
, NULL
, "STRW", "vd", new_mode
)) {
3770 pr_err("Cannot set adaptive keyboard mode\n");
3777 static int adaptive_keyboard_get_next_mode(int mode
)
3780 size_t max_mode
= ARRAY_SIZE(adaptive_keyboard_modes
) - 1;
3782 for (i
= 0; i
<= max_mode
; i
++) {
3783 if (adaptive_keyboard_modes
[i
] == mode
)
3792 return adaptive_keyboard_modes
[i
];
3795 static bool adaptive_keyboard_hotkey_notify_hotkey(unsigned int scancode
)
3797 int current_mode
= 0;
3802 case DFR_CHANGE_ROW
:
3803 if (adaptive_keyboard_mode_is_saved
) {
3804 new_mode
= adaptive_keyboard_prev_mode
;
3805 adaptive_keyboard_mode_is_saved
= false;
3807 current_mode
= adaptive_keyboard_get_mode();
3808 if (current_mode
< 0)
3810 new_mode
= adaptive_keyboard_get_next_mode(
3814 if (adaptive_keyboard_set_mode(new_mode
) < 0)
3819 case DFR_SHOW_QUICKVIEW_ROW
:
3820 current_mode
= adaptive_keyboard_get_mode();
3821 if (current_mode
< 0)
3824 adaptive_keyboard_prev_mode
= current_mode
;
3825 adaptive_keyboard_mode_is_saved
= true;
3827 if (adaptive_keyboard_set_mode (FUNCTION_MODE
) < 0)
3832 if (scancode
< FIRST_ADAPTIVE_KEY
||
3833 scancode
>= FIRST_ADAPTIVE_KEY
+
3834 TP_ACPI_HOTKEYSCAN_EXTENDED_START
-
3835 TP_ACPI_HOTKEYSCAN_ADAPTIVE_START
) {
3836 pr_info("Unhandled adaptive keyboard key: 0x%x\n",
3840 keycode
= hotkey_keycode_map
[scancode
- FIRST_ADAPTIVE_KEY
+
3841 TP_ACPI_HOTKEYSCAN_ADAPTIVE_START
];
3842 if (keycode
!= KEY_RESERVED
) {
3843 mutex_lock(&tpacpi_inputdev_send_mutex
);
3845 input_report_key(tpacpi_inputdev
, keycode
, 1);
3846 input_sync(tpacpi_inputdev
);
3848 input_report_key(tpacpi_inputdev
, keycode
, 0);
3849 input_sync(tpacpi_inputdev
);
3851 mutex_unlock(&tpacpi_inputdev_send_mutex
);
3857 static bool hotkey_notify_hotkey(const u32 hkey
,
3859 bool *ignore_acpi_ev
)
3861 /* 0x1000-0x1FFF: key presses */
3862 unsigned int scancode
= hkey
& 0xfff;
3863 *send_acpi_ev
= true;
3864 *ignore_acpi_ev
= false;
3867 * Original events are in the 0x10XX range, the adaptive keyboard
3868 * found in 2014 X1 Carbon emits events are of 0x11XX. In 2017
3869 * models, additional keys are emitted through 0x13XX.
3871 switch ((hkey
>> 8) & 0xf) {
3874 scancode
<= TP_ACPI_HOTKEYSCAN_ADAPTIVE_START
) {
3875 /* HKEY event 0x1001 is scancode 0x00 */
3877 if (!(hotkey_source_mask
& (1 << scancode
))) {
3878 tpacpi_input_send_key_masked(scancode
);
3879 *send_acpi_ev
= false;
3881 *ignore_acpi_ev
= true;
3888 return adaptive_keyboard_hotkey_notify_hotkey(scancode
);
3891 /* Extended keycodes start at 0x300 and our offset into the map
3892 * TP_ACPI_HOTKEYSCAN_EXTENDED_START. The calculated scancode
3893 * will be positive, but might not be in the correct range.
3895 scancode
-= (0x300 - TP_ACPI_HOTKEYSCAN_EXTENDED_START
);
3896 if (scancode
>= TP_ACPI_HOTKEYSCAN_EXTENDED_START
&&
3897 scancode
< TPACPI_HOTKEY_MAP_LEN
) {
3898 tpacpi_input_send_key(scancode
);
3907 static bool hotkey_notify_wakeup(const u32 hkey
,
3909 bool *ignore_acpi_ev
)
3911 /* 0x2000-0x2FFF: Wakeup reason */
3912 *send_acpi_ev
= true;
3913 *ignore_acpi_ev
= false;
3916 case TP_HKEY_EV_WKUP_S3_UNDOCK
: /* suspend, undock */
3917 case TP_HKEY_EV_WKUP_S4_UNDOCK
: /* hibernation, undock */
3918 hotkey_wakeup_reason
= TP_ACPI_WAKEUP_UNDOCK
;
3919 *ignore_acpi_ev
= true;
3922 case TP_HKEY_EV_WKUP_S3_BAYEJ
: /* suspend, bay eject */
3923 case TP_HKEY_EV_WKUP_S4_BAYEJ
: /* hibernation, bay eject */
3924 hotkey_wakeup_reason
= TP_ACPI_WAKEUP_BAYEJ
;
3925 *ignore_acpi_ev
= true;
3928 case TP_HKEY_EV_WKUP_S3_BATLOW
: /* Battery on critical low level/S3 */
3929 case TP_HKEY_EV_WKUP_S4_BATLOW
: /* Battery on critical low level/S4 */
3930 pr_alert("EMERGENCY WAKEUP: battery almost empty\n");
3931 /* how to auto-heal: */
3932 /* 2313: woke up from S3, go to S4/S5 */
3933 /* 2413: woke up from S4, go to S5 */
3940 if (hotkey_wakeup_reason
!= TP_ACPI_WAKEUP_NONE
) {
3941 pr_info("woke up due to a hot-unplug request...\n");
3942 hotkey_wakeup_reason_notify_change();
3947 static bool hotkey_notify_dockevent(const u32 hkey
,
3949 bool *ignore_acpi_ev
)
3951 /* 0x4000-0x4FFF: dock-related events */
3952 *send_acpi_ev
= true;
3953 *ignore_acpi_ev
= false;
3956 case TP_HKEY_EV_UNDOCK_ACK
:
3957 /* ACPI undock operation completed after wakeup */
3958 hotkey_autosleep_ack
= 1;
3959 pr_info("undocked\n");
3960 hotkey_wakeup_hotunplug_complete_notify_change();
3963 case TP_HKEY_EV_HOTPLUG_DOCK
: /* docked to port replicator */
3964 pr_info("docked into hotplug port replicator\n");
3966 case TP_HKEY_EV_HOTPLUG_UNDOCK
: /* undocked from port replicator */
3967 pr_info("undocked from hotplug port replicator\n");
3975 static bool hotkey_notify_usrevent(const u32 hkey
,
3977 bool *ignore_acpi_ev
)
3979 /* 0x5000-0x5FFF: human interface helpers */
3980 *send_acpi_ev
= true;
3981 *ignore_acpi_ev
= false;
3984 case TP_HKEY_EV_PEN_INSERTED
: /* X61t: tablet pen inserted into bay */
3985 case TP_HKEY_EV_PEN_REMOVED
: /* X61t: tablet pen removed from bay */
3988 case TP_HKEY_EV_TABLET_TABLET
: /* X41t-X61t: tablet mode */
3989 case TP_HKEY_EV_TABLET_NOTEBOOK
: /* X41t-X61t: normal mode */
3990 tpacpi_input_send_tabletsw();
3991 hotkey_tablet_mode_notify_change();
3992 *send_acpi_ev
= false;
3995 case TP_HKEY_EV_LID_CLOSE
: /* Lid closed */
3996 case TP_HKEY_EV_LID_OPEN
: /* Lid opened */
3997 case TP_HKEY_EV_BRGHT_CHANGED
: /* brightness changed */
3998 /* do not propagate these events */
3999 *ignore_acpi_ev
= true;
4007 static void thermal_dump_all_sensors(void);
4009 static bool hotkey_notify_6xxx(const u32 hkey
,
4011 bool *ignore_acpi_ev
)
4013 /* 0x6000-0x6FFF: thermal alarms/notices and keyboard events */
4014 *send_acpi_ev
= true;
4015 *ignore_acpi_ev
= false;
4018 case TP_HKEY_EV_THM_TABLE_CHANGED
:
4019 pr_debug("EC reports: Thermal Table has changed\n");
4020 /* recommended action: do nothing, we don't have
4021 * Lenovo ATM information */
4023 case TP_HKEY_EV_THM_CSM_COMPLETED
:
4024 pr_debug("EC reports: Thermal Control Command set completed (DYTC)\n");
4025 /* recommended action: do nothing, we don't have
4026 * Lenovo ATM information */
4028 case TP_HKEY_EV_THM_TRANSFM_CHANGED
:
4029 pr_debug("EC reports: Thermal Transformation changed (GMTS)\n");
4030 /* recommended action: do nothing, we don't have
4031 * Lenovo ATM information */
4033 case TP_HKEY_EV_ALARM_BAT_HOT
:
4034 pr_crit("THERMAL ALARM: battery is too hot!\n");
4035 /* recommended action: warn user through gui */
4037 case TP_HKEY_EV_ALARM_BAT_XHOT
:
4038 pr_alert("THERMAL EMERGENCY: battery is extremely hot!\n");
4039 /* recommended action: immediate sleep/hibernate */
4041 case TP_HKEY_EV_ALARM_SENSOR_HOT
:
4042 pr_crit("THERMAL ALARM: a sensor reports something is too hot!\n");
4043 /* recommended action: warn user through gui, that */
4044 /* some internal component is too hot */
4046 case TP_HKEY_EV_ALARM_SENSOR_XHOT
:
4047 pr_alert("THERMAL EMERGENCY: a sensor reports something is extremely hot!\n");
4048 /* recommended action: immediate sleep/hibernate */
4050 case TP_HKEY_EV_AC_CHANGED
:
4051 /* X120e, X121e, X220, X220i, X220t, X230, T420, T420s, W520:
4052 * AC status changed; can be triggered by plugging or
4053 * unplugging AC adapter, docking or undocking. */
4057 case TP_HKEY_EV_KEY_NUMLOCK
:
4058 case TP_HKEY_EV_KEY_FN
:
4059 case TP_HKEY_EV_KEY_FN_ESC
:
4060 /* key press events, we just ignore them as long as the EC
4061 * is still reporting them in the normal keyboard stream */
4062 *send_acpi_ev
= false;
4063 *ignore_acpi_ev
= true;
4066 case TP_HKEY_EV_TABLET_CHANGED
:
4067 tpacpi_input_send_tabletsw();
4068 hotkey_tablet_mode_notify_change();
4069 *send_acpi_ev
= false;
4072 case TP_HKEY_EV_PALM_DETECTED
:
4073 case TP_HKEY_EV_PALM_UNDETECTED
:
4074 /* palm detected hovering the keyboard, forward to user-space
4075 * via netlink for consumption */
4079 /* report simply as unknown, no sensor dump */
4083 thermal_dump_all_sensors();
4087 static void hotkey_notify(struct ibm_struct
*ibm
, u32 event
)
4091 bool ignore_acpi_ev
;
4094 if (event
!= 0x80) {
4095 pr_err("unknown HKEY notification event %d\n", event
);
4096 /* forward it to userspace, maybe it knows how to handle it */
4097 acpi_bus_generate_netlink_event(
4098 ibm
->acpi
->device
->pnp
.device_class
,
4099 dev_name(&ibm
->acpi
->device
->dev
),
4105 if (!acpi_evalf(hkey_handle
, &hkey
, "MHKP", "d")) {
4106 pr_err("failed to retrieve HKEY event\n");
4115 send_acpi_ev
= true;
4116 ignore_acpi_ev
= false;
4118 switch (hkey
>> 12) {
4120 /* 0x1000-0x1FFF: key presses */
4121 known_ev
= hotkey_notify_hotkey(hkey
, &send_acpi_ev
,
4125 /* 0x2000-0x2FFF: Wakeup reason */
4126 known_ev
= hotkey_notify_wakeup(hkey
, &send_acpi_ev
,
4130 /* 0x3000-0x3FFF: bay-related wakeups */
4132 case TP_HKEY_EV_BAYEJ_ACK
:
4133 hotkey_autosleep_ack
= 1;
4134 pr_info("bay ejected\n");
4135 hotkey_wakeup_hotunplug_complete_notify_change();
4138 case TP_HKEY_EV_OPTDRV_EJ
:
4139 /* FIXME: kick libata if SATA link offline */
4147 /* 0x4000-0x4FFF: dock-related events */
4148 known_ev
= hotkey_notify_dockevent(hkey
, &send_acpi_ev
,
4152 /* 0x5000-0x5FFF: human interface helpers */
4153 known_ev
= hotkey_notify_usrevent(hkey
, &send_acpi_ev
,
4157 /* 0x6000-0x6FFF: thermal alarms/notices and
4158 * keyboard events */
4159 known_ev
= hotkey_notify_6xxx(hkey
, &send_acpi_ev
,
4163 /* 0x7000-0x7FFF: misc */
4164 if (tp_features
.hotkey_wlsw
&&
4165 hkey
== TP_HKEY_EV_RFKILL_CHANGED
) {
4166 tpacpi_send_radiosw_update();
4171 /* fallthrough - to default */
4176 pr_notice("unhandled HKEY event 0x%04x\n", hkey
);
4177 pr_notice("please report the conditions when this event happened to %s\n",
4181 /* netlink events */
4182 if (!ignore_acpi_ev
&& send_acpi_ev
) {
4183 acpi_bus_generate_netlink_event(
4184 ibm
->acpi
->device
->pnp
.device_class
,
4185 dev_name(&ibm
->acpi
->device
->dev
),
4191 static void hotkey_suspend(void)
4193 /* Do these on suspend, we get the events on early resume! */
4194 hotkey_wakeup_reason
= TP_ACPI_WAKEUP_NONE
;
4195 hotkey_autosleep_ack
= 0;
4197 /* save previous mode of adaptive keyboard of X1 Carbon */
4198 if (tp_features
.has_adaptive_kbd
) {
4199 if (!acpi_evalf(hkey_handle
, &adaptive_keyboard_prev_mode
,
4201 pr_err("Cannot read adaptive keyboard mode.\n");
4206 static void hotkey_resume(void)
4208 tpacpi_disable_brightness_delay();
4210 if (hotkey_status_set(true) < 0 ||
4211 hotkey_mask_set(hotkey_acpi_mask
) < 0)
4212 pr_err("error while attempting to reset the event firmware interface\n");
4214 tpacpi_send_radiosw_update();
4215 hotkey_tablet_mode_notify_change();
4216 hotkey_wakeup_reason_notify_change();
4217 hotkey_wakeup_hotunplug_complete_notify_change();
4218 hotkey_poll_setup_safe(false);
4220 /* restore previous mode of adapive keyboard of X1 Carbon */
4221 if (tp_features
.has_adaptive_kbd
) {
4222 if (!acpi_evalf(hkey_handle
, NULL
, "STRW", "vd",
4223 adaptive_keyboard_prev_mode
)) {
4224 pr_err("Cannot set adaptive keyboard mode.\n");
4229 /* procfs -------------------------------------------------------------- */
4230 static int hotkey_read(struct seq_file
*m
)
4234 if (!tp_features
.hotkey
) {
4235 seq_printf(m
, "status:\t\tnot supported\n");
4239 if (mutex_lock_killable(&hotkey_mutex
))
4240 return -ERESTARTSYS
;
4241 res
= hotkey_status_get(&status
);
4243 res
= hotkey_mask_get();
4244 mutex_unlock(&hotkey_mutex
);
4248 seq_printf(m
, "status:\t\t%s\n", enabled(status
, 0));
4249 if (hotkey_all_mask
) {
4250 seq_printf(m
, "mask:\t\t0x%08x\n", hotkey_user_mask
);
4251 seq_printf(m
, "commands:\tenable, disable, reset, <mask>\n");
4253 seq_printf(m
, "mask:\t\tnot supported\n");
4254 seq_printf(m
, "commands:\tenable, disable, reset\n");
4260 static void hotkey_enabledisable_warn(bool enable
)
4262 tpacpi_log_usertask("procfs hotkey enable/disable");
4263 if (!WARN((tpacpi_lifecycle
== TPACPI_LIFE_RUNNING
|| !enable
),
4264 pr_fmt("hotkey enable/disable functionality has been removed from the driver. Hotkeys are always enabled.\n")))
4265 pr_err("Please remove the hotkey=enable module parameter, it is deprecated. Hotkeys are always enabled.\n");
4268 static int hotkey_write(char *buf
)
4274 if (!tp_features
.hotkey
)
4277 if (mutex_lock_killable(&hotkey_mutex
))
4278 return -ERESTARTSYS
;
4280 mask
= hotkey_user_mask
;
4283 while ((cmd
= strsep(&buf
, ","))) {
4284 if (strlencmp(cmd
, "enable") == 0) {
4285 hotkey_enabledisable_warn(1);
4286 } else if (strlencmp(cmd
, "disable") == 0) {
4287 hotkey_enabledisable_warn(0);
4289 } else if (strlencmp(cmd
, "reset") == 0) {
4290 mask
= (hotkey_all_mask
| hotkey_source_mask
)
4291 & ~hotkey_reserved_mask
;
4292 } else if (sscanf(cmd
, "0x%x", &mask
) == 1) {
4294 } else if (sscanf(cmd
, "%x", &mask
) == 1) {
4303 tpacpi_disclose_usertask("procfs hotkey",
4304 "set mask to 0x%08x\n", mask
);
4305 res
= hotkey_user_mask_set(mask
);
4309 mutex_unlock(&hotkey_mutex
);
4313 static const struct acpi_device_id ibm_htk_device_ids
[] = {
4314 {TPACPI_ACPI_IBM_HKEY_HID
, 0},
4315 {TPACPI_ACPI_LENOVO_HKEY_HID
, 0},
4316 {TPACPI_ACPI_LENOVO_HKEY_V2_HID
, 0},
4320 static struct tp_acpi_drv_struct ibm_hotkey_acpidriver
= {
4321 .hid
= ibm_htk_device_ids
,
4322 .notify
= hotkey_notify
,
4323 .handle
= &hkey_handle
,
4324 .type
= ACPI_DEVICE_NOTIFY
,
4327 static struct ibm_struct hotkey_driver_data
= {
4329 .read
= hotkey_read
,
4330 .write
= hotkey_write
,
4331 .exit
= hotkey_exit
,
4332 .resume
= hotkey_resume
,
4333 .suspend
= hotkey_suspend
,
4334 .acpi
= &ibm_hotkey_acpidriver
,
4337 /*************************************************************************
4338 * Bluetooth subdriver
4342 /* ACPI GBDC/SBDC bits */
4343 TP_ACPI_BLUETOOTH_HWPRESENT
= 0x01, /* Bluetooth hw available */
4344 TP_ACPI_BLUETOOTH_RADIOSSW
= 0x02, /* Bluetooth radio enabled */
4345 TP_ACPI_BLUETOOTH_RESUMECTRL
= 0x04, /* Bluetooth state at resume:
4346 0 = disable, 1 = enable */
4350 /* ACPI \BLTH commands */
4351 TP_ACPI_BLTH_GET_ULTRAPORT_ID
= 0x00, /* Get Ultraport BT ID */
4352 TP_ACPI_BLTH_GET_PWR_ON_RESUME
= 0x01, /* Get power-on-resume state */
4353 TP_ACPI_BLTH_PWR_ON_ON_RESUME
= 0x02, /* Resume powered on */
4354 TP_ACPI_BLTH_PWR_OFF_ON_RESUME
= 0x03, /* Resume powered off */
4355 TP_ACPI_BLTH_SAVE_STATE
= 0x05, /* Save state for S4/S5 */
4358 #define TPACPI_RFK_BLUETOOTH_SW_NAME "tpacpi_bluetooth_sw"
4360 static int bluetooth_get_status(void)
4364 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4365 if (dbg_bluetoothemul
)
4366 return (tpacpi_bluetooth_emulstate
) ?
4367 TPACPI_RFK_RADIO_ON
: TPACPI_RFK_RADIO_OFF
;
4370 if (!acpi_evalf(hkey_handle
, &status
, "GBDC", "d"))
4373 return ((status
& TP_ACPI_BLUETOOTH_RADIOSSW
) != 0) ?
4374 TPACPI_RFK_RADIO_ON
: TPACPI_RFK_RADIO_OFF
;
4377 static int bluetooth_set_status(enum tpacpi_rfkill_state state
)
4381 vdbg_printk(TPACPI_DBG_RFKILL
,
4382 "will attempt to %s bluetooth\n",
4383 (state
== TPACPI_RFK_RADIO_ON
) ? "enable" : "disable");
4385 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4386 if (dbg_bluetoothemul
) {
4387 tpacpi_bluetooth_emulstate
= (state
== TPACPI_RFK_RADIO_ON
);
4392 if (state
== TPACPI_RFK_RADIO_ON
)
4393 status
= TP_ACPI_BLUETOOTH_RADIOSSW
4394 | TP_ACPI_BLUETOOTH_RESUMECTRL
;
4398 if (!acpi_evalf(hkey_handle
, NULL
, "SBDC", "vd", status
))
4404 /* sysfs bluetooth enable ---------------------------------------------- */
4405 static ssize_t
bluetooth_enable_show(struct device
*dev
,
4406 struct device_attribute
*attr
,
4409 return tpacpi_rfk_sysfs_enable_show(TPACPI_RFK_BLUETOOTH_SW_ID
,
4413 static ssize_t
bluetooth_enable_store(struct device
*dev
,
4414 struct device_attribute
*attr
,
4415 const char *buf
, size_t count
)
4417 return tpacpi_rfk_sysfs_enable_store(TPACPI_RFK_BLUETOOTH_SW_ID
,
4421 static DEVICE_ATTR_RW(bluetooth_enable
);
4423 /* --------------------------------------------------------------------- */
4425 static struct attribute
*bluetooth_attributes
[] = {
4426 &dev_attr_bluetooth_enable
.attr
,
4430 static const struct attribute_group bluetooth_attr_group
= {
4431 .attrs
= bluetooth_attributes
,
4434 static const struct tpacpi_rfk_ops bluetooth_tprfk_ops
= {
4435 .get_status
= bluetooth_get_status
,
4436 .set_status
= bluetooth_set_status
,
4439 static void bluetooth_shutdown(void)
4441 /* Order firmware to save current state to NVRAM */
4442 if (!acpi_evalf(NULL
, NULL
, "\\BLTH", "vd",
4443 TP_ACPI_BLTH_SAVE_STATE
))
4444 pr_notice("failed to save bluetooth state to NVRAM\n");
4446 vdbg_printk(TPACPI_DBG_RFKILL
,
4447 "bluetooth state saved to NVRAM\n");
4450 static void bluetooth_exit(void)
4452 sysfs_remove_group(&tpacpi_pdev
->dev
.kobj
,
4453 &bluetooth_attr_group
);
4455 tpacpi_destroy_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID
);
4457 bluetooth_shutdown();
4460 static const struct dmi_system_id bt_fwbug_list
[] __initconst
= {
4462 .ident
= "ThinkPad E485",
4464 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
4465 DMI_MATCH(DMI_BOARD_NAME
, "20KU"),
4469 .ident
= "ThinkPad E585",
4471 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
4472 DMI_MATCH(DMI_BOARD_NAME
, "20KV"),
4476 .ident
= "ThinkPad A285 - 20MW",
4478 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
4479 DMI_MATCH(DMI_BOARD_NAME
, "20MW"),
4483 .ident
= "ThinkPad A285 - 20MX",
4485 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
4486 DMI_MATCH(DMI_BOARD_NAME
, "20MX"),
4490 .ident
= "ThinkPad A485 - 20MU",
4492 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
4493 DMI_MATCH(DMI_BOARD_NAME
, "20MU"),
4497 .ident
= "ThinkPad A485 - 20MV",
4499 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
4500 DMI_MATCH(DMI_BOARD_NAME
, "20MV"),
4506 static const struct pci_device_id fwbug_cards_ids
[] __initconst
= {
4507 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x24F3) },
4508 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x24FD) },
4509 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x2526) },
4514 static int __init
have_bt_fwbug(void)
4517 * Some AMD based ThinkPads have a firmware bug that calling
4518 * "GBDC" will cause bluetooth on Intel wireless cards blocked
4520 if (dmi_check_system(bt_fwbug_list
) && pci_dev_present(fwbug_cards_ids
)) {
4521 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_RFKILL
,
4522 FW_BUG
"disable bluetooth subdriver for Intel cards\n");
4528 static int __init
bluetooth_init(struct ibm_init_struct
*iibm
)
4533 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_RFKILL
,
4534 "initializing bluetooth subdriver\n");
4536 TPACPI_ACPIHANDLE_INIT(hkey
);
4538 /* bluetooth not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
4539 G4x, R30, R31, R40e, R50e, T20-22, X20-21 */
4540 tp_features
.bluetooth
= !have_bt_fwbug() && hkey_handle
&&
4541 acpi_evalf(hkey_handle
, &status
, "GBDC", "qd");
4543 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_RFKILL
,
4544 "bluetooth is %s, status 0x%02x\n",
4545 str_supported(tp_features
.bluetooth
),
4548 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4549 if (dbg_bluetoothemul
) {
4550 tp_features
.bluetooth
= 1;
4551 pr_info("bluetooth switch emulation enabled\n");
4554 if (tp_features
.bluetooth
&&
4555 !(status
& TP_ACPI_BLUETOOTH_HWPRESENT
)) {
4556 /* no bluetooth hardware present in system */
4557 tp_features
.bluetooth
= 0;
4558 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_RFKILL
,
4559 "bluetooth hardware not installed\n");
4562 if (!tp_features
.bluetooth
)
4565 res
= tpacpi_new_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID
,
4566 &bluetooth_tprfk_ops
,
4567 RFKILL_TYPE_BLUETOOTH
,
4568 TPACPI_RFK_BLUETOOTH_SW_NAME
,
4573 res
= sysfs_create_group(&tpacpi_pdev
->dev
.kobj
,
4574 &bluetooth_attr_group
);
4576 tpacpi_destroy_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID
);
4583 /* procfs -------------------------------------------------------------- */
4584 static int bluetooth_read(struct seq_file
*m
)
4586 return tpacpi_rfk_procfs_read(TPACPI_RFK_BLUETOOTH_SW_ID
, m
);
4589 static int bluetooth_write(char *buf
)
4591 return tpacpi_rfk_procfs_write(TPACPI_RFK_BLUETOOTH_SW_ID
, buf
);
4594 static struct ibm_struct bluetooth_driver_data
= {
4595 .name
= "bluetooth",
4596 .read
= bluetooth_read
,
4597 .write
= bluetooth_write
,
4598 .exit
= bluetooth_exit
,
4599 .shutdown
= bluetooth_shutdown
,
4602 /*************************************************************************
4607 /* ACPI GWAN/SWAN bits */
4608 TP_ACPI_WANCARD_HWPRESENT
= 0x01, /* Wan hw available */
4609 TP_ACPI_WANCARD_RADIOSSW
= 0x02, /* Wan radio enabled */
4610 TP_ACPI_WANCARD_RESUMECTRL
= 0x04, /* Wan state at resume:
4611 0 = disable, 1 = enable */
4614 #define TPACPI_RFK_WWAN_SW_NAME "tpacpi_wwan_sw"
4616 static int wan_get_status(void)
4620 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4622 return (tpacpi_wwan_emulstate
) ?
4623 TPACPI_RFK_RADIO_ON
: TPACPI_RFK_RADIO_OFF
;
4626 if (!acpi_evalf(hkey_handle
, &status
, "GWAN", "d"))
4629 return ((status
& TP_ACPI_WANCARD_RADIOSSW
) != 0) ?
4630 TPACPI_RFK_RADIO_ON
: TPACPI_RFK_RADIO_OFF
;
4633 static int wan_set_status(enum tpacpi_rfkill_state state
)
4637 vdbg_printk(TPACPI_DBG_RFKILL
,
4638 "will attempt to %s wwan\n",
4639 (state
== TPACPI_RFK_RADIO_ON
) ? "enable" : "disable");
4641 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4643 tpacpi_wwan_emulstate
= (state
== TPACPI_RFK_RADIO_ON
);
4648 if (state
== TPACPI_RFK_RADIO_ON
)
4649 status
= TP_ACPI_WANCARD_RADIOSSW
4650 | TP_ACPI_WANCARD_RESUMECTRL
;
4654 if (!acpi_evalf(hkey_handle
, NULL
, "SWAN", "vd", status
))
4660 /* sysfs wan enable ---------------------------------------------------- */
4661 static ssize_t
wan_enable_show(struct device
*dev
,
4662 struct device_attribute
*attr
,
4665 return tpacpi_rfk_sysfs_enable_show(TPACPI_RFK_WWAN_SW_ID
,
4669 static ssize_t
wan_enable_store(struct device
*dev
,
4670 struct device_attribute
*attr
,
4671 const char *buf
, size_t count
)
4673 return tpacpi_rfk_sysfs_enable_store(TPACPI_RFK_WWAN_SW_ID
,
4677 static DEVICE_ATTR(wwan_enable
, S_IWUSR
| S_IRUGO
,
4678 wan_enable_show
, wan_enable_store
);
4680 /* --------------------------------------------------------------------- */
4682 static struct attribute
*wan_attributes
[] = {
4683 &dev_attr_wwan_enable
.attr
,
4687 static const struct attribute_group wan_attr_group
= {
4688 .attrs
= wan_attributes
,
4691 static const struct tpacpi_rfk_ops wan_tprfk_ops
= {
4692 .get_status
= wan_get_status
,
4693 .set_status
= wan_set_status
,
4696 static void wan_shutdown(void)
4698 /* Order firmware to save current state to NVRAM */
4699 if (!acpi_evalf(NULL
, NULL
, "\\WGSV", "vd",
4700 TP_ACPI_WGSV_SAVE_STATE
))
4701 pr_notice("failed to save WWAN state to NVRAM\n");
4703 vdbg_printk(TPACPI_DBG_RFKILL
,
4704 "WWAN state saved to NVRAM\n");
4707 static void wan_exit(void)
4709 sysfs_remove_group(&tpacpi_pdev
->dev
.kobj
,
4712 tpacpi_destroy_rfkill(TPACPI_RFK_WWAN_SW_ID
);
4717 static int __init
wan_init(struct ibm_init_struct
*iibm
)
4722 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_RFKILL
,
4723 "initializing wan subdriver\n");
4725 TPACPI_ACPIHANDLE_INIT(hkey
);
4727 tp_features
.wan
= hkey_handle
&&
4728 acpi_evalf(hkey_handle
, &status
, "GWAN", "qd");
4730 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_RFKILL
,
4731 "wan is %s, status 0x%02x\n",
4732 str_supported(tp_features
.wan
),
4735 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4737 tp_features
.wan
= 1;
4738 pr_info("wwan switch emulation enabled\n");
4741 if (tp_features
.wan
&&
4742 !(status
& TP_ACPI_WANCARD_HWPRESENT
)) {
4743 /* no wan hardware present in system */
4744 tp_features
.wan
= 0;
4745 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_RFKILL
,
4746 "wan hardware not installed\n");
4749 if (!tp_features
.wan
)
4752 res
= tpacpi_new_rfkill(TPACPI_RFK_WWAN_SW_ID
,
4755 TPACPI_RFK_WWAN_SW_NAME
,
4760 res
= sysfs_create_group(&tpacpi_pdev
->dev
.kobj
,
4764 tpacpi_destroy_rfkill(TPACPI_RFK_WWAN_SW_ID
);
4771 /* procfs -------------------------------------------------------------- */
4772 static int wan_read(struct seq_file
*m
)
4774 return tpacpi_rfk_procfs_read(TPACPI_RFK_WWAN_SW_ID
, m
);
4777 static int wan_write(char *buf
)
4779 return tpacpi_rfk_procfs_write(TPACPI_RFK_WWAN_SW_ID
, buf
);
4782 static struct ibm_struct wan_driver_data
= {
4787 .shutdown
= wan_shutdown
,
4790 /*************************************************************************
4795 /* ACPI GUWB/SUWB bits */
4796 TP_ACPI_UWB_HWPRESENT
= 0x01, /* UWB hw available */
4797 TP_ACPI_UWB_RADIOSSW
= 0x02, /* UWB radio enabled */
4800 #define TPACPI_RFK_UWB_SW_NAME "tpacpi_uwb_sw"
4802 static int uwb_get_status(void)
4806 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4808 return (tpacpi_uwb_emulstate
) ?
4809 TPACPI_RFK_RADIO_ON
: TPACPI_RFK_RADIO_OFF
;
4812 if (!acpi_evalf(hkey_handle
, &status
, "GUWB", "d"))
4815 return ((status
& TP_ACPI_UWB_RADIOSSW
) != 0) ?
4816 TPACPI_RFK_RADIO_ON
: TPACPI_RFK_RADIO_OFF
;
4819 static int uwb_set_status(enum tpacpi_rfkill_state state
)
4823 vdbg_printk(TPACPI_DBG_RFKILL
,
4824 "will attempt to %s UWB\n",
4825 (state
== TPACPI_RFK_RADIO_ON
) ? "enable" : "disable");
4827 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4829 tpacpi_uwb_emulstate
= (state
== TPACPI_RFK_RADIO_ON
);
4834 if (state
== TPACPI_RFK_RADIO_ON
)
4835 status
= TP_ACPI_UWB_RADIOSSW
;
4839 if (!acpi_evalf(hkey_handle
, NULL
, "SUWB", "vd", status
))
4845 /* --------------------------------------------------------------------- */
4847 static const struct tpacpi_rfk_ops uwb_tprfk_ops
= {
4848 .get_status
= uwb_get_status
,
4849 .set_status
= uwb_set_status
,
4852 static void uwb_exit(void)
4854 tpacpi_destroy_rfkill(TPACPI_RFK_UWB_SW_ID
);
4857 static int __init
uwb_init(struct ibm_init_struct
*iibm
)
4862 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_RFKILL
,
4863 "initializing uwb subdriver\n");
4865 TPACPI_ACPIHANDLE_INIT(hkey
);
4867 tp_features
.uwb
= hkey_handle
&&
4868 acpi_evalf(hkey_handle
, &status
, "GUWB", "qd");
4870 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_RFKILL
,
4871 "uwb is %s, status 0x%02x\n",
4872 str_supported(tp_features
.uwb
),
4875 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4877 tp_features
.uwb
= 1;
4878 pr_info("uwb switch emulation enabled\n");
4881 if (tp_features
.uwb
&&
4882 !(status
& TP_ACPI_UWB_HWPRESENT
)) {
4883 /* no uwb hardware present in system */
4884 tp_features
.uwb
= 0;
4885 dbg_printk(TPACPI_DBG_INIT
,
4886 "uwb hardware not installed\n");
4889 if (!tp_features
.uwb
)
4892 res
= tpacpi_new_rfkill(TPACPI_RFK_UWB_SW_ID
,
4895 TPACPI_RFK_UWB_SW_NAME
,
4900 static struct ibm_struct uwb_driver_data
= {
4903 .flags
.experimental
= 1,
4906 /*************************************************************************
4910 #ifdef CONFIG_THINKPAD_ACPI_VIDEO
4912 enum video_access_mode
{
4913 TPACPI_VIDEO_NONE
= 0,
4914 TPACPI_VIDEO_570
, /* 570 */
4915 TPACPI_VIDEO_770
, /* 600e/x, 770e, 770x */
4916 TPACPI_VIDEO_NEW
, /* all others */
4919 enum { /* video status flags, based on VIDEO_570 */
4920 TP_ACPI_VIDEO_S_LCD
= 0x01, /* LCD output enabled */
4921 TP_ACPI_VIDEO_S_CRT
= 0x02, /* CRT output enabled */
4922 TP_ACPI_VIDEO_S_DVI
= 0x08, /* DVI output enabled */
4925 enum { /* TPACPI_VIDEO_570 constants */
4926 TP_ACPI_VIDEO_570_PHSCMD
= 0x87, /* unknown magic constant :( */
4927 TP_ACPI_VIDEO_570_PHSMASK
= 0x03, /* PHS bits that map to
4928 * video_status_flags */
4929 TP_ACPI_VIDEO_570_PHS2CMD
= 0x8b, /* unknown magic constant :( */
4930 TP_ACPI_VIDEO_570_PHS2SET
= 0x80, /* unknown magic constant :( */
4933 static enum video_access_mode video_supported
;
4934 static int video_orig_autosw
;
4936 static int video_autosw_get(void);
4937 static int video_autosw_set(int enable
);
4939 TPACPI_HANDLE(vid
, root
,
4940 "\\_SB.PCI.AGP.VGA", /* 570 */
4941 "\\_SB.PCI0.AGP0.VID0", /* 600e/x, 770x */
4942 "\\_SB.PCI0.VID0", /* 770e */
4943 "\\_SB.PCI0.VID", /* A21e, G4x, R50e, X30, X40 */
4944 "\\_SB.PCI0.AGP.VGA", /* X100e and a few others */
4945 "\\_SB.PCI0.AGP.VID", /* all others */
4948 TPACPI_HANDLE(vid2
, root
, "\\_SB.PCI0.AGPB.VID"); /* G41 */
4950 static int __init
video_init(struct ibm_init_struct
*iibm
)
4954 vdbg_printk(TPACPI_DBG_INIT
, "initializing video subdriver\n");
4956 TPACPI_ACPIHANDLE_INIT(vid
);
4957 if (tpacpi_is_ibm())
4958 TPACPI_ACPIHANDLE_INIT(vid2
);
4960 if (vid2_handle
&& acpi_evalf(NULL
, &ivga
, "\\IVGA", "d") && ivga
)
4961 /* G41, assume IVGA doesn't change */
4962 vid_handle
= vid2_handle
;
4965 /* video switching not supported on R30, R31 */
4966 video_supported
= TPACPI_VIDEO_NONE
;
4967 else if (tpacpi_is_ibm() &&
4968 acpi_evalf(vid_handle
, &video_orig_autosw
, "SWIT", "qd"))
4970 video_supported
= TPACPI_VIDEO_570
;
4971 else if (tpacpi_is_ibm() &&
4972 acpi_evalf(vid_handle
, &video_orig_autosw
, "^VADL", "qd"))
4973 /* 600e/x, 770e, 770x */
4974 video_supported
= TPACPI_VIDEO_770
;
4977 video_supported
= TPACPI_VIDEO_NEW
;
4979 vdbg_printk(TPACPI_DBG_INIT
, "video is %s, mode %d\n",
4980 str_supported(video_supported
!= TPACPI_VIDEO_NONE
),
4983 return (video_supported
!= TPACPI_VIDEO_NONE
) ? 0 : 1;
4986 static void video_exit(void)
4988 dbg_printk(TPACPI_DBG_EXIT
,
4989 "restoring original video autoswitch mode\n");
4990 if (video_autosw_set(video_orig_autosw
))
4991 pr_err("error while trying to restore original video autoswitch mode\n");
4994 static int video_outputsw_get(void)
4999 switch (video_supported
) {
5000 case TPACPI_VIDEO_570
:
5001 if (!acpi_evalf(NULL
, &i
, "\\_SB.PHS", "dd",
5002 TP_ACPI_VIDEO_570_PHSCMD
))
5004 status
= i
& TP_ACPI_VIDEO_570_PHSMASK
;
5006 case TPACPI_VIDEO_770
:
5007 if (!acpi_evalf(NULL
, &i
, "\\VCDL", "d"))
5010 status
|= TP_ACPI_VIDEO_S_LCD
;
5011 if (!acpi_evalf(NULL
, &i
, "\\VCDC", "d"))
5014 status
|= TP_ACPI_VIDEO_S_CRT
;
5016 case TPACPI_VIDEO_NEW
:
5017 if (!acpi_evalf(NULL
, NULL
, "\\VUPS", "vd", 1) ||
5018 !acpi_evalf(NULL
, &i
, "\\VCDC", "d"))
5021 status
|= TP_ACPI_VIDEO_S_CRT
;
5023 if (!acpi_evalf(NULL
, NULL
, "\\VUPS", "vd", 0) ||
5024 !acpi_evalf(NULL
, &i
, "\\VCDL", "d"))
5027 status
|= TP_ACPI_VIDEO_S_LCD
;
5028 if (!acpi_evalf(NULL
, &i
, "\\VCDD", "d"))
5031 status
|= TP_ACPI_VIDEO_S_DVI
;
5040 static int video_outputsw_set(int status
)
5045 switch (video_supported
) {
5046 case TPACPI_VIDEO_570
:
5047 res
= acpi_evalf(NULL
, NULL
,
5048 "\\_SB.PHS2", "vdd",
5049 TP_ACPI_VIDEO_570_PHS2CMD
,
5050 status
| TP_ACPI_VIDEO_570_PHS2SET
);
5052 case TPACPI_VIDEO_770
:
5053 autosw
= video_autosw_get();
5057 res
= video_autosw_set(1);
5060 res
= acpi_evalf(vid_handle
, NULL
,
5061 "ASWT", "vdd", status
* 0x100, 0);
5062 if (!autosw
&& video_autosw_set(autosw
)) {
5063 pr_err("video auto-switch left enabled due to error\n");
5067 case TPACPI_VIDEO_NEW
:
5068 res
= acpi_evalf(NULL
, NULL
, "\\VUPS", "vd", 0x80) &&
5069 acpi_evalf(NULL
, NULL
, "\\VSDS", "vdd", status
, 1);
5075 return (res
) ? 0 : -EIO
;
5078 static int video_autosw_get(void)
5082 switch (video_supported
) {
5083 case TPACPI_VIDEO_570
:
5084 if (!acpi_evalf(vid_handle
, &autosw
, "SWIT", "d"))
5087 case TPACPI_VIDEO_770
:
5088 case TPACPI_VIDEO_NEW
:
5089 if (!acpi_evalf(vid_handle
, &autosw
, "^VDEE", "d"))
5099 static int video_autosw_set(int enable
)
5101 if (!acpi_evalf(vid_handle
, NULL
, "_DOS", "vd", (enable
) ? 1 : 0))
5106 static int video_outputsw_cycle(void)
5108 int autosw
= video_autosw_get();
5114 switch (video_supported
) {
5115 case TPACPI_VIDEO_570
:
5116 res
= video_autosw_set(1);
5119 res
= acpi_evalf(ec_handle
, NULL
, "_Q16", "v");
5121 case TPACPI_VIDEO_770
:
5122 case TPACPI_VIDEO_NEW
:
5123 res
= video_autosw_set(1);
5126 res
= acpi_evalf(vid_handle
, NULL
, "VSWT", "v");
5131 if (!autosw
&& video_autosw_set(autosw
)) {
5132 pr_err("video auto-switch left enabled due to error\n");
5136 return (res
) ? 0 : -EIO
;
5139 static int video_expand_toggle(void)
5141 switch (video_supported
) {
5142 case TPACPI_VIDEO_570
:
5143 return acpi_evalf(ec_handle
, NULL
, "_Q17", "v") ?
5145 case TPACPI_VIDEO_770
:
5146 return acpi_evalf(vid_handle
, NULL
, "VEXP", "v") ?
5148 case TPACPI_VIDEO_NEW
:
5149 return acpi_evalf(NULL
, NULL
, "\\VEXP", "v") ?
5157 static int video_read(struct seq_file
*m
)
5161 if (video_supported
== TPACPI_VIDEO_NONE
) {
5162 seq_printf(m
, "status:\t\tnot supported\n");
5166 /* Even reads can crash X.org, so... */
5167 if (!capable(CAP_SYS_ADMIN
))
5170 status
= video_outputsw_get();
5174 autosw
= video_autosw_get();
5178 seq_printf(m
, "status:\t\tsupported\n");
5179 seq_printf(m
, "lcd:\t\t%s\n", enabled(status
, 0));
5180 seq_printf(m
, "crt:\t\t%s\n", enabled(status
, 1));
5181 if (video_supported
== TPACPI_VIDEO_NEW
)
5182 seq_printf(m
, "dvi:\t\t%s\n", enabled(status
, 3));
5183 seq_printf(m
, "auto:\t\t%s\n", enabled(autosw
, 0));
5184 seq_printf(m
, "commands:\tlcd_enable, lcd_disable\n");
5185 seq_printf(m
, "commands:\tcrt_enable, crt_disable\n");
5186 if (video_supported
== TPACPI_VIDEO_NEW
)
5187 seq_printf(m
, "commands:\tdvi_enable, dvi_disable\n");
5188 seq_printf(m
, "commands:\tauto_enable, auto_disable\n");
5189 seq_printf(m
, "commands:\tvideo_switch, expand_toggle\n");
5194 static int video_write(char *buf
)
5197 int enable
, disable
, status
;
5200 if (video_supported
== TPACPI_VIDEO_NONE
)
5203 /* Even reads can crash X.org, let alone writes... */
5204 if (!capable(CAP_SYS_ADMIN
))
5210 while ((cmd
= strsep(&buf
, ","))) {
5211 if (strlencmp(cmd
, "lcd_enable") == 0) {
5212 enable
|= TP_ACPI_VIDEO_S_LCD
;
5213 } else if (strlencmp(cmd
, "lcd_disable") == 0) {
5214 disable
|= TP_ACPI_VIDEO_S_LCD
;
5215 } else if (strlencmp(cmd
, "crt_enable") == 0) {
5216 enable
|= TP_ACPI_VIDEO_S_CRT
;
5217 } else if (strlencmp(cmd
, "crt_disable") == 0) {
5218 disable
|= TP_ACPI_VIDEO_S_CRT
;
5219 } else if (video_supported
== TPACPI_VIDEO_NEW
&&
5220 strlencmp(cmd
, "dvi_enable") == 0) {
5221 enable
|= TP_ACPI_VIDEO_S_DVI
;
5222 } else if (video_supported
== TPACPI_VIDEO_NEW
&&
5223 strlencmp(cmd
, "dvi_disable") == 0) {
5224 disable
|= TP_ACPI_VIDEO_S_DVI
;
5225 } else if (strlencmp(cmd
, "auto_enable") == 0) {
5226 res
= video_autosw_set(1);
5229 } else if (strlencmp(cmd
, "auto_disable") == 0) {
5230 res
= video_autosw_set(0);
5233 } else if (strlencmp(cmd
, "video_switch") == 0) {
5234 res
= video_outputsw_cycle();
5237 } else if (strlencmp(cmd
, "expand_toggle") == 0) {
5238 res
= video_expand_toggle();
5245 if (enable
|| disable
) {
5246 status
= video_outputsw_get();
5249 res
= video_outputsw_set((status
& ~disable
) | enable
);
5257 static struct ibm_struct video_driver_data
= {
5260 .write
= video_write
,
5264 #endif /* CONFIG_THINKPAD_ACPI_VIDEO */
5266 /*************************************************************************
5267 * Keyboard backlight subdriver
5270 static enum led_brightness kbdlight_brightness
;
5271 static DEFINE_MUTEX(kbdlight_mutex
);
5273 static int kbdlight_set_level(int level
)
5280 mutex_lock(&kbdlight_mutex
);
5282 if (!acpi_evalf(hkey_handle
, NULL
, "MLCS", "dd", level
))
5285 kbdlight_brightness
= level
;
5287 mutex_unlock(&kbdlight_mutex
);
5292 static int kbdlight_get_level(void)
5299 if (!acpi_evalf(hkey_handle
, &status
, "MLCG", "dd", 0))
5305 return status
& 0x3;
5308 static bool kbdlight_is_supported(void)
5315 if (!acpi_has_method(hkey_handle
, "MLCG")) {
5316 vdbg_printk(TPACPI_DBG_INIT
, "kbdlight MLCG is unavailable\n");
5320 if (!acpi_evalf(hkey_handle
, &status
, "MLCG", "qdd", 0)) {
5321 vdbg_printk(TPACPI_DBG_INIT
, "kbdlight MLCG failed\n");
5326 vdbg_printk(TPACPI_DBG_INIT
, "kbdlight MLCG err: %d\n", status
);
5330 vdbg_printk(TPACPI_DBG_INIT
, "kbdlight MLCG returned 0x%x\n", status
);
5332 * Guessed test for keyboard backlight:
5334 * Machines with backlight keyboard return:
5335 * b010100000010000000XX - ThinkPad X1 Carbon 3rd
5336 * b110100010010000000XX - ThinkPad x230
5337 * b010100000010000000XX - ThinkPad x240
5338 * b010100000010000000XX - ThinkPad W541
5339 * (XX is current backlight level)
5341 * Machines without backlight keyboard return:
5342 * b10100001000000000000 - ThinkPad x230
5343 * b10110001000000000000 - ThinkPad E430
5344 * b00000000000000000000 - ThinkPad E450
5346 * Candidate BITs for detection test (XOR):
5347 * b01000000001000000000
5350 return status
& BIT(9);
5353 static int kbdlight_sysfs_set(struct led_classdev
*led_cdev
,
5354 enum led_brightness brightness
)
5356 return kbdlight_set_level(brightness
);
5359 static enum led_brightness
kbdlight_sysfs_get(struct led_classdev
*led_cdev
)
5363 level
= kbdlight_get_level();
5370 static struct tpacpi_led_classdev tpacpi_led_kbdlight
= {
5372 .name
= "tpacpi::kbd_backlight",
5373 .max_brightness
= 2,
5374 .flags
= LED_BRIGHT_HW_CHANGED
,
5375 .brightness_set_blocking
= &kbdlight_sysfs_set
,
5376 .brightness_get
= &kbdlight_sysfs_get
,
5380 static int __init
kbdlight_init(struct ibm_init_struct
*iibm
)
5384 vdbg_printk(TPACPI_DBG_INIT
, "initializing kbdlight subdriver\n");
5386 TPACPI_ACPIHANDLE_INIT(hkey
);
5388 if (!kbdlight_is_supported()) {
5389 tp_features
.kbdlight
= 0;
5390 vdbg_printk(TPACPI_DBG_INIT
, "kbdlight is unsupported\n");
5394 kbdlight_brightness
= kbdlight_sysfs_get(NULL
);
5395 tp_features
.kbdlight
= 1;
5397 rc
= led_classdev_register(&tpacpi_pdev
->dev
,
5398 &tpacpi_led_kbdlight
.led_classdev
);
5400 tp_features
.kbdlight
= 0;
5404 tpacpi_hotkey_driver_mask_set(hotkey_driver_mask
|
5405 TP_ACPI_HKEY_KBD_LIGHT_MASK
);
5409 static void kbdlight_exit(void)
5411 led_classdev_unregister(&tpacpi_led_kbdlight
.led_classdev
);
5414 static int kbdlight_set_level_and_update(int level
)
5417 struct led_classdev
*led_cdev
;
5419 ret
= kbdlight_set_level(level
);
5420 led_cdev
= &tpacpi_led_kbdlight
.led_classdev
;
5422 if (ret
== 0 && !(led_cdev
->flags
& LED_SUSPENDED
))
5423 led_cdev
->brightness
= level
;
5428 static int kbdlight_read(struct seq_file
*m
)
5432 if (!tp_features
.kbdlight
) {
5433 seq_printf(m
, "status:\t\tnot supported\n");
5435 level
= kbdlight_get_level();
5437 seq_printf(m
, "status:\t\terror %d\n", level
);
5439 seq_printf(m
, "status:\t\t%d\n", level
);
5440 seq_printf(m
, "commands:\t0, 1, 2\n");
5446 static int kbdlight_write(char *buf
)
5449 int res
, level
= -EINVAL
;
5451 if (!tp_features
.kbdlight
)
5454 while ((cmd
= strsep(&buf
, ","))) {
5455 res
= kstrtoint(cmd
, 10, &level
);
5460 if (level
>= 3 || level
< 0)
5463 return kbdlight_set_level_and_update(level
);
5466 static void kbdlight_suspend(void)
5468 struct led_classdev
*led_cdev
;
5470 if (!tp_features
.kbdlight
)
5473 led_cdev
= &tpacpi_led_kbdlight
.led_classdev
;
5474 led_update_brightness(led_cdev
);
5475 led_classdev_suspend(led_cdev
);
5478 static void kbdlight_resume(void)
5480 if (!tp_features
.kbdlight
)
5483 led_classdev_resume(&tpacpi_led_kbdlight
.led_classdev
);
5486 static struct ibm_struct kbdlight_driver_data
= {
5488 .read
= kbdlight_read
,
5489 .write
= kbdlight_write
,
5490 .suspend
= kbdlight_suspend
,
5491 .resume
= kbdlight_resume
,
5492 .exit
= kbdlight_exit
,
5495 /*************************************************************************
5496 * Light (thinklight) subdriver
5499 TPACPI_HANDLE(lght
, root
, "\\LGHT"); /* A21e, A2xm/p, T20-22, X20-21 */
5500 TPACPI_HANDLE(ledb
, ec
, "LEDB"); /* G4x */
5502 static int light_get_status(void)
5506 if (tp_features
.light_status
) {
5507 if (!acpi_evalf(ec_handle
, &status
, "KBLT", "d"))
5515 static int light_set_status(int status
)
5519 if (tp_features
.light
) {
5521 rc
= acpi_evalf(cmos_handle
, NULL
, NULL
, "vd",
5523 TP_CMOS_THINKLIGHT_ON
:
5524 TP_CMOS_THINKLIGHT_OFF
);
5526 rc
= acpi_evalf(lght_handle
, NULL
, NULL
, "vd",
5529 return (rc
) ? 0 : -EIO
;
5535 static int light_sysfs_set(struct led_classdev
*led_cdev
,
5536 enum led_brightness brightness
)
5538 return light_set_status((brightness
!= LED_OFF
) ?
5539 TPACPI_LED_ON
: TPACPI_LED_OFF
);
5542 static enum led_brightness
light_sysfs_get(struct led_classdev
*led_cdev
)
5544 return (light_get_status() == 1) ? LED_FULL
: LED_OFF
;
5547 static struct tpacpi_led_classdev tpacpi_led_thinklight
= {
5549 .name
= "tpacpi::thinklight",
5550 .brightness_set_blocking
= &light_sysfs_set
,
5551 .brightness_get
= &light_sysfs_get
,
5555 static int __init
light_init(struct ibm_init_struct
*iibm
)
5559 vdbg_printk(TPACPI_DBG_INIT
, "initializing light subdriver\n");
5561 if (tpacpi_is_ibm()) {
5562 TPACPI_ACPIHANDLE_INIT(ledb
);
5563 TPACPI_ACPIHANDLE_INIT(lght
);
5565 TPACPI_ACPIHANDLE_INIT(cmos
);
5567 /* light not supported on 570, 600e/x, 770e, 770x, G4x, R30, R31 */
5568 tp_features
.light
= (cmos_handle
|| lght_handle
) && !ledb_handle
;
5570 if (tp_features
.light
)
5571 /* light status not supported on
5572 570, 600e/x, 770e, 770x, G4x, R30, R31, R32, X20 */
5573 tp_features
.light_status
=
5574 acpi_evalf(ec_handle
, NULL
, "KBLT", "qv");
5576 vdbg_printk(TPACPI_DBG_INIT
, "light is %s, light status is %s\n",
5577 str_supported(tp_features
.light
),
5578 str_supported(tp_features
.light_status
));
5580 if (!tp_features
.light
)
5583 rc
= led_classdev_register(&tpacpi_pdev
->dev
,
5584 &tpacpi_led_thinklight
.led_classdev
);
5587 tp_features
.light
= 0;
5588 tp_features
.light_status
= 0;
5596 static void light_exit(void)
5598 led_classdev_unregister(&tpacpi_led_thinklight
.led_classdev
);
5601 static int light_read(struct seq_file
*m
)
5605 if (!tp_features
.light
) {
5606 seq_printf(m
, "status:\t\tnot supported\n");
5607 } else if (!tp_features
.light_status
) {
5608 seq_printf(m
, "status:\t\tunknown\n");
5609 seq_printf(m
, "commands:\ton, off\n");
5611 status
= light_get_status();
5614 seq_printf(m
, "status:\t\t%s\n", onoff(status
, 0));
5615 seq_printf(m
, "commands:\ton, off\n");
5621 static int light_write(char *buf
)
5626 if (!tp_features
.light
)
5629 while ((cmd
= strsep(&buf
, ","))) {
5630 if (strlencmp(cmd
, "on") == 0) {
5632 } else if (strlencmp(cmd
, "off") == 0) {
5638 return light_set_status(newstatus
);
5641 static struct ibm_struct light_driver_data
= {
5644 .write
= light_write
,
5648 /*************************************************************************
5652 /* sysfs cmos_command -------------------------------------------------- */
5653 static ssize_t
cmos_command_store(struct device
*dev
,
5654 struct device_attribute
*attr
,
5655 const char *buf
, size_t count
)
5657 unsigned long cmos_cmd
;
5660 if (parse_strtoul(buf
, 21, &cmos_cmd
))
5663 res
= issue_thinkpad_cmos_command(cmos_cmd
);
5664 return (res
) ? res
: count
;
5667 static DEVICE_ATTR_WO(cmos_command
);
5669 /* --------------------------------------------------------------------- */
5671 static int __init
cmos_init(struct ibm_init_struct
*iibm
)
5675 vdbg_printk(TPACPI_DBG_INIT
,
5676 "initializing cmos commands subdriver\n");
5678 TPACPI_ACPIHANDLE_INIT(cmos
);
5680 vdbg_printk(TPACPI_DBG_INIT
, "cmos commands are %s\n",
5681 str_supported(cmos_handle
!= NULL
));
5683 res
= device_create_file(&tpacpi_pdev
->dev
, &dev_attr_cmos_command
);
5687 return (cmos_handle
) ? 0 : 1;
5690 static void cmos_exit(void)
5692 device_remove_file(&tpacpi_pdev
->dev
, &dev_attr_cmos_command
);
5695 static int cmos_read(struct seq_file
*m
)
5697 /* cmos not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
5698 R30, R31, T20-22, X20-21 */
5700 seq_printf(m
, "status:\t\tnot supported\n");
5702 seq_printf(m
, "status:\t\tsupported\n");
5703 seq_printf(m
, "commands:\t<cmd> (<cmd> is 0-21)\n");
5709 static int cmos_write(char *buf
)
5714 while ((cmd
= strsep(&buf
, ","))) {
5715 if (sscanf(cmd
, "%u", &cmos_cmd
) == 1 &&
5716 cmos_cmd
>= 0 && cmos_cmd
<= 21) {
5721 res
= issue_thinkpad_cmos_command(cmos_cmd
);
5729 static struct ibm_struct cmos_driver_data
= {
5732 .write
= cmos_write
,
5736 /*************************************************************************
5740 enum led_access_mode
{
5741 TPACPI_LED_NONE
= 0,
5742 TPACPI_LED_570
, /* 570 */
5743 TPACPI_LED_OLD
, /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
5744 TPACPI_LED_NEW
, /* all others */
5747 enum { /* For TPACPI_LED_OLD */
5748 TPACPI_LED_EC_HLCL
= 0x0c, /* EC reg to get led to power on */
5749 TPACPI_LED_EC_HLBL
= 0x0d, /* EC reg to blink a lit led */
5750 TPACPI_LED_EC_HLMS
= 0x0e, /* EC reg to select led to command */
5753 static enum led_access_mode led_supported
;
5755 static acpi_handle led_handle
;
5757 #define TPACPI_LED_NUMLEDS 16
5758 static struct tpacpi_led_classdev
*tpacpi_leds
;
5759 static enum led_status_t tpacpi_led_state_cache
[TPACPI_LED_NUMLEDS
];
5760 static const char * const tpacpi_led_names
[TPACPI_LED_NUMLEDS
] = {
5761 /* there's a limit of 19 chars + NULL before 2.6.26 */
5763 "tpacpi:orange:batt",
5764 "tpacpi:green:batt",
5765 "tpacpi::dock_active",
5766 "tpacpi::bay_active",
5767 "tpacpi::dock_batt",
5768 "tpacpi::unknown_led",
5770 "tpacpi::dock_status1",
5771 "tpacpi::dock_status2",
5772 "tpacpi::unknown_led2",
5773 "tpacpi::unknown_led3",
5774 "tpacpi::thinkvantage",
5776 #define TPACPI_SAFE_LEDS 0x1081U
5778 static inline bool tpacpi_is_led_restricted(const unsigned int led
)
5780 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
5783 return (1U & (TPACPI_SAFE_LEDS
>> led
)) == 0;
5787 static int led_get_status(const unsigned int led
)
5790 enum led_status_t led_s
;
5792 switch (led_supported
) {
5793 case TPACPI_LED_570
:
5794 if (!acpi_evalf(ec_handle
,
5795 &status
, "GLED", "dd", 1 << led
))
5797 led_s
= (status
== 0) ?
5802 tpacpi_led_state_cache
[led
] = led_s
;
5811 static int led_set_status(const unsigned int led
,
5812 const enum led_status_t ledstatus
)
5814 /* off, on, blink. Index is led_status_t */
5815 static const unsigned int led_sled_arg1
[] = { 0, 1, 3 };
5816 static const unsigned int led_led_arg1
[] = { 0, 0x80, 0xc0 };
5820 switch (led_supported
) {
5821 case TPACPI_LED_570
:
5823 if (unlikely(led
> 7))
5825 if (unlikely(tpacpi_is_led_restricted(led
)))
5827 if (!acpi_evalf(led_handle
, NULL
, NULL
, "vdd",
5828 (1 << led
), led_sled_arg1
[ledstatus
]))
5831 case TPACPI_LED_OLD
:
5832 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20 */
5833 if (unlikely(led
> 7))
5835 if (unlikely(tpacpi_is_led_restricted(led
)))
5837 rc
= ec_write(TPACPI_LED_EC_HLMS
, (1 << led
));
5839 rc
= ec_write(TPACPI_LED_EC_HLBL
,
5840 (ledstatus
== TPACPI_LED_BLINK
) << led
);
5842 rc
= ec_write(TPACPI_LED_EC_HLCL
,
5843 (ledstatus
!= TPACPI_LED_OFF
) << led
);
5845 case TPACPI_LED_NEW
:
5847 if (unlikely(led
>= TPACPI_LED_NUMLEDS
))
5849 if (unlikely(tpacpi_is_led_restricted(led
)))
5851 if (!acpi_evalf(led_handle
, NULL
, NULL
, "vdd",
5852 led
, led_led_arg1
[ledstatus
]))
5860 tpacpi_led_state_cache
[led
] = ledstatus
;
5865 static int led_sysfs_set(struct led_classdev
*led_cdev
,
5866 enum led_brightness brightness
)
5868 struct tpacpi_led_classdev
*data
= container_of(led_cdev
,
5869 struct tpacpi_led_classdev
, led_classdev
);
5870 enum led_status_t new_state
;
5872 if (brightness
== LED_OFF
)
5873 new_state
= TPACPI_LED_OFF
;
5874 else if (tpacpi_led_state_cache
[data
->led
] != TPACPI_LED_BLINK
)
5875 new_state
= TPACPI_LED_ON
;
5877 new_state
= TPACPI_LED_BLINK
;
5879 return led_set_status(data
->led
, new_state
);
5882 static int led_sysfs_blink_set(struct led_classdev
*led_cdev
,
5883 unsigned long *delay_on
, unsigned long *delay_off
)
5885 struct tpacpi_led_classdev
*data
= container_of(led_cdev
,
5886 struct tpacpi_led_classdev
, led_classdev
);
5888 /* Can we choose the flash rate? */
5889 if (*delay_on
== 0 && *delay_off
== 0) {
5890 /* yes. set them to the hardware blink rate (1 Hz) */
5891 *delay_on
= 500; /* ms */
5892 *delay_off
= 500; /* ms */
5893 } else if ((*delay_on
!= 500) || (*delay_off
!= 500))
5896 return led_set_status(data
->led
, TPACPI_LED_BLINK
);
5899 static enum led_brightness
led_sysfs_get(struct led_classdev
*led_cdev
)
5903 struct tpacpi_led_classdev
*data
= container_of(led_cdev
,
5904 struct tpacpi_led_classdev
, led_classdev
);
5906 rc
= led_get_status(data
->led
);
5908 if (rc
== TPACPI_LED_OFF
|| rc
< 0)
5909 rc
= LED_OFF
; /* no error handling in led class :( */
5916 static void led_exit(void)
5920 for (i
= 0; i
< TPACPI_LED_NUMLEDS
; i
++)
5921 led_classdev_unregister(&tpacpi_leds
[i
].led_classdev
);
5926 static int __init
tpacpi_init_led(unsigned int led
)
5928 /* LEDs with no name don't get registered */
5929 if (!tpacpi_led_names
[led
])
5932 tpacpi_leds
[led
].led_classdev
.brightness_set_blocking
= &led_sysfs_set
;
5933 tpacpi_leds
[led
].led_classdev
.blink_set
= &led_sysfs_blink_set
;
5934 if (led_supported
== TPACPI_LED_570
)
5935 tpacpi_leds
[led
].led_classdev
.brightness_get
= &led_sysfs_get
;
5937 tpacpi_leds
[led
].led_classdev
.name
= tpacpi_led_names
[led
];
5938 tpacpi_leds
[led
].led
= led
;
5940 return led_classdev_register(&tpacpi_pdev
->dev
, &tpacpi_leds
[led
].led_classdev
);
5943 static const struct tpacpi_quirk led_useful_qtable
[] __initconst
= {
5944 TPACPI_Q_IBM('1', 'E', 0x009f), /* A30 */
5945 TPACPI_Q_IBM('1', 'N', 0x009f), /* A31 */
5946 TPACPI_Q_IBM('1', 'G', 0x009f), /* A31 */
5948 TPACPI_Q_IBM('1', 'I', 0x0097), /* T30 */
5949 TPACPI_Q_IBM('1', 'R', 0x0097), /* T40, T41, T42, R50, R51 */
5950 TPACPI_Q_IBM('7', '0', 0x0097), /* T43, R52 */
5951 TPACPI_Q_IBM('1', 'Y', 0x0097), /* T43 */
5952 TPACPI_Q_IBM('1', 'W', 0x0097), /* R50e */
5953 TPACPI_Q_IBM('1', 'V', 0x0097), /* R51 */
5954 TPACPI_Q_IBM('7', '8', 0x0097), /* R51e */
5955 TPACPI_Q_IBM('7', '6', 0x0097), /* R52 */
5957 TPACPI_Q_IBM('1', 'K', 0x00bf), /* X30 */
5958 TPACPI_Q_IBM('1', 'Q', 0x00bf), /* X31, X32 */
5959 TPACPI_Q_IBM('1', 'U', 0x00bf), /* X40 */
5960 TPACPI_Q_IBM('7', '4', 0x00bf), /* X41 */
5961 TPACPI_Q_IBM('7', '5', 0x00bf), /* X41t */
5963 TPACPI_Q_IBM('7', '9', 0x1f97), /* T60 (1) */
5964 TPACPI_Q_IBM('7', '7', 0x1f97), /* Z60* (1) */
5965 TPACPI_Q_IBM('7', 'F', 0x1f97), /* Z61* (1) */
5966 TPACPI_Q_IBM('7', 'B', 0x1fb7), /* X60 (1) */
5968 /* (1) - may have excess leds enabled on MSB */
5970 /* Defaults (order matters, keep last, don't reorder!) */
5972 .vendor
= PCI_VENDOR_ID_LENOVO
,
5973 .bios
= TPACPI_MATCH_ANY
, .ec
= TPACPI_MATCH_ANY
,
5976 { /* IBM ThinkPads with no EC version string */
5977 .vendor
= PCI_VENDOR_ID_IBM
,
5978 .bios
= TPACPI_MATCH_ANY
, .ec
= TPACPI_MATCH_UNKNOWN
,
5981 { /* IBM ThinkPads with EC version string */
5982 .vendor
= PCI_VENDOR_ID_IBM
,
5983 .bios
= TPACPI_MATCH_ANY
, .ec
= TPACPI_MATCH_ANY
,
5988 static enum led_access_mode __init
led_init_detect_mode(void)
5992 if (tpacpi_is_ibm()) {
5994 status
= acpi_get_handle(ec_handle
, "SLED", &led_handle
);
5995 if (ACPI_SUCCESS(status
))
5996 return TPACPI_LED_570
;
5998 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
5999 status
= acpi_get_handle(ec_handle
, "SYSL", &led_handle
);
6000 if (ACPI_SUCCESS(status
))
6001 return TPACPI_LED_OLD
;
6005 status
= acpi_get_handle(ec_handle
, "LED", &led_handle
);
6006 if (ACPI_SUCCESS(status
))
6007 return TPACPI_LED_NEW
;
6009 /* R30, R31, and unknown firmwares */
6011 return TPACPI_LED_NONE
;
6014 static int __init
led_init(struct ibm_init_struct
*iibm
)
6018 unsigned long useful_leds
;
6020 vdbg_printk(TPACPI_DBG_INIT
, "initializing LED subdriver\n");
6022 led_supported
= led_init_detect_mode();
6024 if (led_supported
!= TPACPI_LED_NONE
) {
6025 useful_leds
= tpacpi_check_quirks(led_useful_qtable
,
6026 ARRAY_SIZE(led_useful_qtable
));
6030 led_supported
= TPACPI_LED_NONE
;
6034 vdbg_printk(TPACPI_DBG_INIT
, "LED commands are %s, mode %d\n",
6035 str_supported(led_supported
), led_supported
);
6037 if (led_supported
== TPACPI_LED_NONE
)
6040 tpacpi_leds
= kcalloc(TPACPI_LED_NUMLEDS
, sizeof(*tpacpi_leds
),
6043 pr_err("Out of memory for LED data\n");
6047 for (i
= 0; i
< TPACPI_LED_NUMLEDS
; i
++) {
6048 tpacpi_leds
[i
].led
= -1;
6050 if (!tpacpi_is_led_restricted(i
) && test_bit(i
, &useful_leds
)) {
6051 rc
= tpacpi_init_led(i
);
6059 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
6060 pr_notice("warning: userspace override of important firmware LEDs is enabled\n");
6065 #define str_led_status(s) \
6066 ((s) == TPACPI_LED_OFF ? "off" : \
6067 ((s) == TPACPI_LED_ON ? "on" : "blinking"))
6069 static int led_read(struct seq_file
*m
)
6071 if (!led_supported
) {
6072 seq_printf(m
, "status:\t\tnot supported\n");
6075 seq_printf(m
, "status:\t\tsupported\n");
6077 if (led_supported
== TPACPI_LED_570
) {
6080 for (i
= 0; i
< 8; i
++) {
6081 status
= led_get_status(i
);
6084 seq_printf(m
, "%d:\t\t%s\n",
6085 i
, str_led_status(status
));
6089 seq_printf(m
, "commands:\t<led> on, <led> off, <led> blink (<led> is 0-15)\n");
6094 static int led_write(char *buf
)
6098 enum led_status_t s
;
6103 while ((cmd
= strsep(&buf
, ","))) {
6104 if (sscanf(cmd
, "%d", &led
) != 1)
6107 if (led
< 0 || led
> (TPACPI_LED_NUMLEDS
- 1))
6110 if (tpacpi_leds
[led
].led
< 0)
6113 if (strstr(cmd
, "off")) {
6115 } else if (strstr(cmd
, "on")) {
6117 } else if (strstr(cmd
, "blink")) {
6118 s
= TPACPI_LED_BLINK
;
6123 rc
= led_set_status(led
, s
);
6131 static struct ibm_struct led_driver_data
= {
6138 /*************************************************************************
6142 TPACPI_HANDLE(beep
, ec
, "BEEP"); /* all except R30, R31 */
6144 #define TPACPI_BEEP_Q1 0x0001
6146 static const struct tpacpi_quirk beep_quirk_table
[] __initconst
= {
6147 TPACPI_Q_IBM('I', 'M', TPACPI_BEEP_Q1
), /* 570 */
6148 TPACPI_Q_IBM('I', 'U', TPACPI_BEEP_Q1
), /* 570E - unverified */
6151 static int __init
beep_init(struct ibm_init_struct
*iibm
)
6153 unsigned long quirks
;
6155 vdbg_printk(TPACPI_DBG_INIT
, "initializing beep subdriver\n");
6157 TPACPI_ACPIHANDLE_INIT(beep
);
6159 vdbg_printk(TPACPI_DBG_INIT
, "beep is %s\n",
6160 str_supported(beep_handle
!= NULL
));
6162 quirks
= tpacpi_check_quirks(beep_quirk_table
,
6163 ARRAY_SIZE(beep_quirk_table
));
6165 tp_features
.beep_needs_two_args
= !!(quirks
& TPACPI_BEEP_Q1
);
6167 return (beep_handle
) ? 0 : 1;
6170 static int beep_read(struct seq_file
*m
)
6173 seq_printf(m
, "status:\t\tnot supported\n");
6175 seq_printf(m
, "status:\t\tsupported\n");
6176 seq_printf(m
, "commands:\t<cmd> (<cmd> is 0-17)\n");
6182 static int beep_write(char *buf
)
6190 while ((cmd
= strsep(&buf
, ","))) {
6191 if (sscanf(cmd
, "%u", &beep_cmd
) == 1 &&
6192 beep_cmd
>= 0 && beep_cmd
<= 17) {
6196 if (tp_features
.beep_needs_two_args
) {
6197 if (!acpi_evalf(beep_handle
, NULL
, NULL
, "vdd",
6201 if (!acpi_evalf(beep_handle
, NULL
, NULL
, "vd",
6210 static struct ibm_struct beep_driver_data
= {
6213 .write
= beep_write
,
6216 /*************************************************************************
6220 enum thermal_access_mode
{
6221 TPACPI_THERMAL_NONE
= 0, /* No thermal support */
6222 TPACPI_THERMAL_ACPI_TMP07
, /* Use ACPI TMP0-7 */
6223 TPACPI_THERMAL_ACPI_UPDT
, /* Use ACPI TMP0-7 with UPDT */
6224 TPACPI_THERMAL_TPEC_8
, /* Use ACPI EC regs, 8 sensors */
6225 TPACPI_THERMAL_TPEC_16
, /* Use ACPI EC regs, 16 sensors */
6228 enum { /* TPACPI_THERMAL_TPEC_* */
6229 TP_EC_THERMAL_TMP0
= 0x78, /* ACPI EC regs TMP 0..7 */
6230 TP_EC_THERMAL_TMP8
= 0xC0, /* ACPI EC regs TMP 8..15 */
6231 TP_EC_THERMAL_TMP_NA
= -128, /* ACPI EC sensor not available */
6233 TPACPI_THERMAL_SENSOR_NA
= -128000, /* Sensor not available */
6237 #define TPACPI_MAX_THERMAL_SENSORS 16 /* Max thermal sensors supported */
6238 struct ibm_thermal_sensors_struct
{
6239 s32 temp
[TPACPI_MAX_THERMAL_SENSORS
];
6242 static enum thermal_access_mode thermal_read_mode
;
6244 /* idx is zero-based */
6245 static int thermal_get_sensor(int idx
, s32
*value
)
6251 t
= TP_EC_THERMAL_TMP0
;
6253 switch (thermal_read_mode
) {
6254 #if TPACPI_MAX_THERMAL_SENSORS >= 16
6255 case TPACPI_THERMAL_TPEC_16
:
6256 if (idx
>= 8 && idx
<= 15) {
6257 t
= TP_EC_THERMAL_TMP8
;
6262 case TPACPI_THERMAL_TPEC_8
:
6264 if (!acpi_ec_read(t
+ idx
, &tmp
))
6266 *value
= tmp
* 1000;
6271 case TPACPI_THERMAL_ACPI_UPDT
:
6273 snprintf(tmpi
, sizeof(tmpi
), "TMP%c", '0' + idx
);
6274 if (!acpi_evalf(ec_handle
, NULL
, "UPDT", "v"))
6276 if (!acpi_evalf(ec_handle
, &t
, tmpi
, "d"))
6278 *value
= (t
- 2732) * 100;
6283 case TPACPI_THERMAL_ACPI_TMP07
:
6285 snprintf(tmpi
, sizeof(tmpi
), "TMP%c", '0' + idx
);
6286 if (!acpi_evalf(ec_handle
, &t
, tmpi
, "d"))
6288 if (t
> 127 || t
< -127)
6289 t
= TP_EC_THERMAL_TMP_NA
;
6295 case TPACPI_THERMAL_NONE
:
6303 static int thermal_get_sensors(struct ibm_thermal_sensors_struct
*s
)
6314 if (thermal_read_mode
== TPACPI_THERMAL_TPEC_16
)
6317 for (i
= 0 ; i
< n
; i
++) {
6318 res
= thermal_get_sensor(i
, &s
->temp
[i
]);
6326 static void thermal_dump_all_sensors(void)
6329 struct ibm_thermal_sensors_struct t
;
6331 n
= thermal_get_sensors(&t
);
6335 pr_notice("temperatures (Celsius):");
6337 for (i
= 0; i
< n
; i
++) {
6338 if (t
.temp
[i
] != TPACPI_THERMAL_SENSOR_NA
)
6339 pr_cont(" %d", (int)(t
.temp
[i
] / 1000));
6347 /* sysfs temp##_input -------------------------------------------------- */
6349 static ssize_t
thermal_temp_input_show(struct device
*dev
,
6350 struct device_attribute
*attr
,
6353 struct sensor_device_attribute
*sensor_attr
=
6354 to_sensor_dev_attr(attr
);
6355 int idx
= sensor_attr
->index
;
6359 res
= thermal_get_sensor(idx
, &value
);
6362 if (value
== TPACPI_THERMAL_SENSOR_NA
)
6365 return snprintf(buf
, PAGE_SIZE
, "%d\n", value
);
6368 #define THERMAL_SENSOR_ATTR_TEMP(_idxA, _idxB) \
6369 SENSOR_ATTR(temp##_idxA##_input, S_IRUGO, \
6370 thermal_temp_input_show, NULL, _idxB)
6372 static struct sensor_device_attribute sensor_dev_attr_thermal_temp_input
[] = {
6373 THERMAL_SENSOR_ATTR_TEMP(1, 0),
6374 THERMAL_SENSOR_ATTR_TEMP(2, 1),
6375 THERMAL_SENSOR_ATTR_TEMP(3, 2),
6376 THERMAL_SENSOR_ATTR_TEMP(4, 3),
6377 THERMAL_SENSOR_ATTR_TEMP(5, 4),
6378 THERMAL_SENSOR_ATTR_TEMP(6, 5),
6379 THERMAL_SENSOR_ATTR_TEMP(7, 6),
6380 THERMAL_SENSOR_ATTR_TEMP(8, 7),
6381 THERMAL_SENSOR_ATTR_TEMP(9, 8),
6382 THERMAL_SENSOR_ATTR_TEMP(10, 9),
6383 THERMAL_SENSOR_ATTR_TEMP(11, 10),
6384 THERMAL_SENSOR_ATTR_TEMP(12, 11),
6385 THERMAL_SENSOR_ATTR_TEMP(13, 12),
6386 THERMAL_SENSOR_ATTR_TEMP(14, 13),
6387 THERMAL_SENSOR_ATTR_TEMP(15, 14),
6388 THERMAL_SENSOR_ATTR_TEMP(16, 15),
6391 #define THERMAL_ATTRS(X) \
6392 &sensor_dev_attr_thermal_temp_input[X].dev_attr.attr
6394 static struct attribute
*thermal_temp_input_attr
[] = {
6414 static const struct attribute_group thermal_temp_input16_group
= {
6415 .attrs
= thermal_temp_input_attr
6418 static const struct attribute_group thermal_temp_input8_group
= {
6419 .attrs
= &thermal_temp_input_attr
[8]
6422 #undef THERMAL_SENSOR_ATTR_TEMP
6423 #undef THERMAL_ATTRS
6425 /* --------------------------------------------------------------------- */
6427 static int __init
thermal_init(struct ibm_init_struct
*iibm
)
6434 vdbg_printk(TPACPI_DBG_INIT
, "initializing thermal subdriver\n");
6436 acpi_tmp7
= acpi_evalf(ec_handle
, NULL
, "TMP7", "qv");
6438 if (thinkpad_id
.ec_model
) {
6440 * Direct EC access mode: sensors at registers
6441 * 0x78-0x7F, 0xC0-0xC7. Registers return 0x00 for
6442 * non-implemented, thermal sensors return 0x80 when
6447 for (i
= 0; i
< 8; i
++) {
6448 if (acpi_ec_read(TP_EC_THERMAL_TMP0
+ i
, &t
)) {
6454 if (acpi_ec_read(TP_EC_THERMAL_TMP8
+ i
, &t
)) {
6462 /* This is sheer paranoia, but we handle it anyway */
6464 pr_err("ThinkPad ACPI EC access misbehaving, falling back to ACPI TMPx access mode\n");
6465 thermal_read_mode
= TPACPI_THERMAL_ACPI_TMP07
;
6467 pr_err("ThinkPad ACPI EC access misbehaving, disabling thermal sensors access\n");
6468 thermal_read_mode
= TPACPI_THERMAL_NONE
;
6473 TPACPI_THERMAL_TPEC_16
: TPACPI_THERMAL_TPEC_8
;
6475 } else if (acpi_tmp7
) {
6476 if (tpacpi_is_ibm() &&
6477 acpi_evalf(ec_handle
, NULL
, "UPDT", "qv")) {
6478 /* 600e/x, 770e, 770x */
6479 thermal_read_mode
= TPACPI_THERMAL_ACPI_UPDT
;
6481 /* IBM/LENOVO DSDT EC.TMPx access, max 8 sensors */
6482 thermal_read_mode
= TPACPI_THERMAL_ACPI_TMP07
;
6485 /* temperatures not supported on 570, G4x, R30, R31, R32 */
6486 thermal_read_mode
= TPACPI_THERMAL_NONE
;
6489 vdbg_printk(TPACPI_DBG_INIT
, "thermal is %s, mode %d\n",
6490 str_supported(thermal_read_mode
!= TPACPI_THERMAL_NONE
),
6493 switch (thermal_read_mode
) {
6494 case TPACPI_THERMAL_TPEC_16
:
6495 res
= sysfs_create_group(&tpacpi_hwmon
->kobj
,
6496 &thermal_temp_input16_group
);
6500 case TPACPI_THERMAL_TPEC_8
:
6501 case TPACPI_THERMAL_ACPI_TMP07
:
6502 case TPACPI_THERMAL_ACPI_UPDT
:
6503 res
= sysfs_create_group(&tpacpi_hwmon
->kobj
,
6504 &thermal_temp_input8_group
);
6508 case TPACPI_THERMAL_NONE
:
6516 static void thermal_exit(void)
6518 switch (thermal_read_mode
) {
6519 case TPACPI_THERMAL_TPEC_16
:
6520 sysfs_remove_group(&tpacpi_hwmon
->kobj
,
6521 &thermal_temp_input16_group
);
6523 case TPACPI_THERMAL_TPEC_8
:
6524 case TPACPI_THERMAL_ACPI_TMP07
:
6525 case TPACPI_THERMAL_ACPI_UPDT
:
6526 sysfs_remove_group(&tpacpi_hwmon
->kobj
,
6527 &thermal_temp_input8_group
);
6529 case TPACPI_THERMAL_NONE
:
6535 static int thermal_read(struct seq_file
*m
)
6538 struct ibm_thermal_sensors_struct t
;
6540 n
= thermal_get_sensors(&t
);
6541 if (unlikely(n
< 0))
6544 seq_printf(m
, "temperatures:\t");
6547 for (i
= 0; i
< (n
- 1); i
++)
6548 seq_printf(m
, "%d ", t
.temp
[i
] / 1000);
6549 seq_printf(m
, "%d\n", t
.temp
[i
] / 1000);
6551 seq_printf(m
, "not supported\n");
6556 static struct ibm_struct thermal_driver_data
= {
6558 .read
= thermal_read
,
6559 .exit
= thermal_exit
,
6562 /*************************************************************************
6563 * Backlight/brightness subdriver
6566 #define TPACPI_BACKLIGHT_DEV_NAME "thinkpad_screen"
6569 * ThinkPads can read brightness from two places: EC HBRV (0x31), or
6570 * CMOS NVRAM byte 0x5E, bits 0-3.
6572 * EC HBRV (0x31) has the following layout
6573 * Bit 7: unknown function
6574 * Bit 6: unknown function
6575 * Bit 5: Z: honour scale changes, NZ: ignore scale changes
6576 * Bit 4: must be set to zero to avoid problems
6577 * Bit 3-0: backlight brightness level
6579 * brightness_get_raw returns status data in the HBRV layout
6581 * WARNING: The X61 has been verified to use HBRV for something else, so
6582 * this should be used _only_ on IBM ThinkPads, and maybe with some careful
6583 * testing on the very early *60 Lenovo models...
6587 TP_EC_BACKLIGHT
= 0x31,
6589 /* TP_EC_BACKLIGHT bitmasks */
6590 TP_EC_BACKLIGHT_LVLMSK
= 0x1F,
6591 TP_EC_BACKLIGHT_CMDMSK
= 0xE0,
6592 TP_EC_BACKLIGHT_MAPSW
= 0x20,
6595 enum tpacpi_brightness_access_mode
{
6596 TPACPI_BRGHT_MODE_AUTO
= 0, /* Not implemented yet */
6597 TPACPI_BRGHT_MODE_EC
, /* EC control */
6598 TPACPI_BRGHT_MODE_UCMS_STEP
, /* UCMS step-based control */
6599 TPACPI_BRGHT_MODE_ECNVRAM
, /* EC control w/ NVRAM store */
6600 TPACPI_BRGHT_MODE_MAX
6603 static struct backlight_device
*ibm_backlight_device
;
6605 static enum tpacpi_brightness_access_mode brightness_mode
=
6606 TPACPI_BRGHT_MODE_MAX
;
6608 static unsigned int brightness_enable
= 2; /* 2 = auto, 0 = no, 1 = yes */
6610 static struct mutex brightness_mutex
;
6612 /* NVRAM brightness access,
6613 * call with brightness_mutex held! */
6614 static unsigned int tpacpi_brightness_nvram_get(void)
6618 lnvram
= (nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS
)
6619 & TP_NVRAM_MASK_LEVEL_BRIGHTNESS
)
6620 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS
;
6621 lnvram
&= bright_maxlvl
;
6626 static void tpacpi_brightness_checkpoint_nvram(void)
6631 if (brightness_mode
!= TPACPI_BRGHT_MODE_ECNVRAM
)
6634 vdbg_printk(TPACPI_DBG_BRGHT
,
6635 "trying to checkpoint backlight level to NVRAM...\n");
6637 if (mutex_lock_killable(&brightness_mutex
) < 0)
6640 if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT
, &lec
)))
6642 lec
&= TP_EC_BACKLIGHT_LVLMSK
;
6643 b_nvram
= nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS
);
6645 if (lec
!= ((b_nvram
& TP_NVRAM_MASK_LEVEL_BRIGHTNESS
)
6646 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS
)) {
6647 /* NVRAM needs update */
6648 b_nvram
&= ~(TP_NVRAM_MASK_LEVEL_BRIGHTNESS
<<
6649 TP_NVRAM_POS_LEVEL_BRIGHTNESS
);
6651 nvram_write_byte(b_nvram
, TP_NVRAM_ADDR_BRIGHTNESS
);
6652 dbg_printk(TPACPI_DBG_BRGHT
,
6653 "updated NVRAM backlight level to %u (0x%02x)\n",
6654 (unsigned int) lec
, (unsigned int) b_nvram
);
6656 vdbg_printk(TPACPI_DBG_BRGHT
,
6657 "NVRAM backlight level already is %u (0x%02x)\n",
6658 (unsigned int) lec
, (unsigned int) b_nvram
);
6661 mutex_unlock(&brightness_mutex
);
6665 /* call with brightness_mutex held! */
6666 static int tpacpi_brightness_get_raw(int *status
)
6670 switch (brightness_mode
) {
6671 case TPACPI_BRGHT_MODE_UCMS_STEP
:
6672 *status
= tpacpi_brightness_nvram_get();
6674 case TPACPI_BRGHT_MODE_EC
:
6675 case TPACPI_BRGHT_MODE_ECNVRAM
:
6676 if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT
, &lec
)))
6685 /* call with brightness_mutex held! */
6686 /* do NOT call with illegal backlight level value */
6687 static int tpacpi_brightness_set_ec(unsigned int value
)
6691 if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT
, &lec
)))
6694 if (unlikely(!acpi_ec_write(TP_EC_BACKLIGHT
,
6695 (lec
& TP_EC_BACKLIGHT_CMDMSK
) |
6696 (value
& TP_EC_BACKLIGHT_LVLMSK
))))
6702 /* call with brightness_mutex held! */
6703 static int tpacpi_brightness_set_ucmsstep(unsigned int value
)
6706 unsigned int current_value
, i
;
6708 current_value
= tpacpi_brightness_nvram_get();
6710 if (value
== current_value
)
6713 cmos_cmd
= (value
> current_value
) ?
6714 TP_CMOS_BRIGHTNESS_UP
:
6715 TP_CMOS_BRIGHTNESS_DOWN
;
6716 inc
= (value
> current_value
) ? 1 : -1;
6718 for (i
= current_value
; i
!= value
; i
+= inc
)
6719 if (issue_thinkpad_cmos_command(cmos_cmd
))
6725 /* May return EINTR which can always be mapped to ERESTARTSYS */
6726 static int brightness_set(unsigned int value
)
6730 if (value
> bright_maxlvl
)
6733 vdbg_printk(TPACPI_DBG_BRGHT
,
6734 "set backlight level to %d\n", value
);
6736 res
= mutex_lock_killable(&brightness_mutex
);
6740 switch (brightness_mode
) {
6741 case TPACPI_BRGHT_MODE_EC
:
6742 case TPACPI_BRGHT_MODE_ECNVRAM
:
6743 res
= tpacpi_brightness_set_ec(value
);
6745 case TPACPI_BRGHT_MODE_UCMS_STEP
:
6746 res
= tpacpi_brightness_set_ucmsstep(value
);
6752 mutex_unlock(&brightness_mutex
);
6756 /* sysfs backlight class ----------------------------------------------- */
6758 static int brightness_update_status(struct backlight_device
*bd
)
6760 unsigned int level
=
6761 (bd
->props
.fb_blank
== FB_BLANK_UNBLANK
&&
6762 bd
->props
.power
== FB_BLANK_UNBLANK
) ?
6763 bd
->props
.brightness
: 0;
6765 dbg_printk(TPACPI_DBG_BRGHT
,
6766 "backlight: attempt to set level to %d\n",
6769 /* it is the backlight class's job (caller) to handle
6770 * EINTR and other errors properly */
6771 return brightness_set(level
);
6774 static int brightness_get(struct backlight_device
*bd
)
6778 res
= mutex_lock_killable(&brightness_mutex
);
6782 res
= tpacpi_brightness_get_raw(&status
);
6784 mutex_unlock(&brightness_mutex
);
6789 return status
& TP_EC_BACKLIGHT_LVLMSK
;
6792 static void tpacpi_brightness_notify_change(void)
6794 backlight_force_update(ibm_backlight_device
,
6795 BACKLIGHT_UPDATE_HOTKEY
);
6798 static const struct backlight_ops ibm_backlight_data
= {
6799 .get_brightness
= brightness_get
,
6800 .update_status
= brightness_update_status
,
6803 /* --------------------------------------------------------------------- */
6806 * Call _BCL method of video device. On some ThinkPads this will
6807 * switch the firmware to the ACPI brightness control mode.
6810 static int __init
tpacpi_query_bcl_levels(acpi_handle handle
)
6812 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
6813 union acpi_object
*obj
;
6814 struct acpi_device
*device
, *child
;
6817 if (acpi_bus_get_device(handle
, &device
))
6821 list_for_each_entry(child
, &device
->children
, node
) {
6822 acpi_status status
= acpi_evaluate_object(child
->handle
, "_BCL",
6824 if (ACPI_FAILURE(status
))
6827 obj
= (union acpi_object
*)buffer
.pointer
;
6828 if (!obj
|| (obj
->type
!= ACPI_TYPE_PACKAGE
)) {
6829 pr_err("Unknown _BCL data, please report this to %s\n",
6833 rc
= obj
->package
.count
;
6838 kfree(buffer
.pointer
);
6844 * Returns 0 (no ACPI _BCL or _BCL invalid), or size of brightness map
6846 static unsigned int __init
tpacpi_check_std_acpi_brightness_support(void)
6848 acpi_handle video_device
;
6851 tpacpi_acpi_handle_locate("video", NULL
, &video_device
);
6853 bcl_levels
= tpacpi_query_bcl_levels(video_device
);
6855 tp_features
.bright_acpimode
= (bcl_levels
> 0);
6857 return (bcl_levels
> 2) ? (bcl_levels
- 2) : 0;
6861 * These are only useful for models that have only one possibility
6862 * of GPU. If the BIOS model handles both ATI and Intel, don't use
6865 #define TPACPI_BRGHT_Q_NOEC 0x0001 /* Must NOT use EC HBRV */
6866 #define TPACPI_BRGHT_Q_EC 0x0002 /* Should or must use EC HBRV */
6867 #define TPACPI_BRGHT_Q_ASK 0x8000 /* Ask for user report */
6869 static const struct tpacpi_quirk brightness_quirk_table
[] __initconst
= {
6870 /* Models with ATI GPUs known to require ECNVRAM mode */
6871 TPACPI_Q_IBM('1', 'Y', TPACPI_BRGHT_Q_EC
), /* T43/p ATI */
6873 /* Models with ATI GPUs that can use ECNVRAM */
6874 TPACPI_Q_IBM('1', 'R', TPACPI_BRGHT_Q_EC
), /* R50,51 T40-42 */
6875 TPACPI_Q_IBM('1', 'Q', TPACPI_BRGHT_Q_ASK
|TPACPI_BRGHT_Q_EC
),
6876 TPACPI_Q_IBM('7', '6', TPACPI_BRGHT_Q_EC
), /* R52 */
6877 TPACPI_Q_IBM('7', '8', TPACPI_BRGHT_Q_ASK
|TPACPI_BRGHT_Q_EC
),
6879 /* Models with Intel Extreme Graphics 2 */
6880 TPACPI_Q_IBM('1', 'U', TPACPI_BRGHT_Q_NOEC
), /* X40 */
6881 TPACPI_Q_IBM('1', 'V', TPACPI_BRGHT_Q_ASK
|TPACPI_BRGHT_Q_EC
),
6882 TPACPI_Q_IBM('1', 'W', TPACPI_BRGHT_Q_ASK
|TPACPI_BRGHT_Q_EC
),
6884 /* Models with Intel GMA900 */
6885 TPACPI_Q_IBM('7', '0', TPACPI_BRGHT_Q_NOEC
), /* T43, R52 */
6886 TPACPI_Q_IBM('7', '4', TPACPI_BRGHT_Q_NOEC
), /* X41 */
6887 TPACPI_Q_IBM('7', '5', TPACPI_BRGHT_Q_NOEC
), /* X41 Tablet */
6891 * Returns < 0 for error, otherwise sets tp_features.bright_*
6892 * and bright_maxlvl.
6894 static void __init
tpacpi_detect_brightness_capabilities(void)
6898 vdbg_printk(TPACPI_DBG_INIT
,
6899 "detecting firmware brightness interface capabilities\n");
6901 /* we could run a quirks check here (same table used by
6902 * brightness_init) if needed */
6905 * We always attempt to detect acpi support, so as to switch
6906 * Lenovo Vista BIOS to ACPI brightness mode even if we are not
6907 * going to publish a backlight interface
6909 b
= tpacpi_check_std_acpi_brightness_support();
6919 tp_features
.bright_unkfw
= 1;
6920 bright_maxlvl
= b
- 1;
6922 pr_debug("detected %u brightness levels\n", bright_maxlvl
+ 1);
6925 static int __init
brightness_init(struct ibm_init_struct
*iibm
)
6927 struct backlight_properties props
;
6929 unsigned long quirks
;
6931 vdbg_printk(TPACPI_DBG_INIT
, "initializing brightness subdriver\n");
6933 mutex_init(&brightness_mutex
);
6935 quirks
= tpacpi_check_quirks(brightness_quirk_table
,
6936 ARRAY_SIZE(brightness_quirk_table
));
6938 /* tpacpi_detect_brightness_capabilities() must have run already */
6940 /* if it is unknown, we don't handle it: it wouldn't be safe */
6941 if (tp_features
.bright_unkfw
)
6944 if (!brightness_enable
) {
6945 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_BRGHT
,
6946 "brightness support disabled by module parameter\n");
6950 if (acpi_video_get_backlight_type() != acpi_backlight_vendor
) {
6951 if (brightness_enable
> 1) {
6952 pr_info("Standard ACPI backlight interface available, not loading native one\n");
6954 } else if (brightness_enable
== 1) {
6955 pr_warn("Cannot enable backlight brightness support, ACPI is already handling it. Refer to the acpi_backlight kernel parameter.\n");
6958 } else if (tp_features
.bright_acpimode
&& brightness_enable
> 1) {
6959 pr_notice("Standard ACPI backlight interface not available, thinkpad_acpi native brightness control enabled\n");
6963 * Check for module parameter bogosity, note that we
6964 * init brightness_mode to TPACPI_BRGHT_MODE_MAX in order to be
6965 * able to detect "unspecified"
6967 if (brightness_mode
> TPACPI_BRGHT_MODE_MAX
)
6970 /* TPACPI_BRGHT_MODE_AUTO not implemented yet, just use default */
6971 if (brightness_mode
== TPACPI_BRGHT_MODE_AUTO
||
6972 brightness_mode
== TPACPI_BRGHT_MODE_MAX
) {
6973 if (quirks
& TPACPI_BRGHT_Q_EC
)
6974 brightness_mode
= TPACPI_BRGHT_MODE_ECNVRAM
;
6976 brightness_mode
= TPACPI_BRGHT_MODE_UCMS_STEP
;
6978 dbg_printk(TPACPI_DBG_BRGHT
,
6979 "driver auto-selected brightness_mode=%d\n",
6984 if (!tpacpi_is_ibm() &&
6985 (brightness_mode
== TPACPI_BRGHT_MODE_ECNVRAM
||
6986 brightness_mode
== TPACPI_BRGHT_MODE_EC
))
6989 if (tpacpi_brightness_get_raw(&b
) < 0)
6992 memset(&props
, 0, sizeof(struct backlight_properties
));
6993 props
.type
= BACKLIGHT_PLATFORM
;
6994 props
.max_brightness
= bright_maxlvl
;
6995 props
.brightness
= b
& TP_EC_BACKLIGHT_LVLMSK
;
6996 ibm_backlight_device
= backlight_device_register(TPACPI_BACKLIGHT_DEV_NAME
,
6998 &ibm_backlight_data
,
7000 if (IS_ERR(ibm_backlight_device
)) {
7001 int rc
= PTR_ERR(ibm_backlight_device
);
7002 ibm_backlight_device
= NULL
;
7003 pr_err("Could not register backlight device\n");
7006 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_BRGHT
,
7007 "brightness is supported\n");
7009 if (quirks
& TPACPI_BRGHT_Q_ASK
) {
7010 pr_notice("brightness: will use unverified default: brightness_mode=%d\n",
7012 pr_notice("brightness: please report to %s whether it works well or not on your ThinkPad\n",
7016 /* Added by mistake in early 2007. Probably useless, but it could
7017 * be working around some unknown firmware problem where the value
7018 * read at startup doesn't match the real hardware state... so leave
7019 * it in place just in case */
7020 backlight_update_status(ibm_backlight_device
);
7022 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_BRGHT
,
7023 "brightness: registering brightness hotkeys as change notification\n");
7024 tpacpi_hotkey_driver_mask_set(hotkey_driver_mask
7025 | TP_ACPI_HKEY_BRGHTUP_MASK
7026 | TP_ACPI_HKEY_BRGHTDWN_MASK
);
7030 static void brightness_suspend(void)
7032 tpacpi_brightness_checkpoint_nvram();
7035 static void brightness_shutdown(void)
7037 tpacpi_brightness_checkpoint_nvram();
7040 static void brightness_exit(void)
7042 if (ibm_backlight_device
) {
7043 vdbg_printk(TPACPI_DBG_EXIT
| TPACPI_DBG_BRGHT
,
7044 "calling backlight_device_unregister()\n");
7045 backlight_device_unregister(ibm_backlight_device
);
7048 tpacpi_brightness_checkpoint_nvram();
7051 static int brightness_read(struct seq_file
*m
)
7055 level
= brightness_get(NULL
);
7057 seq_printf(m
, "level:\t\tunreadable\n");
7059 seq_printf(m
, "level:\t\t%d\n", level
);
7060 seq_printf(m
, "commands:\tup, down\n");
7061 seq_printf(m
, "commands:\tlevel <level> (<level> is 0-%d)\n",
7068 static int brightness_write(char *buf
)
7074 level
= brightness_get(NULL
);
7078 while ((cmd
= strsep(&buf
, ","))) {
7079 if (strlencmp(cmd
, "up") == 0) {
7080 if (level
< bright_maxlvl
)
7082 } else if (strlencmp(cmd
, "down") == 0) {
7085 } else if (sscanf(cmd
, "level %d", &level
) == 1 &&
7086 level
>= 0 && level
<= bright_maxlvl
) {
7092 tpacpi_disclose_usertask("procfs brightness",
7093 "set level to %d\n", level
);
7096 * Now we know what the final level should be, so we try to set it.
7097 * Doing it this way makes the syscall restartable in case of EINTR
7099 rc
= brightness_set(level
);
7100 if (!rc
&& ibm_backlight_device
)
7101 backlight_force_update(ibm_backlight_device
,
7102 BACKLIGHT_UPDATE_SYSFS
);
7103 return (rc
== -EINTR
) ? -ERESTARTSYS
: rc
;
7106 static struct ibm_struct brightness_driver_data
= {
7107 .name
= "brightness",
7108 .read
= brightness_read
,
7109 .write
= brightness_write
,
7110 .exit
= brightness_exit
,
7111 .suspend
= brightness_suspend
,
7112 .shutdown
= brightness_shutdown
,
7115 /*************************************************************************
7120 * IBM ThinkPads have a simple volume controller with MUTE gating.
7121 * Very early Lenovo ThinkPads follow the IBM ThinkPad spec.
7123 * Since the *61 series (and probably also the later *60 series), Lenovo
7124 * ThinkPads only implement the MUTE gate.
7127 * Bit 6: MUTE (1 mutes sound)
7129 * Other bits should be zero as far as we know.
7131 * This is also stored in CMOS NVRAM, byte 0x60, bit 6 (MUTE), and
7132 * bits 3-0 (volume). Other bits in NVRAM may have other functions,
7133 * such as bit 7 which is used to detect repeated presses of MUTE,
7134 * and we leave them unchanged.
7136 * On newer Lenovo ThinkPads, the EC can automatically change the volume
7137 * in response to user input. Unfortunately, this rarely works well.
7138 * The laptop changes the state of its internal MUTE gate and, on some
7139 * models, sends KEY_MUTE, causing any user code that responds to the
7140 * mute button to get confused. The hardware MUTE gate is also
7141 * unnecessary, since user code can handle the mute button without
7142 * kernel or EC help.
7144 * To avoid confusing userspace, we simply disable all EC-based mute
7145 * and volume controls when possible.
7148 #ifdef CONFIG_THINKPAD_ACPI_ALSA_SUPPORT
7150 #define TPACPI_ALSA_DRVNAME "ThinkPad EC"
7151 #define TPACPI_ALSA_SHRTNAME "ThinkPad Console Audio Control"
7152 #define TPACPI_ALSA_MIXERNAME TPACPI_ALSA_SHRTNAME
7154 #if SNDRV_CARDS <= 32
7155 #define DEFAULT_ALSA_IDX ~((1 << (SNDRV_CARDS - 3)) - 1)
7157 #define DEFAULT_ALSA_IDX ~((1 << (32 - 3)) - 1)
7159 static int alsa_index
= DEFAULT_ALSA_IDX
; /* last three slots */
7160 static char *alsa_id
= "ThinkPadEC";
7161 static bool alsa_enable
= SNDRV_DEFAULT_ENABLE1
;
7163 struct tpacpi_alsa_data
{
7164 struct snd_card
*card
;
7165 struct snd_ctl_elem_id
*ctl_mute_id
;
7166 struct snd_ctl_elem_id
*ctl_vol_id
;
7169 static struct snd_card
*alsa_card
;
7174 /* TP_EC_AUDIO bits */
7175 TP_EC_AUDIO_MUTESW
= 6,
7177 /* TP_EC_AUDIO bitmasks */
7178 TP_EC_AUDIO_LVL_MSK
= 0x0F,
7179 TP_EC_AUDIO_MUTESW_MSK
= (1 << TP_EC_AUDIO_MUTESW
),
7181 /* Maximum volume */
7182 TP_EC_VOLUME_MAX
= 14,
7185 enum tpacpi_volume_access_mode
{
7186 TPACPI_VOL_MODE_AUTO
= 0, /* Not implemented yet */
7187 TPACPI_VOL_MODE_EC
, /* Pure EC control */
7188 TPACPI_VOL_MODE_UCMS_STEP
, /* UCMS step-based control: N/A */
7189 TPACPI_VOL_MODE_ECNVRAM
, /* EC control w/ NVRAM store */
7193 enum tpacpi_volume_capabilities
{
7194 TPACPI_VOL_CAP_AUTO
= 0, /* Use white/blacklist */
7195 TPACPI_VOL_CAP_VOLMUTE
, /* Output vol and mute */
7196 TPACPI_VOL_CAP_MUTEONLY
, /* Output mute only */
7200 enum tpacpi_mute_btn_mode
{
7201 TP_EC_MUTE_BTN_LATCH
= 0, /* Mute mutes; up/down unmutes */
7202 /* We don't know what mode 1 is. */
7203 TP_EC_MUTE_BTN_NONE
= 2, /* Mute and up/down are just keys */
7204 TP_EC_MUTE_BTN_TOGGLE
= 3, /* Mute toggles; up/down unmutes */
7207 static enum tpacpi_volume_access_mode volume_mode
=
7208 TPACPI_VOL_MODE_MAX
;
7210 static enum tpacpi_volume_capabilities volume_capabilities
;
7211 static bool volume_control_allowed
;
7212 static bool software_mute_requested
= true;
7213 static bool software_mute_active
;
7214 static int software_mute_orig_mode
;
7217 * Used to syncronize writers to TP_EC_AUDIO and
7218 * TP_NVRAM_ADDR_MIXER, as we need to do read-modify-write
7220 static struct mutex volume_mutex
;
7222 static void tpacpi_volume_checkpoint_nvram(void)
7228 if (volume_mode
!= TPACPI_VOL_MODE_ECNVRAM
)
7230 if (!volume_control_allowed
)
7232 if (software_mute_active
)
7235 vdbg_printk(TPACPI_DBG_MIXER
,
7236 "trying to checkpoint mixer state to NVRAM...\n");
7238 if (tp_features
.mixer_no_level_control
)
7239 ec_mask
= TP_EC_AUDIO_MUTESW_MSK
;
7241 ec_mask
= TP_EC_AUDIO_MUTESW_MSK
| TP_EC_AUDIO_LVL_MSK
;
7243 if (mutex_lock_killable(&volume_mutex
) < 0)
7246 if (unlikely(!acpi_ec_read(TP_EC_AUDIO
, &lec
)))
7249 b_nvram
= nvram_read_byte(TP_NVRAM_ADDR_MIXER
);
7251 if (lec
!= (b_nvram
& ec_mask
)) {
7252 /* NVRAM needs update */
7253 b_nvram
&= ~ec_mask
;
7255 nvram_write_byte(b_nvram
, TP_NVRAM_ADDR_MIXER
);
7256 dbg_printk(TPACPI_DBG_MIXER
,
7257 "updated NVRAM mixer status to 0x%02x (0x%02x)\n",
7258 (unsigned int) lec
, (unsigned int) b_nvram
);
7260 vdbg_printk(TPACPI_DBG_MIXER
,
7261 "NVRAM mixer status already is 0x%02x (0x%02x)\n",
7262 (unsigned int) lec
, (unsigned int) b_nvram
);
7266 mutex_unlock(&volume_mutex
);
7269 static int volume_get_status_ec(u8
*status
)
7273 if (!acpi_ec_read(TP_EC_AUDIO
, &s
))
7278 dbg_printk(TPACPI_DBG_MIXER
, "status 0x%02x\n", s
);
7283 static int volume_get_status(u8
*status
)
7285 return volume_get_status_ec(status
);
7288 static int volume_set_status_ec(const u8 status
)
7290 if (!acpi_ec_write(TP_EC_AUDIO
, status
))
7293 dbg_printk(TPACPI_DBG_MIXER
, "set EC mixer to 0x%02x\n", status
);
7296 * On X200s, and possibly on others, it can take a while for
7297 * reads to become correct.
7304 static int volume_set_status(const u8 status
)
7306 return volume_set_status_ec(status
);
7309 /* returns < 0 on error, 0 on no change, 1 on change */
7310 static int __volume_set_mute_ec(const bool mute
)
7315 if (mutex_lock_killable(&volume_mutex
) < 0)
7318 rc
= volume_get_status_ec(&s
);
7322 n
= (mute
) ? s
| TP_EC_AUDIO_MUTESW_MSK
:
7323 s
& ~TP_EC_AUDIO_MUTESW_MSK
;
7326 rc
= volume_set_status_ec(n
);
7332 mutex_unlock(&volume_mutex
);
7336 static int volume_alsa_set_mute(const bool mute
)
7338 dbg_printk(TPACPI_DBG_MIXER
, "ALSA: trying to %smute\n",
7339 (mute
) ? "" : "un");
7340 return __volume_set_mute_ec(mute
);
7343 static int volume_set_mute(const bool mute
)
7347 dbg_printk(TPACPI_DBG_MIXER
, "trying to %smute\n",
7348 (mute
) ? "" : "un");
7350 rc
= __volume_set_mute_ec(mute
);
7351 return (rc
< 0) ? rc
: 0;
7354 /* returns < 0 on error, 0 on no change, 1 on change */
7355 static int __volume_set_volume_ec(const u8 vol
)
7360 if (vol
> TP_EC_VOLUME_MAX
)
7363 if (mutex_lock_killable(&volume_mutex
) < 0)
7366 rc
= volume_get_status_ec(&s
);
7370 n
= (s
& ~TP_EC_AUDIO_LVL_MSK
) | vol
;
7373 rc
= volume_set_status_ec(n
);
7379 mutex_unlock(&volume_mutex
);
7383 static int volume_set_software_mute(bool startup
)
7387 if (!tpacpi_is_lenovo())
7391 if (!acpi_evalf(ec_handle
, &software_mute_orig_mode
,
7395 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_MIXER
,
7396 "Initial HAUM setting was %d\n",
7397 software_mute_orig_mode
);
7400 if (!acpi_evalf(ec_handle
, &result
, "SAUM", "qdd",
7401 (int)TP_EC_MUTE_BTN_NONE
))
7404 if (result
!= TP_EC_MUTE_BTN_NONE
)
7405 pr_warn("Unexpected SAUM result %d\n",
7409 * In software mute mode, the standard codec controls take
7410 * precendence, so we unmute the ThinkPad HW switch at
7411 * startup. Just on case there are SAUM-capable ThinkPads
7412 * with level controls, set max HW volume as well.
7414 if (tp_features
.mixer_no_level_control
)
7415 result
= volume_set_mute(false);
7417 result
= volume_set_status(TP_EC_VOLUME_MAX
);
7420 pr_warn("Failed to unmute the HW mute switch\n");
7425 static void volume_exit_software_mute(void)
7429 if (!acpi_evalf(ec_handle
, &r
, "SAUM", "qdd", software_mute_orig_mode
)
7430 || r
!= software_mute_orig_mode
)
7431 pr_warn("Failed to restore mute mode\n");
7434 static int volume_alsa_set_volume(const u8 vol
)
7436 dbg_printk(TPACPI_DBG_MIXER
,
7437 "ALSA: trying to set volume level to %hu\n", vol
);
7438 return __volume_set_volume_ec(vol
);
7441 static void volume_alsa_notify_change(void)
7443 struct tpacpi_alsa_data
*d
;
7445 if (alsa_card
&& alsa_card
->private_data
) {
7446 d
= alsa_card
->private_data
;
7448 snd_ctl_notify(alsa_card
,
7449 SNDRV_CTL_EVENT_MASK_VALUE
,
7452 snd_ctl_notify(alsa_card
,
7453 SNDRV_CTL_EVENT_MASK_VALUE
,
7458 static int volume_alsa_vol_info(struct snd_kcontrol
*kcontrol
,
7459 struct snd_ctl_elem_info
*uinfo
)
7461 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
7463 uinfo
->value
.integer
.min
= 0;
7464 uinfo
->value
.integer
.max
= TP_EC_VOLUME_MAX
;
7468 static int volume_alsa_vol_get(struct snd_kcontrol
*kcontrol
,
7469 struct snd_ctl_elem_value
*ucontrol
)
7474 rc
= volume_get_status(&s
);
7478 ucontrol
->value
.integer
.value
[0] = s
& TP_EC_AUDIO_LVL_MSK
;
7482 static int volume_alsa_vol_put(struct snd_kcontrol
*kcontrol
,
7483 struct snd_ctl_elem_value
*ucontrol
)
7485 tpacpi_disclose_usertask("ALSA", "set volume to %ld\n",
7486 ucontrol
->value
.integer
.value
[0]);
7487 return volume_alsa_set_volume(ucontrol
->value
.integer
.value
[0]);
7490 #define volume_alsa_mute_info snd_ctl_boolean_mono_info
7492 static int volume_alsa_mute_get(struct snd_kcontrol
*kcontrol
,
7493 struct snd_ctl_elem_value
*ucontrol
)
7498 rc
= volume_get_status(&s
);
7502 ucontrol
->value
.integer
.value
[0] =
7503 (s
& TP_EC_AUDIO_MUTESW_MSK
) ? 0 : 1;
7507 static int volume_alsa_mute_put(struct snd_kcontrol
*kcontrol
,
7508 struct snd_ctl_elem_value
*ucontrol
)
7510 tpacpi_disclose_usertask("ALSA", "%smute\n",
7511 ucontrol
->value
.integer
.value
[0] ?
7513 return volume_alsa_set_mute(!ucontrol
->value
.integer
.value
[0]);
7516 static struct snd_kcontrol_new volume_alsa_control_vol __initdata
= {
7517 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
7518 .name
= "Console Playback Volume",
7520 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
7521 .info
= volume_alsa_vol_info
,
7522 .get
= volume_alsa_vol_get
,
7525 static struct snd_kcontrol_new volume_alsa_control_mute __initdata
= {
7526 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
7527 .name
= "Console Playback Switch",
7529 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
7530 .info
= volume_alsa_mute_info
,
7531 .get
= volume_alsa_mute_get
,
7534 static void volume_suspend(void)
7536 tpacpi_volume_checkpoint_nvram();
7539 static void volume_resume(void)
7541 if (software_mute_active
) {
7542 if (volume_set_software_mute(false) < 0)
7543 pr_warn("Failed to restore software mute\n");
7545 volume_alsa_notify_change();
7549 static void volume_shutdown(void)
7551 tpacpi_volume_checkpoint_nvram();
7554 static void volume_exit(void)
7557 snd_card_free(alsa_card
);
7561 tpacpi_volume_checkpoint_nvram();
7563 if (software_mute_active
)
7564 volume_exit_software_mute();
7567 static int __init
volume_create_alsa_mixer(void)
7569 struct snd_card
*card
;
7570 struct tpacpi_alsa_data
*data
;
7571 struct snd_kcontrol
*ctl_vol
;
7572 struct snd_kcontrol
*ctl_mute
;
7575 rc
= snd_card_new(&tpacpi_pdev
->dev
,
7576 alsa_index
, alsa_id
, THIS_MODULE
,
7577 sizeof(struct tpacpi_alsa_data
), &card
);
7578 if (rc
< 0 || !card
) {
7579 pr_err("Failed to create ALSA card structures: %d\n", rc
);
7583 BUG_ON(!card
->private_data
);
7584 data
= card
->private_data
;
7587 strlcpy(card
->driver
, TPACPI_ALSA_DRVNAME
,
7588 sizeof(card
->driver
));
7589 strlcpy(card
->shortname
, TPACPI_ALSA_SHRTNAME
,
7590 sizeof(card
->shortname
));
7591 snprintf(card
->mixername
, sizeof(card
->mixername
), "ThinkPad EC %s",
7592 (thinkpad_id
.ec_version_str
) ?
7593 thinkpad_id
.ec_version_str
: "(unknown)");
7594 snprintf(card
->longname
, sizeof(card
->longname
),
7595 "%s at EC reg 0x%02x, fw %s", card
->shortname
, TP_EC_AUDIO
,
7596 (thinkpad_id
.ec_version_str
) ?
7597 thinkpad_id
.ec_version_str
: "unknown");
7599 if (volume_control_allowed
) {
7600 volume_alsa_control_vol
.put
= volume_alsa_vol_put
;
7601 volume_alsa_control_vol
.access
=
7602 SNDRV_CTL_ELEM_ACCESS_READWRITE
;
7604 volume_alsa_control_mute
.put
= volume_alsa_mute_put
;
7605 volume_alsa_control_mute
.access
=
7606 SNDRV_CTL_ELEM_ACCESS_READWRITE
;
7609 if (!tp_features
.mixer_no_level_control
) {
7610 ctl_vol
= snd_ctl_new1(&volume_alsa_control_vol
, NULL
);
7611 rc
= snd_ctl_add(card
, ctl_vol
);
7613 pr_err("Failed to create ALSA volume control: %d\n",
7617 data
->ctl_vol_id
= &ctl_vol
->id
;
7620 ctl_mute
= snd_ctl_new1(&volume_alsa_control_mute
, NULL
);
7621 rc
= snd_ctl_add(card
, ctl_mute
);
7623 pr_err("Failed to create ALSA mute control: %d\n", rc
);
7626 data
->ctl_mute_id
= &ctl_mute
->id
;
7628 rc
= snd_card_register(card
);
7630 pr_err("Failed to register ALSA card: %d\n", rc
);
7638 snd_card_free(card
);
7642 #define TPACPI_VOL_Q_MUTEONLY 0x0001 /* Mute-only control available */
7643 #define TPACPI_VOL_Q_LEVEL 0x0002 /* Volume control available */
7645 static const struct tpacpi_quirk volume_quirk_table
[] __initconst
= {
7646 /* Whitelist volume level on all IBM by default */
7647 { .vendor
= PCI_VENDOR_ID_IBM
,
7648 .bios
= TPACPI_MATCH_ANY
,
7649 .ec
= TPACPI_MATCH_ANY
,
7650 .quirks
= TPACPI_VOL_Q_LEVEL
},
7652 /* Lenovo models with volume control (needs confirmation) */
7653 TPACPI_QEC_LNV('7', 'C', TPACPI_VOL_Q_LEVEL
), /* R60/i */
7654 TPACPI_QEC_LNV('7', 'E', TPACPI_VOL_Q_LEVEL
), /* R60e/i */
7655 TPACPI_QEC_LNV('7', '9', TPACPI_VOL_Q_LEVEL
), /* T60/p */
7656 TPACPI_QEC_LNV('7', 'B', TPACPI_VOL_Q_LEVEL
), /* X60/s */
7657 TPACPI_QEC_LNV('7', 'J', TPACPI_VOL_Q_LEVEL
), /* X60t */
7658 TPACPI_QEC_LNV('7', '7', TPACPI_VOL_Q_LEVEL
), /* Z60 */
7659 TPACPI_QEC_LNV('7', 'F', TPACPI_VOL_Q_LEVEL
), /* Z61 */
7661 /* Whitelist mute-only on all Lenovo by default */
7662 { .vendor
= PCI_VENDOR_ID_LENOVO
,
7663 .bios
= TPACPI_MATCH_ANY
,
7664 .ec
= TPACPI_MATCH_ANY
,
7665 .quirks
= TPACPI_VOL_Q_MUTEONLY
}
7668 static int __init
volume_init(struct ibm_init_struct
*iibm
)
7670 unsigned long quirks
;
7673 vdbg_printk(TPACPI_DBG_INIT
, "initializing volume subdriver\n");
7675 mutex_init(&volume_mutex
);
7678 * Check for module parameter bogosity, note that we
7679 * init volume_mode to TPACPI_VOL_MODE_MAX in order to be
7680 * able to detect "unspecified"
7682 if (volume_mode
> TPACPI_VOL_MODE_MAX
)
7685 if (volume_mode
== TPACPI_VOL_MODE_UCMS_STEP
) {
7686 pr_err("UCMS step volume mode not implemented, please contact %s\n",
7691 if (volume_capabilities
>= TPACPI_VOL_CAP_MAX
)
7695 * The ALSA mixer is our primary interface.
7696 * When disabled, don't install the subdriver at all
7699 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_MIXER
,
7700 "ALSA mixer disabled by parameter, not loading volume subdriver...\n");
7704 quirks
= tpacpi_check_quirks(volume_quirk_table
,
7705 ARRAY_SIZE(volume_quirk_table
));
7707 switch (volume_capabilities
) {
7708 case TPACPI_VOL_CAP_AUTO
:
7709 if (quirks
& TPACPI_VOL_Q_MUTEONLY
)
7710 tp_features
.mixer_no_level_control
= 1;
7711 else if (quirks
& TPACPI_VOL_Q_LEVEL
)
7712 tp_features
.mixer_no_level_control
= 0;
7714 return 1; /* no mixer */
7716 case TPACPI_VOL_CAP_VOLMUTE
:
7717 tp_features
.mixer_no_level_control
= 0;
7719 case TPACPI_VOL_CAP_MUTEONLY
:
7720 tp_features
.mixer_no_level_control
= 1;
7726 if (volume_capabilities
!= TPACPI_VOL_CAP_AUTO
)
7727 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_MIXER
,
7728 "using user-supplied volume_capabilities=%d\n",
7729 volume_capabilities
);
7731 if (volume_mode
== TPACPI_VOL_MODE_AUTO
||
7732 volume_mode
== TPACPI_VOL_MODE_MAX
) {
7733 volume_mode
= TPACPI_VOL_MODE_ECNVRAM
;
7735 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_MIXER
,
7736 "driver auto-selected volume_mode=%d\n",
7739 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_MIXER
,
7740 "using user-supplied volume_mode=%d\n",
7744 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_MIXER
,
7745 "mute is supported, volume control is %s\n",
7746 str_supported(!tp_features
.mixer_no_level_control
));
7748 if (software_mute_requested
&& volume_set_software_mute(true) == 0) {
7749 software_mute_active
= true;
7751 rc
= volume_create_alsa_mixer();
7753 pr_err("Could not create the ALSA mixer interface\n");
7757 pr_info("Console audio control enabled, mode: %s\n",
7758 (volume_control_allowed
) ?
7759 "override (read/write)" :
7760 "monitor (read only)");
7763 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_MIXER
,
7764 "registering volume hotkeys as change notification\n");
7765 tpacpi_hotkey_driver_mask_set(hotkey_driver_mask
7766 | TP_ACPI_HKEY_VOLUP_MASK
7767 | TP_ACPI_HKEY_VOLDWN_MASK
7768 | TP_ACPI_HKEY_MUTE_MASK
);
7773 static int volume_read(struct seq_file
*m
)
7777 if (volume_get_status(&status
) < 0) {
7778 seq_printf(m
, "level:\t\tunreadable\n");
7780 if (tp_features
.mixer_no_level_control
)
7781 seq_printf(m
, "level:\t\tunsupported\n");
7783 seq_printf(m
, "level:\t\t%d\n",
7784 status
& TP_EC_AUDIO_LVL_MSK
);
7786 seq_printf(m
, "mute:\t\t%s\n",
7787 onoff(status
, TP_EC_AUDIO_MUTESW
));
7789 if (volume_control_allowed
) {
7790 seq_printf(m
, "commands:\tunmute, mute\n");
7791 if (!tp_features
.mixer_no_level_control
) {
7792 seq_printf(m
, "commands:\tup, down\n");
7793 seq_printf(m
, "commands:\tlevel <level> (<level> is 0-%d)\n",
7802 static int volume_write(char *buf
)
7805 u8 new_level
, new_mute
;
7811 * We do allow volume control at driver startup, so that the
7812 * user can set initial state through the volume=... parameter hack.
7814 if (!volume_control_allowed
&& tpacpi_lifecycle
!= TPACPI_LIFE_INIT
) {
7815 if (unlikely(!tp_warned
.volume_ctrl_forbidden
)) {
7816 tp_warned
.volume_ctrl_forbidden
= 1;
7817 pr_notice("Console audio control in monitor mode, changes are not allowed\n");
7818 pr_notice("Use the volume_control=1 module parameter to enable volume control\n");
7823 rc
= volume_get_status(&s
);
7827 new_level
= s
& TP_EC_AUDIO_LVL_MSK
;
7828 new_mute
= s
& TP_EC_AUDIO_MUTESW_MSK
;
7830 while ((cmd
= strsep(&buf
, ","))) {
7831 if (!tp_features
.mixer_no_level_control
) {
7832 if (strlencmp(cmd
, "up") == 0) {
7835 else if (new_level
< TP_EC_VOLUME_MAX
)
7838 } else if (strlencmp(cmd
, "down") == 0) {
7841 else if (new_level
> 0)
7844 } else if (sscanf(cmd
, "level %u", &l
) == 1 &&
7845 l
>= 0 && l
<= TP_EC_VOLUME_MAX
) {
7850 if (strlencmp(cmd
, "mute") == 0)
7851 new_mute
= TP_EC_AUDIO_MUTESW_MSK
;
7852 else if (strlencmp(cmd
, "unmute") == 0)
7858 if (tp_features
.mixer_no_level_control
) {
7859 tpacpi_disclose_usertask("procfs volume", "%smute\n",
7860 new_mute
? "" : "un");
7861 rc
= volume_set_mute(!!new_mute
);
7863 tpacpi_disclose_usertask("procfs volume",
7864 "%smute and set level to %d\n",
7865 new_mute
? "" : "un", new_level
);
7866 rc
= volume_set_status(new_mute
| new_level
);
7868 volume_alsa_notify_change();
7870 return (rc
== -EINTR
) ? -ERESTARTSYS
: rc
;
7873 static struct ibm_struct volume_driver_data
= {
7875 .read
= volume_read
,
7876 .write
= volume_write
,
7877 .exit
= volume_exit
,
7878 .suspend
= volume_suspend
,
7879 .resume
= volume_resume
,
7880 .shutdown
= volume_shutdown
,
7883 #else /* !CONFIG_THINKPAD_ACPI_ALSA_SUPPORT */
7885 #define alsa_card NULL
7887 static inline void volume_alsa_notify_change(void)
7891 static int __init
volume_init(struct ibm_init_struct
*iibm
)
7893 pr_info("volume: disabled as there is no ALSA support in this kernel\n");
7898 static struct ibm_struct volume_driver_data
= {
7902 #endif /* CONFIG_THINKPAD_ACPI_ALSA_SUPPORT */
7904 /*************************************************************************
7911 * TPACPI_FAN_RD_ACPI_GFAN:
7912 * ACPI GFAN method: returns fan level
7914 * see TPACPI_FAN_WR_ACPI_SFAN
7915 * EC 0x2f (HFSP) not available if GFAN exists
7917 * TPACPI_FAN_WR_ACPI_SFAN:
7918 * ACPI SFAN method: sets fan level, 0 (stop) to 7 (max)
7920 * EC 0x2f (HFSP) might be available *for reading*, but do not use
7923 * TPACPI_FAN_WR_TPEC:
7924 * ThinkPad EC register 0x2f (HFSP): fan control loop mode
7925 * Supported on almost all ThinkPads
7927 * Fan speed changes of any sort (including those caused by the
7928 * disengaged mode) are usually done slowly by the firmware as the
7929 * maximum amount of fan duty cycle change per second seems to be
7932 * Reading is not available if GFAN exists.
7933 * Writing is not available if SFAN exists.
7936 * 7 automatic mode engaged;
7937 * (default operation mode of the ThinkPad)
7938 * fan level is ignored in this mode.
7939 * 6 full speed mode (takes precedence over bit 7);
7940 * not available on all thinkpads. May disable
7941 * the tachometer while the fan controller ramps up
7942 * the speed (which can take up to a few *minutes*).
7943 * Speeds up fan to 100% duty-cycle, which is far above
7944 * the standard RPM levels. It is not impossible that
7945 * it could cause hardware damage.
7946 * 5-3 unused in some models. Extra bits for fan level
7947 * in others, but still useless as all values above
7948 * 7 map to the same speed as level 7 in these models.
7949 * 2-0 fan level (0..7 usually)
7951 * 0x07 = max (set when temperatures critical)
7952 * Some ThinkPads may have other levels, see
7953 * TPACPI_FAN_WR_ACPI_FANS (X31/X40/X41)
7955 * FIRMWARE BUG: on some models, EC 0x2f might not be initialized at
7956 * boot. Apparently the EC does not initialize it, so unless ACPI DSDT
7957 * does so, its initial value is meaningless (0x07).
7959 * For firmware bugs, refer to:
7960 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
7964 * ThinkPad EC register 0x84 (LSB), 0x85 (MSB):
7965 * Main fan tachometer reading (in RPM)
7967 * This register is present on all ThinkPads with a new-style EC, and
7968 * it is known not to be present on the A21m/e, and T22, as there is
7969 * something else in offset 0x84 according to the ACPI DSDT. Other
7970 * ThinkPads from this same time period (and earlier) probably lack the
7971 * tachometer as well.
7973 * Unfortunately a lot of ThinkPads with new-style ECs but whose firmware
7974 * was never fixed by IBM to report the EC firmware version string
7975 * probably support the tachometer (like the early X models), so
7976 * detecting it is quite hard. We need more data to know for sure.
7978 * FIRMWARE BUG: always read 0x84 first, otherwise incorrect readings
7981 * FIRMWARE BUG: may go stale while the EC is switching to full speed
7984 * For firmware bugs, refer to:
7985 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
7989 * ThinkPad EC register 0x31 bit 0 (only on select models)
7991 * When bit 0 of EC register 0x31 is zero, the tachometer registers
7992 * show the speed of the main fan. When bit 0 of EC register 0x31
7993 * is one, the tachometer registers show the speed of the auxiliary
7996 * Fan control seems to affect both fans, regardless of the state
7999 * So far, only the firmware for the X60/X61 non-tablet versions
8000 * seem to support this (firmware TP-7M).
8002 * TPACPI_FAN_WR_ACPI_FANS:
8003 * ThinkPad X31, X40, X41. Not available in the X60.
8005 * FANS ACPI handle: takes three arguments: low speed, medium speed,
8006 * high speed. ACPI DSDT seems to map these three speeds to levels
8007 * as follows: STOP LOW LOW MED MED HIGH HIGH HIGH HIGH
8008 * (this map is stored on FAN0..FAN8 as "0,1,1,2,2,3,3,3,3")
8010 * The speeds are stored on handles
8011 * (FANA:FAN9), (FANC:FANB), (FANE:FAND).
8013 * There are three default speed sets, accessible as handles:
8014 * FS1L,FS1M,FS1H; FS2L,FS2M,FS2H; FS3L,FS3M,FS3H
8016 * ACPI DSDT switches which set is in use depending on various
8019 * TPACPI_FAN_WR_TPEC is also available and should be used to
8020 * command the fan. The X31/X40/X41 seems to have 8 fan levels,
8021 * but the ACPI tables just mention level 7.
8024 enum { /* Fan control constants */
8025 fan_status_offset
= 0x2f, /* EC register 0x2f */
8026 fan_rpm_offset
= 0x84, /* EC register 0x84: LSB, 0x85 MSB (RPM)
8027 * 0x84 must be read before 0x85 */
8028 fan_select_offset
= 0x31, /* EC register 0x31 (Firmware 7M)
8029 bit 0 selects which fan is active */
8031 TP_EC_FAN_FULLSPEED
= 0x40, /* EC fan mode: full speed */
8032 TP_EC_FAN_AUTO
= 0x80, /* EC fan mode: auto fan control */
8034 TPACPI_FAN_LAST_LEVEL
= 0x100, /* Use cached last-seen fan level */
8037 enum fan_status_access_mode
{
8038 TPACPI_FAN_NONE
= 0, /* No fan status or control */
8039 TPACPI_FAN_RD_ACPI_GFAN
, /* Use ACPI GFAN */
8040 TPACPI_FAN_RD_TPEC
, /* Use ACPI EC regs 0x2f, 0x84-0x85 */
8043 enum fan_control_access_mode
{
8044 TPACPI_FAN_WR_NONE
= 0, /* No fan control */
8045 TPACPI_FAN_WR_ACPI_SFAN
, /* Use ACPI SFAN */
8046 TPACPI_FAN_WR_TPEC
, /* Use ACPI EC reg 0x2f */
8047 TPACPI_FAN_WR_ACPI_FANS
, /* Use ACPI FANS and EC reg 0x2f */
8050 enum fan_control_commands
{
8051 TPACPI_FAN_CMD_SPEED
= 0x0001, /* speed command */
8052 TPACPI_FAN_CMD_LEVEL
= 0x0002, /* level command */
8053 TPACPI_FAN_CMD_ENABLE
= 0x0004, /* enable/disable cmd,
8054 * and also watchdog cmd */
8057 static bool fan_control_allowed
;
8059 static enum fan_status_access_mode fan_status_access_mode
;
8060 static enum fan_control_access_mode fan_control_access_mode
;
8061 static enum fan_control_commands fan_control_commands
;
8063 static u8 fan_control_initial_status
;
8064 static u8 fan_control_desired_level
;
8065 static u8 fan_control_resume_level
;
8066 static int fan_watchdog_maxinterval
;
8068 static struct mutex fan_mutex
;
8070 static void fan_watchdog_fire(struct work_struct
*ignored
);
8071 static DECLARE_DELAYED_WORK(fan_watchdog_task
, fan_watchdog_fire
);
8073 TPACPI_HANDLE(fans
, ec
, "FANS"); /* X31, X40, X41 */
8074 TPACPI_HANDLE(gfan
, ec
, "GFAN", /* 570 */
8075 "\\FSPD", /* 600e/x, 770e, 770x */
8077 TPACPI_HANDLE(sfan
, ec
, "SFAN", /* 570 */
8078 "JFNS", /* 770x-JL */
8082 * Unitialized HFSP quirk: ACPI DSDT and EC fail to initialize the
8083 * HFSP register at boot, so it contains 0x07 but the Thinkpad could
8084 * be in auto mode (0x80).
8086 * This is corrected by any write to HFSP either by the driver, or
8089 * We assume 0x07 really means auto mode while this quirk is active,
8090 * as this is far more likely than the ThinkPad being in level 7,
8091 * which is only used by the firmware during thermal emergencies.
8093 * Enable for TP-1Y (T43), TP-78 (R51e), TP-76 (R52),
8094 * TP-70 (T43, R52), which are known to be buggy.
8097 static void fan_quirk1_setup(void)
8099 if (fan_control_initial_status
== 0x07) {
8100 pr_notice("fan_init: initial fan status is unknown, assuming it is in auto mode\n");
8101 tp_features
.fan_ctrl_status_undef
= 1;
8105 static void fan_quirk1_handle(u8
*fan_status
)
8107 if (unlikely(tp_features
.fan_ctrl_status_undef
)) {
8108 if (*fan_status
!= fan_control_initial_status
) {
8109 /* something changed the HFSP regisnter since
8110 * driver init time, so it is not undefined
8112 tp_features
.fan_ctrl_status_undef
= 0;
8114 /* Return most likely status. In fact, it
8115 * might be the only possible status */
8116 *fan_status
= TP_EC_FAN_AUTO
;
8121 /* Select main fan on X60/X61, NOOP on others */
8122 static bool fan_select_fan1(void)
8124 if (tp_features
.second_fan
) {
8127 if (ec_read(fan_select_offset
, &val
) < 0)
8130 if (ec_write(fan_select_offset
, val
) < 0)
8136 /* Select secondary fan on X60/X61 */
8137 static bool fan_select_fan2(void)
8141 if (!tp_features
.second_fan
)
8144 if (ec_read(fan_select_offset
, &val
) < 0)
8147 if (ec_write(fan_select_offset
, val
) < 0)
8154 * Call with fan_mutex held
8156 static void fan_update_desired_level(u8 status
)
8159 (TP_EC_FAN_AUTO
| TP_EC_FAN_FULLSPEED
)) == 0) {
8161 fan_control_desired_level
= 7;
8163 fan_control_desired_level
= status
;
8167 static int fan_get_status(u8
*status
)
8172 * Add TPACPI_FAN_RD_ACPI_FANS ? */
8174 switch (fan_status_access_mode
) {
8175 case TPACPI_FAN_RD_ACPI_GFAN
: {
8176 /* 570, 600e/x, 770e, 770x */
8179 if (unlikely(!acpi_evalf(gfan_handle
, &res
, NULL
, "d")))
8183 *status
= res
& 0x07;
8187 case TPACPI_FAN_RD_TPEC
:
8188 /* all except 570, 600e/x, 770e, 770x */
8189 if (unlikely(!acpi_ec_read(fan_status_offset
, &s
)))
8192 if (likely(status
)) {
8194 fan_quirk1_handle(status
);
8206 static int fan_get_status_safe(u8
*status
)
8211 if (mutex_lock_killable(&fan_mutex
))
8212 return -ERESTARTSYS
;
8213 rc
= fan_get_status(&s
);
8215 fan_update_desired_level(s
);
8216 mutex_unlock(&fan_mutex
);
8226 static int fan_get_speed(unsigned int *speed
)
8230 switch (fan_status_access_mode
) {
8231 case TPACPI_FAN_RD_TPEC
:
8232 /* all except 570, 600e/x, 770e, 770x */
8233 if (unlikely(!fan_select_fan1()))
8235 if (unlikely(!acpi_ec_read(fan_rpm_offset
, &lo
) ||
8236 !acpi_ec_read(fan_rpm_offset
+ 1, &hi
)))
8240 *speed
= (hi
<< 8) | lo
;
8251 static int fan2_get_speed(unsigned int *speed
)
8256 switch (fan_status_access_mode
) {
8257 case TPACPI_FAN_RD_TPEC
:
8258 /* all except 570, 600e/x, 770e, 770x */
8259 if (unlikely(!fan_select_fan2()))
8261 rc
= !acpi_ec_read(fan_rpm_offset
, &lo
) ||
8262 !acpi_ec_read(fan_rpm_offset
+ 1, &hi
);
8263 fan_select_fan1(); /* play it safe */
8268 *speed
= (hi
<< 8) | lo
;
8279 static int fan_set_level(int level
)
8281 if (!fan_control_allowed
)
8284 switch (fan_control_access_mode
) {
8285 case TPACPI_FAN_WR_ACPI_SFAN
:
8286 if ((level
< 0) || (level
> 7))
8289 if (tp_features
.second_fan_ctl
) {
8290 if (!fan_select_fan2() ||
8291 !acpi_evalf(sfan_handle
, NULL
, NULL
, "vd", level
)) {
8292 pr_warn("Couldn't set 2nd fan level, disabling support\n");
8293 tp_features
.second_fan_ctl
= 0;
8297 if (!acpi_evalf(sfan_handle
, NULL
, NULL
, "vd", level
))
8301 case TPACPI_FAN_WR_ACPI_FANS
:
8302 case TPACPI_FAN_WR_TPEC
:
8303 if (!(level
& TP_EC_FAN_AUTO
) &&
8304 !(level
& TP_EC_FAN_FULLSPEED
) &&
8305 ((level
< 0) || (level
> 7)))
8308 /* safety net should the EC not support AUTO
8309 * or FULLSPEED mode bits and just ignore them */
8310 if (level
& TP_EC_FAN_FULLSPEED
)
8311 level
|= 7; /* safety min speed 7 */
8312 else if (level
& TP_EC_FAN_AUTO
)
8313 level
|= 4; /* safety min speed 4 */
8315 if (tp_features
.second_fan_ctl
) {
8316 if (!fan_select_fan2() ||
8317 !acpi_ec_write(fan_status_offset
, level
)) {
8318 pr_warn("Couldn't set 2nd fan level, disabling support\n");
8319 tp_features
.second_fan_ctl
= 0;
8324 if (!acpi_ec_write(fan_status_offset
, level
))
8327 tp_features
.fan_ctrl_status_undef
= 0;
8334 vdbg_printk(TPACPI_DBG_FAN
,
8335 "fan control: set fan control register to 0x%02x\n", level
);
8339 static int fan_set_level_safe(int level
)
8343 if (!fan_control_allowed
)
8346 if (mutex_lock_killable(&fan_mutex
))
8347 return -ERESTARTSYS
;
8349 if (level
== TPACPI_FAN_LAST_LEVEL
)
8350 level
= fan_control_desired_level
;
8352 rc
= fan_set_level(level
);
8354 fan_update_desired_level(level
);
8356 mutex_unlock(&fan_mutex
);
8360 static int fan_set_enable(void)
8365 if (!fan_control_allowed
)
8368 if (mutex_lock_killable(&fan_mutex
))
8369 return -ERESTARTSYS
;
8371 switch (fan_control_access_mode
) {
8372 case TPACPI_FAN_WR_ACPI_FANS
:
8373 case TPACPI_FAN_WR_TPEC
:
8374 rc
= fan_get_status(&s
);
8378 /* Don't go out of emergency fan mode */
8381 s
|= TP_EC_FAN_AUTO
| 4; /* min fan speed 4 */
8384 if (!acpi_ec_write(fan_status_offset
, s
))
8387 tp_features
.fan_ctrl_status_undef
= 0;
8392 case TPACPI_FAN_WR_ACPI_SFAN
:
8393 rc
= fan_get_status(&s
);
8399 /* Set fan to at least level 4 */
8402 if (!acpi_evalf(sfan_handle
, NULL
, NULL
, "vd", s
))
8412 mutex_unlock(&fan_mutex
);
8415 vdbg_printk(TPACPI_DBG_FAN
,
8416 "fan control: set fan control register to 0x%02x\n",
8421 static int fan_set_disable(void)
8425 if (!fan_control_allowed
)
8428 if (mutex_lock_killable(&fan_mutex
))
8429 return -ERESTARTSYS
;
8432 switch (fan_control_access_mode
) {
8433 case TPACPI_FAN_WR_ACPI_FANS
:
8434 case TPACPI_FAN_WR_TPEC
:
8435 if (!acpi_ec_write(fan_status_offset
, 0x00))
8438 fan_control_desired_level
= 0;
8439 tp_features
.fan_ctrl_status_undef
= 0;
8443 case TPACPI_FAN_WR_ACPI_SFAN
:
8444 if (!acpi_evalf(sfan_handle
, NULL
, NULL
, "vd", 0x00))
8447 fan_control_desired_level
= 0;
8455 vdbg_printk(TPACPI_DBG_FAN
,
8456 "fan control: set fan control register to 0\n");
8458 mutex_unlock(&fan_mutex
);
8462 static int fan_set_speed(int speed
)
8466 if (!fan_control_allowed
)
8469 if (mutex_lock_killable(&fan_mutex
))
8470 return -ERESTARTSYS
;
8473 switch (fan_control_access_mode
) {
8474 case TPACPI_FAN_WR_ACPI_FANS
:
8475 if (speed
>= 0 && speed
<= 65535) {
8476 if (!acpi_evalf(fans_handle
, NULL
, NULL
, "vddd",
8477 speed
, speed
, speed
))
8487 mutex_unlock(&fan_mutex
);
8491 static void fan_watchdog_reset(void)
8493 if (fan_control_access_mode
== TPACPI_FAN_WR_NONE
)
8496 if (fan_watchdog_maxinterval
> 0 &&
8497 tpacpi_lifecycle
!= TPACPI_LIFE_EXITING
)
8498 mod_delayed_work(tpacpi_wq
, &fan_watchdog_task
,
8499 msecs_to_jiffies(fan_watchdog_maxinterval
* 1000));
8501 cancel_delayed_work(&fan_watchdog_task
);
8504 static void fan_watchdog_fire(struct work_struct
*ignored
)
8508 if (tpacpi_lifecycle
!= TPACPI_LIFE_RUNNING
)
8511 pr_notice("fan watchdog: enabling fan\n");
8512 rc
= fan_set_enable();
8514 pr_err("fan watchdog: error %d while enabling fan, will try again later...\n",
8516 /* reschedule for later */
8517 fan_watchdog_reset();
8522 * SYSFS fan layout: hwmon compatible (device)
8525 * 0: "disengaged" mode
8527 * 2: native EC "auto" mode (recommended, hardware default)
8529 * pwm*: set speed in manual mode, ignored otherwise.
8530 * 0 is level 0; 255 is level 7. Intermediate points done with linear
8533 * fan*_input: tachometer reading, RPM
8536 * SYSFS fan layout: extensions
8538 * fan_watchdog (driver):
8539 * fan watchdog interval in seconds, 0 disables (default), max 120
8542 /* sysfs fan pwm1_enable ----------------------------------------------- */
8543 static ssize_t
fan_pwm1_enable_show(struct device
*dev
,
8544 struct device_attribute
*attr
,
8550 res
= fan_get_status_safe(&status
);
8554 if (status
& TP_EC_FAN_FULLSPEED
) {
8556 } else if (status
& TP_EC_FAN_AUTO
) {
8561 return snprintf(buf
, PAGE_SIZE
, "%d\n", mode
);
8564 static ssize_t
fan_pwm1_enable_store(struct device
*dev
,
8565 struct device_attribute
*attr
,
8566 const char *buf
, size_t count
)
8571 if (parse_strtoul(buf
, 2, &t
))
8574 tpacpi_disclose_usertask("hwmon pwm1_enable",
8575 "set fan mode to %lu\n", t
);
8579 level
= TP_EC_FAN_FULLSPEED
;
8582 level
= TPACPI_FAN_LAST_LEVEL
;
8585 level
= TP_EC_FAN_AUTO
;
8588 /* reserved for software-controlled auto mode */
8594 res
= fan_set_level_safe(level
);
8600 fan_watchdog_reset();
8605 static DEVICE_ATTR(pwm1_enable
, S_IWUSR
| S_IRUGO
,
8606 fan_pwm1_enable_show
, fan_pwm1_enable_store
);
8608 /* sysfs fan pwm1 ------------------------------------------------------ */
8609 static ssize_t
fan_pwm1_show(struct device
*dev
,
8610 struct device_attribute
*attr
,
8616 res
= fan_get_status_safe(&status
);
8621 (TP_EC_FAN_AUTO
| TP_EC_FAN_FULLSPEED
)) != 0)
8622 status
= fan_control_desired_level
;
8627 return snprintf(buf
, PAGE_SIZE
, "%u\n", (status
* 255) / 7);
8630 static ssize_t
fan_pwm1_store(struct device
*dev
,
8631 struct device_attribute
*attr
,
8632 const char *buf
, size_t count
)
8636 u8 status
, newlevel
;
8638 if (parse_strtoul(buf
, 255, &s
))
8641 tpacpi_disclose_usertask("hwmon pwm1",
8642 "set fan speed to %lu\n", s
);
8644 /* scale down from 0-255 to 0-7 */
8645 newlevel
= (s
>> 5) & 0x07;
8647 if (mutex_lock_killable(&fan_mutex
))
8648 return -ERESTARTSYS
;
8650 rc
= fan_get_status(&status
);
8651 if (!rc
&& (status
&
8652 (TP_EC_FAN_AUTO
| TP_EC_FAN_FULLSPEED
)) == 0) {
8653 rc
= fan_set_level(newlevel
);
8657 fan_update_desired_level(newlevel
);
8658 fan_watchdog_reset();
8662 mutex_unlock(&fan_mutex
);
8663 return (rc
) ? rc
: count
;
8666 static DEVICE_ATTR(pwm1
, S_IWUSR
| S_IRUGO
, fan_pwm1_show
, fan_pwm1_store
);
8668 /* sysfs fan fan1_input ------------------------------------------------ */
8669 static ssize_t
fan_fan1_input_show(struct device
*dev
,
8670 struct device_attribute
*attr
,
8676 res
= fan_get_speed(&speed
);
8680 return snprintf(buf
, PAGE_SIZE
, "%u\n", speed
);
8683 static DEVICE_ATTR(fan1_input
, S_IRUGO
, fan_fan1_input_show
, NULL
);
8685 /* sysfs fan fan2_input ------------------------------------------------ */
8686 static ssize_t
fan_fan2_input_show(struct device
*dev
,
8687 struct device_attribute
*attr
,
8693 res
= fan2_get_speed(&speed
);
8697 return snprintf(buf
, PAGE_SIZE
, "%u\n", speed
);
8700 static DEVICE_ATTR(fan2_input
, S_IRUGO
, fan_fan2_input_show
, NULL
);
8702 /* sysfs fan fan_watchdog (hwmon driver) ------------------------------- */
8703 static ssize_t
fan_watchdog_show(struct device_driver
*drv
, char *buf
)
8705 return snprintf(buf
, PAGE_SIZE
, "%u\n", fan_watchdog_maxinterval
);
8708 static ssize_t
fan_watchdog_store(struct device_driver
*drv
, const char *buf
,
8713 if (parse_strtoul(buf
, 120, &t
))
8716 if (!fan_control_allowed
)
8719 fan_watchdog_maxinterval
= t
;
8720 fan_watchdog_reset();
8722 tpacpi_disclose_usertask("fan_watchdog", "set to %lu\n", t
);
8726 static DRIVER_ATTR_RW(fan_watchdog
);
8728 /* --------------------------------------------------------------------- */
8729 static struct attribute
*fan_attributes
[] = {
8730 &dev_attr_pwm1_enable
.attr
, &dev_attr_pwm1
.attr
,
8731 &dev_attr_fan1_input
.attr
,
8732 NULL
, /* for fan2_input */
8736 static const struct attribute_group fan_attr_group
= {
8737 .attrs
= fan_attributes
,
8740 #define TPACPI_FAN_Q1 0x0001 /* Unitialized HFSP */
8741 #define TPACPI_FAN_2FAN 0x0002 /* EC 0x31 bit 0 selects fan2 */
8742 #define TPACPI_FAN_2CTL 0x0004 /* selects fan2 control */
8744 static const struct tpacpi_quirk fan_quirk_table
[] __initconst
= {
8745 TPACPI_QEC_IBM('1', 'Y', TPACPI_FAN_Q1
),
8746 TPACPI_QEC_IBM('7', '8', TPACPI_FAN_Q1
),
8747 TPACPI_QEC_IBM('7', '6', TPACPI_FAN_Q1
),
8748 TPACPI_QEC_IBM('7', '0', TPACPI_FAN_Q1
),
8749 TPACPI_QEC_LNV('7', 'M', TPACPI_FAN_2FAN
),
8750 TPACPI_Q_LNV('N', '1', TPACPI_FAN_2FAN
),
8751 TPACPI_Q_LNV3('N', '1', 'D', TPACPI_FAN_2CTL
), /* P70 */
8752 TPACPI_Q_LNV3('N', '1', 'E', TPACPI_FAN_2CTL
), /* P50 */
8753 TPACPI_Q_LNV3('N', '1', 'T', TPACPI_FAN_2CTL
), /* P71 */
8754 TPACPI_Q_LNV3('N', '1', 'U', TPACPI_FAN_2CTL
), /* P51 */
8755 TPACPI_Q_LNV3('N', '2', 'C', TPACPI_FAN_2CTL
), /* P52 / P72 */
8756 TPACPI_Q_LNV3('N', '2', 'E', TPACPI_FAN_2CTL
), /* P1 / X1 Extreme (1st gen) */
8757 TPACPI_Q_LNV3('N', '2', 'O', TPACPI_FAN_2CTL
), /* P1 / X1 Extreme (2nd gen) */
8760 static int __init
fan_init(struct ibm_init_struct
*iibm
)
8763 unsigned long quirks
;
8765 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_FAN
,
8766 "initializing fan subdriver\n");
8768 mutex_init(&fan_mutex
);
8769 fan_status_access_mode
= TPACPI_FAN_NONE
;
8770 fan_control_access_mode
= TPACPI_FAN_WR_NONE
;
8771 fan_control_commands
= 0;
8772 fan_watchdog_maxinterval
= 0;
8773 tp_features
.fan_ctrl_status_undef
= 0;
8774 tp_features
.second_fan
= 0;
8775 tp_features
.second_fan_ctl
= 0;
8776 fan_control_desired_level
= 7;
8778 if (tpacpi_is_ibm()) {
8779 TPACPI_ACPIHANDLE_INIT(fans
);
8780 TPACPI_ACPIHANDLE_INIT(gfan
);
8781 TPACPI_ACPIHANDLE_INIT(sfan
);
8784 quirks
= tpacpi_check_quirks(fan_quirk_table
,
8785 ARRAY_SIZE(fan_quirk_table
));
8788 /* 570, 600e/x, 770e, 770x */
8789 fan_status_access_mode
= TPACPI_FAN_RD_ACPI_GFAN
;
8791 /* all other ThinkPads: note that even old-style
8792 * ThinkPad ECs supports the fan control register */
8793 if (likely(acpi_ec_read(fan_status_offset
,
8794 &fan_control_initial_status
))) {
8795 fan_status_access_mode
= TPACPI_FAN_RD_TPEC
;
8796 if (quirks
& TPACPI_FAN_Q1
)
8798 if (quirks
& TPACPI_FAN_2FAN
) {
8799 tp_features
.second_fan
= 1;
8800 pr_info("secondary fan support enabled\n");
8802 if (quirks
& TPACPI_FAN_2CTL
) {
8803 tp_features
.second_fan
= 1;
8804 tp_features
.second_fan_ctl
= 1;
8805 pr_info("secondary fan control enabled\n");
8808 pr_err("ThinkPad ACPI EC access misbehaving, fan status and control unavailable\n");
8815 fan_control_access_mode
= TPACPI_FAN_WR_ACPI_SFAN
;
8816 fan_control_commands
|=
8817 TPACPI_FAN_CMD_LEVEL
| TPACPI_FAN_CMD_ENABLE
;
8820 /* gfan without sfan means no fan control */
8821 /* all other models implement TP EC 0x2f control */
8825 fan_control_access_mode
=
8826 TPACPI_FAN_WR_ACPI_FANS
;
8827 fan_control_commands
|=
8828 TPACPI_FAN_CMD_SPEED
|
8829 TPACPI_FAN_CMD_LEVEL
|
8830 TPACPI_FAN_CMD_ENABLE
;
8832 fan_control_access_mode
= TPACPI_FAN_WR_TPEC
;
8833 fan_control_commands
|=
8834 TPACPI_FAN_CMD_LEVEL
|
8835 TPACPI_FAN_CMD_ENABLE
;
8840 vdbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_FAN
,
8841 "fan is %s, modes %d, %d\n",
8842 str_supported(fan_status_access_mode
!= TPACPI_FAN_NONE
||
8843 fan_control_access_mode
!= TPACPI_FAN_WR_NONE
),
8844 fan_status_access_mode
, fan_control_access_mode
);
8846 /* fan control master switch */
8847 if (!fan_control_allowed
) {
8848 fan_control_access_mode
= TPACPI_FAN_WR_NONE
;
8849 fan_control_commands
= 0;
8850 dbg_printk(TPACPI_DBG_INIT
| TPACPI_DBG_FAN
,
8851 "fan control features disabled by parameter\n");
8854 /* update fan_control_desired_level */
8855 if (fan_status_access_mode
!= TPACPI_FAN_NONE
)
8856 fan_get_status_safe(NULL
);
8858 if (fan_status_access_mode
!= TPACPI_FAN_NONE
||
8859 fan_control_access_mode
!= TPACPI_FAN_WR_NONE
) {
8860 if (tp_features
.second_fan
) {
8861 /* attach second fan tachometer */
8862 fan_attributes
[ARRAY_SIZE(fan_attributes
)-2] =
8863 &dev_attr_fan2_input
.attr
;
8865 rc
= sysfs_create_group(&tpacpi_hwmon
->kobj
,
8870 rc
= driver_create_file(&tpacpi_hwmon_pdriver
.driver
,
8871 &driver_attr_fan_watchdog
);
8873 sysfs_remove_group(&tpacpi_hwmon
->kobj
,
8882 static void fan_exit(void)
8884 vdbg_printk(TPACPI_DBG_EXIT
| TPACPI_DBG_FAN
,
8885 "cancelling any pending fan watchdog tasks\n");
8887 /* FIXME: can we really do this unconditionally? */
8888 sysfs_remove_group(&tpacpi_hwmon
->kobj
, &fan_attr_group
);
8889 driver_remove_file(&tpacpi_hwmon_pdriver
.driver
,
8890 &driver_attr_fan_watchdog
);
8892 cancel_delayed_work(&fan_watchdog_task
);
8893 flush_workqueue(tpacpi_wq
);
8896 static void fan_suspend(void)
8900 if (!fan_control_allowed
)
8903 /* Store fan status in cache */
8904 fan_control_resume_level
= 0;
8905 rc
= fan_get_status_safe(&fan_control_resume_level
);
8907 pr_notice("failed to read fan level for later restore during resume: %d\n",
8910 /* if it is undefined, don't attempt to restore it.
8912 if (tp_features
.fan_ctrl_status_undef
)
8913 fan_control_resume_level
= 0;
8916 static void fan_resume(void)
8918 u8 current_level
= 7;
8919 bool do_set
= false;
8922 /* DSDT *always* updates status on resume */
8923 tp_features
.fan_ctrl_status_undef
= 0;
8925 if (!fan_control_allowed
||
8926 !fan_control_resume_level
||
8927 (fan_get_status_safe(¤t_level
) < 0))
8930 switch (fan_control_access_mode
) {
8931 case TPACPI_FAN_WR_ACPI_SFAN
:
8932 /* never decrease fan level */
8933 do_set
= (fan_control_resume_level
> current_level
);
8935 case TPACPI_FAN_WR_ACPI_FANS
:
8936 case TPACPI_FAN_WR_TPEC
:
8937 /* never decrease fan level, scale is:
8938 * TP_EC_FAN_FULLSPEED > 7 >= TP_EC_FAN_AUTO
8940 * We expect the firmware to set either 7 or AUTO, but we
8941 * handle FULLSPEED out of paranoia.
8943 * So, we can safely only restore FULLSPEED or 7, anything
8944 * else could slow the fan. Restoring AUTO is useless, at
8945 * best that's exactly what the DSDT already set (it is the
8948 * Always keep in mind that the DSDT *will* have set the
8949 * fans to what the vendor supposes is the best level. We
8950 * muck with it only to speed the fan up.
8952 if (fan_control_resume_level
!= 7 &&
8953 !(fan_control_resume_level
& TP_EC_FAN_FULLSPEED
))
8956 do_set
= !(current_level
& TP_EC_FAN_FULLSPEED
) &&
8957 (current_level
!= fan_control_resume_level
);
8963 pr_notice("restoring fan level to 0x%02x\n",
8964 fan_control_resume_level
);
8965 rc
= fan_set_level_safe(fan_control_resume_level
);
8967 pr_notice("failed to restore fan level: %d\n", rc
);
8971 static int fan_read(struct seq_file
*m
)
8975 unsigned int speed
= 0;
8977 switch (fan_status_access_mode
) {
8978 case TPACPI_FAN_RD_ACPI_GFAN
:
8979 /* 570, 600e/x, 770e, 770x */
8980 rc
= fan_get_status_safe(&status
);
8984 seq_printf(m
, "status:\t\t%s\n"
8986 (status
!= 0) ? "enabled" : "disabled", status
);
8989 case TPACPI_FAN_RD_TPEC
:
8990 /* all except 570, 600e/x, 770e, 770x */
8991 rc
= fan_get_status_safe(&status
);
8995 seq_printf(m
, "status:\t\t%s\n",
8996 (status
!= 0) ? "enabled" : "disabled");
8998 rc
= fan_get_speed(&speed
);
9002 seq_printf(m
, "speed:\t\t%d\n", speed
);
9004 if (status
& TP_EC_FAN_FULLSPEED
)
9005 /* Disengaged mode takes precedence */
9006 seq_printf(m
, "level:\t\tdisengaged\n");
9007 else if (status
& TP_EC_FAN_AUTO
)
9008 seq_printf(m
, "level:\t\tauto\n");
9010 seq_printf(m
, "level:\t\t%d\n", status
);
9013 case TPACPI_FAN_NONE
:
9015 seq_printf(m
, "status:\t\tnot supported\n");
9018 if (fan_control_commands
& TPACPI_FAN_CMD_LEVEL
) {
9019 seq_printf(m
, "commands:\tlevel <level>");
9021 switch (fan_control_access_mode
) {
9022 case TPACPI_FAN_WR_ACPI_SFAN
:
9023 seq_printf(m
, " (<level> is 0-7)\n");
9027 seq_printf(m
, " (<level> is 0-7, auto, disengaged, full-speed)\n");
9032 if (fan_control_commands
& TPACPI_FAN_CMD_ENABLE
)
9033 seq_printf(m
, "commands:\tenable, disable\n"
9034 "commands:\twatchdog <timeout> (<timeout> is 0 (off), 1-120 (seconds))\n");
9036 if (fan_control_commands
& TPACPI_FAN_CMD_SPEED
)
9037 seq_printf(m
, "commands:\tspeed <speed> (<speed> is 0-65535)\n");
9042 static int fan_write_cmd_level(const char *cmd
, int *rc
)
9046 if (strlencmp(cmd
, "level auto") == 0)
9047 level
= TP_EC_FAN_AUTO
;
9048 else if ((strlencmp(cmd
, "level disengaged") == 0) |
9049 (strlencmp(cmd
, "level full-speed") == 0))
9050 level
= TP_EC_FAN_FULLSPEED
;
9051 else if (sscanf(cmd
, "level %d", &level
) != 1)
9054 *rc
= fan_set_level_safe(level
);
9056 pr_err("level command accepted for unsupported access mode %d\n",
9057 fan_control_access_mode
);
9059 tpacpi_disclose_usertask("procfs fan",
9060 "set level to %d\n", level
);
9065 static int fan_write_cmd_enable(const char *cmd
, int *rc
)
9067 if (strlencmp(cmd
, "enable") != 0)
9070 *rc
= fan_set_enable();
9072 pr_err("enable command accepted for unsupported access mode %d\n",
9073 fan_control_access_mode
);
9075 tpacpi_disclose_usertask("procfs fan", "enable\n");
9080 static int fan_write_cmd_disable(const char *cmd
, int *rc
)
9082 if (strlencmp(cmd
, "disable") != 0)
9085 *rc
= fan_set_disable();
9087 pr_err("disable command accepted for unsupported access mode %d\n",
9088 fan_control_access_mode
);
9090 tpacpi_disclose_usertask("procfs fan", "disable\n");
9095 static int fan_write_cmd_speed(const char *cmd
, int *rc
)
9100 * Support speed <low> <medium> <high> ? */
9102 if (sscanf(cmd
, "speed %d", &speed
) != 1)
9105 *rc
= fan_set_speed(speed
);
9107 pr_err("speed command accepted for unsupported access mode %d\n",
9108 fan_control_access_mode
);
9110 tpacpi_disclose_usertask("procfs fan",
9111 "set speed to %d\n", speed
);
9116 static int fan_write_cmd_watchdog(const char *cmd
, int *rc
)
9120 if (sscanf(cmd
, "watchdog %d", &interval
) != 1)
9123 if (interval
< 0 || interval
> 120)
9126 fan_watchdog_maxinterval
= interval
;
9127 tpacpi_disclose_usertask("procfs fan",
9128 "set watchdog timer to %d\n",
9135 static int fan_write(char *buf
)
9140 while (!rc
&& (cmd
= strsep(&buf
, ","))) {
9141 if (!((fan_control_commands
& TPACPI_FAN_CMD_LEVEL
) &&
9142 fan_write_cmd_level(cmd
, &rc
)) &&
9143 !((fan_control_commands
& TPACPI_FAN_CMD_ENABLE
) &&
9144 (fan_write_cmd_enable(cmd
, &rc
) ||
9145 fan_write_cmd_disable(cmd
, &rc
) ||
9146 fan_write_cmd_watchdog(cmd
, &rc
))) &&
9147 !((fan_control_commands
& TPACPI_FAN_CMD_SPEED
) &&
9148 fan_write_cmd_speed(cmd
, &rc
))
9152 fan_watchdog_reset();
9158 static struct ibm_struct fan_driver_data
= {
9163 .suspend
= fan_suspend
,
9164 .resume
= fan_resume
,
9167 /*************************************************************************
9168 * Mute LED subdriver
9171 #define TPACPI_LED_MAX 2
9173 struct tp_led_table
{
9180 static struct tp_led_table led_tables
[TPACPI_LED_MAX
] = {
9181 [LED_AUDIO_MUTE
] = {
9186 [LED_AUDIO_MICMUTE
] = {
9193 static int mute_led_on_off(struct tp_led_table
*t
, bool state
)
9198 if (ACPI_FAILURE(acpi_get_handle(hkey_handle
, t
->name
, &temp
))) {
9199 pr_warn("Thinkpad ACPI has no %s interface.\n", t
->name
);
9203 if (!acpi_evalf(hkey_handle
, &output
, t
->name
, "dd",
9204 state
? t
->on_value
: t
->off_value
))
9211 static int tpacpi_led_set(int whichled
, bool on
)
9213 struct tp_led_table
*t
;
9215 t
= &led_tables
[whichled
];
9216 if (t
->state
< 0 || t
->state
== on
)
9218 return mute_led_on_off(t
, on
);
9221 static int tpacpi_led_mute_set(struct led_classdev
*led_cdev
,
9222 enum led_brightness brightness
)
9224 return tpacpi_led_set(LED_AUDIO_MUTE
, brightness
!= LED_OFF
);
9227 static int tpacpi_led_micmute_set(struct led_classdev
*led_cdev
,
9228 enum led_brightness brightness
)
9230 return tpacpi_led_set(LED_AUDIO_MICMUTE
, brightness
!= LED_OFF
);
9233 static struct led_classdev mute_led_cdev
[TPACPI_LED_MAX
] = {
9234 [LED_AUDIO_MUTE
] = {
9235 .name
= "platform::mute",
9236 .max_brightness
= 1,
9237 .brightness_set_blocking
= tpacpi_led_mute_set
,
9238 .default_trigger
= "audio-mute",
9240 [LED_AUDIO_MICMUTE
] = {
9241 .name
= "platform::micmute",
9242 .max_brightness
= 1,
9243 .brightness_set_blocking
= tpacpi_led_micmute_set
,
9244 .default_trigger
= "audio-micmute",
9248 static int mute_led_init(struct ibm_init_struct
*iibm
)
9253 for (i
= 0; i
< TPACPI_LED_MAX
; i
++) {
9254 struct tp_led_table
*t
= &led_tables
[i
];
9255 if (ACPI_FAILURE(acpi_get_handle(hkey_handle
, t
->name
, &temp
))) {
9260 mute_led_cdev
[i
].brightness
= ledtrig_audio_get(i
);
9261 err
= led_classdev_register(&tpacpi_pdev
->dev
, &mute_led_cdev
[i
]);
9264 led_classdev_unregister(&mute_led_cdev
[i
]);
9271 static void mute_led_exit(void)
9275 for (i
= 0; i
< TPACPI_LED_MAX
; i
++) {
9276 led_classdev_unregister(&mute_led_cdev
[i
]);
9277 tpacpi_led_set(i
, false);
9281 static void mute_led_resume(void)
9285 for (i
= 0; i
< TPACPI_LED_MAX
; i
++) {
9286 struct tp_led_table
*t
= &led_tables
[i
];
9288 mute_led_on_off(t
, t
->state
);
9292 static struct ibm_struct mute_led_driver_data
= {
9294 .exit
= mute_led_exit
,
9295 .resume
= mute_led_resume
,
9299 * Battery Wear Control Driver
9300 * Contact: Ognjen Galic <smclt30p@gmail.com>
9305 #define GET_START "BCTG"
9306 #define SET_START "BCCS"
9307 #define GET_STOP "BCSG"
9308 #define SET_STOP "BCSS"
9310 #define START_ATTR "charge_start_threshold"
9311 #define STOP_ATTR "charge_stop_threshold"
9320 /* Error condition bit */
9321 METHOD_ERR
= BIT(31),
9325 /* This is used in the get/set helpers */
9330 struct tpacpi_battery_data
{
9337 struct tpacpi_battery_driver_data
{
9338 struct tpacpi_battery_data batteries
[3];
9339 int individual_addressing
;
9342 static struct tpacpi_battery_driver_data battery_info
;
9344 /* ACPI helpers/functions/probes */
9347 * This evaluates a ACPI method call specific to the battery
9348 * ACPI extension. The specifics are that an error is marked
9349 * in the 32rd bit of the response, so we just check that here.
9351 static acpi_status
tpacpi_battery_acpi_eval(char *method
, int *ret
, int param
)
9355 if (!acpi_evalf(hkey_handle
, &response
, method
, "dd", param
)) {
9356 acpi_handle_err(hkey_handle
, "%s: evaluate failed", method
);
9359 if (response
& METHOD_ERR
) {
9360 acpi_handle_err(hkey_handle
,
9361 "%s evaluated but flagged as error", method
);
9368 static int tpacpi_battery_get(int what
, int battery
, int *ret
)
9371 case THRESHOLD_START
:
9372 if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_START
, ret
, battery
))
9375 /* The value is in the low 8 bits of the response */
9378 case THRESHOLD_STOP
:
9379 if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_STOP
, ret
, battery
))
9381 /* Value is in lower 8 bits */
9384 * On the stop value, if we return 0 that
9385 * does not make any sense. 0 means Default, which
9386 * means that charging stops at 100%, so we return
9393 pr_crit("wrong parameter: %d", what
);
9398 static int tpacpi_battery_set(int what
, int battery
, int value
)
9401 /* The first 8 bits are the value of the threshold */
9403 /* The battery ID is in bits 8-9, 2 bits */
9404 param
|= battery
<< 8;
9407 case THRESHOLD_START
:
9408 if ACPI_FAILURE(tpacpi_battery_acpi_eval(SET_START
, &ret
, param
)) {
9409 pr_err("failed to set charge threshold on battery %d",
9414 case THRESHOLD_STOP
:
9415 if ACPI_FAILURE(tpacpi_battery_acpi_eval(SET_STOP
, &ret
, param
)) {
9416 pr_err("failed to set stop threshold: %d", battery
);
9421 pr_crit("wrong parameter: %d", what
);
9426 static int tpacpi_battery_probe(int battery
)
9430 memset(&battery_info
.batteries
[battery
], 0,
9431 sizeof(battery_info
.batteries
[battery
]));
9434 * 1) Get the current start threshold
9435 * 2) Check for support
9436 * 3) Get the current stop threshold
9437 * 4) Check for support
9439 if (acpi_has_method(hkey_handle
, GET_START
)) {
9440 if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_START
, &ret
, battery
)) {
9441 pr_err("Error probing battery %d\n", battery
);
9444 /* Individual addressing is in bit 9 */
9446 battery_info
.individual_addressing
= true;
9447 /* Support is marked in bit 8 */
9449 battery_info
.batteries
[battery
].start_support
= 1;
9452 if (tpacpi_battery_get(THRESHOLD_START
, battery
,
9453 &battery_info
.batteries
[battery
].charge_start
)) {
9454 pr_err("Error probing battery %d\n", battery
);
9458 if (acpi_has_method(hkey_handle
, GET_STOP
)) {
9459 if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_STOP
, &ret
, battery
)) {
9460 pr_err("Error probing battery stop; %d\n", battery
);
9463 /* Support is marked in bit 8 */
9465 battery_info
.batteries
[battery
].stop_support
= 1;
9468 if (tpacpi_battery_get(THRESHOLD_STOP
, battery
,
9469 &battery_info
.batteries
[battery
].charge_stop
)) {
9470 pr_err("Error probing battery stop: %d\n", battery
);
9474 pr_info("battery %d registered (start %d, stop %d)",
9476 battery_info
.batteries
[battery
].charge_start
,
9477 battery_info
.batteries
[battery
].charge_stop
);
9482 /* General helper functions */
9484 static int tpacpi_battery_get_id(const char *battery_name
)
9487 if (strcmp(battery_name
, "BAT0") == 0 ||
9488 tp_features
.battery_force_primary
)
9490 if (strcmp(battery_name
, "BAT1") == 0)
9491 return BAT_SECONDARY
;
9493 * If for some reason the battery is not BAT0 nor is it
9494 * BAT1, we will assume it's the default, first battery,
9497 pr_warn("unknown battery %s, assuming primary", battery_name
);
9501 /* sysfs interface */
9503 static ssize_t
tpacpi_battery_store(int what
,
9505 const char *buf
, size_t count
)
9507 struct power_supply
*supply
= to_power_supply(dev
);
9508 unsigned long value
;
9511 * Some systems have support for more than
9512 * one battery. If that is the case,
9513 * tpacpi_battery_probe marked that addressing
9514 * them individually is supported, so we do that
9515 * based on the device struct.
9517 * On systems that are not supported, we assume
9518 * the primary as most of the ACPI calls fail
9519 * with "Any Battery" as the parameter.
9521 if (battery_info
.individual_addressing
)
9522 /* BAT_PRIMARY or BAT_SECONDARY */
9523 battery
= tpacpi_battery_get_id(supply
->desc
->name
);
9525 battery
= BAT_PRIMARY
;
9527 rval
= kstrtoul(buf
, 10, &value
);
9532 case THRESHOLD_START
:
9533 if (!battery_info
.batteries
[battery
].start_support
)
9535 /* valid values are [0, 99] */
9538 if (value
> battery_info
.batteries
[battery
].charge_stop
)
9540 if (tpacpi_battery_set(THRESHOLD_START
, battery
, value
))
9542 battery_info
.batteries
[battery
].charge_start
= value
;
9545 case THRESHOLD_STOP
:
9546 if (!battery_info
.batteries
[battery
].stop_support
)
9548 /* valid values are [1, 100] */
9549 if (value
< 1 || value
> 100)
9551 if (value
< battery_info
.batteries
[battery
].charge_start
)
9553 battery_info
.batteries
[battery
].charge_stop
= value
;
9555 * When 100 is passed to stop, we need to flip
9556 * it to 0 as that the EC understands that as
9557 * "Default", which will charge to 100%
9561 if (tpacpi_battery_set(THRESHOLD_STOP
, battery
, value
))
9565 pr_crit("Wrong parameter: %d", what
);
9571 static ssize_t
tpacpi_battery_show(int what
,
9575 struct power_supply
*supply
= to_power_supply(dev
);
9578 * Some systems have support for more than
9579 * one battery. If that is the case,
9580 * tpacpi_battery_probe marked that addressing
9581 * them individually is supported, so we;
9582 * based on the device struct.
9584 * On systems that are not supported, we assume
9585 * the primary as most of the ACPI calls fail
9586 * with "Any Battery" as the parameter.
9588 if (battery_info
.individual_addressing
)
9589 /* BAT_PRIMARY or BAT_SECONDARY */
9590 battery
= tpacpi_battery_get_id(supply
->desc
->name
);
9592 battery
= BAT_PRIMARY
;
9593 if (tpacpi_battery_get(what
, battery
, &ret
))
9595 return sprintf(buf
, "%d\n", ret
);
9598 static ssize_t
charge_start_threshold_show(struct device
*device
,
9599 struct device_attribute
*attr
,
9602 return tpacpi_battery_show(THRESHOLD_START
, device
, buf
);
9605 static ssize_t
charge_stop_threshold_show(struct device
*device
,
9606 struct device_attribute
*attr
,
9609 return tpacpi_battery_show(THRESHOLD_STOP
, device
, buf
);
9612 static ssize_t
charge_start_threshold_store(struct device
*dev
,
9613 struct device_attribute
*attr
,
9614 const char *buf
, size_t count
)
9616 return tpacpi_battery_store(THRESHOLD_START
, dev
, buf
, count
);
9619 static ssize_t
charge_stop_threshold_store(struct device
*dev
,
9620 struct device_attribute
*attr
,
9621 const char *buf
, size_t count
)
9623 return tpacpi_battery_store(THRESHOLD_STOP
, dev
, buf
, count
);
9626 static DEVICE_ATTR_RW(charge_start_threshold
);
9627 static DEVICE_ATTR_RW(charge_stop_threshold
);
9629 static struct attribute
*tpacpi_battery_attrs
[] = {
9630 &dev_attr_charge_start_threshold
.attr
,
9631 &dev_attr_charge_stop_threshold
.attr
,
9635 ATTRIBUTE_GROUPS(tpacpi_battery
);
9637 /* ACPI battery hooking */
9639 static int tpacpi_battery_add(struct power_supply
*battery
)
9641 int batteryid
= tpacpi_battery_get_id(battery
->desc
->name
);
9643 if (tpacpi_battery_probe(batteryid
))
9645 if (device_add_groups(&battery
->dev
, tpacpi_battery_groups
))
9650 static int tpacpi_battery_remove(struct power_supply
*battery
)
9652 device_remove_groups(&battery
->dev
, tpacpi_battery_groups
);
9656 static struct acpi_battery_hook battery_hook
= {
9657 .add_battery
= tpacpi_battery_add
,
9658 .remove_battery
= tpacpi_battery_remove
,
9659 .name
= "ThinkPad Battery Extension",
9662 /* Subdriver init/exit */
9664 static const struct tpacpi_quirk battery_quirk_table
[] __initconst
= {
9666 * Individual addressing is broken on models that expose the
9667 * primary battery as BAT1.
9669 TPACPI_Q_LNV('J', '7', true), /* B5400 */
9670 TPACPI_Q_LNV('J', 'I', true), /* Thinkpad 11e */
9671 TPACPI_Q_LNV3('R', '0', 'B', true), /* Thinkpad 11e gen 3 */
9672 TPACPI_Q_LNV3('R', '0', 'C', true), /* Thinkpad 13 */
9673 TPACPI_Q_LNV3('R', '0', 'J', true), /* Thinkpad 13 gen 2 */
9676 static int __init
tpacpi_battery_init(struct ibm_init_struct
*ibm
)
9678 memset(&battery_info
, 0, sizeof(battery_info
));
9680 tp_features
.battery_force_primary
= tpacpi_check_quirks(
9681 battery_quirk_table
,
9682 ARRAY_SIZE(battery_quirk_table
));
9684 battery_hook_register(&battery_hook
);
9688 static void tpacpi_battery_exit(void)
9690 battery_hook_unregister(&battery_hook
);
9693 static struct ibm_struct battery_driver_data
= {
9695 .exit
= tpacpi_battery_exit
,
9698 /*************************************************************************
9699 * LCD Shadow subdriver, for the Lenovo PrivacyGuard feature
9702 static int lcdshadow_state
;
9704 static int lcdshadow_on_off(bool state
)
9706 acpi_handle set_shadow_handle
;
9709 if (ACPI_FAILURE(acpi_get_handle(hkey_handle
, "SSSS", &set_shadow_handle
))) {
9710 pr_warn("Thinkpad ACPI has no %s interface.\n", "SSSS");
9714 if (!acpi_evalf(set_shadow_handle
, &output
, NULL
, "dd", (int)state
))
9717 lcdshadow_state
= state
;
9721 static int lcdshadow_set(bool on
)
9723 if (lcdshadow_state
< 0)
9724 return lcdshadow_state
;
9725 if (lcdshadow_state
== on
)
9727 return lcdshadow_on_off(on
);
9730 static int tpacpi_lcdshadow_init(struct ibm_init_struct
*iibm
)
9732 acpi_handle get_shadow_handle
;
9735 if (ACPI_FAILURE(acpi_get_handle(hkey_handle
, "GSSS", &get_shadow_handle
))) {
9736 lcdshadow_state
= -ENODEV
;
9740 if (!acpi_evalf(get_shadow_handle
, &output
, NULL
, "dd", 0)) {
9741 lcdshadow_state
= -EIO
;
9744 if (!(output
& 0x10000)) {
9745 lcdshadow_state
= -ENODEV
;
9748 lcdshadow_state
= output
& 0x1;
9753 static void lcdshadow_resume(void)
9755 if (lcdshadow_state
>= 0)
9756 lcdshadow_on_off(lcdshadow_state
);
9759 static int lcdshadow_read(struct seq_file
*m
)
9761 if (lcdshadow_state
< 0) {
9762 seq_puts(m
, "status:\t\tnot supported\n");
9764 seq_printf(m
, "status:\t\t%d\n", lcdshadow_state
);
9765 seq_puts(m
, "commands:\t0, 1\n");
9771 static int lcdshadow_write(char *buf
)
9774 int res
, state
= -EINVAL
;
9776 if (lcdshadow_state
< 0)
9779 while ((cmd
= strsep(&buf
, ","))) {
9780 res
= kstrtoint(cmd
, 10, &state
);
9785 if (state
>= 2 || state
< 0)
9788 return lcdshadow_set(state
);
9791 static struct ibm_struct lcdshadow_driver_data
= {
9792 .name
= "lcdshadow",
9793 .resume
= lcdshadow_resume
,
9794 .read
= lcdshadow_read
,
9795 .write
= lcdshadow_write
,
9798 /****************************************************************************
9799 ****************************************************************************
9803 ****************************************************************************
9804 ****************************************************************************/
9807 * HKEY event callout for other subdrivers go here
9808 * (yes, it is ugly, but it is quick, safe, and gets the job done
9810 static void tpacpi_driver_event(const unsigned int hkey_event
)
9812 if (ibm_backlight_device
) {
9813 switch (hkey_event
) {
9814 case TP_HKEY_EV_BRGHT_UP
:
9815 case TP_HKEY_EV_BRGHT_DOWN
:
9816 tpacpi_brightness_notify_change();
9820 switch (hkey_event
) {
9821 case TP_HKEY_EV_VOL_UP
:
9822 case TP_HKEY_EV_VOL_DOWN
:
9823 case TP_HKEY_EV_VOL_MUTE
:
9824 volume_alsa_notify_change();
9827 if (tp_features
.kbdlight
&& hkey_event
== TP_HKEY_EV_KBD_LIGHT
) {
9828 enum led_brightness brightness
;
9830 mutex_lock(&kbdlight_mutex
);
9833 * Check the brightness actually changed, setting the brightness
9834 * through kbdlight_set_level() also triggers this event.
9836 brightness
= kbdlight_sysfs_get(NULL
);
9837 if (kbdlight_brightness
!= brightness
) {
9838 kbdlight_brightness
= brightness
;
9839 led_classdev_notify_brightness_hw_changed(
9840 &tpacpi_led_kbdlight
.led_classdev
, brightness
);
9843 mutex_unlock(&kbdlight_mutex
);
9847 static void hotkey_driver_event(const unsigned int scancode
)
9849 tpacpi_driver_event(TP_HKEY_EV_HOTKEY_BASE
+ scancode
);
9852 /* --------------------------------------------------------------------- */
9855 static struct proc_dir_entry
*proc_dir
;
9858 * Module and infrastructure proble, init and exit handling
9861 static bool force_load
;
9863 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
9864 static const char * __init
str_supported(int is_supported
)
9866 static char text_unsupported
[] __initdata
= "not supported";
9868 return (is_supported
) ? &text_unsupported
[4] : &text_unsupported
[0];
9870 #endif /* CONFIG_THINKPAD_ACPI_DEBUG */
9872 static void ibm_exit(struct ibm_struct
*ibm
)
9874 dbg_printk(TPACPI_DBG_EXIT
, "removing %s\n", ibm
->name
);
9876 list_del_init(&ibm
->all_drivers
);
9878 if (ibm
->flags
.acpi_notify_installed
) {
9879 dbg_printk(TPACPI_DBG_EXIT
,
9880 "%s: acpi_remove_notify_handler\n", ibm
->name
);
9882 acpi_remove_notify_handler(*ibm
->acpi
->handle
,
9884 dispatch_acpi_notify
);
9885 ibm
->flags
.acpi_notify_installed
= 0;
9888 if (ibm
->flags
.proc_created
) {
9889 dbg_printk(TPACPI_DBG_EXIT
,
9890 "%s: remove_proc_entry\n", ibm
->name
);
9891 remove_proc_entry(ibm
->name
, proc_dir
);
9892 ibm
->flags
.proc_created
= 0;
9895 if (ibm
->flags
.acpi_driver_registered
) {
9896 dbg_printk(TPACPI_DBG_EXIT
,
9897 "%s: acpi_bus_unregister_driver\n", ibm
->name
);
9899 acpi_bus_unregister_driver(ibm
->acpi
->driver
);
9900 kfree(ibm
->acpi
->driver
);
9901 ibm
->acpi
->driver
= NULL
;
9902 ibm
->flags
.acpi_driver_registered
= 0;
9905 if (ibm
->flags
.init_called
&& ibm
->exit
) {
9907 ibm
->flags
.init_called
= 0;
9910 dbg_printk(TPACPI_DBG_INIT
, "finished removing %s\n", ibm
->name
);
9913 static int __init
ibm_init(struct ibm_init_struct
*iibm
)
9916 struct ibm_struct
*ibm
= iibm
->data
;
9917 struct proc_dir_entry
*entry
;
9919 BUG_ON(ibm
== NULL
);
9921 INIT_LIST_HEAD(&ibm
->all_drivers
);
9923 if (ibm
->flags
.experimental
&& !experimental
)
9926 dbg_printk(TPACPI_DBG_INIT
,
9927 "probing for %s\n", ibm
->name
);
9930 ret
= iibm
->init(iibm
);
9932 return 0; /* probe failed */
9936 ibm
->flags
.init_called
= 1;
9940 if (ibm
->acpi
->hid
) {
9941 ret
= register_tpacpi_subdriver(ibm
);
9946 if (ibm
->acpi
->notify
) {
9947 ret
= setup_acpi_notify(ibm
);
9948 if (ret
== -ENODEV
) {
9949 pr_notice("disabling subdriver %s\n",
9959 dbg_printk(TPACPI_DBG_INIT
,
9960 "%s installed\n", ibm
->name
);
9963 umode_t mode
= iibm
->base_procfs_mode
;
9969 entry
= proc_create_data(ibm
->name
, mode
, proc_dir
,
9970 &dispatch_proc_ops
, ibm
);
9972 pr_err("unable to create proc entry %s\n", ibm
->name
);
9976 ibm
->flags
.proc_created
= 1;
9979 list_add_tail(&ibm
->all_drivers
, &tpacpi_all_drivers
);
9984 dbg_printk(TPACPI_DBG_INIT
,
9985 "%s: at error exit path with result %d\n",
9989 return (ret
< 0) ? ret
: 0;
9994 static char __init
tpacpi_parse_fw_id(const char * const s
,
9995 u32
*model
, u16
*release
)
9999 if (!s
|| strlen(s
) < 8)
10002 for (i
= 0; i
< 8; i
++)
10003 if (!((s
[i
] >= '0' && s
[i
] <= '9') ||
10004 (s
[i
] >= 'A' && s
[i
] <= 'Z')))
10008 * Most models: xxyTkkWW (#.##c)
10009 * Ancient 570/600 and -SL lacks (#.##c)
10011 if (s
[3] == 'T' || s
[3] == 'N') {
10012 *model
= TPID(s
[0], s
[1]);
10013 *release
= TPVER(s
[4], s
[5]);
10016 /* New models: xxxyTkkW (#.##c); T550 and some others */
10017 } else if (s
[4] == 'T' || s
[4] == 'N') {
10018 *model
= TPID3(s
[0], s
[1], s
[2]);
10019 *release
= TPVER(s
[5], s
[6]);
10027 static void find_new_ec_fwstr(const struct dmi_header
*dm
, void *private)
10029 char *ec_fw_string
= (char *) private;
10030 const char *dmi_data
= (const char *)dm
;
10032 * ThinkPad Embedded Controller Program Table on newer models
10034 * Offset | Name | Width | Description
10035 * ----------------------------------------------------
10036 * 0x00 | Type | BYTE | 0x8C
10037 * 0x01 | Length | BYTE |
10038 * 0x02 | Handle | WORD | Varies
10039 * 0x04 | Signature | BYTEx6 | ASCII for "LENOVO"
10040 * 0x0A | OEM struct offset | BYTE | 0x0B
10041 * 0x0B | OEM struct number | BYTE | 0x07, for this structure
10042 * 0x0C | OEM struct revision | BYTE | 0x01, for this format
10043 * 0x0D | ECP version ID | STR ID |
10044 * 0x0E | ECP release date | STR ID |
10047 /* Return if data structure not match */
10048 if (dm
->type
!= 140 || dm
->length
< 0x0F ||
10049 memcmp(dmi_data
+ 4, "LENOVO", 6) != 0 ||
10050 dmi_data
[0x0A] != 0x0B || dmi_data
[0x0B] != 0x07 ||
10051 dmi_data
[0x0C] != 0x01)
10054 /* fwstr is the first 8byte string */
10055 strncpy(ec_fw_string
, dmi_data
+ 0x0F, 8);
10058 /* returns 0 - probe ok, or < 0 - probe error.
10059 * Probe ok doesn't mean thinkpad found.
10060 * On error, kfree() cleanup on tp->* is not performed, caller must do it */
10061 static int __must_check __init
get_thinkpad_model_data(
10062 struct thinkpad_id_data
*tp
)
10064 const struct dmi_device
*dev
= NULL
;
10065 char ec_fw_string
[18] = {0};
10072 memset(tp
, 0, sizeof(*tp
));
10074 if (dmi_name_in_vendors("IBM"))
10075 tp
->vendor
= PCI_VENDOR_ID_IBM
;
10076 else if (dmi_name_in_vendors("LENOVO"))
10077 tp
->vendor
= PCI_VENDOR_ID_LENOVO
;
10081 s
= dmi_get_system_info(DMI_BIOS_VERSION
);
10082 tp
->bios_version_str
= kstrdup(s
, GFP_KERNEL
);
10083 if (s
&& !tp
->bios_version_str
)
10086 /* Really ancient ThinkPad 240X will fail this, which is fine */
10087 t
= tpacpi_parse_fw_id(tp
->bios_version_str
,
10088 &tp
->bios_model
, &tp
->bios_release
);
10089 if (t
!= 'E' && t
!= 'C')
10093 * ThinkPad T23 or newer, A31 or newer, R50e or newer,
10094 * X32 or newer, all Z series; Some models must have an
10095 * up-to-date BIOS or they will not be detected.
10097 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
10099 while ((dev
= dmi_find_device(DMI_DEV_TYPE_OEM_STRING
, NULL
, dev
))) {
10100 if (sscanf(dev
->name
,
10101 "IBM ThinkPad Embedded Controller -[%17c",
10102 ec_fw_string
) == 1) {
10103 ec_fw_string
[sizeof(ec_fw_string
) - 1] = 0;
10104 ec_fw_string
[strcspn(ec_fw_string
, " ]")] = 0;
10109 /* Newer ThinkPads have different EC program info table */
10110 if (!ec_fw_string
[0])
10111 dmi_walk(find_new_ec_fwstr
, &ec_fw_string
);
10113 if (ec_fw_string
[0]) {
10114 tp
->ec_version_str
= kstrdup(ec_fw_string
, GFP_KERNEL
);
10115 if (!tp
->ec_version_str
)
10118 t
= tpacpi_parse_fw_id(ec_fw_string
,
10119 &tp
->ec_model
, &tp
->ec_release
);
10121 pr_notice("ThinkPad firmware release %s doesn't match the known patterns\n",
10123 pr_notice("please report this to %s\n", TPACPI_MAIL
);
10127 s
= dmi_get_system_info(DMI_PRODUCT_VERSION
);
10128 if (s
&& !(strncasecmp(s
, "ThinkPad", 8) && strncasecmp(s
, "Lenovo", 6))) {
10129 tp
->model_str
= kstrdup(s
, GFP_KERNEL
);
10130 if (!tp
->model_str
)
10133 s
= dmi_get_system_info(DMI_BIOS_VENDOR
);
10134 if (s
&& !(strncasecmp(s
, "Lenovo", 6))) {
10135 tp
->model_str
= kstrdup(s
, GFP_KERNEL
);
10136 if (!tp
->model_str
)
10141 s
= dmi_get_system_info(DMI_PRODUCT_NAME
);
10142 tp
->nummodel_str
= kstrdup(s
, GFP_KERNEL
);
10143 if (s
&& !tp
->nummodel_str
)
10149 static int __init
probe_for_thinkpad(void)
10156 /* It would be dangerous to run the driver in this case */
10157 if (!tpacpi_is_ibm() && !tpacpi_is_lenovo())
10161 * Non-ancient models have better DMI tagging, but very old models
10162 * don't. tpacpi_is_fw_known() is a cheat to help in that case.
10164 is_thinkpad
= (thinkpad_id
.model_str
!= NULL
) ||
10165 (thinkpad_id
.ec_model
!= 0) ||
10166 tpacpi_is_fw_known();
10168 /* The EC handler is required */
10169 tpacpi_acpi_handle_locate("ec", TPACPI_ACPI_EC_HID
, &ec_handle
);
10172 pr_err("Not yet supported ThinkPad detected!\n");
10176 if (!is_thinkpad
&& !force_load
)
10182 static void __init
thinkpad_acpi_init_banner(void)
10184 pr_info("%s v%s\n", TPACPI_DESC
, TPACPI_VERSION
);
10185 pr_info("%s\n", TPACPI_URL
);
10187 pr_info("ThinkPad BIOS %s, EC %s\n",
10188 (thinkpad_id
.bios_version_str
) ?
10189 thinkpad_id
.bios_version_str
: "unknown",
10190 (thinkpad_id
.ec_version_str
) ?
10191 thinkpad_id
.ec_version_str
: "unknown");
10193 BUG_ON(!thinkpad_id
.vendor
);
10195 if (thinkpad_id
.model_str
)
10196 pr_info("%s %s, model %s\n",
10197 (thinkpad_id
.vendor
== PCI_VENDOR_ID_IBM
) ?
10198 "IBM" : ((thinkpad_id
.vendor
==
10199 PCI_VENDOR_ID_LENOVO
) ?
10200 "Lenovo" : "Unknown vendor"),
10201 thinkpad_id
.model_str
,
10202 (thinkpad_id
.nummodel_str
) ?
10203 thinkpad_id
.nummodel_str
: "unknown");
10206 /* Module init, exit, parameters */
10208 static struct ibm_init_struct ibms_init
[] __initdata
= {
10210 .data
= &thinkpad_acpi_driver_data
,
10213 .init
= hotkey_init
,
10214 .data
= &hotkey_driver_data
,
10217 .init
= bluetooth_init
,
10218 .data
= &bluetooth_driver_data
,
10222 .data
= &wan_driver_data
,
10226 .data
= &uwb_driver_data
,
10228 #ifdef CONFIG_THINKPAD_ACPI_VIDEO
10230 .init
= video_init
,
10231 .base_procfs_mode
= S_IRUSR
,
10232 .data
= &video_driver_data
,
10236 .init
= kbdlight_init
,
10237 .data
= &kbdlight_driver_data
,
10240 .init
= light_init
,
10241 .data
= &light_driver_data
,
10245 .data
= &cmos_driver_data
,
10249 .data
= &led_driver_data
,
10253 .data
= &beep_driver_data
,
10256 .init
= thermal_init
,
10257 .data
= &thermal_driver_data
,
10260 .init
= brightness_init
,
10261 .data
= &brightness_driver_data
,
10264 .init
= volume_init
,
10265 .data
= &volume_driver_data
,
10269 .data
= &fan_driver_data
,
10272 .init
= mute_led_init
,
10273 .data
= &mute_led_driver_data
,
10276 .init
= tpacpi_battery_init
,
10277 .data
= &battery_driver_data
,
10280 .init
= tpacpi_lcdshadow_init
,
10281 .data
= &lcdshadow_driver_data
,
10285 static int __init
set_ibm_param(const char *val
, const struct kernel_param
*kp
)
10288 struct ibm_struct
*ibm
;
10290 if (!kp
|| !kp
->name
|| !val
)
10293 for (i
= 0; i
< ARRAY_SIZE(ibms_init
); i
++) {
10294 ibm
= ibms_init
[i
].data
;
10295 WARN_ON(ibm
== NULL
);
10297 if (!ibm
|| !ibm
->name
)
10300 if (strcmp(ibm
->name
, kp
->name
) == 0 && ibm
->write
) {
10301 if (strlen(val
) > sizeof(ibms_init
[i
].param
) - 1)
10303 strcpy(ibms_init
[i
].param
, val
);
10311 module_param(experimental
, int, 0444);
10312 MODULE_PARM_DESC(experimental
,
10313 "Enables experimental features when non-zero");
10315 module_param_named(debug
, dbg_level
, uint
, 0);
10316 MODULE_PARM_DESC(debug
, "Sets debug level bit-mask");
10318 module_param(force_load
, bool, 0444);
10319 MODULE_PARM_DESC(force_load
,
10320 "Attempts to load the driver even on a mis-identified ThinkPad when true");
10322 module_param_named(fan_control
, fan_control_allowed
, bool, 0444);
10323 MODULE_PARM_DESC(fan_control
,
10324 "Enables setting fan parameters features when true");
10326 module_param_named(brightness_mode
, brightness_mode
, uint
, 0444);
10327 MODULE_PARM_DESC(brightness_mode
,
10328 "Selects brightness control strategy: 0=auto, 1=EC, 2=UCMS, 3=EC+NVRAM");
10330 module_param(brightness_enable
, uint
, 0444);
10331 MODULE_PARM_DESC(brightness_enable
,
10332 "Enables backlight control when 1, disables when 0");
10334 #ifdef CONFIG_THINKPAD_ACPI_ALSA_SUPPORT
10335 module_param_named(volume_mode
, volume_mode
, uint
, 0444);
10336 MODULE_PARM_DESC(volume_mode
,
10337 "Selects volume control strategy: 0=auto, 1=EC, 2=N/A, 3=EC+NVRAM");
10339 module_param_named(volume_capabilities
, volume_capabilities
, uint
, 0444);
10340 MODULE_PARM_DESC(volume_capabilities
,
10341 "Selects the mixer capabilities: 0=auto, 1=volume and mute, 2=mute only");
10343 module_param_named(volume_control
, volume_control_allowed
, bool, 0444);
10344 MODULE_PARM_DESC(volume_control
,
10345 "Enables software override for the console audio control when true");
10347 module_param_named(software_mute
, software_mute_requested
, bool, 0444);
10348 MODULE_PARM_DESC(software_mute
,
10349 "Request full software mute control");
10351 /* ALSA module API parameters */
10352 module_param_named(index
, alsa_index
, int, 0444);
10353 MODULE_PARM_DESC(index
, "ALSA index for the ACPI EC Mixer");
10354 module_param_named(id
, alsa_id
, charp
, 0444);
10355 MODULE_PARM_DESC(id
, "ALSA id for the ACPI EC Mixer");
10356 module_param_named(enable
, alsa_enable
, bool, 0444);
10357 MODULE_PARM_DESC(enable
, "Enable the ALSA interface for the ACPI EC Mixer");
10358 #endif /* CONFIG_THINKPAD_ACPI_ALSA_SUPPORT */
10360 /* The module parameter can't be read back, that's why 0 is used here */
10361 #define TPACPI_PARAM(feature) \
10362 module_param_call(feature, set_ibm_param, NULL, NULL, 0); \
10363 MODULE_PARM_DESC(feature, "Simulates thinkpad-acpi procfs command at module load, see documentation")
10365 TPACPI_PARAM(hotkey
);
10366 TPACPI_PARAM(bluetooth
);
10367 TPACPI_PARAM(video
);
10368 TPACPI_PARAM(light
);
10369 TPACPI_PARAM(cmos
);
10371 TPACPI_PARAM(beep
);
10372 TPACPI_PARAM(brightness
);
10373 TPACPI_PARAM(volume
);
10376 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
10377 module_param(dbg_wlswemul
, uint
, 0444);
10378 MODULE_PARM_DESC(dbg_wlswemul
, "Enables WLSW emulation");
10379 module_param_named(wlsw_state
, tpacpi_wlsw_emulstate
, bool, 0);
10380 MODULE_PARM_DESC(wlsw_state
,
10381 "Initial state of the emulated WLSW switch");
10383 module_param(dbg_bluetoothemul
, uint
, 0444);
10384 MODULE_PARM_DESC(dbg_bluetoothemul
, "Enables bluetooth switch emulation");
10385 module_param_named(bluetooth_state
, tpacpi_bluetooth_emulstate
, bool, 0);
10386 MODULE_PARM_DESC(bluetooth_state
,
10387 "Initial state of the emulated bluetooth switch");
10389 module_param(dbg_wwanemul
, uint
, 0444);
10390 MODULE_PARM_DESC(dbg_wwanemul
, "Enables WWAN switch emulation");
10391 module_param_named(wwan_state
, tpacpi_wwan_emulstate
, bool, 0);
10392 MODULE_PARM_DESC(wwan_state
,
10393 "Initial state of the emulated WWAN switch");
10395 module_param(dbg_uwbemul
, uint
, 0444);
10396 MODULE_PARM_DESC(dbg_uwbemul
, "Enables UWB switch emulation");
10397 module_param_named(uwb_state
, tpacpi_uwb_emulstate
, bool, 0);
10398 MODULE_PARM_DESC(uwb_state
,
10399 "Initial state of the emulated UWB switch");
10402 static void thinkpad_acpi_module_exit(void)
10404 struct ibm_struct
*ibm
, *itmp
;
10406 tpacpi_lifecycle
= TPACPI_LIFE_EXITING
;
10408 list_for_each_entry_safe_reverse(ibm
, itmp
,
10409 &tpacpi_all_drivers
,
10414 dbg_printk(TPACPI_DBG_INIT
, "finished subdriver exit path...\n");
10416 if (tpacpi_inputdev
) {
10417 if (tp_features
.input_device_registered
)
10418 input_unregister_device(tpacpi_inputdev
);
10420 input_free_device(tpacpi_inputdev
);
10421 kfree(hotkey_keycode_map
);
10425 hwmon_device_unregister(tpacpi_hwmon
);
10427 if (tpacpi_sensors_pdev
)
10428 platform_device_unregister(tpacpi_sensors_pdev
);
10430 platform_device_unregister(tpacpi_pdev
);
10432 if (tp_features
.sensors_pdrv_attrs_registered
)
10433 tpacpi_remove_driver_attributes(&tpacpi_hwmon_pdriver
.driver
);
10434 if (tp_features
.platform_drv_attrs_registered
)
10435 tpacpi_remove_driver_attributes(&tpacpi_pdriver
.driver
);
10437 if (tp_features
.sensors_pdrv_registered
)
10438 platform_driver_unregister(&tpacpi_hwmon_pdriver
);
10440 if (tp_features
.platform_drv_registered
)
10441 platform_driver_unregister(&tpacpi_pdriver
);
10444 remove_proc_entry(TPACPI_PROC_DIR
, acpi_root_dir
);
10447 destroy_workqueue(tpacpi_wq
);
10449 kfree(thinkpad_id
.bios_version_str
);
10450 kfree(thinkpad_id
.ec_version_str
);
10451 kfree(thinkpad_id
.model_str
);
10452 kfree(thinkpad_id
.nummodel_str
);
10456 static int __init
thinkpad_acpi_module_init(void)
10460 tpacpi_lifecycle
= TPACPI_LIFE_INIT
;
10462 /* Driver-level probe */
10464 ret
= get_thinkpad_model_data(&thinkpad_id
);
10466 pr_err("unable to get DMI data: %d\n", ret
);
10467 thinkpad_acpi_module_exit();
10470 ret
= probe_for_thinkpad();
10472 thinkpad_acpi_module_exit();
10476 /* Driver initialization */
10478 thinkpad_acpi_init_banner();
10479 tpacpi_check_outdated_fw();
10481 TPACPI_ACPIHANDLE_INIT(ecrd
);
10482 TPACPI_ACPIHANDLE_INIT(ecwr
);
10484 tpacpi_wq
= create_singlethread_workqueue(TPACPI_WORKQUEUE_NAME
);
10486 thinkpad_acpi_module_exit();
10490 proc_dir
= proc_mkdir(TPACPI_PROC_DIR
, acpi_root_dir
);
10492 pr_err("unable to create proc dir " TPACPI_PROC_DIR
"\n");
10493 thinkpad_acpi_module_exit();
10497 ret
= platform_driver_register(&tpacpi_pdriver
);
10499 pr_err("unable to register main platform driver\n");
10500 thinkpad_acpi_module_exit();
10503 tp_features
.platform_drv_registered
= 1;
10505 ret
= platform_driver_register(&tpacpi_hwmon_pdriver
);
10507 pr_err("unable to register hwmon platform driver\n");
10508 thinkpad_acpi_module_exit();
10511 tp_features
.sensors_pdrv_registered
= 1;
10513 ret
= tpacpi_create_driver_attributes(&tpacpi_pdriver
.driver
);
10515 tp_features
.platform_drv_attrs_registered
= 1;
10516 ret
= tpacpi_create_driver_attributes(
10517 &tpacpi_hwmon_pdriver
.driver
);
10520 pr_err("unable to create sysfs driver attributes\n");
10521 thinkpad_acpi_module_exit();
10524 tp_features
.sensors_pdrv_attrs_registered
= 1;
10527 /* Device initialization */
10528 tpacpi_pdev
= platform_device_register_simple(TPACPI_DRVR_NAME
, -1,
10530 if (IS_ERR(tpacpi_pdev
)) {
10531 ret
= PTR_ERR(tpacpi_pdev
);
10532 tpacpi_pdev
= NULL
;
10533 pr_err("unable to register platform device\n");
10534 thinkpad_acpi_module_exit();
10537 tpacpi_sensors_pdev
= platform_device_register_simple(
10538 TPACPI_HWMON_DRVR_NAME
,
10540 if (IS_ERR(tpacpi_sensors_pdev
)) {
10541 ret
= PTR_ERR(tpacpi_sensors_pdev
);
10542 tpacpi_sensors_pdev
= NULL
;
10543 pr_err("unable to register hwmon platform device\n");
10544 thinkpad_acpi_module_exit();
10547 tp_features
.sensors_pdev_attrs_registered
= 1;
10548 tpacpi_hwmon
= hwmon_device_register_with_groups(
10549 &tpacpi_sensors_pdev
->dev
, TPACPI_NAME
, NULL
, NULL
);
10551 if (IS_ERR(tpacpi_hwmon
)) {
10552 ret
= PTR_ERR(tpacpi_hwmon
);
10553 tpacpi_hwmon
= NULL
;
10554 pr_err("unable to register hwmon device\n");
10555 thinkpad_acpi_module_exit();
10558 mutex_init(&tpacpi_inputdev_send_mutex
);
10559 tpacpi_inputdev
= input_allocate_device();
10560 if (!tpacpi_inputdev
) {
10561 thinkpad_acpi_module_exit();
10564 /* Prepare input device, but don't register */
10565 tpacpi_inputdev
->name
= "ThinkPad Extra Buttons";
10566 tpacpi_inputdev
->phys
= TPACPI_DRVR_NAME
"/input0";
10567 tpacpi_inputdev
->id
.bustype
= BUS_HOST
;
10568 tpacpi_inputdev
->id
.vendor
= thinkpad_id
.vendor
;
10569 tpacpi_inputdev
->id
.product
= TPACPI_HKEY_INPUT_PRODUCT
;
10570 tpacpi_inputdev
->id
.version
= TPACPI_HKEY_INPUT_VERSION
;
10571 tpacpi_inputdev
->dev
.parent
= &tpacpi_pdev
->dev
;
10574 /* Init subdriver dependencies */
10575 tpacpi_detect_brightness_capabilities();
10577 /* Init subdrivers */
10578 for (i
= 0; i
< ARRAY_SIZE(ibms_init
); i
++) {
10579 ret
= ibm_init(&ibms_init
[i
]);
10580 if (ret
>= 0 && *ibms_init
[i
].param
)
10581 ret
= ibms_init
[i
].data
->write(ibms_init
[i
].param
);
10583 thinkpad_acpi_module_exit();
10588 tpacpi_lifecycle
= TPACPI_LIFE_RUNNING
;
10590 ret
= input_register_device(tpacpi_inputdev
);
10592 pr_err("unable to register input device\n");
10593 thinkpad_acpi_module_exit();
10596 tp_features
.input_device_registered
= 1;
10602 MODULE_ALIAS(TPACPI_DRVR_SHORTNAME
);
10605 * This will autoload the driver in almost every ThinkPad
10606 * in widespread use.
10608 * Only _VERY_ old models, like the 240, 240x and 570 lack
10609 * the HKEY event interface.
10611 MODULE_DEVICE_TABLE(acpi
, ibm_htk_device_ids
);
10614 * DMI matching for module autoloading
10616 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
10617 * See http://thinkwiki.org/wiki/BIOS_Upgrade_Downloads
10619 * Only models listed in thinkwiki will be supported, so add yours
10620 * if it is not there yet.
10622 #define IBM_BIOS_MODULE_ALIAS(__type) \
10623 MODULE_ALIAS("dmi:bvnIBM:bvr" __type "ET??WW*")
10625 /* Ancient thinkpad BIOSes have to be identified by
10626 * BIOS type or model number, and there are far less
10627 * BIOS types than model numbers... */
10628 IBM_BIOS_MODULE_ALIAS("I[MU]"); /* 570, 570e */
10630 MODULE_AUTHOR("Borislav Deianov <borislav@users.sf.net>");
10631 MODULE_AUTHOR("Henrique de Moraes Holschuh <hmh@hmh.eng.br>");
10632 MODULE_DESCRIPTION(TPACPI_DESC
);
10633 MODULE_VERSION(TPACPI_VERSION
);
10634 MODULE_LICENSE("GPL");
10636 module_init(thinkpad_acpi_module_init
);
10637 module_exit(thinkpad_acpi_module_exit
);