This source file includes following definitions.
- str_supported
- tpacpi_log_usertask
- tpacpi_check_quirks
- tpacpi_is_lenovo
- tpacpi_is_ibm
- acpi_evalf
- acpi_ec_read
- acpi_ec_write
- issue_thinkpad_cmos_command
- drv_acpi_handle_init
- tpacpi_acpi_handle_locate_callback
- tpacpi_acpi_handle_locate
- dispatch_acpi_notify
- setup_acpi_notify
- tpacpi_device_add
- register_tpacpi_subdriver
- dispatch_proc_show
- dispatch_proc_open
- dispatch_proc_write
- next_cmd
- tpacpi_suspend_handler
- tpacpi_resume_handler
- tpacpi_shutdown_handler
- create_attr_set
- add_to_attr_set
- add_many_to_attr_set
- delete_attr_set
- parse_strtoul
- tpacpi_disable_brightness_delay
- printk_deprecated_attribute
- tpacpi_rfk_update_swstate
- tpacpi_rfk_update_swstate_all
- tpacpi_rfk_update_hwblock_state
- tpacpi_rfk_check_hwblock_state
- tpacpi_rfk_hook_set_block
- tpacpi_new_rfkill
- tpacpi_destroy_rfkill
- printk_deprecated_rfkill_attribute
- tpacpi_rfk_sysfs_enable_show
- tpacpi_rfk_sysfs_enable_store
- tpacpi_rfk_procfs_read
- tpacpi_rfk_procfs_write
- interface_version_show
- debug_level_show
- debug_level_store
- version_show
- wlsw_emulstate_show
- wlsw_emulstate_store
- bluetooth_emulstate_show
- bluetooth_emulstate_store
- wwan_emulstate_show
- wwan_emulstate_store
- uwb_emulstate_show
- uwb_emulstate_store
- tpacpi_create_driver_attributes
- tpacpi_remove_driver_attributes
- tpacpi_check_outdated_fw
- tpacpi_is_fw_known
- thinkpad_acpi_driver_read
- hotkey_get_wlsw
- hotkey_gmms_get_tablet_mode
- hotkey_get_tablet_mode
- hotkey_mask_get
- hotkey_mask_warn_incomplete_mask
- hotkey_mask_set
- hotkey_user_mask_set
- tpacpi_hotkey_driver_mask_set
- hotkey_status_get
- hotkey_status_set
- tpacpi_input_send_tabletsw
- tpacpi_input_send_key
- tpacpi_input_send_key_masked
- tpacpi_hotkey_send_key
- hotkey_read_nvram
- issue_volchange
- issue_brightnesschange
- hotkey_compare_and_issue_event
- hotkey_kthread
- hotkey_poll_stop_sync
- hotkey_poll_setup
- hotkey_poll_setup_safe
- hotkey_poll_set_freq
- hotkey_poll_setup
- hotkey_poll_setup_safe
- hotkey_inputdev_open
- hotkey_inputdev_close
- hotkey_enable_show
- hotkey_enable_store
- hotkey_mask_show
- hotkey_mask_store
- hotkey_bios_enabled_show
- hotkey_bios_mask_show
- hotkey_all_mask_show
- hotkey_adaptive_all_mask_show
- hotkey_recommended_mask_show
- hotkey_source_mask_show
- hotkey_source_mask_store
- hotkey_poll_freq_show
- hotkey_poll_freq_store
- hotkey_radio_sw_show
- hotkey_radio_sw_notify_change
- hotkey_tablet_mode_show
- hotkey_tablet_mode_notify_change
- hotkey_wakeup_reason_show
- hotkey_wakeup_reason_notify_change
- hotkey_wakeup_hotunplug_complete_show
- hotkey_wakeup_hotunplug_complete_notify_change
- adaptive_kbd_mode_show
- adaptive_kbd_mode_store
- tpacpi_send_radiosw_update
- hotkey_exit
- hotkey_unmap
- hotkey_init_tablet_mode
- hotkey_init
- adaptive_keyboard_get_mode
- adaptive_keyboard_set_mode
- adaptive_keyboard_get_next_mode
- adaptive_keyboard_hotkey_notify_hotkey
- hotkey_notify_hotkey
- hotkey_notify_wakeup
- hotkey_notify_dockevent
- hotkey_notify_usrevent
- hotkey_notify_6xxx
- hotkey_notify
- hotkey_suspend
- hotkey_resume
- hotkey_read
- hotkey_enabledisable_warn
- hotkey_write
- bluetooth_get_status
- bluetooth_set_status
- bluetooth_enable_show
- bluetooth_enable_store
- bluetooth_shutdown
- bluetooth_exit
- have_bt_fwbug
- bluetooth_init
- bluetooth_read
- bluetooth_write
- wan_get_status
- wan_set_status
- wan_enable_show
- wan_enable_store
- wan_shutdown
- wan_exit
- wan_init
- wan_read
- wan_write
- uwb_get_status
- uwb_set_status
- uwb_exit
- uwb_init
- video_init
- video_exit
- video_outputsw_get
- video_outputsw_set
- video_autosw_get
- video_autosw_set
- video_outputsw_cycle
- video_expand_toggle
- video_read
- video_write
- kbdlight_set_level
- kbdlight_get_level
- kbdlight_is_supported
- kbdlight_sysfs_set
- kbdlight_sysfs_get
- kbdlight_init
- kbdlight_exit
- kbdlight_set_level_and_update
- kbdlight_read
- kbdlight_write
- kbdlight_suspend
- kbdlight_resume
- light_get_status
- light_set_status
- light_sysfs_set
- light_sysfs_get
- light_init
- light_exit
- light_read
- light_write
- cmos_command_store
- cmos_init
- cmos_exit
- cmos_read
- cmos_write
- tpacpi_is_led_restricted
- led_get_status
- led_set_status
- led_sysfs_set
- led_sysfs_blink_set
- led_sysfs_get
- led_exit
- tpacpi_init_led
- led_init_detect_mode
- led_init
- led_read
- led_write
- beep_init
- beep_read
- beep_write
- thermal_get_sensor
- thermal_get_sensors
- thermal_dump_all_sensors
- thermal_temp_input_show
- thermal_init
- thermal_exit
- thermal_read
- tpacpi_brightness_nvram_get
- tpacpi_brightness_checkpoint_nvram
- tpacpi_brightness_get_raw
- tpacpi_brightness_set_ec
- tpacpi_brightness_set_ucmsstep
- brightness_set
- brightness_update_status
- brightness_get
- tpacpi_brightness_notify_change
- tpacpi_query_bcl_levels
- tpacpi_check_std_acpi_brightness_support
- tpacpi_detect_brightness_capabilities
- brightness_init
- brightness_suspend
- brightness_shutdown
- brightness_exit
- brightness_read
- brightness_write
- tpacpi_volume_checkpoint_nvram
- volume_get_status_ec
- volume_get_status
- volume_set_status_ec
- volume_set_status
- __volume_set_mute_ec
- volume_alsa_set_mute
- volume_set_mute
- __volume_set_volume_ec
- volume_set_software_mute
- volume_exit_software_mute
- volume_alsa_set_volume
- volume_alsa_notify_change
- volume_alsa_vol_info
- volume_alsa_vol_get
- volume_alsa_vol_put
- volume_alsa_mute_get
- volume_alsa_mute_put
- volume_suspend
- volume_resume
- volume_shutdown
- volume_exit
- volume_create_alsa_mixer
- volume_init
- volume_read
- volume_write
- volume_alsa_notify_change
- volume_init
- fan_quirk1_setup
- fan_quirk1_handle
- fan_select_fan1
- fan_select_fan2
- fan_update_desired_level
- fan_get_status
- fan_get_status_safe
- fan_get_speed
- fan2_get_speed
- fan_set_level
- fan_set_level_safe
- fan_set_enable
- fan_set_disable
- fan_set_speed
- fan_watchdog_reset
- fan_watchdog_fire
- fan_pwm1_enable_show
- fan_pwm1_enable_store
- fan_pwm1_show
- fan_pwm1_store
- fan_fan1_input_show
- fan_fan2_input_show
- fan_watchdog_show
- fan_watchdog_store
- fan_init
- fan_exit
- fan_suspend
- fan_resume
- fan_read
- fan_write_cmd_level
- fan_write_cmd_enable
- fan_write_cmd_disable
- fan_write_cmd_speed
- fan_write_cmd_watchdog
- fan_write
- mute_led_on_off
- tpacpi_led_set
- tpacpi_led_mute_set
- tpacpi_led_micmute_set
- mute_led_init
- mute_led_exit
- mute_led_resume
- tpacpi_battery_acpi_eval
- tpacpi_battery_get
- tpacpi_battery_set
- tpacpi_battery_probe
- tpacpi_battery_get_id
- tpacpi_battery_store
- tpacpi_battery_show
- charge_start_threshold_show
- charge_stop_threshold_show
- charge_start_threshold_store
- charge_stop_threshold_store
- tpacpi_battery_add
- tpacpi_battery_remove
- tpacpi_battery_init
- tpacpi_battery_exit
- lcdshadow_on_off
- lcdshadow_set
- tpacpi_lcdshadow_init
- lcdshadow_resume
- lcdshadow_read
- lcdshadow_write
- tpacpi_driver_event
- hotkey_driver_event
- str_supported
- ibm_exit
- ibm_init
- tpacpi_parse_fw_id
- find_new_ec_fwstr
- get_thinkpad_model_data
- probe_for_thinkpad
- thinkpad_acpi_init_banner
- set_ibm_param
- thinkpad_acpi_module_exit
- thinkpad_acpi_module_init
1
2
3
4
5
6
7
8
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11 #define TPACPI_VERSION "0.26"
12 #define TPACPI_SYSFS_VERSION 0x030000
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37 #include <linux/kernel.h>
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/types.h>
41 #include <linux/string.h>
42 #include <linux/list.h>
43 #include <linux/mutex.h>
44 #include <linux/sched.h>
45 #include <linux/sched/signal.h>
46 #include <linux/kthread.h>
47 #include <linux/freezer.h>
48 #include <linux/delay.h>
49 #include <linux/slab.h>
50 #include <linux/nvram.h>
51 #include <linux/proc_fs.h>
52 #include <linux/seq_file.h>
53 #include <linux/sysfs.h>
54 #include <linux/backlight.h>
55 #include <linux/bitops.h>
56 #include <linux/fb.h>
57 #include <linux/platform_device.h>
58 #include <linux/hwmon.h>
59 #include <linux/hwmon-sysfs.h>
60 #include <linux/input.h>
61 #include <linux/leds.h>
62 #include <linux/rfkill.h>
63 #include <linux/dmi.h>
64 #include <linux/jiffies.h>
65 #include <linux/workqueue.h>
66 #include <linux/acpi.h>
67 #include <linux/pci.h>
68 #include <linux/power_supply.h>
69 #include <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>
75
76
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
84
85
86 enum tp_nvram_addr {
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,
92 };
93
94
95 enum {
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,
109 };
110
111
112 enum {
113 TP_NVRAM_LEVEL_VOLUME_MAX = 14,
114 };
115
116
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"
121
122
123 #define TPACPI_HKEY_INPUT_PRODUCT 0x5054
124 #define TPACPI_HKEY_INPUT_VERSION 0x4101
125
126
127 enum {
128 TP_ACPI_WGSV_GET_STATE = 0x01,
129 TP_ACPI_WGSV_PWR_ON_ON_RESUME = 0x02,
130 TP_ACPI_WGSV_PWR_OFF_ON_RESUME = 0x03,
131 TP_ACPI_WGSV_SAVE_STATE = 0x04,
132 };
133
134
135 enum {
136 TP_ACPI_WGSV_STATE_WWANEXIST = 0x0001,
137 TP_ACPI_WGSV_STATE_WWANPWR = 0x0002,
138 TP_ACPI_WGSV_STATE_WWANPWRRES = 0x0004,
139 TP_ACPI_WGSV_STATE_WWANBIOSOFF = 0x0008,
140 TP_ACPI_WGSV_STATE_BLTHEXIST = 0x0001,
141 TP_ACPI_WGSV_STATE_BLTHPWR = 0x0002,
142 TP_ACPI_WGSV_STATE_BLTHPWRRES = 0x0004,
143 TP_ACPI_WGSV_STATE_BLTHBIOSOFF = 0x0008,
144 TP_ACPI_WGSV_STATE_UWBEXIST = 0x0010,
145 TP_ACPI_WGSV_STATE_UWBPWR = 0x0020,
146 };
147
148
149 enum tpacpi_hkey_event_t {
150
151 TP_HKEY_EV_HOTKEY_BASE = 0x1001,
152 TP_HKEY_EV_BRGHT_UP = 0x1010,
153 TP_HKEY_EV_BRGHT_DOWN = 0x1011,
154 TP_HKEY_EV_KBD_LIGHT = 0x1012,
155 TP_HKEY_EV_VOL_UP = 0x1015,
156 TP_HKEY_EV_VOL_DOWN = 0x1016,
157 TP_HKEY_EV_VOL_MUTE = 0x1017,
158
159
160 TP_HKEY_EV_WKUP_S3_UNDOCK = 0x2304,
161 TP_HKEY_EV_WKUP_S4_UNDOCK = 0x2404,
162 TP_HKEY_EV_WKUP_S3_BAYEJ = 0x2305,
163 TP_HKEY_EV_WKUP_S4_BAYEJ = 0x2405,
164 TP_HKEY_EV_WKUP_S3_BATLOW = 0x2313,
165 TP_HKEY_EV_WKUP_S4_BATLOW = 0x2413,
166
167
168 TP_HKEY_EV_BAYEJ_ACK = 0x3003,
169 TP_HKEY_EV_UNDOCK_ACK = 0x4003,
170
171
172 TP_HKEY_EV_OPTDRV_EJ = 0x3006,
173 TP_HKEY_EV_HOTPLUG_DOCK = 0x4010,
174
175 TP_HKEY_EV_HOTPLUG_UNDOCK = 0x4011,
176
177
178
179 TP_HKEY_EV_LID_CLOSE = 0x5001,
180 TP_HKEY_EV_LID_OPEN = 0x5002,
181 TP_HKEY_EV_TABLET_TABLET = 0x5009,
182 TP_HKEY_EV_TABLET_NOTEBOOK = 0x500a,
183 TP_HKEY_EV_TABLET_CHANGED = 0x60c0,
184
185
186 TP_HKEY_EV_PEN_INSERTED = 0x500b,
187 TP_HKEY_EV_PEN_REMOVED = 0x500c,
188 TP_HKEY_EV_BRGHT_CHANGED = 0x5010,
189
190
191 TP_HKEY_EV_KEY_NUMLOCK = 0x6000,
192 TP_HKEY_EV_KEY_FN = 0x6005,
193 TP_HKEY_EV_KEY_FN_ESC = 0x6060,
194
195
196 TP_HKEY_EV_ALARM_BAT_HOT = 0x6011,
197 TP_HKEY_EV_ALARM_BAT_XHOT = 0x6012,
198 TP_HKEY_EV_ALARM_SENSOR_HOT = 0x6021,
199 TP_HKEY_EV_ALARM_SENSOR_XHOT = 0x6022,
200 TP_HKEY_EV_THM_TABLE_CHANGED = 0x6030,
201 TP_HKEY_EV_THM_CSM_COMPLETED = 0x6032,
202
203
204 TP_HKEY_EV_THM_TRANSFM_CHANGED = 0x60F0,
205
206
207
208 TP_HKEY_EV_AC_CHANGED = 0x6040,
209
210
211 TP_HKEY_EV_PALM_DETECTED = 0x60b0,
212 TP_HKEY_EV_PALM_UNDETECTED = 0x60b1,
213
214
215 TP_HKEY_EV_RFKILL_CHANGED = 0x7000,
216 };
217
218
219
220
221
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"
227
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"
233
234 #define TPACPI_NVRAM_KTHREAD_NAME "ktpacpi_nvramd"
235 #define TPACPI_WORKQUEUE_NAME "ktpacpid"
236
237 #define TPACPI_MAX_ACPI_ARGS 3
238
239
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
249
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)))
253
254
255
256
257
258
259 struct ibm_struct;
260
261 struct tp_acpi_drv_struct {
262 const struct acpi_device_id *hid;
263 struct acpi_driver *driver;
264
265 void (*notify) (struct ibm_struct *, u32);
266 acpi_handle *handle;
267 u32 type;
268 struct acpi_device *device;
269 };
270
271 struct ibm_struct {
272 char *name;
273
274 int (*read) (struct seq_file *);
275 int (*write) (char *);
276 void (*exit) (void);
277 void (*resume) (void);
278 void (*suspend) (void);
279 void (*shutdown) (void);
280
281 struct list_head all_drivers;
282
283 struct tp_acpi_drv_struct *acpi;
284
285 struct {
286 u8 acpi_driver_registered:1;
287 u8 acpi_notify_installed:1;
288 u8 proc_created:1;
289 u8 init_called:1;
290 u8 experimental:1;
291 } flags;
292 };
293
294 struct ibm_init_struct {
295 char param[32];
296
297 int (*init) (struct ibm_init_struct *);
298 umode_t base_procfs_mode;
299 struct ibm_struct *data;
300 };
301
302 static struct {
303 u32 bluetooth:1;
304 u32 hotkey:1;
305 u32 hotkey_mask:1;
306 u32 hotkey_wlsw:1;
307 enum {
308 TP_HOTKEY_TABLET_NONE = 0,
309 TP_HOTKEY_TABLET_USES_MHKG,
310 TP_HOTKEY_TABLET_USES_GMMS,
311 } hotkey_tablet;
312 u32 kbdlight:1;
313 u32 light:1;
314 u32 light_status:1;
315 u32 bright_acpimode:1;
316 u32 bright_unkfw:1;
317 u32 wan:1;
318 u32 uwb:1;
319 u32 fan_ctrl_status_undef:1;
320 u32 second_fan:1;
321 u32 beep_needs_two_args:1;
322 u32 mixer_no_level_control:1;
323 u32 battery_force_primary:1;
324 u32 input_device_registered:1;
325 u32 platform_drv_registered:1;
326 u32 platform_drv_attrs_registered:1;
327 u32 sensors_pdrv_registered:1;
328 u32 sensors_pdrv_attrs_registered:1;
329 u32 sensors_pdev_attrs_registered:1;
330 u32 hotkey_poll_active:1;
331 u32 has_adaptive_kbd:1;
332 } tp_features;
333
334 static struct {
335 u16 hotkey_mask_ff:1;
336 u16 volume_ctrl_forbidden:1;
337 } tp_warned;
338
339 struct thinkpad_id_data {
340 unsigned int vendor;
341
342
343 char *bios_version_str;
344 char *ec_version_str;
345
346 u32 bios_model;
347 u32 ec_model;
348 u16 bios_release;
349 u16 ec_release;
350
351 char *model_str;
352 char *nummodel_str;
353 };
354 static struct thinkpad_id_data thinkpad_id;
355
356 static enum {
357 TPACPI_LIFE_INIT = 0,
358 TPACPI_LIFE_RUNNING,
359 TPACPI_LIFE_EXITING,
360 } tpacpi_lifecycle;
361
362 static int experimental;
363 static u32 dbg_level;
364
365 static struct workqueue_struct *tpacpi_wq;
366
367 enum led_status_t {
368 TPACPI_LED_OFF = 0,
369 TPACPI_LED_ON,
370 TPACPI_LED_BLINK,
371 };
372
373
374 struct tpacpi_led_classdev {
375 struct led_classdev led_classdev;
376 int led;
377 };
378
379
380 static unsigned int bright_maxlvl;
381
382 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
383 static int dbg_wlswemul;
384 static bool tpacpi_wlsw_emulstate;
385 static int dbg_bluetoothemul;
386 static bool tpacpi_bluetooth_emulstate;
387 static int dbg_wwanemul;
388 static bool tpacpi_wwan_emulstate;
389 static int dbg_uwbemul;
390 static bool tpacpi_uwb_emulstate;
391 #endif
392
393
394
395
396
397
398 #define dbg_printk(a_dbg_level, format, arg...) \
399 do { \
400 if (dbg_level & (a_dbg_level)) \
401 printk(KERN_DEBUG pr_fmt("%s: " format), \
402 __func__, ##arg); \
403 } while (0)
404
405 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
406 #define vdbg_printk dbg_printk
407 static const char *str_supported(int is_supported);
408 #else
409 static inline const char *str_supported(int is_supported) { return ""; }
410 #define vdbg_printk(a_dbg_level, format, arg...) \
411 do { if (0) no_printk(format, ##arg); } while (0)
412 #endif
413
414 static void tpacpi_log_usertask(const char * const what)
415 {
416 printk(KERN_DEBUG pr_fmt("%s: access by process with PID %d\n"),
417 what, task_tgid_vnr(current));
418 }
419
420 #define tpacpi_disclose_usertask(what, format, arg...) \
421 do { \
422 if (unlikely((dbg_level & TPACPI_DBG_DISCLOSETASK) && \
423 (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) { \
424 printk(KERN_DEBUG pr_fmt("%s: PID %d: " format), \
425 what, task_tgid_vnr(current), ## arg); \
426 } \
427 } while (0)
428
429
430
431
432
433
434
435
436
437
438 #define TPACPI_MATCH_ANY 0xffffffffU
439 #define TPACPI_MATCH_ANY_VERSION 0xffffU
440 #define TPACPI_MATCH_UNKNOWN 0U
441
442
443 #define TPID(__c1, __c2) (((__c1) << 8) | (__c2))
444 #define TPID3(__c1, __c2, __c3) (((__c1) << 16) | ((__c2) << 8) | (__c3))
445 #define TPVER TPID
446
447 #define TPACPI_Q_IBM(__id1, __id2, __quirk) \
448 { .vendor = PCI_VENDOR_ID_IBM, \
449 .bios = TPID(__id1, __id2), \
450 .ec = TPACPI_MATCH_ANY, \
451 .quirks = (__quirk) }
452
453 #define TPACPI_Q_LNV(__id1, __id2, __quirk) \
454 { .vendor = PCI_VENDOR_ID_LENOVO, \
455 .bios = TPID(__id1, __id2), \
456 .ec = TPACPI_MATCH_ANY, \
457 .quirks = (__quirk) }
458
459 #define TPACPI_Q_LNV3(__id1, __id2, __id3, __quirk) \
460 { .vendor = PCI_VENDOR_ID_LENOVO, \
461 .bios = TPID3(__id1, __id2, __id3), \
462 .ec = TPACPI_MATCH_ANY, \
463 .quirks = (__quirk) }
464
465 #define TPACPI_QEC_IBM(__id1, __id2, __quirk) \
466 { .vendor = PCI_VENDOR_ID_IBM, \
467 .bios = TPACPI_MATCH_ANY, \
468 .ec = TPID(__id1, __id2), \
469 .quirks = (__quirk) }
470
471 #define TPACPI_QEC_LNV(__id1, __id2, __quirk) \
472 { .vendor = PCI_VENDOR_ID_LENOVO, \
473 .bios = TPACPI_MATCH_ANY, \
474 .ec = TPID(__id1, __id2), \
475 .quirks = (__quirk) }
476
477 struct tpacpi_quirk {
478 unsigned int vendor;
479 u32 bios;
480 u32 ec;
481 unsigned long quirks;
482 };
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497 static unsigned long __init tpacpi_check_quirks(
498 const struct tpacpi_quirk *qlist,
499 unsigned int qlist_size)
500 {
501 while (qlist_size) {
502 if ((qlist->vendor == thinkpad_id.vendor ||
503 qlist->vendor == TPACPI_MATCH_ANY) &&
504 (qlist->bios == thinkpad_id.bios_model ||
505 qlist->bios == TPACPI_MATCH_ANY) &&
506 (qlist->ec == thinkpad_id.ec_model ||
507 qlist->ec == TPACPI_MATCH_ANY))
508 return qlist->quirks;
509
510 qlist_size--;
511 qlist++;
512 }
513 return 0;
514 }
515
516 static inline bool __pure __init tpacpi_is_lenovo(void)
517 {
518 return thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO;
519 }
520
521 static inline bool __pure __init tpacpi_is_ibm(void)
522 {
523 return thinkpad_id.vendor == PCI_VENDOR_ID_IBM;
524 }
525
526
527
528
529
530
531
532
533
534
535
536
537
538 static acpi_handle root_handle;
539 static acpi_handle ec_handle;
540
541 #define TPACPI_HANDLE(object, parent, paths...) \
542 static acpi_handle object##_handle; \
543 static const acpi_handle * const object##_parent __initconst = \
544 &parent##_handle; \
545 static char *object##_paths[] __initdata = { paths }
546
547 TPACPI_HANDLE(ecrd, ec, "ECRD");
548 TPACPI_HANDLE(ecwr, ec, "ECWR");
549
550 TPACPI_HANDLE(cmos, root, "\\UCMS",
551
552 "\\CMOS",
553 "\\CMS",
554 );
555
556 TPACPI_HANDLE(hkey, ec, "\\_SB.HKEY",
557 "^HKEY",
558 "HKEY",
559 );
560
561
562
563
564
565 static int acpi_evalf(acpi_handle handle,
566 int *res, char *method, char *fmt, ...)
567 {
568 char *fmt0 = fmt;
569 struct acpi_object_list params;
570 union acpi_object in_objs[TPACPI_MAX_ACPI_ARGS];
571 struct acpi_buffer result, *resultp;
572 union acpi_object out_obj;
573 acpi_status status;
574 va_list ap;
575 char res_type;
576 int success;
577 int quiet;
578
579 if (!*fmt) {
580 pr_err("acpi_evalf() called with empty format\n");
581 return 0;
582 }
583
584 if (*fmt == 'q') {
585 quiet = 1;
586 fmt++;
587 } else
588 quiet = 0;
589
590 res_type = *(fmt++);
591
592 params.count = 0;
593 params.pointer = &in_objs[0];
594
595 va_start(ap, fmt);
596 while (*fmt) {
597 char c = *(fmt++);
598 switch (c) {
599 case 'd':
600 in_objs[params.count].integer.value = va_arg(ap, int);
601 in_objs[params.count++].type = ACPI_TYPE_INTEGER;
602 break;
603
604 default:
605 pr_err("acpi_evalf() called with invalid format character '%c'\n",
606 c);
607 va_end(ap);
608 return 0;
609 }
610 }
611 va_end(ap);
612
613 if (res_type != 'v') {
614 result.length = sizeof(out_obj);
615 result.pointer = &out_obj;
616 resultp = &result;
617 } else
618 resultp = NULL;
619
620 status = acpi_evaluate_object(handle, method, ¶ms, resultp);
621
622 switch (res_type) {
623 case 'd':
624 success = (status == AE_OK &&
625 out_obj.type == ACPI_TYPE_INTEGER);
626 if (success && res)
627 *res = out_obj.integer.value;
628 break;
629 case 'v':
630 success = status == AE_OK;
631 break;
632
633 default:
634 pr_err("acpi_evalf() called with invalid format character '%c'\n",
635 res_type);
636 return 0;
637 }
638
639 if (!success && !quiet)
640 pr_err("acpi_evalf(%s, %s, ...) failed: %s\n",
641 method, fmt0, acpi_format_exception(status));
642
643 return success;
644 }
645
646 static int acpi_ec_read(int i, u8 *p)
647 {
648 int v;
649
650 if (ecrd_handle) {
651 if (!acpi_evalf(ecrd_handle, &v, NULL, "dd", i))
652 return 0;
653 *p = v;
654 } else {
655 if (ec_read(i, p) < 0)
656 return 0;
657 }
658
659 return 1;
660 }
661
662 static int acpi_ec_write(int i, u8 v)
663 {
664 if (ecwr_handle) {
665 if (!acpi_evalf(ecwr_handle, NULL, NULL, "vdd", i, v))
666 return 0;
667 } else {
668 if (ec_write(i, v) < 0)
669 return 0;
670 }
671
672 return 1;
673 }
674
675 static int issue_thinkpad_cmos_command(int cmos_cmd)
676 {
677 if (!cmos_handle)
678 return -ENXIO;
679
680 if (!acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd))
681 return -EIO;
682
683 return 0;
684 }
685
686
687
688
689
690 #define TPACPI_ACPIHANDLE_INIT(object) \
691 drv_acpi_handle_init(#object, &object##_handle, *object##_parent, \
692 object##_paths, ARRAY_SIZE(object##_paths))
693
694 static void __init drv_acpi_handle_init(const char *name,
695 acpi_handle *handle, const acpi_handle parent,
696 char **paths, const int num_paths)
697 {
698 int i;
699 acpi_status status;
700
701 vdbg_printk(TPACPI_DBG_INIT, "trying to locate ACPI handle for %s\n",
702 name);
703
704 for (i = 0; i < num_paths; i++) {
705 status = acpi_get_handle(parent, paths[i], handle);
706 if (ACPI_SUCCESS(status)) {
707 dbg_printk(TPACPI_DBG_INIT,
708 "Found ACPI handle %s for %s\n",
709 paths[i], name);
710 return;
711 }
712 }
713
714 vdbg_printk(TPACPI_DBG_INIT, "ACPI handle for %s not found\n",
715 name);
716 *handle = NULL;
717 }
718
719 static acpi_status __init tpacpi_acpi_handle_locate_callback(acpi_handle handle,
720 u32 level, void *context, void **return_value)
721 {
722 struct acpi_device *dev;
723 if (!strcmp(context, "video")) {
724 if (acpi_bus_get_device(handle, &dev))
725 return AE_OK;
726 if (strcmp(ACPI_VIDEO_HID, acpi_device_hid(dev)))
727 return AE_OK;
728 }
729
730 *(acpi_handle *)return_value = handle;
731
732 return AE_CTRL_TERMINATE;
733 }
734
735 static void __init tpacpi_acpi_handle_locate(const char *name,
736 const char *hid,
737 acpi_handle *handle)
738 {
739 acpi_status status;
740 acpi_handle device_found;
741
742 BUG_ON(!name || !handle);
743 vdbg_printk(TPACPI_DBG_INIT,
744 "trying to locate ACPI handle for %s, using HID %s\n",
745 name, hid ? hid : "NULL");
746
747 memset(&device_found, 0, sizeof(device_found));
748 status = acpi_get_devices(hid, tpacpi_acpi_handle_locate_callback,
749 (void *)name, &device_found);
750
751 *handle = NULL;
752
753 if (ACPI_SUCCESS(status)) {
754 *handle = device_found;
755 dbg_printk(TPACPI_DBG_INIT,
756 "Found ACPI handle for %s\n", name);
757 } else {
758 vdbg_printk(TPACPI_DBG_INIT,
759 "Could not locate an ACPI handle for %s: %s\n",
760 name, acpi_format_exception(status));
761 }
762 }
763
764 static void dispatch_acpi_notify(acpi_handle handle, u32 event, void *data)
765 {
766 struct ibm_struct *ibm = data;
767
768 if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
769 return;
770
771 if (!ibm || !ibm->acpi || !ibm->acpi->notify)
772 return;
773
774 ibm->acpi->notify(ibm, event);
775 }
776
777 static int __init setup_acpi_notify(struct ibm_struct *ibm)
778 {
779 acpi_status status;
780 int rc;
781
782 BUG_ON(!ibm->acpi);
783
784 if (!*ibm->acpi->handle)
785 return 0;
786
787 vdbg_printk(TPACPI_DBG_INIT,
788 "setting up ACPI notify for %s\n", ibm->name);
789
790 rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
791 if (rc < 0) {
792 pr_err("acpi_bus_get_device(%s) failed: %d\n", ibm->name, rc);
793 return -ENODEV;
794 }
795
796 ibm->acpi->device->driver_data = ibm;
797 sprintf(acpi_device_class(ibm->acpi->device), "%s/%s",
798 TPACPI_ACPI_EVENT_PREFIX,
799 ibm->name);
800
801 status = acpi_install_notify_handler(*ibm->acpi->handle,
802 ibm->acpi->type, dispatch_acpi_notify, ibm);
803 if (ACPI_FAILURE(status)) {
804 if (status == AE_ALREADY_EXISTS) {
805 pr_notice("another device driver is already handling %s events\n",
806 ibm->name);
807 } else {
808 pr_err("acpi_install_notify_handler(%s) failed: %s\n",
809 ibm->name, acpi_format_exception(status));
810 }
811 return -ENODEV;
812 }
813 ibm->flags.acpi_notify_installed = 1;
814 return 0;
815 }
816
817 static int __init tpacpi_device_add(struct acpi_device *device)
818 {
819 return 0;
820 }
821
822 static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
823 {
824 int rc;
825
826 dbg_printk(TPACPI_DBG_INIT,
827 "registering %s as an ACPI driver\n", ibm->name);
828
829 BUG_ON(!ibm->acpi);
830
831 ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
832 if (!ibm->acpi->driver) {
833 pr_err("failed to allocate memory for ibm->acpi->driver\n");
834 return -ENOMEM;
835 }
836
837 sprintf(ibm->acpi->driver->name, "%s_%s", TPACPI_NAME, ibm->name);
838 ibm->acpi->driver->ids = ibm->acpi->hid;
839
840 ibm->acpi->driver->ops.add = &tpacpi_device_add;
841
842 rc = acpi_bus_register_driver(ibm->acpi->driver);
843 if (rc < 0) {
844 pr_err("acpi_bus_register_driver(%s) failed: %d\n",
845 ibm->name, rc);
846 kfree(ibm->acpi->driver);
847 ibm->acpi->driver = NULL;
848 } else if (!rc)
849 ibm->flags.acpi_driver_registered = 1;
850
851 return rc;
852 }
853
854
855
856
857
858
859
860
861
862
863 static int dispatch_proc_show(struct seq_file *m, void *v)
864 {
865 struct ibm_struct *ibm = m->private;
866
867 if (!ibm || !ibm->read)
868 return -EINVAL;
869 return ibm->read(m);
870 }
871
872 static int dispatch_proc_open(struct inode *inode, struct file *file)
873 {
874 return single_open(file, dispatch_proc_show, PDE_DATA(inode));
875 }
876
877 static ssize_t dispatch_proc_write(struct file *file,
878 const char __user *userbuf,
879 size_t count, loff_t *pos)
880 {
881 struct ibm_struct *ibm = PDE_DATA(file_inode(file));
882 char *kernbuf;
883 int ret;
884
885 if (!ibm || !ibm->write)
886 return -EINVAL;
887 if (count > PAGE_SIZE - 2)
888 return -EINVAL;
889
890 kernbuf = kmalloc(count + 2, GFP_KERNEL);
891 if (!kernbuf)
892 return -ENOMEM;
893
894 if (copy_from_user(kernbuf, userbuf, count)) {
895 kfree(kernbuf);
896 return -EFAULT;
897 }
898
899 kernbuf[count] = 0;
900 strcat(kernbuf, ",");
901 ret = ibm->write(kernbuf);
902 if (ret == 0)
903 ret = count;
904
905 kfree(kernbuf);
906
907 return ret;
908 }
909
910 static const struct file_operations dispatch_proc_fops = {
911 .owner = THIS_MODULE,
912 .open = dispatch_proc_open,
913 .read = seq_read,
914 .llseek = seq_lseek,
915 .release = single_release,
916 .write = dispatch_proc_write,
917 };
918
919 static char *next_cmd(char **cmds)
920 {
921 char *start = *cmds;
922 char *end;
923
924 while ((end = strchr(start, ',')) && end == start)
925 start = end + 1;
926
927 if (!end)
928 return NULL;
929
930 *end = 0;
931 *cmds = end + 1;
932 return start;
933 }
934
935
936
937
938
939
940
941
942
943
944 static struct platform_device *tpacpi_pdev;
945 static struct platform_device *tpacpi_sensors_pdev;
946 static struct device *tpacpi_hwmon;
947 static struct input_dev *tpacpi_inputdev;
948 static struct mutex tpacpi_inputdev_send_mutex;
949 static LIST_HEAD(tpacpi_all_drivers);
950
951 #ifdef CONFIG_PM_SLEEP
952 static int tpacpi_suspend_handler(struct device *dev)
953 {
954 struct ibm_struct *ibm, *itmp;
955
956 list_for_each_entry_safe(ibm, itmp,
957 &tpacpi_all_drivers,
958 all_drivers) {
959 if (ibm->suspend)
960 (ibm->suspend)();
961 }
962
963 return 0;
964 }
965
966 static int tpacpi_resume_handler(struct device *dev)
967 {
968 struct ibm_struct *ibm, *itmp;
969
970 list_for_each_entry_safe(ibm, itmp,
971 &tpacpi_all_drivers,
972 all_drivers) {
973 if (ibm->resume)
974 (ibm->resume)();
975 }
976
977 return 0;
978 }
979 #endif
980
981 static SIMPLE_DEV_PM_OPS(tpacpi_pm,
982 tpacpi_suspend_handler, tpacpi_resume_handler);
983
984 static void tpacpi_shutdown_handler(struct platform_device *pdev)
985 {
986 struct ibm_struct *ibm, *itmp;
987
988 list_for_each_entry_safe(ibm, itmp,
989 &tpacpi_all_drivers,
990 all_drivers) {
991 if (ibm->shutdown)
992 (ibm->shutdown)();
993 }
994 }
995
996 static struct platform_driver tpacpi_pdriver = {
997 .driver = {
998 .name = TPACPI_DRVR_NAME,
999 .pm = &tpacpi_pm,
1000 },
1001 .shutdown = tpacpi_shutdown_handler,
1002 };
1003
1004 static struct platform_driver tpacpi_hwmon_pdriver = {
1005 .driver = {
1006 .name = TPACPI_HWMON_DRVR_NAME,
1007 },
1008 };
1009
1010
1011
1012
1013
1014 struct attribute_set {
1015 unsigned int members, max_members;
1016 struct attribute_group group;
1017 };
1018
1019 struct attribute_set_obj {
1020 struct attribute_set s;
1021 struct attribute *a;
1022 } __attribute__((packed));
1023
1024 static struct attribute_set *create_attr_set(unsigned int max_members,
1025 const char *name)
1026 {
1027 struct attribute_set_obj *sobj;
1028
1029 if (max_members == 0)
1030 return NULL;
1031
1032
1033 sobj = kzalloc(sizeof(struct attribute_set_obj) +
1034 max_members * sizeof(struct attribute *),
1035 GFP_KERNEL);
1036 if (!sobj)
1037 return NULL;
1038 sobj->s.max_members = max_members;
1039 sobj->s.group.attrs = &sobj->a;
1040 sobj->s.group.name = name;
1041
1042 return &sobj->s;
1043 }
1044
1045 #define destroy_attr_set(_set) \
1046 kfree(_set);
1047
1048
1049 static int add_to_attr_set(struct attribute_set *s, struct attribute *attr)
1050 {
1051 if (!s || !attr)
1052 return -EINVAL;
1053
1054 if (s->members >= s->max_members)
1055 return -ENOMEM;
1056
1057 s->group.attrs[s->members] = attr;
1058 s->members++;
1059
1060 return 0;
1061 }
1062
1063 static int add_many_to_attr_set(struct attribute_set *s,
1064 struct attribute **attr,
1065 unsigned int count)
1066 {
1067 int i, res;
1068
1069 for (i = 0; i < count; i++) {
1070 res = add_to_attr_set(s, attr[i]);
1071 if (res)
1072 return res;
1073 }
1074
1075 return 0;
1076 }
1077
1078 static void delete_attr_set(struct attribute_set *s, struct kobject *kobj)
1079 {
1080 sysfs_remove_group(kobj, &s->group);
1081 destroy_attr_set(s);
1082 }
1083
1084 #define register_attr_set_with_sysfs(_attr_set, _kobj) \
1085 sysfs_create_group(_kobj, &_attr_set->group)
1086
1087 static int parse_strtoul(const char *buf,
1088 unsigned long max, unsigned long *value)
1089 {
1090 char *endp;
1091
1092 *value = simple_strtoul(skip_spaces(buf), &endp, 0);
1093 endp = skip_spaces(endp);
1094 if (*endp || *value > max)
1095 return -EINVAL;
1096
1097 return 0;
1098 }
1099
1100 static void tpacpi_disable_brightness_delay(void)
1101 {
1102 if (acpi_evalf(hkey_handle, NULL, "PWMS", "qvd", 0))
1103 pr_notice("ACPI backlight control delay disabled\n");
1104 }
1105
1106 static void printk_deprecated_attribute(const char * const what,
1107 const char * const details)
1108 {
1109 tpacpi_log_usertask("deprecated sysfs attribute");
1110 pr_warn("WARNING: sysfs attribute %s is deprecated and will be removed. %s\n",
1111 what, details);
1112 }
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138 enum tpacpi_rfkill_state {
1139 TPACPI_RFK_RADIO_OFF = 0,
1140 TPACPI_RFK_RADIO_ON
1141 };
1142
1143
1144 enum tpacpi_rfk_id {
1145 TPACPI_RFK_BLUETOOTH_SW_ID = 0,
1146 TPACPI_RFK_WWAN_SW_ID,
1147 TPACPI_RFK_UWB_SW_ID,
1148 TPACPI_RFK_SW_MAX
1149 };
1150
1151 static const char *tpacpi_rfkill_names[] = {
1152 [TPACPI_RFK_BLUETOOTH_SW_ID] = "bluetooth",
1153 [TPACPI_RFK_WWAN_SW_ID] = "wwan",
1154 [TPACPI_RFK_UWB_SW_ID] = "uwb",
1155 [TPACPI_RFK_SW_MAX] = NULL
1156 };
1157
1158
1159 struct tpacpi_rfk {
1160 struct rfkill *rfkill;
1161 enum tpacpi_rfk_id id;
1162 const struct tpacpi_rfk_ops *ops;
1163 };
1164
1165 struct tpacpi_rfk_ops {
1166
1167 int (*get_status)(void);
1168 int (*set_status)(const enum tpacpi_rfkill_state);
1169 };
1170
1171 static struct tpacpi_rfk *tpacpi_rfkill_switches[TPACPI_RFK_SW_MAX];
1172
1173
1174 static int tpacpi_rfk_update_swstate(const struct tpacpi_rfk *tp_rfk)
1175 {
1176 int status;
1177
1178 if (!tp_rfk)
1179 return -ENODEV;
1180
1181 status = (tp_rfk->ops->get_status)();
1182 if (status < 0)
1183 return status;
1184
1185 rfkill_set_sw_state(tp_rfk->rfkill,
1186 (status == TPACPI_RFK_RADIO_OFF));
1187
1188 return status;
1189 }
1190
1191
1192 static void tpacpi_rfk_update_swstate_all(void)
1193 {
1194 unsigned int i;
1195
1196 for (i = 0; i < TPACPI_RFK_SW_MAX; i++)
1197 tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[i]);
1198 }
1199
1200
1201
1202
1203
1204 static void tpacpi_rfk_update_hwblock_state(bool blocked)
1205 {
1206 unsigned int i;
1207 struct tpacpi_rfk *tp_rfk;
1208
1209 for (i = 0; i < TPACPI_RFK_SW_MAX; i++) {
1210 tp_rfk = tpacpi_rfkill_switches[i];
1211 if (tp_rfk) {
1212 if (rfkill_set_hw_state(tp_rfk->rfkill,
1213 blocked)) {
1214
1215 }
1216 }
1217 }
1218 }
1219
1220
1221 static int hotkey_get_wlsw(void);
1222
1223
1224 static bool tpacpi_rfk_check_hwblock_state(void)
1225 {
1226 int res = hotkey_get_wlsw();
1227 int hw_blocked;
1228
1229
1230 if (res < 0)
1231 return false;
1232
1233 hw_blocked = (res == TPACPI_RFK_RADIO_OFF);
1234 tpacpi_rfk_update_hwblock_state(hw_blocked);
1235
1236 return hw_blocked;
1237 }
1238
1239 static int tpacpi_rfk_hook_set_block(void *data, bool blocked)
1240 {
1241 struct tpacpi_rfk *tp_rfk = data;
1242 int res;
1243
1244 dbg_printk(TPACPI_DBG_RFKILL,
1245 "request to change radio state to %s\n",
1246 blocked ? "blocked" : "unblocked");
1247
1248
1249 res = (tp_rfk->ops->set_status)(blocked ?
1250 TPACPI_RFK_RADIO_OFF : TPACPI_RFK_RADIO_ON);
1251
1252
1253 tpacpi_rfk_update_swstate(tp_rfk);
1254
1255 return (res < 0) ? res : 0;
1256 }
1257
1258 static const struct rfkill_ops tpacpi_rfk_rfkill_ops = {
1259 .set_block = tpacpi_rfk_hook_set_block,
1260 };
1261
1262 static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
1263 const struct tpacpi_rfk_ops *tp_rfkops,
1264 const enum rfkill_type rfktype,
1265 const char *name,
1266 const bool set_default)
1267 {
1268 struct tpacpi_rfk *atp_rfk;
1269 int res;
1270 bool sw_state = false;
1271 bool hw_state;
1272 int sw_status;
1273
1274 BUG_ON(id >= TPACPI_RFK_SW_MAX || tpacpi_rfkill_switches[id]);
1275
1276 atp_rfk = kzalloc(sizeof(struct tpacpi_rfk), GFP_KERNEL);
1277 if (atp_rfk)
1278 atp_rfk->rfkill = rfkill_alloc(name,
1279 &tpacpi_pdev->dev,
1280 rfktype,
1281 &tpacpi_rfk_rfkill_ops,
1282 atp_rfk);
1283 if (!atp_rfk || !atp_rfk->rfkill) {
1284 pr_err("failed to allocate memory for rfkill class\n");
1285 kfree(atp_rfk);
1286 return -ENOMEM;
1287 }
1288
1289 atp_rfk->id = id;
1290 atp_rfk->ops = tp_rfkops;
1291
1292 sw_status = (tp_rfkops->get_status)();
1293 if (sw_status < 0) {
1294 pr_err("failed to read initial state for %s, error %d\n",
1295 name, sw_status);
1296 } else {
1297 sw_state = (sw_status == TPACPI_RFK_RADIO_OFF);
1298 if (set_default) {
1299
1300
1301 rfkill_init_sw_state(atp_rfk->rfkill, sw_state);
1302 }
1303 }
1304 hw_state = tpacpi_rfk_check_hwblock_state();
1305 rfkill_set_hw_state(atp_rfk->rfkill, hw_state);
1306
1307 res = rfkill_register(atp_rfk->rfkill);
1308 if (res < 0) {
1309 pr_err("failed to register %s rfkill switch: %d\n", name, res);
1310 rfkill_destroy(atp_rfk->rfkill);
1311 kfree(atp_rfk);
1312 return res;
1313 }
1314
1315 tpacpi_rfkill_switches[id] = atp_rfk;
1316
1317 pr_info("rfkill switch %s: radio is %sblocked\n",
1318 name, (sw_state || hw_state) ? "" : "un");
1319 return 0;
1320 }
1321
1322 static void tpacpi_destroy_rfkill(const enum tpacpi_rfk_id id)
1323 {
1324 struct tpacpi_rfk *tp_rfk;
1325
1326 BUG_ON(id >= TPACPI_RFK_SW_MAX);
1327
1328 tp_rfk = tpacpi_rfkill_switches[id];
1329 if (tp_rfk) {
1330 rfkill_unregister(tp_rfk->rfkill);
1331 rfkill_destroy(tp_rfk->rfkill);
1332 tpacpi_rfkill_switches[id] = NULL;
1333 kfree(tp_rfk);
1334 }
1335 }
1336
1337 static void printk_deprecated_rfkill_attribute(const char * const what)
1338 {
1339 printk_deprecated_attribute(what,
1340 "Please switch to generic rfkill before year 2010");
1341 }
1342
1343
1344 static ssize_t tpacpi_rfk_sysfs_enable_show(const enum tpacpi_rfk_id id,
1345 struct device_attribute *attr,
1346 char *buf)
1347 {
1348 int status;
1349
1350 printk_deprecated_rfkill_attribute(attr->attr.name);
1351
1352
1353 if (tpacpi_rfk_check_hwblock_state()) {
1354 status = TPACPI_RFK_RADIO_OFF;
1355 } else {
1356 status = tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
1357 if (status < 0)
1358 return status;
1359 }
1360
1361 return snprintf(buf, PAGE_SIZE, "%d\n",
1362 (status == TPACPI_RFK_RADIO_ON) ? 1 : 0);
1363 }
1364
1365 static ssize_t tpacpi_rfk_sysfs_enable_store(const enum tpacpi_rfk_id id,
1366 struct device_attribute *attr,
1367 const char *buf, size_t count)
1368 {
1369 unsigned long t;
1370 int res;
1371
1372 printk_deprecated_rfkill_attribute(attr->attr.name);
1373
1374 if (parse_strtoul(buf, 1, &t))
1375 return -EINVAL;
1376
1377 tpacpi_disclose_usertask(attr->attr.name, "set to %ld\n", t);
1378
1379
1380 if (tpacpi_rfk_check_hwblock_state() && !!t)
1381 return -EPERM;
1382
1383 res = tpacpi_rfkill_switches[id]->ops->set_status((!!t) ?
1384 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF);
1385 tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
1386
1387 return (res < 0) ? res : count;
1388 }
1389
1390
1391 static int tpacpi_rfk_procfs_read(const enum tpacpi_rfk_id id, struct seq_file *m)
1392 {
1393 if (id >= TPACPI_RFK_SW_MAX)
1394 seq_printf(m, "status:\t\tnot supported\n");
1395 else {
1396 int status;
1397
1398
1399 if (tpacpi_rfk_check_hwblock_state()) {
1400 status = TPACPI_RFK_RADIO_OFF;
1401 } else {
1402 status = tpacpi_rfk_update_swstate(
1403 tpacpi_rfkill_switches[id]);
1404 if (status < 0)
1405 return status;
1406 }
1407
1408 seq_printf(m, "status:\t\t%s\n",
1409 (status == TPACPI_RFK_RADIO_ON) ?
1410 "enabled" : "disabled");
1411 seq_printf(m, "commands:\tenable, disable\n");
1412 }
1413
1414 return 0;
1415 }
1416
1417 static int tpacpi_rfk_procfs_write(const enum tpacpi_rfk_id id, char *buf)
1418 {
1419 char *cmd;
1420 int status = -1;
1421 int res = 0;
1422
1423 if (id >= TPACPI_RFK_SW_MAX)
1424 return -ENODEV;
1425
1426 while ((cmd = next_cmd(&buf))) {
1427 if (strlencmp(cmd, "enable") == 0)
1428 status = TPACPI_RFK_RADIO_ON;
1429 else if (strlencmp(cmd, "disable") == 0)
1430 status = TPACPI_RFK_RADIO_OFF;
1431 else
1432 return -EINVAL;
1433 }
1434
1435 if (status != -1) {
1436 tpacpi_disclose_usertask("procfs", "attempt to %s %s\n",
1437 (status == TPACPI_RFK_RADIO_ON) ?
1438 "enable" : "disable",
1439 tpacpi_rfkill_names[id]);
1440 res = (tpacpi_rfkill_switches[id]->ops->set_status)(status);
1441 tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
1442 }
1443
1444 return res;
1445 }
1446
1447
1448
1449
1450
1451
1452 static ssize_t interface_version_show(struct device_driver *drv, char *buf)
1453 {
1454 return snprintf(buf, PAGE_SIZE, "0x%08x\n", TPACPI_SYSFS_VERSION);
1455 }
1456 static DRIVER_ATTR_RO(interface_version);
1457
1458
1459 static ssize_t debug_level_show(struct device_driver *drv, char *buf)
1460 {
1461 return snprintf(buf, PAGE_SIZE, "0x%04x\n", dbg_level);
1462 }
1463
1464 static ssize_t debug_level_store(struct device_driver *drv, const char *buf,
1465 size_t count)
1466 {
1467 unsigned long t;
1468
1469 if (parse_strtoul(buf, 0xffff, &t))
1470 return -EINVAL;
1471
1472 dbg_level = t;
1473
1474 return count;
1475 }
1476 static DRIVER_ATTR_RW(debug_level);
1477
1478
1479 static ssize_t version_show(struct device_driver *drv, char *buf)
1480 {
1481 return snprintf(buf, PAGE_SIZE, "%s v%s\n",
1482 TPACPI_DESC, TPACPI_VERSION);
1483 }
1484 static DRIVER_ATTR_RO(version);
1485
1486
1487
1488 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
1489
1490
1491 static ssize_t wlsw_emulstate_show(struct device_driver *drv, char *buf)
1492 {
1493 return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wlsw_emulstate);
1494 }
1495
1496 static ssize_t wlsw_emulstate_store(struct device_driver *drv, const char *buf,
1497 size_t count)
1498 {
1499 unsigned long t;
1500
1501 if (parse_strtoul(buf, 1, &t))
1502 return -EINVAL;
1503
1504 if (tpacpi_wlsw_emulstate != !!t) {
1505 tpacpi_wlsw_emulstate = !!t;
1506 tpacpi_rfk_update_hwblock_state(!t);
1507 }
1508
1509 return count;
1510 }
1511 static DRIVER_ATTR_RW(wlsw_emulstate);
1512
1513
1514 static ssize_t bluetooth_emulstate_show(struct device_driver *drv, char *buf)
1515 {
1516 return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_bluetooth_emulstate);
1517 }
1518
1519 static ssize_t bluetooth_emulstate_store(struct device_driver *drv,
1520 const char *buf, size_t count)
1521 {
1522 unsigned long t;
1523
1524 if (parse_strtoul(buf, 1, &t))
1525 return -EINVAL;
1526
1527 tpacpi_bluetooth_emulstate = !!t;
1528
1529 return count;
1530 }
1531 static DRIVER_ATTR_RW(bluetooth_emulstate);
1532
1533
1534 static ssize_t wwan_emulstate_show(struct device_driver *drv, char *buf)
1535 {
1536 return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wwan_emulstate);
1537 }
1538
1539 static ssize_t wwan_emulstate_store(struct device_driver *drv, const char *buf,
1540 size_t count)
1541 {
1542 unsigned long t;
1543
1544 if (parse_strtoul(buf, 1, &t))
1545 return -EINVAL;
1546
1547 tpacpi_wwan_emulstate = !!t;
1548
1549 return count;
1550 }
1551 static DRIVER_ATTR_RW(wwan_emulstate);
1552
1553
1554 static ssize_t uwb_emulstate_show(struct device_driver *drv, char *buf)
1555 {
1556 return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_uwb_emulstate);
1557 }
1558
1559 static ssize_t uwb_emulstate_store(struct device_driver *drv, const char *buf,
1560 size_t count)
1561 {
1562 unsigned long t;
1563
1564 if (parse_strtoul(buf, 1, &t))
1565 return -EINVAL;
1566
1567 tpacpi_uwb_emulstate = !!t;
1568
1569 return count;
1570 }
1571 static DRIVER_ATTR_RW(uwb_emulstate);
1572 #endif
1573
1574
1575
1576 static struct driver_attribute *tpacpi_driver_attributes[] = {
1577 &driver_attr_debug_level, &driver_attr_version,
1578 &driver_attr_interface_version,
1579 };
1580
1581 static int __init tpacpi_create_driver_attributes(struct device_driver *drv)
1582 {
1583 int i, res;
1584
1585 i = 0;
1586 res = 0;
1587 while (!res && i < ARRAY_SIZE(tpacpi_driver_attributes)) {
1588 res = driver_create_file(drv, tpacpi_driver_attributes[i]);
1589 i++;
1590 }
1591
1592 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
1593 if (!res && dbg_wlswemul)
1594 res = driver_create_file(drv, &driver_attr_wlsw_emulstate);
1595 if (!res && dbg_bluetoothemul)
1596 res = driver_create_file(drv, &driver_attr_bluetooth_emulstate);
1597 if (!res && dbg_wwanemul)
1598 res = driver_create_file(drv, &driver_attr_wwan_emulstate);
1599 if (!res && dbg_uwbemul)
1600 res = driver_create_file(drv, &driver_attr_uwb_emulstate);
1601 #endif
1602
1603 return res;
1604 }
1605
1606 static void tpacpi_remove_driver_attributes(struct device_driver *drv)
1607 {
1608 int i;
1609
1610 for (i = 0; i < ARRAY_SIZE(tpacpi_driver_attributes); i++)
1611 driver_remove_file(drv, tpacpi_driver_attributes[i]);
1612
1613 #ifdef THINKPAD_ACPI_DEBUGFACILITIES
1614 driver_remove_file(drv, &driver_attr_wlsw_emulstate);
1615 driver_remove_file(drv, &driver_attr_bluetooth_emulstate);
1616 driver_remove_file(drv, &driver_attr_wwan_emulstate);
1617 driver_remove_file(drv, &driver_attr_uwb_emulstate);
1618 #endif
1619 }
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646 #define TPV_Q(__v, __id1, __id2, __bv1, __bv2) \
1647 { .vendor = (__v), \
1648 .bios = TPID(__id1, __id2), \
1649 .ec = TPACPI_MATCH_ANY, \
1650 .quirks = TPACPI_MATCH_ANY_VERSION << 16 \
1651 | TPVER(__bv1, __bv2) }
1652
1653 #define TPV_Q_X(__v, __bid1, __bid2, __bv1, __bv2, \
1654 __eid, __ev1, __ev2) \
1655 { .vendor = (__v), \
1656 .bios = TPID(__bid1, __bid2), \
1657 .ec = __eid, \
1658 .quirks = TPVER(__ev1, __ev2) << 16 \
1659 | TPVER(__bv1, __bv2) }
1660
1661 #define TPV_QI0(__id1, __id2, __bv1, __bv2) \
1662 TPV_Q(PCI_VENDOR_ID_IBM, __id1, __id2, __bv1, __bv2)
1663
1664
1665 #define TPV_QI1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
1666 TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2, \
1667 __bv1, __bv2, TPID(__id1, __id2), \
1668 __ev1, __ev2), \
1669 TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2, \
1670 __bv1, __bv2, TPACPI_MATCH_UNKNOWN, \
1671 __ev1, __ev2)
1672
1673
1674 #define TPV_QI2(__bid1, __bid2, __bv1, __bv2, \
1675 __eid1, __eid2, __ev1, __ev2) \
1676 TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2, \
1677 __bv1, __bv2, TPID(__eid1, __eid2), \
1678 __ev1, __ev2), \
1679 TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2, \
1680 __bv1, __bv2, TPACPI_MATCH_UNKNOWN, \
1681 __ev1, __ev2)
1682
1683 #define TPV_QL0(__id1, __id2, __bv1, __bv2) \
1684 TPV_Q(PCI_VENDOR_ID_LENOVO, __id1, __id2, __bv1, __bv2)
1685
1686 #define TPV_QL1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
1687 TPV_Q_X(PCI_VENDOR_ID_LENOVO, __id1, __id2, \
1688 __bv1, __bv2, TPID(__id1, __id2), \
1689 __ev1, __ev2)
1690
1691 #define TPV_QL2(__bid1, __bid2, __bv1, __bv2, \
1692 __eid1, __eid2, __ev1, __ev2) \
1693 TPV_Q_X(PCI_VENDOR_ID_LENOVO, __bid1, __bid2, \
1694 __bv1, __bv2, TPID(__eid1, __eid2), \
1695 __ev1, __ev2)
1696
1697 static const struct tpacpi_quirk tpacpi_bios_version_qtable[] __initconst = {
1698
1699
1700 TPV_QI0('I', 'M', '6', '5'),
1701 TPV_QI0('I', 'U', '2', '6'),
1702 TPV_QI0('I', 'B', '5', '4'),
1703 TPV_QI0('I', 'H', '4', '7'),
1704 TPV_QI0('I', 'N', '3', '6'),
1705 TPV_QI0('I', 'T', '5', '5'),
1706 TPV_QI0('I', 'D', '4', '8'),
1707 TPV_QI0('I', 'I', '4', '2'),
1708 TPV_QI0('I', 'O', '2', '3'),
1709
1710
1711
1712 TPV_QI0('I', 'W', '5', '9'),
1713 TPV_QI0('I', 'V', '6', '9'),
1714 TPV_QI0('1', '0', '2', '6'),
1715 TPV_QI0('K', 'U', '3', '6'),
1716 TPV_QI0('K', 'X', '3', '6'),
1717 TPV_QI0('K', 'Y', '3', '8'),
1718 TPV_QI0('1', 'B', '1', '7'),
1719 TPV_QI0('1', '3', '2', '0'),
1720 TPV_QI0('1', 'E', '7', '3'),
1721 TPV_QI1('1', 'G', '4', '1', '1', '7'),
1722 TPV_QI1('1', 'N', '1', '6', '0', '7'),
1723
1724
1725
1726 TPV_QI0('1', 'T', 'A', '6'),
1727 TPV_QI0('1', 'X', '5', '7'),
1728
1729
1730
1731 TPV_QI0('1', 'C', 'F', '0'),
1732 TPV_QI0('1', 'F', 'F', '1'),
1733 TPV_QI0('1', 'M', '9', '7'),
1734 TPV_QI0('1', 'O', '6', '1'),
1735 TPV_QI0('1', 'P', '6', '5'),
1736 TPV_QI0('1', 'S', '7', '0'),
1737 TPV_QI1('1', 'R', 'D', 'R', '7', '1'),
1738
1739 TPV_QI1('1', 'V', '7', '1', '2', '8'),
1740 TPV_QI1('7', '8', '7', '1', '0', '6'),
1741 TPV_QI1('7', '6', '6', '9', '1', '6'),
1742 TPV_QI1('7', '0', '6', '9', '2', '8'),
1743
1744 TPV_QI0('I', 'Y', '6', '1'),
1745 TPV_QI0('K', 'Z', '3', '4'),
1746 TPV_QI0('1', '6', '3', '2'),
1747 TPV_QI1('1', 'A', '6', '4', '2', '3'),
1748 TPV_QI1('1', 'I', '7', '1', '2', '0'),
1749 TPV_QI1('1', 'Y', '6', '5', '2', '9'),
1750
1751 TPV_QL1('7', '9', 'E', '3', '5', '0'),
1752 TPV_QL1('7', 'C', 'D', '2', '2', '2'),
1753 TPV_QL1('7', 'E', 'D', '0', '1', '5'),
1754
1755
1756 TPV_QI2('1', 'W', '9', '0', '1', 'V', '2', '8'),
1757 TPV_QL2('7', 'I', '3', '4', '7', '9', '5', '0'),
1758
1759
1760
1761 TPV_QI0('I', 'Z', '9', 'D'),
1762 TPV_QI0('1', 'D', '7', '0'),
1763 TPV_QI1('1', 'K', '4', '8', '1', '8'),
1764 TPV_QI1('1', 'Q', '9', '7', '2', '3'),
1765 TPV_QI1('1', 'U', 'D', '3', 'B', '2'),
1766 TPV_QI1('7', '4', '6', '4', '2', '7'),
1767 TPV_QI1('7', '5', '6', '0', '2', '0'),
1768
1769 TPV_QL1('7', 'B', 'D', '7', '4', '0'),
1770 TPV_QL1('7', 'J', '3', '0', '1', '3'),
1771
1772
1773
1774 };
1775
1776 #undef TPV_QL1
1777 #undef TPV_QL0
1778 #undef TPV_QI2
1779 #undef TPV_QI1
1780 #undef TPV_QI0
1781 #undef TPV_Q_X
1782 #undef TPV_Q
1783
1784 static void __init tpacpi_check_outdated_fw(void)
1785 {
1786 unsigned long fwvers;
1787 u16 ec_version, bios_version;
1788
1789 fwvers = tpacpi_check_quirks(tpacpi_bios_version_qtable,
1790 ARRAY_SIZE(tpacpi_bios_version_qtable));
1791
1792 if (!fwvers)
1793 return;
1794
1795 bios_version = fwvers & 0xffffU;
1796 ec_version = (fwvers >> 16) & 0xffffU;
1797
1798
1799 if ((bios_version > thinkpad_id.bios_release) ||
1800 (ec_version > thinkpad_id.ec_release &&
1801 ec_version != TPACPI_MATCH_ANY_VERSION)) {
1802
1803
1804
1805
1806
1807
1808
1809 pr_warn("WARNING: Outdated ThinkPad BIOS/EC firmware\n");
1810 pr_warn("WARNING: This firmware may be missing critical bug fixes and/or important features\n");
1811 }
1812 }
1813
1814 static bool __init tpacpi_is_fw_known(void)
1815 {
1816 return tpacpi_check_quirks(tpacpi_bios_version_qtable,
1817 ARRAY_SIZE(tpacpi_bios_version_qtable)) != 0;
1818 }
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832 static int thinkpad_acpi_driver_read(struct seq_file *m)
1833 {
1834 seq_printf(m, "driver:\t\t%s\n", TPACPI_DESC);
1835 seq_printf(m, "version:\t%s\n", TPACPI_VERSION);
1836 return 0;
1837 }
1838
1839 static struct ibm_struct thinkpad_acpi_driver_data = {
1840 .name = "driver",
1841 .read = thinkpad_acpi_driver_read,
1842 };
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869 enum {
1870 TP_ACPI_HOTKEYSCAN_FNF1 = 0,
1871 TP_ACPI_HOTKEYSCAN_FNF2,
1872 TP_ACPI_HOTKEYSCAN_FNF3,
1873 TP_ACPI_HOTKEYSCAN_FNF4,
1874 TP_ACPI_HOTKEYSCAN_FNF5,
1875 TP_ACPI_HOTKEYSCAN_FNF6,
1876 TP_ACPI_HOTKEYSCAN_FNF7,
1877 TP_ACPI_HOTKEYSCAN_FNF8,
1878 TP_ACPI_HOTKEYSCAN_FNF9,
1879 TP_ACPI_HOTKEYSCAN_FNF10,
1880 TP_ACPI_HOTKEYSCAN_FNF11,
1881 TP_ACPI_HOTKEYSCAN_FNF12,
1882 TP_ACPI_HOTKEYSCAN_FNBACKSPACE,
1883 TP_ACPI_HOTKEYSCAN_FNINSERT,
1884 TP_ACPI_HOTKEYSCAN_FNDELETE,
1885 TP_ACPI_HOTKEYSCAN_FNHOME,
1886 TP_ACPI_HOTKEYSCAN_FNEND,
1887 TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1888 TP_ACPI_HOTKEYSCAN_FNPAGEDOWN,
1889 TP_ACPI_HOTKEYSCAN_FNSPACE,
1890 TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1891 TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1892 TP_ACPI_HOTKEYSCAN_MUTE,
1893 TP_ACPI_HOTKEYSCAN_THINKPAD,
1894 TP_ACPI_HOTKEYSCAN_UNK1,
1895 TP_ACPI_HOTKEYSCAN_UNK2,
1896 TP_ACPI_HOTKEYSCAN_UNK3,
1897 TP_ACPI_HOTKEYSCAN_UNK4,
1898 TP_ACPI_HOTKEYSCAN_UNK5,
1899 TP_ACPI_HOTKEYSCAN_UNK6,
1900 TP_ACPI_HOTKEYSCAN_UNK7,
1901 TP_ACPI_HOTKEYSCAN_UNK8,
1902
1903
1904 TP_ACPI_HOTKEYSCAN_ADAPTIVE_START,
1905 TP_ACPI_HOTKEYSCAN_MUTE2 = TP_ACPI_HOTKEYSCAN_ADAPTIVE_START,
1906 TP_ACPI_HOTKEYSCAN_BRIGHTNESS_ZERO,
1907 TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL,
1908 TP_ACPI_HOTKEYSCAN_CLOUD,
1909 TP_ACPI_HOTKEYSCAN_UNK9,
1910 TP_ACPI_HOTKEYSCAN_VOICE,
1911 TP_ACPI_HOTKEYSCAN_UNK10,
1912 TP_ACPI_HOTKEYSCAN_GESTURES,
1913 TP_ACPI_HOTKEYSCAN_UNK11,
1914 TP_ACPI_HOTKEYSCAN_UNK12,
1915 TP_ACPI_HOTKEYSCAN_UNK13,
1916 TP_ACPI_HOTKEYSCAN_CONFIG,
1917 TP_ACPI_HOTKEYSCAN_NEW_TAB,
1918 TP_ACPI_HOTKEYSCAN_RELOAD,
1919 TP_ACPI_HOTKEYSCAN_BACK,
1920 TP_ACPI_HOTKEYSCAN_MIC_DOWN,
1921 TP_ACPI_HOTKEYSCAN_MIC_UP,
1922 TP_ACPI_HOTKEYSCAN_MIC_CANCELLATION,
1923 TP_ACPI_HOTKEYSCAN_CAMERA_MODE,
1924 TP_ACPI_HOTKEYSCAN_ROTATE_DISPLAY,
1925
1926
1927 TP_ACPI_HOTKEYSCAN_EXTENDED_START,
1928
1929 TP_ACPI_HOTKEYSCAN_STAR = 69,
1930 TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL2,
1931 TP_ACPI_HOTKEYSCAN_CALCULATOR,
1932 TP_ACPI_HOTKEYSCAN_BLUETOOTH,
1933 TP_ACPI_HOTKEYSCAN_KEYBOARD,
1934
1935
1936 TPACPI_HOTKEY_MAP_LEN
1937 };
1938
1939 enum {
1940 TPACPI_HKEY_NVRAM_KNOWN_MASK = 0x00fb88c0U,
1941 TPACPI_HKEY_NVRAM_GOOD_MASK = 0x00fb8000U,
1942 };
1943
1944 enum {
1945 TP_ACPI_HKEY_DISPSWTCH_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNF7,
1946 TP_ACPI_HKEY_DISPXPAND_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNF8,
1947 TP_ACPI_HKEY_HIBERNATE_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNF12,
1948 TP_ACPI_HKEY_BRGHTUP_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNHOME,
1949 TP_ACPI_HKEY_BRGHTDWN_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNEND,
1950 TP_ACPI_HKEY_KBD_LIGHT_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1951 TP_ACPI_HKEY_ZOOM_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNSPACE,
1952 TP_ACPI_HKEY_VOLUP_MASK = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1953 TP_ACPI_HKEY_VOLDWN_MASK = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1954 TP_ACPI_HKEY_MUTE_MASK = 1 << TP_ACPI_HOTKEYSCAN_MUTE,
1955 TP_ACPI_HKEY_THINKPAD_MASK = 1 << TP_ACPI_HOTKEYSCAN_THINKPAD,
1956 };
1957
1958 enum {
1959 TP_NVRAM_HKEY_GROUP_HK2 = TP_ACPI_HKEY_THINKPAD_MASK |
1960 TP_ACPI_HKEY_ZOOM_MASK |
1961 TP_ACPI_HKEY_DISPSWTCH_MASK |
1962 TP_ACPI_HKEY_HIBERNATE_MASK,
1963 TP_NVRAM_HKEY_GROUP_BRIGHTNESS = TP_ACPI_HKEY_BRGHTUP_MASK |
1964 TP_ACPI_HKEY_BRGHTDWN_MASK,
1965 TP_NVRAM_HKEY_GROUP_VOLUME = TP_ACPI_HKEY_VOLUP_MASK |
1966 TP_ACPI_HKEY_VOLDWN_MASK |
1967 TP_ACPI_HKEY_MUTE_MASK,
1968 };
1969
1970 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1971 struct tp_nvram_state {
1972 u16 thinkpad_toggle:1;
1973 u16 zoom_toggle:1;
1974 u16 display_toggle:1;
1975 u16 thinklight_toggle:1;
1976 u16 hibernate_toggle:1;
1977 u16 displayexp_toggle:1;
1978 u16 display_state:1;
1979 u16 brightness_toggle:1;
1980 u16 volume_toggle:1;
1981 u16 mute:1;
1982
1983 u8 brightness_level;
1984 u8 volume_level;
1985 };
1986
1987
1988 static struct task_struct *tpacpi_hotkey_task;
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999 static struct mutex hotkey_thread_data_mutex;
2000 static unsigned int hotkey_config_change;
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012 static u32 hotkey_source_mask;
2013 static unsigned int hotkey_poll_freq = 10;
2014
2015 #define HOTKEY_CONFIG_CRITICAL_START \
2016 do { \
2017 mutex_lock(&hotkey_thread_data_mutex); \
2018 hotkey_config_change++; \
2019 } while (0);
2020 #define HOTKEY_CONFIG_CRITICAL_END \
2021 mutex_unlock(&hotkey_thread_data_mutex);
2022
2023 #else
2024
2025 #define hotkey_source_mask 0U
2026 #define HOTKEY_CONFIG_CRITICAL_START
2027 #define HOTKEY_CONFIG_CRITICAL_END
2028
2029 #endif
2030
2031 static struct mutex hotkey_mutex;
2032
2033 static enum {
2034 TP_ACPI_WAKEUP_NONE = 0,
2035 TP_ACPI_WAKEUP_BAYEJ,
2036 TP_ACPI_WAKEUP_UNDOCK,
2037 } hotkey_wakeup_reason;
2038
2039 static int hotkey_autosleep_ack;
2040
2041 static u32 hotkey_orig_mask;
2042 static u32 hotkey_all_mask;
2043 static u32 hotkey_adaptive_all_mask;
2044 static u32 hotkey_reserved_mask;
2045 static u32 hotkey_driver_mask;
2046 static u32 hotkey_user_mask;
2047 static u32 hotkey_acpi_mask;
2048
2049 static u16 *hotkey_keycode_map;
2050
2051 static struct attribute_set *hotkey_dev_attributes;
2052
2053 static void tpacpi_driver_event(const unsigned int hkey_event);
2054 static void hotkey_driver_event(const unsigned int scancode);
2055 static void hotkey_poll_setup(const bool may_warn);
2056
2057
2058 #define TP_HOTKEY_TABLET_MASK (1 << 3)
2059 enum {
2060 TP_ACPI_MULTI_MODE_INVALID = 0,
2061 TP_ACPI_MULTI_MODE_UNKNOWN = 1 << 0,
2062 TP_ACPI_MULTI_MODE_LAPTOP = 1 << 1,
2063 TP_ACPI_MULTI_MODE_TABLET = 1 << 2,
2064 TP_ACPI_MULTI_MODE_FLAT = 1 << 3,
2065 TP_ACPI_MULTI_MODE_STAND = 1 << 4,
2066 TP_ACPI_MULTI_MODE_TENT = 1 << 5,
2067 TP_ACPI_MULTI_MODE_STAND_TENT = 1 << 6,
2068 };
2069
2070 enum {
2071
2072
2073
2074
2075
2076 TP_ACPI_MULTI_MODE_TABLET_LIKE = TP_ACPI_MULTI_MODE_TABLET |
2077 TP_ACPI_MULTI_MODE_STAND |
2078 TP_ACPI_MULTI_MODE_TENT |
2079 TP_ACPI_MULTI_MODE_STAND_TENT,
2080 };
2081
2082 static int hotkey_get_wlsw(void)
2083 {
2084 int status;
2085
2086 if (!tp_features.hotkey_wlsw)
2087 return -ENODEV;
2088
2089 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
2090 if (dbg_wlswemul)
2091 return (tpacpi_wlsw_emulstate) ?
2092 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
2093 #endif
2094
2095 if (!acpi_evalf(hkey_handle, &status, "WLSW", "d"))
2096 return -EIO;
2097
2098 return (status) ? TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
2099 }
2100
2101 static int hotkey_gmms_get_tablet_mode(int s, int *has_tablet_mode)
2102 {
2103 int type = (s >> 16) & 0xffff;
2104 int value = s & 0xffff;
2105 int mode = TP_ACPI_MULTI_MODE_INVALID;
2106 int valid_modes = 0;
2107
2108 if (has_tablet_mode)
2109 *has_tablet_mode = 0;
2110
2111 switch (type) {
2112 case 1:
2113 valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2114 TP_ACPI_MULTI_MODE_TABLET |
2115 TP_ACPI_MULTI_MODE_STAND_TENT;
2116 break;
2117 case 2:
2118 valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2119 TP_ACPI_MULTI_MODE_FLAT |
2120 TP_ACPI_MULTI_MODE_TABLET |
2121 TP_ACPI_MULTI_MODE_STAND |
2122 TP_ACPI_MULTI_MODE_TENT;
2123 break;
2124 case 3:
2125 valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2126 TP_ACPI_MULTI_MODE_FLAT;
2127 break;
2128 case 4:
2129 case 5:
2130
2131
2132
2133 valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2134 TP_ACPI_MULTI_MODE_FLAT |
2135 TP_ACPI_MULTI_MODE_TABLET |
2136 TP_ACPI_MULTI_MODE_STAND |
2137 TP_ACPI_MULTI_MODE_TENT;
2138 break;
2139 default:
2140 pr_err("Unknown multi mode status type %d with value 0x%04X, please report this to %s\n",
2141 type, value, TPACPI_MAIL);
2142 return 0;
2143 }
2144
2145 if (has_tablet_mode && (valid_modes & TP_ACPI_MULTI_MODE_TABLET_LIKE))
2146 *has_tablet_mode = 1;
2147
2148 switch (value) {
2149 case 1:
2150 mode = TP_ACPI_MULTI_MODE_LAPTOP;
2151 break;
2152 case 2:
2153 mode = TP_ACPI_MULTI_MODE_FLAT;
2154 break;
2155 case 3:
2156 mode = TP_ACPI_MULTI_MODE_TABLET;
2157 break;
2158 case 4:
2159 if (type == 1)
2160 mode = TP_ACPI_MULTI_MODE_STAND_TENT;
2161 else
2162 mode = TP_ACPI_MULTI_MODE_STAND;
2163 break;
2164 case 5:
2165 mode = TP_ACPI_MULTI_MODE_TENT;
2166 break;
2167 default:
2168 if (type == 5 && value == 0xffff) {
2169 pr_warn("Multi mode status is undetected, assuming laptop\n");
2170 return 0;
2171 }
2172 }
2173
2174 if (!(mode & valid_modes)) {
2175 pr_err("Unknown/reserved multi mode value 0x%04X for type %d, please report this to %s\n",
2176 value, type, TPACPI_MAIL);
2177 return 0;
2178 }
2179
2180 return !!(mode & TP_ACPI_MULTI_MODE_TABLET_LIKE);
2181 }
2182
2183 static int hotkey_get_tablet_mode(int *status)
2184 {
2185 int s;
2186
2187 switch (tp_features.hotkey_tablet) {
2188 case TP_HOTKEY_TABLET_USES_MHKG:
2189 if (!acpi_evalf(hkey_handle, &s, "MHKG", "d"))
2190 return -EIO;
2191
2192 *status = ((s & TP_HOTKEY_TABLET_MASK) != 0);
2193 break;
2194 case TP_HOTKEY_TABLET_USES_GMMS:
2195 if (!acpi_evalf(hkey_handle, &s, "GMMS", "dd", 0))
2196 return -EIO;
2197
2198 *status = hotkey_gmms_get_tablet_mode(s, NULL);
2199 break;
2200 default:
2201 break;
2202 }
2203
2204 return 0;
2205 }
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215 static int hotkey_mask_get(void)
2216 {
2217 if (tp_features.hotkey_mask) {
2218 u32 m = 0;
2219
2220 if (!acpi_evalf(hkey_handle, &m, "DHKN", "d"))
2221 return -EIO;
2222
2223 hotkey_acpi_mask = m;
2224 } else {
2225
2226 hotkey_acpi_mask = hotkey_all_mask;
2227 }
2228
2229
2230 hotkey_user_mask &= (hotkey_acpi_mask | hotkey_source_mask);
2231
2232 return 0;
2233 }
2234
2235 static void hotkey_mask_warn_incomplete_mask(void)
2236 {
2237
2238 const u32 wantedmask = hotkey_driver_mask &
2239 ~(hotkey_acpi_mask | hotkey_source_mask) &
2240 (hotkey_all_mask | TPACPI_HKEY_NVRAM_KNOWN_MASK);
2241
2242 if (wantedmask)
2243 pr_notice("required events 0x%08x not enabled!\n", wantedmask);
2244 }
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255 static int hotkey_mask_set(u32 mask)
2256 {
2257 int i;
2258 int rc = 0;
2259
2260 const u32 fwmask = mask & ~hotkey_source_mask;
2261
2262 if (tp_features.hotkey_mask) {
2263 for (i = 0; i < 32; i++) {
2264 if (!acpi_evalf(hkey_handle,
2265 NULL, "MHKM", "vdd", i + 1,
2266 !!(mask & (1 << i)))) {
2267 rc = -EIO;
2268 break;
2269 }
2270 }
2271 }
2272
2273
2274
2275
2276
2277
2278
2279
2280 if (!hotkey_mask_get() && !rc && (fwmask & ~hotkey_acpi_mask)) {
2281 pr_notice("asked for hotkey mask 0x%08x, but firmware forced it to 0x%08x\n",
2282 fwmask, hotkey_acpi_mask);
2283 }
2284
2285 if (tpacpi_lifecycle != TPACPI_LIFE_EXITING)
2286 hotkey_mask_warn_incomplete_mask();
2287
2288 return rc;
2289 }
2290
2291
2292
2293
2294
2295
2296 static int hotkey_user_mask_set(const u32 mask)
2297 {
2298 int rc;
2299
2300
2301
2302 if (!tp_warned.hotkey_mask_ff &&
2303 (mask == 0xffff || mask == 0xffffff ||
2304 mask == 0xffffffff)) {
2305 tp_warned.hotkey_mask_ff = 1;
2306 pr_notice("setting the hotkey mask to 0x%08x is likely not the best way to go about it\n",
2307 mask);
2308 pr_notice("please consider using the driver defaults, and refer to up-to-date thinkpad-acpi documentation\n");
2309 }
2310
2311
2312
2313 rc = hotkey_mask_set((mask | hotkey_driver_mask) & ~hotkey_source_mask);
2314
2315
2316 hotkey_user_mask = mask & (hotkey_acpi_mask | hotkey_source_mask);
2317
2318 return rc;
2319 }
2320
2321
2322
2323
2324
2325
2326 static int tpacpi_hotkey_driver_mask_set(const u32 mask)
2327 {
2328 int rc;
2329
2330
2331 if (!tp_features.hotkey) {
2332 hotkey_driver_mask = mask;
2333 return 0;
2334 }
2335
2336 mutex_lock(&hotkey_mutex);
2337
2338 HOTKEY_CONFIG_CRITICAL_START
2339 hotkey_driver_mask = mask;
2340 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2341 hotkey_source_mask |= (mask & ~hotkey_all_mask);
2342 #endif
2343 HOTKEY_CONFIG_CRITICAL_END
2344
2345 rc = hotkey_mask_set((hotkey_acpi_mask | hotkey_driver_mask) &
2346 ~hotkey_source_mask);
2347 hotkey_poll_setup(true);
2348
2349 mutex_unlock(&hotkey_mutex);
2350
2351 return rc;
2352 }
2353
2354 static int hotkey_status_get(int *status)
2355 {
2356 if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
2357 return -EIO;
2358
2359 return 0;
2360 }
2361
2362 static int hotkey_status_set(bool enable)
2363 {
2364 if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", enable ? 1 : 0))
2365 return -EIO;
2366
2367 return 0;
2368 }
2369
2370 static void tpacpi_input_send_tabletsw(void)
2371 {
2372 int state;
2373
2374 if (tp_features.hotkey_tablet &&
2375 !hotkey_get_tablet_mode(&state)) {
2376 mutex_lock(&tpacpi_inputdev_send_mutex);
2377
2378 input_report_switch(tpacpi_inputdev,
2379 SW_TABLET_MODE, !!state);
2380 input_sync(tpacpi_inputdev);
2381
2382 mutex_unlock(&tpacpi_inputdev_send_mutex);
2383 }
2384 }
2385
2386
2387 static void tpacpi_input_send_key(const unsigned int scancode)
2388 {
2389 const unsigned int keycode = hotkey_keycode_map[scancode];
2390
2391 if (keycode != KEY_RESERVED) {
2392 mutex_lock(&tpacpi_inputdev_send_mutex);
2393
2394 input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
2395 input_report_key(tpacpi_inputdev, keycode, 1);
2396 input_sync(tpacpi_inputdev);
2397
2398 input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
2399 input_report_key(tpacpi_inputdev, keycode, 0);
2400 input_sync(tpacpi_inputdev);
2401
2402 mutex_unlock(&tpacpi_inputdev_send_mutex);
2403 }
2404 }
2405
2406
2407 static void tpacpi_input_send_key_masked(const unsigned int scancode)
2408 {
2409 hotkey_driver_event(scancode);
2410 if (hotkey_user_mask & (1 << scancode))
2411 tpacpi_input_send_key(scancode);
2412 }
2413
2414 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2415 static struct tp_acpi_drv_struct ibm_hotkey_acpidriver;
2416
2417
2418 static void tpacpi_hotkey_send_key(unsigned int scancode)
2419 {
2420 tpacpi_input_send_key_masked(scancode);
2421 }
2422
2423 static void hotkey_read_nvram(struct tp_nvram_state *n, const u32 m)
2424 {
2425 u8 d;
2426
2427 if (m & TP_NVRAM_HKEY_GROUP_HK2) {
2428 d = nvram_read_byte(TP_NVRAM_ADDR_HK2);
2429 n->thinkpad_toggle = !!(d & TP_NVRAM_MASK_HKT_THINKPAD);
2430 n->zoom_toggle = !!(d & TP_NVRAM_MASK_HKT_ZOOM);
2431 n->display_toggle = !!(d & TP_NVRAM_MASK_HKT_DISPLAY);
2432 n->hibernate_toggle = !!(d & TP_NVRAM_MASK_HKT_HIBERNATE);
2433 }
2434 if (m & TP_ACPI_HKEY_KBD_LIGHT_MASK) {
2435 d = nvram_read_byte(TP_NVRAM_ADDR_THINKLIGHT);
2436 n->thinklight_toggle = !!(d & TP_NVRAM_MASK_THINKLIGHT);
2437 }
2438 if (m & TP_ACPI_HKEY_DISPXPAND_MASK) {
2439 d = nvram_read_byte(TP_NVRAM_ADDR_VIDEO);
2440 n->displayexp_toggle =
2441 !!(d & TP_NVRAM_MASK_HKT_DISPEXPND);
2442 }
2443 if (m & TP_NVRAM_HKEY_GROUP_BRIGHTNESS) {
2444 d = nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS);
2445 n->brightness_level = (d & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
2446 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
2447 n->brightness_toggle =
2448 !!(d & TP_NVRAM_MASK_HKT_BRIGHTNESS);
2449 }
2450 if (m & TP_NVRAM_HKEY_GROUP_VOLUME) {
2451 d = nvram_read_byte(TP_NVRAM_ADDR_MIXER);
2452 n->volume_level = (d & TP_NVRAM_MASK_LEVEL_VOLUME)
2453 >> TP_NVRAM_POS_LEVEL_VOLUME;
2454 n->mute = !!(d & TP_NVRAM_MASK_MUTE);
2455 n->volume_toggle = !!(d & TP_NVRAM_MASK_HKT_VOLUME);
2456 }
2457 }
2458
2459 #define TPACPI_COMPARE_KEY(__scancode, __member) \
2460 do { \
2461 if ((event_mask & (1 << __scancode)) && \
2462 oldn->__member != newn->__member) \
2463 tpacpi_hotkey_send_key(__scancode); \
2464 } while (0)
2465
2466 #define TPACPI_MAY_SEND_KEY(__scancode) \
2467 do { \
2468 if (event_mask & (1 << __scancode)) \
2469 tpacpi_hotkey_send_key(__scancode); \
2470 } while (0)
2471
2472 static void issue_volchange(const unsigned int oldvol,
2473 const unsigned int newvol,
2474 const u32 event_mask)
2475 {
2476 unsigned int i = oldvol;
2477
2478 while (i > newvol) {
2479 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
2480 i--;
2481 }
2482 while (i < newvol) {
2483 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2484 i++;
2485 }
2486 }
2487
2488 static void issue_brightnesschange(const unsigned int oldbrt,
2489 const unsigned int newbrt,
2490 const u32 event_mask)
2491 {
2492 unsigned int i = oldbrt;
2493
2494 while (i > newbrt) {
2495 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
2496 i--;
2497 }
2498 while (i < newbrt) {
2499 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
2500 i++;
2501 }
2502 }
2503
2504 static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn,
2505 struct tp_nvram_state *newn,
2506 const u32 event_mask)
2507 {
2508
2509 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_THINKPAD, thinkpad_toggle);
2510 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNSPACE, zoom_toggle);
2511 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF7, display_toggle);
2512 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF12, hibernate_toggle);
2513
2514 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNPAGEUP, thinklight_toggle);
2515
2516 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF8, displayexp_toggle);
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535 if (newn->mute) {
2536
2537 if (!oldn->mute ||
2538 oldn->volume_toggle != newn->volume_toggle ||
2539 oldn->volume_level != newn->volume_level) {
2540
2541
2542 issue_volchange(oldn->volume_level, newn->volume_level,
2543 event_mask);
2544 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE);
2545 }
2546 } else {
2547
2548 if (oldn->mute) {
2549
2550 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2551 }
2552 if (oldn->volume_level != newn->volume_level) {
2553 issue_volchange(oldn->volume_level, newn->volume_level,
2554 event_mask);
2555 } else if (oldn->volume_toggle != newn->volume_toggle) {
2556
2557 if (newn->volume_level == 0)
2558 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
2559 else if (newn->volume_level >= TP_NVRAM_LEVEL_VOLUME_MAX)
2560 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2561 }
2562 }
2563
2564
2565 if (oldn->brightness_level != newn->brightness_level) {
2566 issue_brightnesschange(oldn->brightness_level,
2567 newn->brightness_level, event_mask);
2568 } else if (oldn->brightness_toggle != newn->brightness_toggle) {
2569
2570 if (newn->brightness_level == 0)
2571 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
2572 else if (newn->brightness_level >= bright_maxlvl
2573 && !tp_features.bright_unkfw)
2574 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
2575 }
2576
2577 #undef TPACPI_COMPARE_KEY
2578 #undef TPACPI_MAY_SEND_KEY
2579 }
2580
2581
2582
2583
2584
2585
2586
2587
2588 static int hotkey_kthread(void *data)
2589 {
2590 struct tp_nvram_state s[2];
2591 u32 poll_mask, event_mask;
2592 unsigned int si, so;
2593 unsigned long t;
2594 unsigned int change_detector;
2595 unsigned int poll_freq;
2596 bool was_frozen;
2597
2598 if (tpacpi_lifecycle == TPACPI_LIFE_EXITING)
2599 goto exit;
2600
2601 set_freezable();
2602
2603 so = 0;
2604 si = 1;
2605 t = 0;
2606
2607
2608 mutex_lock(&hotkey_thread_data_mutex);
2609 change_detector = hotkey_config_change;
2610 poll_mask = hotkey_source_mask;
2611 event_mask = hotkey_source_mask &
2612 (hotkey_driver_mask | hotkey_user_mask);
2613 poll_freq = hotkey_poll_freq;
2614 mutex_unlock(&hotkey_thread_data_mutex);
2615 hotkey_read_nvram(&s[so], poll_mask);
2616
2617 while (!kthread_should_stop()) {
2618 if (t == 0) {
2619 if (likely(poll_freq))
2620 t = 1000/poll_freq;
2621 else
2622 t = 100;
2623 }
2624 t = msleep_interruptible(t);
2625 if (unlikely(kthread_freezable_should_stop(&was_frozen)))
2626 break;
2627
2628 if (t > 0 && !was_frozen)
2629 continue;
2630
2631 mutex_lock(&hotkey_thread_data_mutex);
2632 if (was_frozen || hotkey_config_change != change_detector) {
2633
2634 si = so;
2635 t = 0;
2636 change_detector = hotkey_config_change;
2637 }
2638 poll_mask = hotkey_source_mask;
2639 event_mask = hotkey_source_mask &
2640 (hotkey_driver_mask | hotkey_user_mask);
2641 poll_freq = hotkey_poll_freq;
2642 mutex_unlock(&hotkey_thread_data_mutex);
2643
2644 if (likely(poll_mask)) {
2645 hotkey_read_nvram(&s[si], poll_mask);
2646 if (likely(si != so)) {
2647 hotkey_compare_and_issue_event(&s[so], &s[si],
2648 event_mask);
2649 }
2650 }
2651
2652 so = si;
2653 si ^= 1;
2654 }
2655
2656 exit:
2657 return 0;
2658 }
2659
2660
2661 static void hotkey_poll_stop_sync(void)
2662 {
2663 if (tpacpi_hotkey_task) {
2664 kthread_stop(tpacpi_hotkey_task);
2665 tpacpi_hotkey_task = NULL;
2666 }
2667 }
2668
2669
2670 static void hotkey_poll_setup(const bool may_warn)
2671 {
2672 const u32 poll_driver_mask = hotkey_driver_mask & hotkey_source_mask;
2673 const u32 poll_user_mask = hotkey_user_mask & hotkey_source_mask;
2674
2675 if (hotkey_poll_freq > 0 &&
2676 (poll_driver_mask ||
2677 (poll_user_mask && tpacpi_inputdev->users > 0))) {
2678 if (!tpacpi_hotkey_task) {
2679 tpacpi_hotkey_task = kthread_run(hotkey_kthread,
2680 NULL, TPACPI_NVRAM_KTHREAD_NAME);
2681 if (IS_ERR(tpacpi_hotkey_task)) {
2682 tpacpi_hotkey_task = NULL;
2683 pr_err("could not create kernel thread for hotkey polling\n");
2684 }
2685 }
2686 } else {
2687 hotkey_poll_stop_sync();
2688 if (may_warn && (poll_driver_mask || poll_user_mask) &&
2689 hotkey_poll_freq == 0) {
2690 pr_notice("hot keys 0x%08x and/or events 0x%08x require polling, which is currently disabled\n",
2691 poll_user_mask, poll_driver_mask);
2692 }
2693 }
2694 }
2695
2696 static void hotkey_poll_setup_safe(const bool may_warn)
2697 {
2698 mutex_lock(&hotkey_mutex);
2699 hotkey_poll_setup(may_warn);
2700 mutex_unlock(&hotkey_mutex);
2701 }
2702
2703
2704 static void hotkey_poll_set_freq(unsigned int freq)
2705 {
2706 if (!freq)
2707 hotkey_poll_stop_sync();
2708
2709 hotkey_poll_freq = freq;
2710 }
2711
2712 #else
2713
2714 static void hotkey_poll_setup(const bool __unused)
2715 {
2716 }
2717
2718 static void hotkey_poll_setup_safe(const bool __unused)
2719 {
2720 }
2721
2722 #endif
2723
2724 static int hotkey_inputdev_open(struct input_dev *dev)
2725 {
2726 switch (tpacpi_lifecycle) {
2727 case TPACPI_LIFE_INIT:
2728 case TPACPI_LIFE_RUNNING:
2729 hotkey_poll_setup_safe(false);
2730 return 0;
2731 case TPACPI_LIFE_EXITING:
2732 return -EBUSY;
2733 }
2734
2735
2736 BUG();
2737 return -EBUSY;
2738 }
2739
2740 static void hotkey_inputdev_close(struct input_dev *dev)
2741 {
2742
2743 if (tpacpi_lifecycle != TPACPI_LIFE_EXITING &&
2744 !(hotkey_source_mask & hotkey_driver_mask))
2745 hotkey_poll_setup_safe(false);
2746 }
2747
2748
2749 static ssize_t hotkey_enable_show(struct device *dev,
2750 struct device_attribute *attr,
2751 char *buf)
2752 {
2753 int res, status;
2754
2755 printk_deprecated_attribute("hotkey_enable",
2756 "Hotkey reporting is always enabled");
2757
2758 res = hotkey_status_get(&status);
2759 if (res)
2760 return res;
2761
2762 return snprintf(buf, PAGE_SIZE, "%d\n", status);
2763 }
2764
2765 static ssize_t hotkey_enable_store(struct device *dev,
2766 struct device_attribute *attr,
2767 const char *buf, size_t count)
2768 {
2769 unsigned long t;
2770
2771 printk_deprecated_attribute("hotkey_enable",
2772 "Hotkeys can be disabled through hotkey_mask");
2773
2774 if (parse_strtoul(buf, 1, &t))
2775 return -EINVAL;
2776
2777 if (t == 0)
2778 return -EPERM;
2779
2780 return count;
2781 }
2782
2783 static DEVICE_ATTR_RW(hotkey_enable);
2784
2785
2786 static ssize_t hotkey_mask_show(struct device *dev,
2787 struct device_attribute *attr,
2788 char *buf)
2789 {
2790 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_user_mask);
2791 }
2792
2793 static ssize_t hotkey_mask_store(struct device *dev,
2794 struct device_attribute *attr,
2795 const char *buf, size_t count)
2796 {
2797 unsigned long t;
2798 int res;
2799
2800 if (parse_strtoul(buf, 0xffffffffUL, &t))
2801 return -EINVAL;
2802
2803 if (mutex_lock_killable(&hotkey_mutex))
2804 return -ERESTARTSYS;
2805
2806 res = hotkey_user_mask_set(t);
2807
2808 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2809 hotkey_poll_setup(true);
2810 #endif
2811
2812 mutex_unlock(&hotkey_mutex);
2813
2814 tpacpi_disclose_usertask("hotkey_mask", "set to 0x%08lx\n", t);
2815
2816 return (res) ? res : count;
2817 }
2818
2819 static DEVICE_ATTR_RW(hotkey_mask);
2820
2821
2822 static ssize_t hotkey_bios_enabled_show(struct device *dev,
2823 struct device_attribute *attr,
2824 char *buf)
2825 {
2826 return sprintf(buf, "0\n");
2827 }
2828
2829 static DEVICE_ATTR_RO(hotkey_bios_enabled);
2830
2831
2832 static ssize_t hotkey_bios_mask_show(struct device *dev,
2833 struct device_attribute *attr,
2834 char *buf)
2835 {
2836 printk_deprecated_attribute("hotkey_bios_mask",
2837 "This attribute is useless.");
2838 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask);
2839 }
2840
2841 static DEVICE_ATTR_RO(hotkey_bios_mask);
2842
2843
2844 static ssize_t hotkey_all_mask_show(struct device *dev,
2845 struct device_attribute *attr,
2846 char *buf)
2847 {
2848 return snprintf(buf, PAGE_SIZE, "0x%08x\n",
2849 hotkey_all_mask | hotkey_source_mask);
2850 }
2851
2852 static DEVICE_ATTR_RO(hotkey_all_mask);
2853
2854
2855 static ssize_t hotkey_adaptive_all_mask_show(struct device *dev,
2856 struct device_attribute *attr,
2857 char *buf)
2858 {
2859 return snprintf(buf, PAGE_SIZE, "0x%08x\n",
2860 hotkey_adaptive_all_mask | hotkey_source_mask);
2861 }
2862
2863 static DEVICE_ATTR_RO(hotkey_adaptive_all_mask);
2864
2865
2866 static ssize_t hotkey_recommended_mask_show(struct device *dev,
2867 struct device_attribute *attr,
2868 char *buf)
2869 {
2870 return snprintf(buf, PAGE_SIZE, "0x%08x\n",
2871 (hotkey_all_mask | hotkey_source_mask)
2872 & ~hotkey_reserved_mask);
2873 }
2874
2875 static DEVICE_ATTR_RO(hotkey_recommended_mask);
2876
2877 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2878
2879
2880 static ssize_t hotkey_source_mask_show(struct device *dev,
2881 struct device_attribute *attr,
2882 char *buf)
2883 {
2884 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_source_mask);
2885 }
2886
2887 static ssize_t hotkey_source_mask_store(struct device *dev,
2888 struct device_attribute *attr,
2889 const char *buf, size_t count)
2890 {
2891 unsigned long t;
2892 u32 r_ev;
2893 int rc;
2894
2895 if (parse_strtoul(buf, 0xffffffffUL, &t) ||
2896 ((t & ~TPACPI_HKEY_NVRAM_KNOWN_MASK) != 0))
2897 return -EINVAL;
2898
2899 if (mutex_lock_killable(&hotkey_mutex))
2900 return -ERESTARTSYS;
2901
2902 HOTKEY_CONFIG_CRITICAL_START
2903 hotkey_source_mask = t;
2904 HOTKEY_CONFIG_CRITICAL_END
2905
2906 rc = hotkey_mask_set((hotkey_user_mask | hotkey_driver_mask) &
2907 ~hotkey_source_mask);
2908 hotkey_poll_setup(true);
2909
2910
2911 r_ev = hotkey_driver_mask & ~(hotkey_acpi_mask & hotkey_all_mask)
2912 & ~hotkey_source_mask & TPACPI_HKEY_NVRAM_KNOWN_MASK;
2913
2914 mutex_unlock(&hotkey_mutex);
2915
2916 if (rc < 0)
2917 pr_err("hotkey_source_mask: failed to update the firmware event mask!\n");
2918
2919 if (r_ev)
2920 pr_notice("hotkey_source_mask: some important events were disabled: 0x%04x\n",
2921 r_ev);
2922
2923 tpacpi_disclose_usertask("hotkey_source_mask", "set to 0x%08lx\n", t);
2924
2925 return (rc < 0) ? rc : count;
2926 }
2927
2928 static DEVICE_ATTR_RW(hotkey_source_mask);
2929
2930
2931 static ssize_t hotkey_poll_freq_show(struct device *dev,
2932 struct device_attribute *attr,
2933 char *buf)
2934 {
2935 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_poll_freq);
2936 }
2937
2938 static ssize_t hotkey_poll_freq_store(struct device *dev,
2939 struct device_attribute *attr,
2940 const char *buf, size_t count)
2941 {
2942 unsigned long t;
2943
2944 if (parse_strtoul(buf, 25, &t))
2945 return -EINVAL;
2946
2947 if (mutex_lock_killable(&hotkey_mutex))
2948 return -ERESTARTSYS;
2949
2950 hotkey_poll_set_freq(t);
2951 hotkey_poll_setup(true);
2952
2953 mutex_unlock(&hotkey_mutex);
2954
2955 tpacpi_disclose_usertask("hotkey_poll_freq", "set to %lu\n", t);
2956
2957 return count;
2958 }
2959
2960 static DEVICE_ATTR_RW(hotkey_poll_freq);
2961
2962 #endif
2963
2964
2965 static ssize_t hotkey_radio_sw_show(struct device *dev,
2966 struct device_attribute *attr,
2967 char *buf)
2968 {
2969 int res;
2970 res = hotkey_get_wlsw();
2971 if (res < 0)
2972 return res;
2973
2974
2975 tpacpi_rfk_update_hwblock_state((res == TPACPI_RFK_RADIO_OFF));
2976
2977 return snprintf(buf, PAGE_SIZE, "%d\n",
2978 (res == TPACPI_RFK_RADIO_OFF) ? 0 : 1);
2979 }
2980
2981 static DEVICE_ATTR_RO(hotkey_radio_sw);
2982
2983 static void hotkey_radio_sw_notify_change(void)
2984 {
2985 if (tp_features.hotkey_wlsw)
2986 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
2987 "hotkey_radio_sw");
2988 }
2989
2990
2991 static ssize_t hotkey_tablet_mode_show(struct device *dev,
2992 struct device_attribute *attr,
2993 char *buf)
2994 {
2995 int res, s;
2996 res = hotkey_get_tablet_mode(&s);
2997 if (res < 0)
2998 return res;
2999
3000 return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
3001 }
3002
3003 static DEVICE_ATTR_RO(hotkey_tablet_mode);
3004
3005 static void hotkey_tablet_mode_notify_change(void)
3006 {
3007 if (tp_features.hotkey_tablet)
3008 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
3009 "hotkey_tablet_mode");
3010 }
3011
3012
3013 static ssize_t hotkey_wakeup_reason_show(struct device *dev,
3014 struct device_attribute *attr,
3015 char *buf)
3016 {
3017 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_wakeup_reason);
3018 }
3019
3020 static DEVICE_ATTR(wakeup_reason, S_IRUGO, hotkey_wakeup_reason_show, NULL);
3021
3022 static void hotkey_wakeup_reason_notify_change(void)
3023 {
3024 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
3025 "wakeup_reason");
3026 }
3027
3028
3029 static ssize_t hotkey_wakeup_hotunplug_complete_show(struct device *dev,
3030 struct device_attribute *attr,
3031 char *buf)
3032 {
3033 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_autosleep_ack);
3034 }
3035
3036 static DEVICE_ATTR(wakeup_hotunplug_complete, S_IRUGO,
3037 hotkey_wakeup_hotunplug_complete_show, NULL);
3038
3039 static void hotkey_wakeup_hotunplug_complete_notify_change(void)
3040 {
3041 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
3042 "wakeup_hotunplug_complete");
3043 }
3044
3045
3046
3047 static int adaptive_keyboard_get_mode(void);
3048 static int adaptive_keyboard_set_mode(int new_mode);
3049
3050 enum ADAPTIVE_KEY_MODE {
3051 HOME_MODE,
3052 WEB_BROWSER_MODE,
3053 WEB_CONFERENCE_MODE,
3054 FUNCTION_MODE,
3055 LAYFLAT_MODE
3056 };
3057
3058 static ssize_t adaptive_kbd_mode_show(struct device *dev,
3059 struct device_attribute *attr,
3060 char *buf)
3061 {
3062 int current_mode;
3063
3064 current_mode = adaptive_keyboard_get_mode();
3065 if (current_mode < 0)
3066 return current_mode;
3067
3068 return snprintf(buf, PAGE_SIZE, "%d\n", current_mode);
3069 }
3070
3071 static ssize_t adaptive_kbd_mode_store(struct device *dev,
3072 struct device_attribute *attr,
3073 const char *buf, size_t count)
3074 {
3075 unsigned long t;
3076 int res;
3077
3078 if (parse_strtoul(buf, LAYFLAT_MODE, &t))
3079 return -EINVAL;
3080
3081 res = adaptive_keyboard_set_mode(t);
3082 return (res < 0) ? res : count;
3083 }
3084
3085 static DEVICE_ATTR_RW(adaptive_kbd_mode);
3086
3087 static struct attribute *adaptive_kbd_attributes[] = {
3088 &dev_attr_adaptive_kbd_mode.attr,
3089 NULL
3090 };
3091
3092 static const struct attribute_group adaptive_kbd_attr_group = {
3093 .attrs = adaptive_kbd_attributes,
3094 };
3095
3096
3097
3098 static struct attribute *hotkey_attributes[] __initdata = {
3099 &dev_attr_hotkey_enable.attr,
3100 &dev_attr_hotkey_bios_enabled.attr,
3101 &dev_attr_hotkey_bios_mask.attr,
3102 &dev_attr_wakeup_reason.attr,
3103 &dev_attr_wakeup_hotunplug_complete.attr,
3104 &dev_attr_hotkey_mask.attr,
3105 &dev_attr_hotkey_all_mask.attr,
3106 &dev_attr_hotkey_adaptive_all_mask.attr,
3107 &dev_attr_hotkey_recommended_mask.attr,
3108 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3109 &dev_attr_hotkey_source_mask.attr,
3110 &dev_attr_hotkey_poll_freq.attr,
3111 #endif
3112 };
3113
3114
3115
3116
3117 static void tpacpi_send_radiosw_update(void)
3118 {
3119 int wlsw;
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132 wlsw = hotkey_get_wlsw();
3133
3134
3135 if (wlsw == TPACPI_RFK_RADIO_OFF)
3136 tpacpi_rfk_update_hwblock_state(true);
3137
3138
3139 tpacpi_rfk_update_swstate_all();
3140
3141
3142 if (wlsw == TPACPI_RFK_RADIO_ON)
3143 tpacpi_rfk_update_hwblock_state(false);
3144
3145
3146 if (!(wlsw < 0)) {
3147 mutex_lock(&tpacpi_inputdev_send_mutex);
3148
3149 input_report_switch(tpacpi_inputdev,
3150 SW_RFKILL_ALL, (wlsw > 0));
3151 input_sync(tpacpi_inputdev);
3152
3153 mutex_unlock(&tpacpi_inputdev_send_mutex);
3154 }
3155
3156
3157
3158
3159
3160 hotkey_radio_sw_notify_change();
3161 }
3162
3163 static void hotkey_exit(void)
3164 {
3165 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3166 mutex_lock(&hotkey_mutex);
3167 hotkey_poll_stop_sync();
3168 mutex_unlock(&hotkey_mutex);
3169 #endif
3170
3171 if (hotkey_dev_attributes)
3172 delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
3173
3174 dbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_HKEY,
3175 "restoring original HKEY status and mask\n");
3176
3177
3178 if (((tp_features.hotkey_mask &&
3179 hotkey_mask_set(hotkey_orig_mask)) |
3180 hotkey_status_set(false)) != 0)
3181 pr_err("failed to restore hot key mask to BIOS defaults\n");
3182 }
3183
3184 static void __init hotkey_unmap(const unsigned int scancode)
3185 {
3186 if (hotkey_keycode_map[scancode] != KEY_RESERVED) {
3187 clear_bit(hotkey_keycode_map[scancode],
3188 tpacpi_inputdev->keybit);
3189 hotkey_keycode_map[scancode] = KEY_RESERVED;
3190 }
3191 }
3192
3193
3194
3195
3196
3197
3198 #define TPACPI_HK_Q_INIMASK 0x0001
3199
3200 static const struct tpacpi_quirk tpacpi_hotkey_qtable[] __initconst = {
3201 TPACPI_Q_IBM('I', 'H', TPACPI_HK_Q_INIMASK),
3202 TPACPI_Q_IBM('I', 'N', TPACPI_HK_Q_INIMASK),
3203 TPACPI_Q_IBM('I', 'D', TPACPI_HK_Q_INIMASK),
3204 TPACPI_Q_IBM('I', 'W', TPACPI_HK_Q_INIMASK),
3205 TPACPI_Q_IBM('I', 'V', TPACPI_HK_Q_INIMASK),
3206 TPACPI_Q_IBM('1', '0', TPACPI_HK_Q_INIMASK),
3207 TPACPI_Q_IBM('K', 'U', TPACPI_HK_Q_INIMASK),
3208 TPACPI_Q_IBM('K', 'X', TPACPI_HK_Q_INIMASK),
3209 TPACPI_Q_IBM('K', 'Y', TPACPI_HK_Q_INIMASK),
3210 TPACPI_Q_IBM('1', 'B', TPACPI_HK_Q_INIMASK),
3211 TPACPI_Q_IBM('1', '3', TPACPI_HK_Q_INIMASK),
3212 TPACPI_Q_IBM('1', 'E', TPACPI_HK_Q_INIMASK),
3213 TPACPI_Q_IBM('1', 'C', TPACPI_HK_Q_INIMASK),
3214 TPACPI_Q_IBM('1', 'F', TPACPI_HK_Q_INIMASK),
3215 TPACPI_Q_IBM('I', 'Y', TPACPI_HK_Q_INIMASK),
3216 TPACPI_Q_IBM('K', 'Z', TPACPI_HK_Q_INIMASK),
3217 TPACPI_Q_IBM('1', '6', TPACPI_HK_Q_INIMASK),
3218 TPACPI_Q_IBM('I', 'Z', TPACPI_HK_Q_INIMASK),
3219 TPACPI_Q_IBM('1', 'D', TPACPI_HK_Q_INIMASK),
3220 };
3221
3222 typedef u16 tpacpi_keymap_entry_t;
3223 typedef tpacpi_keymap_entry_t tpacpi_keymap_t[TPACPI_HOTKEY_MAP_LEN];
3224
3225 static int hotkey_init_tablet_mode(void)
3226 {
3227 int in_tablet_mode = 0, res;
3228 char *type = NULL;
3229
3230 if (acpi_evalf(hkey_handle, &res, "GMMS", "qdd", 0)) {
3231 int has_tablet_mode;
3232
3233 in_tablet_mode = hotkey_gmms_get_tablet_mode(res,
3234 &has_tablet_mode);
3235 if (has_tablet_mode)
3236 tp_features.hotkey_tablet = TP_HOTKEY_TABLET_USES_GMMS;
3237 type = "GMMS";
3238 } else if (acpi_evalf(hkey_handle, &res, "MHKG", "qd")) {
3239
3240 tp_features.hotkey_tablet = TP_HOTKEY_TABLET_USES_MHKG;
3241 in_tablet_mode = !!(res & TP_HOTKEY_TABLET_MASK);
3242 type = "MHKG";
3243 }
3244
3245 if (!tp_features.hotkey_tablet)
3246 return 0;
3247
3248 pr_info("Tablet mode switch found (type: %s), currently in %s mode\n",
3249 type, in_tablet_mode ? "tablet" : "laptop");
3250
3251 res = add_to_attr_set(hotkey_dev_attributes,
3252 &dev_attr_hotkey_tablet_mode.attr);
3253 if (res)
3254 return -1;
3255
3256 return in_tablet_mode;
3257 }
3258
3259 static int __init hotkey_init(struct ibm_init_struct *iibm)
3260 {
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291 enum keymap_index {
3292 TPACPI_KEYMAP_IBM_GENERIC = 0,
3293 TPACPI_KEYMAP_LENOVO_GENERIC,
3294 };
3295
3296 static const tpacpi_keymap_t tpacpi_keymaps[] __initconst = {
3297
3298 [TPACPI_KEYMAP_IBM_GENERIC] = {
3299
3300 KEY_FN_F1, KEY_BATTERY, KEY_COFFEE, KEY_SLEEP,
3301 KEY_WLAN, KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
3302 KEY_FN_F9, KEY_FN_F10, KEY_FN_F11, KEY_SUSPEND,
3303
3304
3305 KEY_UNKNOWN,
3306 KEY_UNKNOWN,
3307 KEY_UNKNOWN,
3308
3309
3310 KEY_RESERVED,
3311 KEY_RESERVED,
3312
3313
3314 KEY_RESERVED,
3315
3316 KEY_UNKNOWN,
3317 KEY_ZOOM,
3318
3319
3320
3321
3322 KEY_RESERVED,
3323 KEY_RESERVED,
3324 KEY_RESERVED,
3325
3326 KEY_VENDOR,
3327
3328
3329 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3330 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3331
3332
3333 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3334 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3335 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3336 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3337 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3338
3339
3340 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3341 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3342 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3343 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3344 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3345 KEY_UNKNOWN, KEY_UNKNOWN
3346
3347 },
3348
3349
3350 [TPACPI_KEYMAP_LENOVO_GENERIC] = {
3351
3352 KEY_FN_F1, KEY_COFFEE, KEY_BATTERY, KEY_SLEEP,
3353 KEY_WLAN, KEY_CAMERA, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
3354 KEY_FN_F9, KEY_FN_F10, KEY_FN_F11, KEY_SUSPEND,
3355
3356
3357 KEY_UNKNOWN,
3358 KEY_UNKNOWN,
3359 KEY_UNKNOWN,
3360
3361
3362
3363
3364 KEY_BRIGHTNESSUP,
3365 KEY_BRIGHTNESSDOWN,
3366
3367 KEY_RESERVED,
3368
3369 KEY_UNKNOWN,
3370 KEY_ZOOM,
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383 KEY_RESERVED,
3384 KEY_RESERVED,
3385 KEY_RESERVED,
3386
3387 KEY_VENDOR,
3388
3389
3390 KEY_UNKNOWN, KEY_UNKNOWN,
3391
3392
3393
3394
3395
3396 KEY_MICMUTE,
3397
3398
3399 KEY_UNKNOWN,
3400
3401
3402 KEY_CONFIG, KEY_SEARCH, KEY_SCALE, KEY_FILE,
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412 KEY_RESERVED,
3413 KEY_BRIGHTNESS_MIN,
3414 KEY_RESERVED,
3415 KEY_RESERVED,
3416 KEY_RESERVED,
3417 KEY_VOICECOMMAND,
3418 KEY_RESERVED,
3419 KEY_RESERVED,
3420 KEY_RESERVED,
3421 KEY_RESERVED,
3422 KEY_RESERVED,
3423 KEY_CONFIG,
3424 KEY_RESERVED,
3425 KEY_REFRESH,
3426 KEY_BACK,
3427 KEY_RESERVED,
3428 KEY_RESERVED,
3429 KEY_RESERVED,
3430 KEY_RESERVED,
3431 KEY_RESERVED,
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3445 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3446 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3447 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3448 KEY_UNKNOWN,
3449
3450 KEY_BOOKMARKS,
3451 KEY_RESERVED,
3452 KEY_CALC,
3453 KEY_BLUETOOTH,
3454 KEY_KEYBOARD
3455 },
3456 };
3457
3458 static const struct tpacpi_quirk tpacpi_keymap_qtable[] __initconst = {
3459
3460 {
3461 .vendor = PCI_VENDOR_ID_IBM,
3462 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
3463 .quirks = TPACPI_KEYMAP_IBM_GENERIC,
3464 },
3465 {
3466 .vendor = PCI_VENDOR_ID_LENOVO,
3467 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
3468 .quirks = TPACPI_KEYMAP_LENOVO_GENERIC,
3469 },
3470 };
3471
3472 #define TPACPI_HOTKEY_MAP_SIZE sizeof(tpacpi_keymap_t)
3473 #define TPACPI_HOTKEY_MAP_TYPESIZE sizeof(tpacpi_keymap_entry_t)
3474
3475 int res, i;
3476 int status;
3477 int hkeyv;
3478 bool radiosw_state = false;
3479 bool tabletsw_state = false;
3480
3481 unsigned long quirks;
3482 unsigned long keymap_id;
3483
3484 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3485 "initializing hotkey subdriver\n");
3486
3487 BUG_ON(!tpacpi_inputdev);
3488 BUG_ON(tpacpi_inputdev->open != NULL ||
3489 tpacpi_inputdev->close != NULL);
3490
3491 TPACPI_ACPIHANDLE_INIT(hkey);
3492 mutex_init(&hotkey_mutex);
3493
3494 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3495 mutex_init(&hotkey_thread_data_mutex);
3496 #endif
3497
3498
3499 tp_features.hotkey = hkey_handle != NULL;
3500
3501 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3502 "hotkeys are %s\n",
3503 str_supported(tp_features.hotkey));
3504
3505 if (!tp_features.hotkey)
3506 return 1;
3507
3508 quirks = tpacpi_check_quirks(tpacpi_hotkey_qtable,
3509 ARRAY_SIZE(tpacpi_hotkey_qtable));
3510
3511 tpacpi_disable_brightness_delay();
3512
3513
3514
3515 hotkey_dev_attributes = create_attr_set(
3516 ARRAY_SIZE(hotkey_attributes) + 2,
3517 NULL);
3518 if (!hotkey_dev_attributes)
3519 return -ENOMEM;
3520 res = add_many_to_attr_set(hotkey_dev_attributes,
3521 hotkey_attributes,
3522 ARRAY_SIZE(hotkey_attributes));
3523 if (res)
3524 goto err_exit;
3525
3526
3527
3528
3529 if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) {
3530 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3531 "firmware HKEY interface version: 0x%x\n",
3532 hkeyv);
3533
3534 switch (hkeyv >> 8) {
3535 case 1:
3536
3537
3538
3539
3540
3541
3542 if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
3543 "MHKA", "qd")) {
3544 pr_err("missing MHKA handler, please report this to %s\n",
3545 TPACPI_MAIL);
3546
3547 hotkey_all_mask = 0x080cU;
3548 } else {
3549 tp_features.hotkey_mask = 1;
3550 }
3551 break;
3552
3553 case 2:
3554
3555
3556
3557
3558
3559 if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
3560 "MHKA", "dd", 1)) {
3561 pr_err("missing MHKA handler, please report this to %s\n",
3562 TPACPI_MAIL);
3563
3564 hotkey_all_mask = 0x080cU;
3565 } else {
3566 tp_features.hotkey_mask = 1;
3567 }
3568
3569
3570
3571
3572
3573 if (acpi_evalf(hkey_handle, &hotkey_adaptive_all_mask,
3574 "MHKA", "dd", 2)) {
3575 if (hotkey_adaptive_all_mask != 0) {
3576 tp_features.has_adaptive_kbd = true;
3577 res = sysfs_create_group(
3578 &tpacpi_pdev->dev.kobj,
3579 &adaptive_kbd_attr_group);
3580 if (res)
3581 goto err_exit;
3582 }
3583 } else {
3584 tp_features.has_adaptive_kbd = false;
3585 hotkey_adaptive_all_mask = 0x0U;
3586 }
3587 break;
3588
3589 default:
3590 pr_err("unknown version of the HKEY interface: 0x%x\n",
3591 hkeyv);
3592 pr_err("please report this to %s\n", TPACPI_MAIL);
3593 break;
3594 }
3595 }
3596
3597 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3598 "hotkey masks are %s\n",
3599 str_supported(tp_features.hotkey_mask));
3600
3601
3602 if (!tp_features.hotkey_mask && !hotkey_all_mask &&
3603 (quirks & TPACPI_HK_Q_INIMASK))
3604 hotkey_all_mask = 0x080cU;
3605
3606
3607 if (tp_features.hotkey_mask) {
3608
3609
3610 res = hotkey_mask_get();
3611 if (res)
3612 goto err_exit;
3613
3614 hotkey_orig_mask = hotkey_acpi_mask;
3615 } else {
3616 hotkey_orig_mask = hotkey_all_mask;
3617 hotkey_acpi_mask = hotkey_all_mask;
3618 }
3619
3620 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
3621 if (dbg_wlswemul) {
3622 tp_features.hotkey_wlsw = 1;
3623 radiosw_state = !!tpacpi_wlsw_emulstate;
3624 pr_info("radio switch emulation enabled\n");
3625 } else
3626 #endif
3627
3628 if (acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
3629 tp_features.hotkey_wlsw = 1;
3630 radiosw_state = !!status;
3631 pr_info("radio switch found; radios are %s\n",
3632 enabled(status, 0));
3633 }
3634 if (tp_features.hotkey_wlsw)
3635 res = add_to_attr_set(hotkey_dev_attributes,
3636 &dev_attr_hotkey_radio_sw.attr);
3637
3638 res = hotkey_init_tablet_mode();
3639 if (res < 0)
3640 goto err_exit;
3641
3642 tabletsw_state = res;
3643
3644 res = register_attr_set_with_sysfs(hotkey_dev_attributes,
3645 &tpacpi_pdev->dev.kobj);
3646 if (res)
3647 goto err_exit;
3648
3649
3650 keymap_id = tpacpi_check_quirks(tpacpi_keymap_qtable,
3651 ARRAY_SIZE(tpacpi_keymap_qtable));
3652 BUG_ON(keymap_id >= ARRAY_SIZE(tpacpi_keymaps));
3653 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3654 "using keymap number %lu\n", keymap_id);
3655
3656 hotkey_keycode_map = kmemdup(&tpacpi_keymaps[keymap_id],
3657 TPACPI_HOTKEY_MAP_SIZE, GFP_KERNEL);
3658 if (!hotkey_keycode_map) {
3659 pr_err("failed to allocate memory for key map\n");
3660 res = -ENOMEM;
3661 goto err_exit;
3662 }
3663
3664 input_set_capability(tpacpi_inputdev, EV_MSC, MSC_SCAN);
3665 tpacpi_inputdev->keycodesize = TPACPI_HOTKEY_MAP_TYPESIZE;
3666 tpacpi_inputdev->keycodemax = TPACPI_HOTKEY_MAP_LEN;
3667 tpacpi_inputdev->keycode = hotkey_keycode_map;
3668 for (i = 0; i < TPACPI_HOTKEY_MAP_LEN; i++) {
3669 if (hotkey_keycode_map[i] != KEY_RESERVED) {
3670 input_set_capability(tpacpi_inputdev, EV_KEY,
3671 hotkey_keycode_map[i]);
3672 } else {
3673 if (i < sizeof(hotkey_reserved_mask)*8)
3674 hotkey_reserved_mask |= 1 << i;
3675 }
3676 }
3677
3678 if (tp_features.hotkey_wlsw) {
3679 input_set_capability(tpacpi_inputdev, EV_SW, SW_RFKILL_ALL);
3680 input_report_switch(tpacpi_inputdev,
3681 SW_RFKILL_ALL, radiosw_state);
3682 }
3683 if (tp_features.hotkey_tablet) {
3684 input_set_capability(tpacpi_inputdev, EV_SW, SW_TABLET_MODE);
3685 input_report_switch(tpacpi_inputdev,
3686 SW_TABLET_MODE, tabletsw_state);
3687 }
3688
3689
3690
3691
3692 if (acpi_video_get_backlight_type() != acpi_backlight_vendor) {
3693 pr_info("This ThinkPad has standard ACPI backlight brightness control, supported by the ACPI video driver\n");
3694 pr_notice("Disabling thinkpad-acpi brightness events by default...\n");
3695
3696
3697
3698
3699 hotkey_reserved_mask |=
3700 (1 << TP_ACPI_HOTKEYSCAN_FNHOME)
3701 | (1 << TP_ACPI_HOTKEYSCAN_FNEND);
3702 hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNHOME);
3703 hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNEND);
3704 }
3705
3706 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3707 hotkey_source_mask = TPACPI_HKEY_NVRAM_GOOD_MASK
3708 & ~hotkey_all_mask
3709 & ~hotkey_reserved_mask;
3710
3711 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3712 "hotkey source mask 0x%08x, polling freq %u\n",
3713 hotkey_source_mask, hotkey_poll_freq);
3714 #endif
3715
3716 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3717 "enabling firmware HKEY event interface...\n");
3718 res = hotkey_status_set(true);
3719 if (res) {
3720 hotkey_exit();
3721 return res;
3722 }
3723 res = hotkey_mask_set(((hotkey_all_mask & ~hotkey_reserved_mask)
3724 | hotkey_driver_mask)
3725 & ~hotkey_source_mask);
3726 if (res < 0 && res != -ENXIO) {
3727 hotkey_exit();
3728 return res;
3729 }
3730 hotkey_user_mask = (hotkey_acpi_mask | hotkey_source_mask)
3731 & ~hotkey_reserved_mask;
3732 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3733 "initial masks: user=0x%08x, fw=0x%08x, poll=0x%08x\n",
3734 hotkey_user_mask, hotkey_acpi_mask, hotkey_source_mask);
3735
3736 tpacpi_inputdev->open = &hotkey_inputdev_open;
3737 tpacpi_inputdev->close = &hotkey_inputdev_close;
3738
3739 hotkey_poll_setup_safe(true);
3740
3741 return 0;
3742
3743 err_exit:
3744 delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
3745 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
3746 &adaptive_kbd_attr_group);
3747
3748 hotkey_dev_attributes = NULL;
3749
3750 return (res < 0) ? res : 1;
3751 }
3752
3753
3754
3755
3756
3757
3758
3759
3760 static const int adaptive_keyboard_modes[] = {
3761 HOME_MODE,
3762
3763
3764 FUNCTION_MODE
3765 };
3766
3767 #define DFR_CHANGE_ROW 0x101
3768 #define DFR_SHOW_QUICKVIEW_ROW 0x102
3769 #define FIRST_ADAPTIVE_KEY 0x103
3770
3771
3772
3773
3774 static bool adaptive_keyboard_mode_is_saved;
3775 static int adaptive_keyboard_prev_mode;
3776
3777 static int adaptive_keyboard_get_mode(void)
3778 {
3779 int mode = 0;
3780
3781 if (!acpi_evalf(hkey_handle, &mode, "GTRW", "dd", 0)) {
3782 pr_err("Cannot read adaptive keyboard mode\n");
3783 return -EIO;
3784 }
3785
3786 return mode;
3787 }
3788
3789 static int adaptive_keyboard_set_mode(int new_mode)
3790 {
3791 if (new_mode < 0 ||
3792 new_mode > LAYFLAT_MODE)
3793 return -EINVAL;
3794
3795 if (!acpi_evalf(hkey_handle, NULL, "STRW", "vd", new_mode)) {
3796 pr_err("Cannot set adaptive keyboard mode\n");
3797 return -EIO;
3798 }
3799
3800 return 0;
3801 }
3802
3803 static int adaptive_keyboard_get_next_mode(int mode)
3804 {
3805 size_t i;
3806 size_t max_mode = ARRAY_SIZE(adaptive_keyboard_modes) - 1;
3807
3808 for (i = 0; i <= max_mode; i++) {
3809 if (adaptive_keyboard_modes[i] == mode)
3810 break;
3811 }
3812
3813 if (i >= max_mode)
3814 i = 0;
3815 else
3816 i++;
3817
3818 return adaptive_keyboard_modes[i];
3819 }
3820
3821 static bool adaptive_keyboard_hotkey_notify_hotkey(unsigned int scancode)
3822 {
3823 int current_mode = 0;
3824 int new_mode = 0;
3825 int keycode;
3826
3827 switch (scancode) {
3828 case DFR_CHANGE_ROW:
3829 if (adaptive_keyboard_mode_is_saved) {
3830 new_mode = adaptive_keyboard_prev_mode;
3831 adaptive_keyboard_mode_is_saved = false;
3832 } else {
3833 current_mode = adaptive_keyboard_get_mode();
3834 if (current_mode < 0)
3835 return false;
3836 new_mode = adaptive_keyboard_get_next_mode(
3837 current_mode);
3838 }
3839
3840 if (adaptive_keyboard_set_mode(new_mode) < 0)
3841 return false;
3842
3843 return true;
3844
3845 case DFR_SHOW_QUICKVIEW_ROW:
3846 current_mode = adaptive_keyboard_get_mode();
3847 if (current_mode < 0)
3848 return false;
3849
3850 adaptive_keyboard_prev_mode = current_mode;
3851 adaptive_keyboard_mode_is_saved = true;
3852
3853 if (adaptive_keyboard_set_mode (FUNCTION_MODE) < 0)
3854 return false;
3855 return true;
3856
3857 default:
3858 if (scancode < FIRST_ADAPTIVE_KEY ||
3859 scancode >= FIRST_ADAPTIVE_KEY +
3860 TP_ACPI_HOTKEYSCAN_EXTENDED_START -
3861 TP_ACPI_HOTKEYSCAN_ADAPTIVE_START) {
3862 pr_info("Unhandled adaptive keyboard key: 0x%x\n",
3863 scancode);
3864 return false;
3865 }
3866 keycode = hotkey_keycode_map[scancode - FIRST_ADAPTIVE_KEY +
3867 TP_ACPI_HOTKEYSCAN_ADAPTIVE_START];
3868 if (keycode != KEY_RESERVED) {
3869 mutex_lock(&tpacpi_inputdev_send_mutex);
3870
3871 input_report_key(tpacpi_inputdev, keycode, 1);
3872 input_sync(tpacpi_inputdev);
3873
3874 input_report_key(tpacpi_inputdev, keycode, 0);
3875 input_sync(tpacpi_inputdev);
3876
3877 mutex_unlock(&tpacpi_inputdev_send_mutex);
3878 }
3879 return true;
3880 }
3881 }
3882
3883 static bool hotkey_notify_hotkey(const u32 hkey,
3884 bool *send_acpi_ev,
3885 bool *ignore_acpi_ev)
3886 {
3887
3888 unsigned int scancode = hkey & 0xfff;
3889 *send_acpi_ev = true;
3890 *ignore_acpi_ev = false;
3891
3892
3893
3894
3895
3896
3897 switch ((hkey >> 8) & 0xf) {
3898 case 0:
3899 if (scancode > 0 &&
3900 scancode <= TP_ACPI_HOTKEYSCAN_ADAPTIVE_START) {
3901
3902 scancode--;
3903 if (!(hotkey_source_mask & (1 << scancode))) {
3904 tpacpi_input_send_key_masked(scancode);
3905 *send_acpi_ev = false;
3906 } else {
3907 *ignore_acpi_ev = true;
3908 }
3909 return true;
3910 }
3911 break;
3912
3913 case 1:
3914 return adaptive_keyboard_hotkey_notify_hotkey(scancode);
3915
3916 case 3:
3917
3918
3919
3920
3921 scancode -= (0x300 - TP_ACPI_HOTKEYSCAN_EXTENDED_START);
3922 if (scancode >= TP_ACPI_HOTKEYSCAN_EXTENDED_START &&
3923 scancode < TPACPI_HOTKEY_MAP_LEN) {
3924 tpacpi_input_send_key(scancode);
3925 return true;
3926 }
3927 break;
3928 }
3929
3930 return false;
3931 }
3932
3933 static bool hotkey_notify_wakeup(const u32 hkey,
3934 bool *send_acpi_ev,
3935 bool *ignore_acpi_ev)
3936 {
3937
3938 *send_acpi_ev = true;
3939 *ignore_acpi_ev = false;
3940
3941 switch (hkey) {
3942 case TP_HKEY_EV_WKUP_S3_UNDOCK:
3943 case TP_HKEY_EV_WKUP_S4_UNDOCK:
3944 hotkey_wakeup_reason = TP_ACPI_WAKEUP_UNDOCK;
3945 *ignore_acpi_ev = true;
3946 break;
3947
3948 case TP_HKEY_EV_WKUP_S3_BAYEJ:
3949 case TP_HKEY_EV_WKUP_S4_BAYEJ:
3950 hotkey_wakeup_reason = TP_ACPI_WAKEUP_BAYEJ;
3951 *ignore_acpi_ev = true;
3952 break;
3953
3954 case TP_HKEY_EV_WKUP_S3_BATLOW:
3955 case TP_HKEY_EV_WKUP_S4_BATLOW:
3956 pr_alert("EMERGENCY WAKEUP: battery almost empty\n");
3957
3958
3959
3960 break;
3961
3962 default:
3963 return false;
3964 }
3965
3966 if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
3967 pr_info("woke up due to a hot-unplug request...\n");
3968 hotkey_wakeup_reason_notify_change();
3969 }
3970 return true;
3971 }
3972
3973 static bool hotkey_notify_dockevent(const u32 hkey,
3974 bool *send_acpi_ev,
3975 bool *ignore_acpi_ev)
3976 {
3977
3978 *send_acpi_ev = true;
3979 *ignore_acpi_ev = false;
3980
3981 switch (hkey) {
3982 case TP_HKEY_EV_UNDOCK_ACK:
3983
3984 hotkey_autosleep_ack = 1;
3985 pr_info("undocked\n");
3986 hotkey_wakeup_hotunplug_complete_notify_change();
3987 return true;
3988
3989 case TP_HKEY_EV_HOTPLUG_DOCK:
3990 pr_info("docked into hotplug port replicator\n");
3991 return true;
3992 case TP_HKEY_EV_HOTPLUG_UNDOCK:
3993 pr_info("undocked from hotplug port replicator\n");
3994 return true;
3995
3996 default:
3997 return false;
3998 }
3999 }
4000
4001 static bool hotkey_notify_usrevent(const u32 hkey,
4002 bool *send_acpi_ev,
4003 bool *ignore_acpi_ev)
4004 {
4005
4006 *send_acpi_ev = true;
4007 *ignore_acpi_ev = false;
4008
4009 switch (hkey) {
4010 case TP_HKEY_EV_PEN_INSERTED:
4011 case TP_HKEY_EV_PEN_REMOVED:
4012 return true;
4013
4014 case TP_HKEY_EV_TABLET_TABLET:
4015 case TP_HKEY_EV_TABLET_NOTEBOOK:
4016 tpacpi_input_send_tabletsw();
4017 hotkey_tablet_mode_notify_change();
4018 *send_acpi_ev = false;
4019 return true;
4020
4021 case TP_HKEY_EV_LID_CLOSE:
4022 case TP_HKEY_EV_LID_OPEN:
4023 case TP_HKEY_EV_BRGHT_CHANGED:
4024
4025 *ignore_acpi_ev = true;
4026 return true;
4027
4028 default:
4029 return false;
4030 }
4031 }
4032
4033 static void thermal_dump_all_sensors(void);
4034
4035 static bool hotkey_notify_6xxx(const u32 hkey,
4036 bool *send_acpi_ev,
4037 bool *ignore_acpi_ev)
4038 {
4039
4040 *send_acpi_ev = true;
4041 *ignore_acpi_ev = false;
4042
4043 switch (hkey) {
4044 case TP_HKEY_EV_THM_TABLE_CHANGED:
4045 pr_debug("EC reports: Thermal Table has changed\n");
4046
4047
4048 return true;
4049 case TP_HKEY_EV_THM_CSM_COMPLETED:
4050 pr_debug("EC reports: Thermal Control Command set completed (DYTC)\n");
4051
4052
4053 return true;
4054 case TP_HKEY_EV_THM_TRANSFM_CHANGED:
4055 pr_debug("EC reports: Thermal Transformation changed (GMTS)\n");
4056
4057
4058 return true;
4059 case TP_HKEY_EV_ALARM_BAT_HOT:
4060 pr_crit("THERMAL ALARM: battery is too hot!\n");
4061
4062 break;
4063 case TP_HKEY_EV_ALARM_BAT_XHOT:
4064 pr_alert("THERMAL EMERGENCY: battery is extremely hot!\n");
4065
4066 break;
4067 case TP_HKEY_EV_ALARM_SENSOR_HOT:
4068 pr_crit("THERMAL ALARM: a sensor reports something is too hot!\n");
4069
4070
4071 break;
4072 case TP_HKEY_EV_ALARM_SENSOR_XHOT:
4073 pr_alert("THERMAL EMERGENCY: a sensor reports something is extremely hot!\n");
4074
4075 break;
4076 case TP_HKEY_EV_AC_CHANGED:
4077
4078
4079
4080
4081
4082
4083 case TP_HKEY_EV_KEY_NUMLOCK:
4084 case TP_HKEY_EV_KEY_FN:
4085 case TP_HKEY_EV_KEY_FN_ESC:
4086
4087
4088 *send_acpi_ev = false;
4089 *ignore_acpi_ev = true;
4090 return true;
4091
4092 case TP_HKEY_EV_TABLET_CHANGED:
4093 tpacpi_input_send_tabletsw();
4094 hotkey_tablet_mode_notify_change();
4095 *send_acpi_ev = false;
4096 return true;
4097
4098 case TP_HKEY_EV_PALM_DETECTED:
4099 case TP_HKEY_EV_PALM_UNDETECTED:
4100
4101
4102 return true;
4103
4104 default:
4105
4106 return false;
4107 }
4108
4109 thermal_dump_all_sensors();
4110 return true;
4111 }
4112
4113 static void hotkey_notify(struct ibm_struct *ibm, u32 event)
4114 {
4115 u32 hkey;
4116 bool send_acpi_ev;
4117 bool ignore_acpi_ev;
4118 bool known_ev;
4119
4120 if (event != 0x80) {
4121 pr_err("unknown HKEY notification event %d\n", event);
4122
4123 acpi_bus_generate_netlink_event(
4124 ibm->acpi->device->pnp.device_class,
4125 dev_name(&ibm->acpi->device->dev),
4126 event, 0);
4127 return;
4128 }
4129
4130 while (1) {
4131 if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
4132 pr_err("failed to retrieve HKEY event\n");
4133 return;
4134 }
4135
4136 if (hkey == 0) {
4137
4138 return;
4139 }
4140
4141 send_acpi_ev = true;
4142 ignore_acpi_ev = false;
4143
4144 switch (hkey >> 12) {
4145 case 1:
4146
4147 known_ev = hotkey_notify_hotkey(hkey, &send_acpi_ev,
4148 &ignore_acpi_ev);
4149 break;
4150 case 2:
4151
4152 known_ev = hotkey_notify_wakeup(hkey, &send_acpi_ev,
4153 &ignore_acpi_ev);
4154 break;
4155 case 3:
4156
4157 switch (hkey) {
4158 case TP_HKEY_EV_BAYEJ_ACK:
4159 hotkey_autosleep_ack = 1;
4160 pr_info("bay ejected\n");
4161 hotkey_wakeup_hotunplug_complete_notify_change();
4162 known_ev = true;
4163 break;
4164 case TP_HKEY_EV_OPTDRV_EJ:
4165
4166 known_ev = true;
4167 break;
4168 default:
4169 known_ev = false;
4170 }
4171 break;
4172 case 4:
4173
4174 known_ev = hotkey_notify_dockevent(hkey, &send_acpi_ev,
4175 &ignore_acpi_ev);
4176 break;
4177 case 5:
4178
4179 known_ev = hotkey_notify_usrevent(hkey, &send_acpi_ev,
4180 &ignore_acpi_ev);
4181 break;
4182 case 6:
4183
4184
4185 known_ev = hotkey_notify_6xxx(hkey, &send_acpi_ev,
4186 &ignore_acpi_ev);
4187 break;
4188 case 7:
4189
4190 if (tp_features.hotkey_wlsw &&
4191 hkey == TP_HKEY_EV_RFKILL_CHANGED) {
4192 tpacpi_send_radiosw_update();
4193 send_acpi_ev = 0;
4194 known_ev = true;
4195 break;
4196 }
4197
4198 default:
4199 known_ev = false;
4200 }
4201 if (!known_ev) {
4202 pr_notice("unhandled HKEY event 0x%04x\n", hkey);
4203 pr_notice("please report the conditions when this event happened to %s\n",
4204 TPACPI_MAIL);
4205 }
4206
4207
4208 if (!ignore_acpi_ev && send_acpi_ev) {
4209 acpi_bus_generate_netlink_event(
4210 ibm->acpi->device->pnp.device_class,
4211 dev_name(&ibm->acpi->device->dev),
4212 event, hkey);
4213 }
4214 }
4215 }
4216
4217 static void hotkey_suspend(void)
4218 {
4219
4220 hotkey_wakeup_reason = TP_ACPI_WAKEUP_NONE;
4221 hotkey_autosleep_ack = 0;
4222
4223
4224 if (tp_features.has_adaptive_kbd) {
4225 if (!acpi_evalf(hkey_handle, &adaptive_keyboard_prev_mode,
4226 "GTRW", "dd", 0)) {
4227 pr_err("Cannot read adaptive keyboard mode.\n");
4228 }
4229 }
4230 }
4231
4232 static void hotkey_resume(void)
4233 {
4234 tpacpi_disable_brightness_delay();
4235
4236 if (hotkey_status_set(true) < 0 ||
4237 hotkey_mask_set(hotkey_acpi_mask) < 0)
4238 pr_err("error while attempting to reset the event firmware interface\n");
4239
4240 tpacpi_send_radiosw_update();
4241 hotkey_tablet_mode_notify_change();
4242 hotkey_wakeup_reason_notify_change();
4243 hotkey_wakeup_hotunplug_complete_notify_change();
4244 hotkey_poll_setup_safe(false);
4245
4246
4247 if (tp_features.has_adaptive_kbd) {
4248 if (!acpi_evalf(hkey_handle, NULL, "STRW", "vd",
4249 adaptive_keyboard_prev_mode)) {
4250 pr_err("Cannot set adaptive keyboard mode.\n");
4251 }
4252 }
4253 }
4254
4255
4256 static int hotkey_read(struct seq_file *m)
4257 {
4258 int res, status;
4259
4260 if (!tp_features.hotkey) {
4261 seq_printf(m, "status:\t\tnot supported\n");
4262 return 0;
4263 }
4264
4265 if (mutex_lock_killable(&hotkey_mutex))
4266 return -ERESTARTSYS;
4267 res = hotkey_status_get(&status);
4268 if (!res)
4269 res = hotkey_mask_get();
4270 mutex_unlock(&hotkey_mutex);
4271 if (res)
4272 return res;
4273
4274 seq_printf(m, "status:\t\t%s\n", enabled(status, 0));
4275 if (hotkey_all_mask) {
4276 seq_printf(m, "mask:\t\t0x%08x\n", hotkey_user_mask);
4277 seq_printf(m, "commands:\tenable, disable, reset, <mask>\n");
4278 } else {
4279 seq_printf(m, "mask:\t\tnot supported\n");
4280 seq_printf(m, "commands:\tenable, disable, reset\n");
4281 }
4282
4283 return 0;
4284 }
4285
4286 static void hotkey_enabledisable_warn(bool enable)
4287 {
4288 tpacpi_log_usertask("procfs hotkey enable/disable");
4289 if (!WARN((tpacpi_lifecycle == TPACPI_LIFE_RUNNING || !enable),
4290 pr_fmt("hotkey enable/disable functionality has been removed from the driver. Hotkeys are always enabled.\n")))
4291 pr_err("Please remove the hotkey=enable module parameter, it is deprecated. Hotkeys are always enabled.\n");
4292 }
4293
4294 static int hotkey_write(char *buf)
4295 {
4296 int res;
4297 u32 mask;
4298 char *cmd;
4299
4300 if (!tp_features.hotkey)
4301 return -ENODEV;
4302
4303 if (mutex_lock_killable(&hotkey_mutex))
4304 return -ERESTARTSYS;
4305
4306 mask = hotkey_user_mask;
4307
4308 res = 0;
4309 while ((cmd = next_cmd(&buf))) {
4310 if (strlencmp(cmd, "enable") == 0) {
4311 hotkey_enabledisable_warn(1);
4312 } else if (strlencmp(cmd, "disable") == 0) {
4313 hotkey_enabledisable_warn(0);
4314 res = -EPERM;
4315 } else if (strlencmp(cmd, "reset") == 0) {
4316 mask = (hotkey_all_mask | hotkey_source_mask)
4317 & ~hotkey_reserved_mask;
4318 } else if (sscanf(cmd, "0x%x", &mask) == 1) {
4319
4320 } else if (sscanf(cmd, "%x", &mask) == 1) {
4321
4322 } else {
4323 res = -EINVAL;
4324 goto errexit;
4325 }
4326 }
4327
4328 if (!res) {
4329 tpacpi_disclose_usertask("procfs hotkey",
4330 "set mask to 0x%08x\n", mask);
4331 res = hotkey_user_mask_set(mask);
4332 }
4333
4334 errexit:
4335 mutex_unlock(&hotkey_mutex);
4336 return res;
4337 }
4338
4339 static const struct acpi_device_id ibm_htk_device_ids[] = {
4340 {TPACPI_ACPI_IBM_HKEY_HID, 0},
4341 {TPACPI_ACPI_LENOVO_HKEY_HID, 0},
4342 {TPACPI_ACPI_LENOVO_HKEY_V2_HID, 0},
4343 {"", 0},
4344 };
4345
4346 static struct tp_acpi_drv_struct ibm_hotkey_acpidriver = {
4347 .hid = ibm_htk_device_ids,
4348 .notify = hotkey_notify,
4349 .handle = &hkey_handle,
4350 .type = ACPI_DEVICE_NOTIFY,
4351 };
4352
4353 static struct ibm_struct hotkey_driver_data = {
4354 .name = "hotkey",
4355 .read = hotkey_read,
4356 .write = hotkey_write,
4357 .exit = hotkey_exit,
4358 .resume = hotkey_resume,
4359 .suspend = hotkey_suspend,
4360 .acpi = &ibm_hotkey_acpidriver,
4361 };
4362
4363
4364
4365
4366
4367 enum {
4368
4369 TP_ACPI_BLUETOOTH_HWPRESENT = 0x01,
4370 TP_ACPI_BLUETOOTH_RADIOSSW = 0x02,
4371 TP_ACPI_BLUETOOTH_RESUMECTRL = 0x04,
4372
4373 };
4374
4375 enum {
4376
4377 TP_ACPI_BLTH_GET_ULTRAPORT_ID = 0x00,
4378 TP_ACPI_BLTH_GET_PWR_ON_RESUME = 0x01,
4379 TP_ACPI_BLTH_PWR_ON_ON_RESUME = 0x02,
4380 TP_ACPI_BLTH_PWR_OFF_ON_RESUME = 0x03,
4381 TP_ACPI_BLTH_SAVE_STATE = 0x05,
4382 };
4383
4384 #define TPACPI_RFK_BLUETOOTH_SW_NAME "tpacpi_bluetooth_sw"
4385
4386 static int bluetooth_get_status(void)
4387 {
4388 int status;
4389
4390 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4391 if (dbg_bluetoothemul)
4392 return (tpacpi_bluetooth_emulstate) ?
4393 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4394 #endif
4395
4396 if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
4397 return -EIO;
4398
4399 return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0) ?
4400 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4401 }
4402
4403 static int bluetooth_set_status(enum tpacpi_rfkill_state state)
4404 {
4405 int status;
4406
4407 vdbg_printk(TPACPI_DBG_RFKILL,
4408 "will attempt to %s bluetooth\n",
4409 (state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable");
4410
4411 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4412 if (dbg_bluetoothemul) {
4413 tpacpi_bluetooth_emulstate = (state == TPACPI_RFK_RADIO_ON);
4414 return 0;
4415 }
4416 #endif
4417
4418 if (state == TPACPI_RFK_RADIO_ON)
4419 status = TP_ACPI_BLUETOOTH_RADIOSSW
4420 | TP_ACPI_BLUETOOTH_RESUMECTRL;
4421 else
4422 status = 0;
4423
4424 if (!acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status))
4425 return -EIO;
4426
4427 return 0;
4428 }
4429
4430
4431 static ssize_t bluetooth_enable_show(struct device *dev,
4432 struct device_attribute *attr,
4433 char *buf)
4434 {
4435 return tpacpi_rfk_sysfs_enable_show(TPACPI_RFK_BLUETOOTH_SW_ID,
4436 attr, buf);
4437 }
4438
4439 static ssize_t bluetooth_enable_store(struct device *dev,
4440 struct device_attribute *attr,
4441 const char *buf, size_t count)
4442 {
4443 return tpacpi_rfk_sysfs_enable_store(TPACPI_RFK_BLUETOOTH_SW_ID,
4444 attr, buf, count);
4445 }
4446
4447 static DEVICE_ATTR_RW(bluetooth_enable);
4448
4449
4450
4451 static struct attribute *bluetooth_attributes[] = {
4452 &dev_attr_bluetooth_enable.attr,
4453 NULL
4454 };
4455
4456 static const struct attribute_group bluetooth_attr_group = {
4457 .attrs = bluetooth_attributes,
4458 };
4459
4460 static const struct tpacpi_rfk_ops bluetooth_tprfk_ops = {
4461 .get_status = bluetooth_get_status,
4462 .set_status = bluetooth_set_status,
4463 };
4464
4465 static void bluetooth_shutdown(void)
4466 {
4467
4468 if (!acpi_evalf(NULL, NULL, "\\BLTH", "vd",
4469 TP_ACPI_BLTH_SAVE_STATE))
4470 pr_notice("failed to save bluetooth state to NVRAM\n");
4471 else
4472 vdbg_printk(TPACPI_DBG_RFKILL,
4473 "bluetooth state saved to NVRAM\n");
4474 }
4475
4476 static void bluetooth_exit(void)
4477 {
4478 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
4479 &bluetooth_attr_group);
4480
4481 tpacpi_destroy_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID);
4482
4483 bluetooth_shutdown();
4484 }
4485
4486 static const struct dmi_system_id bt_fwbug_list[] __initconst = {
4487 {
4488 .ident = "ThinkPad E485",
4489 .matches = {
4490 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
4491 DMI_MATCH(DMI_BOARD_NAME, "20KU"),
4492 },
4493 },
4494 {
4495 .ident = "ThinkPad E585",
4496 .matches = {
4497 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
4498 DMI_MATCH(DMI_BOARD_NAME, "20KV"),
4499 },
4500 },
4501 {
4502 .ident = "ThinkPad A285 - 20MW",
4503 .matches = {
4504 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
4505 DMI_MATCH(DMI_BOARD_NAME, "20MW"),
4506 },
4507 },
4508 {
4509 .ident = "ThinkPad A285 - 20MX",
4510 .matches = {
4511 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
4512 DMI_MATCH(DMI_BOARD_NAME, "20MX"),
4513 },
4514 },
4515 {
4516 .ident = "ThinkPad A485 - 20MU",
4517 .matches = {
4518 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
4519 DMI_MATCH(DMI_BOARD_NAME, "20MU"),
4520 },
4521 },
4522 {
4523 .ident = "ThinkPad A485 - 20MV",
4524 .matches = {
4525 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
4526 DMI_MATCH(DMI_BOARD_NAME, "20MV"),
4527 },
4528 },
4529 {}
4530 };
4531
4532 static const struct pci_device_id fwbug_cards_ids[] __initconst = {
4533 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x24F3) },
4534 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x24FD) },
4535 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2526) },
4536 {}
4537 };
4538
4539
4540 static int __init have_bt_fwbug(void)
4541 {
4542
4543
4544
4545
4546 if (dmi_check_system(bt_fwbug_list) && pci_dev_present(fwbug_cards_ids)) {
4547 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4548 FW_BUG "disable bluetooth subdriver for Intel cards\n");
4549 return 1;
4550 } else
4551 return 0;
4552 }
4553
4554 static int __init bluetooth_init(struct ibm_init_struct *iibm)
4555 {
4556 int res;
4557 int status = 0;
4558
4559 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4560 "initializing bluetooth subdriver\n");
4561
4562 TPACPI_ACPIHANDLE_INIT(hkey);
4563
4564
4565
4566 tp_features.bluetooth = !have_bt_fwbug() && hkey_handle &&
4567 acpi_evalf(hkey_handle, &status, "GBDC", "qd");
4568
4569 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4570 "bluetooth is %s, status 0x%02x\n",
4571 str_supported(tp_features.bluetooth),
4572 status);
4573
4574 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4575 if (dbg_bluetoothemul) {
4576 tp_features.bluetooth = 1;
4577 pr_info("bluetooth switch emulation enabled\n");
4578 } else
4579 #endif
4580 if (tp_features.bluetooth &&
4581 !(status & TP_ACPI_BLUETOOTH_HWPRESENT)) {
4582
4583 tp_features.bluetooth = 0;
4584 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4585 "bluetooth hardware not installed\n");
4586 }
4587
4588 if (!tp_features.bluetooth)
4589 return 1;
4590
4591 res = tpacpi_new_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID,
4592 &bluetooth_tprfk_ops,
4593 RFKILL_TYPE_BLUETOOTH,
4594 TPACPI_RFK_BLUETOOTH_SW_NAME,
4595 true);
4596 if (res)
4597 return res;
4598
4599 res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
4600 &bluetooth_attr_group);
4601 if (res) {
4602 tpacpi_destroy_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID);
4603 return res;
4604 }
4605
4606 return 0;
4607 }
4608
4609
4610 static int bluetooth_read(struct seq_file *m)
4611 {
4612 return tpacpi_rfk_procfs_read(TPACPI_RFK_BLUETOOTH_SW_ID, m);
4613 }
4614
4615 static int bluetooth_write(char *buf)
4616 {
4617 return tpacpi_rfk_procfs_write(TPACPI_RFK_BLUETOOTH_SW_ID, buf);
4618 }
4619
4620 static struct ibm_struct bluetooth_driver_data = {
4621 .name = "bluetooth",
4622 .read = bluetooth_read,
4623 .write = bluetooth_write,
4624 .exit = bluetooth_exit,
4625 .shutdown = bluetooth_shutdown,
4626 };
4627
4628
4629
4630
4631
4632 enum {
4633
4634 TP_ACPI_WANCARD_HWPRESENT = 0x01,
4635 TP_ACPI_WANCARD_RADIOSSW = 0x02,
4636 TP_ACPI_WANCARD_RESUMECTRL = 0x04,
4637
4638 };
4639
4640 #define TPACPI_RFK_WWAN_SW_NAME "tpacpi_wwan_sw"
4641
4642 static int wan_get_status(void)
4643 {
4644 int status;
4645
4646 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4647 if (dbg_wwanemul)
4648 return (tpacpi_wwan_emulstate) ?
4649 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4650 #endif
4651
4652 if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
4653 return -EIO;
4654
4655 return ((status & TP_ACPI_WANCARD_RADIOSSW) != 0) ?
4656 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4657 }
4658
4659 static int wan_set_status(enum tpacpi_rfkill_state state)
4660 {
4661 int status;
4662
4663 vdbg_printk(TPACPI_DBG_RFKILL,
4664 "will attempt to %s wwan\n",
4665 (state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable");
4666
4667 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4668 if (dbg_wwanemul) {
4669 tpacpi_wwan_emulstate = (state == TPACPI_RFK_RADIO_ON);
4670 return 0;
4671 }
4672 #endif
4673
4674 if (state == TPACPI_RFK_RADIO_ON)
4675 status = TP_ACPI_WANCARD_RADIOSSW
4676 | TP_ACPI_WANCARD_RESUMECTRL;
4677 else
4678 status = 0;
4679
4680 if (!acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status))
4681 return -EIO;
4682
4683 return 0;
4684 }
4685
4686
4687 static ssize_t wan_enable_show(struct device *dev,
4688 struct device_attribute *attr,
4689 char *buf)
4690 {
4691 return tpacpi_rfk_sysfs_enable_show(TPACPI_RFK_WWAN_SW_ID,
4692 attr, buf);
4693 }
4694
4695 static ssize_t wan_enable_store(struct device *dev,
4696 struct device_attribute *attr,
4697 const char *buf, size_t count)
4698 {
4699 return tpacpi_rfk_sysfs_enable_store(TPACPI_RFK_WWAN_SW_ID,
4700 attr, buf, count);
4701 }
4702
4703 static DEVICE_ATTR(wwan_enable, S_IWUSR | S_IRUGO,
4704 wan_enable_show, wan_enable_store);
4705
4706
4707
4708 static struct attribute *wan_attributes[] = {
4709 &dev_attr_wwan_enable.attr,
4710 NULL
4711 };
4712
4713 static const struct attribute_group wan_attr_group = {
4714 .attrs = wan_attributes,
4715 };
4716
4717 static const struct tpacpi_rfk_ops wan_tprfk_ops = {
4718 .get_status = wan_get_status,
4719 .set_status = wan_set_status,
4720 };
4721
4722 static void wan_shutdown(void)
4723 {
4724
4725 if (!acpi_evalf(NULL, NULL, "\\WGSV", "vd",
4726 TP_ACPI_WGSV_SAVE_STATE))
4727 pr_notice("failed to save WWAN state to NVRAM\n");
4728 else
4729 vdbg_printk(TPACPI_DBG_RFKILL,
4730 "WWAN state saved to NVRAM\n");
4731 }
4732
4733 static void wan_exit(void)
4734 {
4735 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
4736 &wan_attr_group);
4737
4738 tpacpi_destroy_rfkill(TPACPI_RFK_WWAN_SW_ID);
4739
4740 wan_shutdown();
4741 }
4742
4743 static int __init wan_init(struct ibm_init_struct *iibm)
4744 {
4745 int res;
4746 int status = 0;
4747
4748 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4749 "initializing wan subdriver\n");
4750
4751 TPACPI_ACPIHANDLE_INIT(hkey);
4752
4753 tp_features.wan = hkey_handle &&
4754 acpi_evalf(hkey_handle, &status, "GWAN", "qd");
4755
4756 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4757 "wan is %s, status 0x%02x\n",
4758 str_supported(tp_features.wan),
4759 status);
4760
4761 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4762 if (dbg_wwanemul) {
4763 tp_features.wan = 1;
4764 pr_info("wwan switch emulation enabled\n");
4765 } else
4766 #endif
4767 if (tp_features.wan &&
4768 !(status & TP_ACPI_WANCARD_HWPRESENT)) {
4769
4770 tp_features.wan = 0;
4771 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4772 "wan hardware not installed\n");
4773 }
4774
4775 if (!tp_features.wan)
4776 return 1;
4777
4778 res = tpacpi_new_rfkill(TPACPI_RFK_WWAN_SW_ID,
4779 &wan_tprfk_ops,
4780 RFKILL_TYPE_WWAN,
4781 TPACPI_RFK_WWAN_SW_NAME,
4782 true);
4783 if (res)
4784 return res;
4785
4786 res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
4787 &wan_attr_group);
4788
4789 if (res) {
4790 tpacpi_destroy_rfkill(TPACPI_RFK_WWAN_SW_ID);
4791 return res;
4792 }
4793
4794 return 0;
4795 }
4796
4797
4798 static int wan_read(struct seq_file *m)
4799 {
4800 return tpacpi_rfk_procfs_read(TPACPI_RFK_WWAN_SW_ID, m);
4801 }
4802
4803 static int wan_write(char *buf)
4804 {
4805 return tpacpi_rfk_procfs_write(TPACPI_RFK_WWAN_SW_ID, buf);
4806 }
4807
4808 static struct ibm_struct wan_driver_data = {
4809 .name = "wan",
4810 .read = wan_read,
4811 .write = wan_write,
4812 .exit = wan_exit,
4813 .shutdown = wan_shutdown,
4814 };
4815
4816
4817
4818
4819
4820 enum {
4821
4822 TP_ACPI_UWB_HWPRESENT = 0x01,
4823 TP_ACPI_UWB_RADIOSSW = 0x02,
4824 };
4825
4826 #define TPACPI_RFK_UWB_SW_NAME "tpacpi_uwb_sw"
4827
4828 static int uwb_get_status(void)
4829 {
4830 int status;
4831
4832 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4833 if (dbg_uwbemul)
4834 return (tpacpi_uwb_emulstate) ?
4835 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4836 #endif
4837
4838 if (!acpi_evalf(hkey_handle, &status, "GUWB", "d"))
4839 return -EIO;
4840
4841 return ((status & TP_ACPI_UWB_RADIOSSW) != 0) ?
4842 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4843 }
4844
4845 static int uwb_set_status(enum tpacpi_rfkill_state state)
4846 {
4847 int status;
4848
4849 vdbg_printk(TPACPI_DBG_RFKILL,
4850 "will attempt to %s UWB\n",
4851 (state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable");
4852
4853 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4854 if (dbg_uwbemul) {
4855 tpacpi_uwb_emulstate = (state == TPACPI_RFK_RADIO_ON);
4856 return 0;
4857 }
4858 #endif
4859
4860 if (state == TPACPI_RFK_RADIO_ON)
4861 status = TP_ACPI_UWB_RADIOSSW;
4862 else
4863 status = 0;
4864
4865 if (!acpi_evalf(hkey_handle, NULL, "SUWB", "vd", status))
4866 return -EIO;
4867
4868 return 0;
4869 }
4870
4871
4872
4873 static const struct tpacpi_rfk_ops uwb_tprfk_ops = {
4874 .get_status = uwb_get_status,
4875 .set_status = uwb_set_status,
4876 };
4877
4878 static void uwb_exit(void)
4879 {
4880 tpacpi_destroy_rfkill(TPACPI_RFK_UWB_SW_ID);
4881 }
4882
4883 static int __init uwb_init(struct ibm_init_struct *iibm)
4884 {
4885 int res;
4886 int status = 0;
4887
4888 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4889 "initializing uwb subdriver\n");
4890
4891 TPACPI_ACPIHANDLE_INIT(hkey);
4892
4893 tp_features.uwb = hkey_handle &&
4894 acpi_evalf(hkey_handle, &status, "GUWB", "qd");
4895
4896 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4897 "uwb is %s, status 0x%02x\n",
4898 str_supported(tp_features.uwb),
4899 status);
4900
4901 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4902 if (dbg_uwbemul) {
4903 tp_features.uwb = 1;
4904 pr_info("uwb switch emulation enabled\n");
4905 } else
4906 #endif
4907 if (tp_features.uwb &&
4908 !(status & TP_ACPI_UWB_HWPRESENT)) {
4909
4910 tp_features.uwb = 0;
4911 dbg_printk(TPACPI_DBG_INIT,
4912 "uwb hardware not installed\n");
4913 }
4914
4915 if (!tp_features.uwb)
4916 return 1;
4917
4918 res = tpacpi_new_rfkill(TPACPI_RFK_UWB_SW_ID,
4919 &uwb_tprfk_ops,
4920 RFKILL_TYPE_UWB,
4921 TPACPI_RFK_UWB_SW_NAME,
4922 false);
4923 return res;
4924 }
4925
4926 static struct ibm_struct uwb_driver_data = {
4927 .name = "uwb",
4928 .exit = uwb_exit,
4929 .flags.experimental = 1,
4930 };
4931
4932
4933
4934
4935
4936 #ifdef CONFIG_THINKPAD_ACPI_VIDEO
4937
4938 enum video_access_mode {
4939 TPACPI_VIDEO_NONE = 0,
4940 TPACPI_VIDEO_570,
4941 TPACPI_VIDEO_770,
4942 TPACPI_VIDEO_NEW,
4943 };
4944
4945 enum {
4946 TP_ACPI_VIDEO_S_LCD = 0x01,
4947 TP_ACPI_VIDEO_S_CRT = 0x02,
4948 TP_ACPI_VIDEO_S_DVI = 0x08,
4949 };
4950
4951 enum {
4952 TP_ACPI_VIDEO_570_PHSCMD = 0x87,
4953 TP_ACPI_VIDEO_570_PHSMASK = 0x03,
4954
4955 TP_ACPI_VIDEO_570_PHS2CMD = 0x8b,
4956 TP_ACPI_VIDEO_570_PHS2SET = 0x80,
4957 };
4958
4959 static enum video_access_mode video_supported;
4960 static int video_orig_autosw;
4961
4962 static int video_autosw_get(void);
4963 static int video_autosw_set(int enable);
4964
4965 TPACPI_HANDLE(vid, root,
4966 "\\_SB.PCI.AGP.VGA",
4967 "\\_SB.PCI0.AGP0.VID0",
4968 "\\_SB.PCI0.VID0",
4969 "\\_SB.PCI0.VID",
4970 "\\_SB.PCI0.AGP.VGA",
4971 "\\_SB.PCI0.AGP.VID",
4972 );
4973
4974 TPACPI_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID");
4975
4976 static int __init video_init(struct ibm_init_struct *iibm)
4977 {
4978 int ivga;
4979
4980 vdbg_printk(TPACPI_DBG_INIT, "initializing video subdriver\n");
4981
4982 TPACPI_ACPIHANDLE_INIT(vid);
4983 if (tpacpi_is_ibm())
4984 TPACPI_ACPIHANDLE_INIT(vid2);
4985
4986 if (vid2_handle && acpi_evalf(NULL, &ivga, "\\IVGA", "d") && ivga)
4987
4988 vid_handle = vid2_handle;
4989
4990 if (!vid_handle)
4991
4992 video_supported = TPACPI_VIDEO_NONE;
4993 else if (tpacpi_is_ibm() &&
4994 acpi_evalf(vid_handle, &video_orig_autosw, "SWIT", "qd"))
4995
4996 video_supported = TPACPI_VIDEO_570;
4997 else if (tpacpi_is_ibm() &&
4998 acpi_evalf(vid_handle, &video_orig_autosw, "^VADL", "qd"))
4999
5000 video_supported = TPACPI_VIDEO_770;
5001 else
5002
5003 video_supported = TPACPI_VIDEO_NEW;
5004
5005 vdbg_printk(TPACPI_DBG_INIT, "video is %s, mode %d\n",
5006 str_supported(video_supported != TPACPI_VIDEO_NONE),
5007 video_supported);
5008
5009 return (video_supported != TPACPI_VIDEO_NONE) ? 0 : 1;
5010 }
5011
5012 static void video_exit(void)
5013 {
5014 dbg_printk(TPACPI_DBG_EXIT,
5015 "restoring original video autoswitch mode\n");
5016 if (video_autosw_set(video_orig_autosw))
5017 pr_err("error while trying to restore original video autoswitch mode\n");
5018 }
5019
5020 static int video_outputsw_get(void)
5021 {
5022 int status = 0;
5023 int i;
5024
5025 switch (video_supported) {
5026 case TPACPI_VIDEO_570:
5027 if (!acpi_evalf(NULL, &i, "\\_SB.PHS", "dd",
5028 TP_ACPI_VIDEO_570_PHSCMD))
5029 return -EIO;
5030 status = i & TP_ACPI_VIDEO_570_PHSMASK;
5031 break;
5032 case TPACPI_VIDEO_770:
5033 if (!acpi_evalf(NULL, &i, "\\VCDL", "d"))
5034 return -EIO;
5035 if (i)
5036 status |= TP_ACPI_VIDEO_S_LCD;
5037 if (!acpi_evalf(NULL, &i, "\\VCDC", "d"))
5038 return -EIO;
5039 if (i)
5040 status |= TP_ACPI_VIDEO_S_CRT;
5041 break;
5042 case TPACPI_VIDEO_NEW:
5043 if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 1) ||
5044 !acpi_evalf(NULL, &i, "\\VCDC", "d"))
5045 return -EIO;
5046 if (i)
5047 status |= TP_ACPI_VIDEO_S_CRT;
5048
5049 if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0) ||
5050 !acpi_evalf(NULL, &i, "\\VCDL", "d"))
5051 return -EIO;
5052 if (i)
5053 status |= TP_ACPI_VIDEO_S_LCD;
5054 if (!acpi_evalf(NULL, &i, "\\VCDD", "d"))
5055 return -EIO;
5056 if (i)
5057 status |= TP_ACPI_VIDEO_S_DVI;
5058 break;
5059 default:
5060 return -ENOSYS;
5061 }
5062
5063 return status;
5064 }
5065
5066 static int video_outputsw_set(int status)
5067 {
5068 int autosw;
5069 int res = 0;
5070
5071 switch (video_supported) {
5072 case TPACPI_VIDEO_570:
5073 res = acpi_evalf(NULL, NULL,
5074 "\\_SB.PHS2", "vdd",
5075 TP_ACPI_VIDEO_570_PHS2CMD,
5076 status | TP_ACPI_VIDEO_570_PHS2SET);
5077 break;
5078 case TPACPI_VIDEO_770:
5079 autosw = video_autosw_get();
5080 if (autosw < 0)
5081 return autosw;
5082
5083 res = video_autosw_set(1);
5084 if (res)
5085 return res;
5086 res = acpi_evalf(vid_handle, NULL,
5087 "ASWT", "vdd", status * 0x100, 0);
5088 if (!autosw && video_autosw_set(autosw)) {
5089 pr_err("video auto-switch left enabled due to error\n");
5090 return -EIO;
5091 }
5092 break;
5093 case TPACPI_VIDEO_NEW:
5094 res = acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0x80) &&
5095 acpi_evalf(NULL, NULL, "\\VSDS", "vdd", status, 1);
5096 break;
5097 default:
5098 return -ENOSYS;
5099 }
5100
5101 return (res) ? 0 : -EIO;
5102 }
5103
5104 static int video_autosw_get(void)
5105 {
5106 int autosw = 0;
5107
5108 switch (video_supported) {
5109 case TPACPI_VIDEO_570:
5110 if (!acpi_evalf(vid_handle, &autosw, "SWIT", "d"))
5111 return -EIO;
5112 break;
5113 case TPACPI_VIDEO_770:
5114 case TPACPI_VIDEO_NEW:
5115 if (!acpi_evalf(vid_handle, &autosw, "^VDEE", "d"))
5116 return -EIO;
5117 break;
5118 default:
5119 return -ENOSYS;
5120 }
5121
5122 return autosw & 1;
5123 }
5124
5125 static int video_autosw_set(int enable)
5126 {
5127 if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", (enable) ? 1 : 0))
5128 return -EIO;
5129 return 0;
5130 }
5131
5132 static int video_outputsw_cycle(void)
5133 {
5134 int autosw = video_autosw_get();
5135 int res;
5136
5137 if (autosw < 0)
5138 return autosw;
5139
5140 switch (video_supported) {
5141 case TPACPI_VIDEO_570:
5142 res = video_autosw_set(1);
5143 if (res)
5144 return res;
5145 res = acpi_evalf(ec_handle, NULL, "_Q16", "v");
5146 break;
5147 case TPACPI_VIDEO_770:
5148 case TPACPI_VIDEO_NEW:
5149 res = video_autosw_set(1);
5150 if (res)
5151 return res;
5152 res = acpi_evalf(vid_handle, NULL, "VSWT", "v");
5153 break;
5154 default:
5155 return -ENOSYS;
5156 }
5157 if (!autosw && video_autosw_set(autosw)) {
5158 pr_err("video auto-switch left enabled due to error\n");
5159 return -EIO;
5160 }
5161
5162 return (res) ? 0 : -EIO;
5163 }
5164
5165 static int video_expand_toggle(void)
5166 {
5167 switch (video_supported) {
5168 case TPACPI_VIDEO_570:
5169 return acpi_evalf(ec_handle, NULL, "_Q17", "v") ?
5170 0 : -EIO;
5171 case TPACPI_VIDEO_770:
5172 return acpi_evalf(vid_handle, NULL, "VEXP", "v") ?
5173 0 : -EIO;
5174 case TPACPI_VIDEO_NEW:
5175 return acpi_evalf(NULL, NULL, "\\VEXP", "v") ?
5176 0 : -EIO;
5177 default:
5178 return -ENOSYS;
5179 }
5180
5181 }
5182
5183 static int video_read(struct seq_file *m)
5184 {
5185 int status, autosw;
5186
5187 if (video_supported == TPACPI_VIDEO_NONE) {
5188 seq_printf(m, "status:\t\tnot supported\n");
5189 return 0;
5190 }
5191
5192
5193 if (!capable(CAP_SYS_ADMIN))
5194 return -EPERM;
5195
5196 status = video_outputsw_get();
5197 if (status < 0)
5198 return status;
5199
5200 autosw = video_autosw_get();
5201 if (autosw < 0)
5202 return autosw;
5203
5204 seq_printf(m, "status:\t\tsupported\n");
5205 seq_printf(m, "lcd:\t\t%s\n", enabled(status, 0));
5206 seq_printf(m, "crt:\t\t%s\n", enabled(status, 1));
5207 if (video_supported == TPACPI_VIDEO_NEW)
5208 seq_printf(m, "dvi:\t\t%s\n", enabled(status, 3));
5209 seq_printf(m, "auto:\t\t%s\n", enabled(autosw, 0));
5210 seq_printf(m, "commands:\tlcd_enable, lcd_disable\n");
5211 seq_printf(m, "commands:\tcrt_enable, crt_disable\n");
5212 if (video_supported == TPACPI_VIDEO_NEW)
5213 seq_printf(m, "commands:\tdvi_enable, dvi_disable\n");
5214 seq_printf(m, "commands:\tauto_enable, auto_disable\n");
5215 seq_printf(m, "commands:\tvideo_switch, expand_toggle\n");
5216
5217 return 0;
5218 }
5219
5220 static int video_write(char *buf)
5221 {
5222 char *cmd;
5223 int enable, disable, status;
5224 int res;
5225
5226 if (video_supported == TPACPI_VIDEO_NONE)
5227 return -ENODEV;
5228
5229
5230 if (!capable(CAP_SYS_ADMIN))
5231 return -EPERM;
5232
5233 enable = 0;
5234 disable = 0;
5235
5236 while ((cmd = next_cmd(&buf))) {
5237 if (strlencmp(cmd, "lcd_enable") == 0) {
5238 enable |= TP_ACPI_VIDEO_S_LCD;
5239 } else if (strlencmp(cmd, "lcd_disable") == 0) {
5240 disable |= TP_ACPI_VIDEO_S_LCD;
5241 } else if (strlencmp(cmd, "crt_enable") == 0) {
5242 enable |= TP_ACPI_VIDEO_S_CRT;
5243 } else if (strlencmp(cmd, "crt_disable") == 0) {
5244 disable |= TP_ACPI_VIDEO_S_CRT;
5245 } else if (video_supported == TPACPI_VIDEO_NEW &&
5246 strlencmp(cmd, "dvi_enable") == 0) {
5247 enable |= TP_ACPI_VIDEO_S_DVI;
5248 } else if (video_supported == TPACPI_VIDEO_NEW &&
5249 strlencmp(cmd, "dvi_disable") == 0) {
5250 disable |= TP_ACPI_VIDEO_S_DVI;
5251 } else if (strlencmp(cmd, "auto_enable") == 0) {
5252 res = video_autosw_set(1);
5253 if (res)
5254 return res;
5255 } else if (strlencmp(cmd, "auto_disable") == 0) {
5256 res = video_autosw_set(0);
5257 if (res)
5258 return res;
5259 } else if (strlencmp(cmd, "video_switch") == 0) {
5260 res = video_outputsw_cycle();
5261 if (res)
5262 return res;
5263 } else if (strlencmp(cmd, "expand_toggle") == 0) {
5264 res = video_expand_toggle();
5265 if (res)
5266 return res;
5267 } else
5268 return -EINVAL;
5269 }
5270
5271 if (enable || disable) {
5272 status = video_outputsw_get();
5273 if (status < 0)
5274 return status;
5275 res = video_outputsw_set((status & ~disable) | enable);
5276 if (res)
5277 return res;
5278 }
5279
5280 return 0;
5281 }
5282
5283 static struct ibm_struct video_driver_data = {
5284 .name = "video",
5285 .read = video_read,
5286 .write = video_write,
5287 .exit = video_exit,
5288 };
5289
5290 #endif
5291
5292
5293
5294
5295
5296 static enum led_brightness kbdlight_brightness;
5297 static DEFINE_MUTEX(kbdlight_mutex);
5298
5299 static int kbdlight_set_level(int level)
5300 {
5301 int ret = 0;
5302
5303 if (!hkey_handle)
5304 return -ENXIO;
5305
5306 mutex_lock(&kbdlight_mutex);
5307
5308 if (!acpi_evalf(hkey_handle, NULL, "MLCS", "dd", level))
5309 ret = -EIO;
5310 else
5311 kbdlight_brightness = level;
5312
5313 mutex_unlock(&kbdlight_mutex);
5314
5315 return ret;
5316 }
5317
5318 static int kbdlight_get_level(void)
5319 {
5320 int status = 0;
5321
5322 if (!hkey_handle)
5323 return -ENXIO;
5324
5325 if (!acpi_evalf(hkey_handle, &status, "MLCG", "dd", 0))
5326 return -EIO;
5327
5328 if (status < 0)
5329 return status;
5330
5331 return status & 0x3;
5332 }
5333
5334 static bool kbdlight_is_supported(void)
5335 {
5336 int status = 0;
5337
5338 if (!hkey_handle)
5339 return false;
5340
5341 if (!acpi_has_method(hkey_handle, "MLCG")) {
5342 vdbg_printk(TPACPI_DBG_INIT, "kbdlight MLCG is unavailable\n");
5343 return false;
5344 }
5345
5346 if (!acpi_evalf(hkey_handle, &status, "MLCG", "qdd", 0)) {
5347 vdbg_printk(TPACPI_DBG_INIT, "kbdlight MLCG failed\n");
5348 return false;
5349 }
5350
5351 if (status < 0) {
5352 vdbg_printk(TPACPI_DBG_INIT, "kbdlight MLCG err: %d\n", status);
5353 return false;
5354 }
5355
5356 vdbg_printk(TPACPI_DBG_INIT, "kbdlight MLCG returned 0x%x\n", status);
5357
5358
5359
5360
5361
5362
5363
5364
5365
5366
5367
5368
5369
5370
5371
5372
5373
5374
5375
5376 return status & BIT(9);
5377 }
5378
5379 static int kbdlight_sysfs_set(struct led_classdev *led_cdev,
5380 enum led_brightness brightness)
5381 {
5382 return kbdlight_set_level(brightness);
5383 }
5384
5385 static enum led_brightness kbdlight_sysfs_get(struct led_classdev *led_cdev)
5386 {
5387 int level;
5388
5389 level = kbdlight_get_level();
5390 if (level < 0)
5391 return 0;
5392
5393 return level;
5394 }
5395
5396 static struct tpacpi_led_classdev tpacpi_led_kbdlight = {
5397 .led_classdev = {
5398 .name = "tpacpi::kbd_backlight",
5399 .max_brightness = 2,
5400 .flags = LED_BRIGHT_HW_CHANGED,
5401 .brightness_set_blocking = &kbdlight_sysfs_set,
5402 .brightness_get = &kbdlight_sysfs_get,
5403 }
5404 };
5405
5406 static int __init kbdlight_init(struct ibm_init_struct *iibm)
5407 {
5408 int rc;
5409
5410 vdbg_printk(TPACPI_DBG_INIT, "initializing kbdlight subdriver\n");
5411
5412 TPACPI_ACPIHANDLE_INIT(hkey);
5413
5414 if (!kbdlight_is_supported()) {
5415 tp_features.kbdlight = 0;
5416 vdbg_printk(TPACPI_DBG_INIT, "kbdlight is unsupported\n");
5417 return 1;
5418 }
5419
5420 kbdlight_brightness = kbdlight_sysfs_get(NULL);
5421 tp_features.kbdlight = 1;
5422
5423 rc = led_classdev_register(&tpacpi_pdev->dev,
5424 &tpacpi_led_kbdlight.led_classdev);
5425 if (rc < 0) {
5426 tp_features.kbdlight = 0;
5427 return rc;
5428 }
5429
5430 tpacpi_hotkey_driver_mask_set(hotkey_driver_mask |
5431 TP_ACPI_HKEY_KBD_LIGHT_MASK);
5432 return 0;
5433 }
5434
5435 static void kbdlight_exit(void)
5436 {
5437 if (tp_features.kbdlight)
5438 led_classdev_unregister(&tpacpi_led_kbdlight.led_classdev);
5439 }
5440
5441 static int kbdlight_set_level_and_update(int level)
5442 {
5443 int ret;
5444 struct led_classdev *led_cdev;
5445
5446 ret = kbdlight_set_level(level);
5447 led_cdev = &tpacpi_led_kbdlight.led_classdev;
5448
5449 if (ret == 0 && !(led_cdev->flags & LED_SUSPENDED))
5450 led_cdev->brightness = level;
5451
5452 return ret;
5453 }
5454
5455 static int kbdlight_read(struct seq_file *m)
5456 {
5457 int level;
5458
5459 if (!tp_features.kbdlight) {
5460 seq_printf(m, "status:\t\tnot supported\n");
5461 } else {
5462 level = kbdlight_get_level();
5463 if (level < 0)
5464 seq_printf(m, "status:\t\terror %d\n", level);
5465 else
5466 seq_printf(m, "status:\t\t%d\n", level);
5467 seq_printf(m, "commands:\t0, 1, 2\n");
5468 }
5469
5470 return 0;
5471 }
5472
5473 static int kbdlight_write(char *buf)
5474 {
5475 char *cmd;
5476 int level = -1;
5477
5478 if (!tp_features.kbdlight)
5479 return -ENODEV;
5480
5481 while ((cmd = next_cmd(&buf))) {
5482 if (strlencmp(cmd, "0") == 0)
5483 level = 0;
5484 else if (strlencmp(cmd, "1") == 0)
5485 level = 1;
5486 else if (strlencmp(cmd, "2") == 0)
5487 level = 2;
5488 else
5489 return -EINVAL;
5490 }
5491
5492 if (level == -1)
5493 return -EINVAL;
5494
5495 return kbdlight_set_level_and_update(level);
5496 }
5497
5498 static void kbdlight_suspend(void)
5499 {
5500 struct led_classdev *led_cdev;
5501
5502 if (!tp_features.kbdlight)
5503 return;
5504
5505 led_cdev = &tpacpi_led_kbdlight.led_classdev;
5506 led_update_brightness(led_cdev);
5507 led_classdev_suspend(led_cdev);
5508 }
5509
5510 static void kbdlight_resume(void)
5511 {
5512 if (!tp_features.kbdlight)
5513 return;
5514
5515 led_classdev_resume(&tpacpi_led_kbdlight.led_classdev);
5516 }
5517
5518 static struct ibm_struct kbdlight_driver_data = {
5519 .name = "kbdlight",
5520 .read = kbdlight_read,
5521 .write = kbdlight_write,
5522 .suspend = kbdlight_suspend,
5523 .resume = kbdlight_resume,
5524 .exit = kbdlight_exit,
5525 };
5526
5527
5528
5529
5530
5531 TPACPI_HANDLE(lght, root, "\\LGHT");
5532 TPACPI_HANDLE(ledb, ec, "LEDB");
5533
5534 static int light_get_status(void)
5535 {
5536 int status = 0;
5537
5538 if (tp_features.light_status) {
5539 if (!acpi_evalf(ec_handle, &status, "KBLT", "d"))
5540 return -EIO;
5541 return (!!status);
5542 }
5543
5544 return -ENXIO;
5545 }
5546
5547 static int light_set_status(int status)
5548 {
5549 int rc;
5550
5551 if (tp_features.light) {
5552 if (cmos_handle) {
5553 rc = acpi_evalf(cmos_handle, NULL, NULL, "vd",
5554 (status) ?
5555 TP_CMOS_THINKLIGHT_ON :
5556 TP_CMOS_THINKLIGHT_OFF);
5557 } else {
5558 rc = acpi_evalf(lght_handle, NULL, NULL, "vd",
5559 (status) ? 1 : 0);
5560 }
5561 return (rc) ? 0 : -EIO;
5562 }
5563
5564 return -ENXIO;
5565 }
5566
5567 static int light_sysfs_set(struct led_classdev *led_cdev,
5568 enum led_brightness brightness)
5569 {
5570 return light_set_status((brightness != LED_OFF) ?
5571 TPACPI_LED_ON : TPACPI_LED_OFF);
5572 }
5573
5574 static enum led_brightness light_sysfs_get(struct led_classdev *led_cdev)
5575 {
5576 return (light_get_status() == 1) ? LED_FULL : LED_OFF;
5577 }
5578
5579 static struct tpacpi_led_classdev tpacpi_led_thinklight = {
5580 .led_classdev = {
5581 .name = "tpacpi::thinklight",
5582 .brightness_set_blocking = &light_sysfs_set,
5583 .brightness_get = &light_sysfs_get,
5584 }
5585 };
5586
5587 static int __init light_init(struct ibm_init_struct *iibm)
5588 {
5589 int rc;
5590
5591 vdbg_printk(TPACPI_DBG_INIT, "initializing light subdriver\n");
5592
5593 if (tpacpi_is_ibm()) {
5594 TPACPI_ACPIHANDLE_INIT(ledb);
5595 TPACPI_ACPIHANDLE_INIT(lght);
5596 }
5597 TPACPI_ACPIHANDLE_INIT(cmos);
5598
5599
5600 tp_features.light = (cmos_handle || lght_handle) && !ledb_handle;
5601
5602 if (tp_features.light)
5603
5604
5605 tp_features.light_status =
5606 acpi_evalf(ec_handle, NULL, "KBLT", "qv");
5607
5608 vdbg_printk(TPACPI_DBG_INIT, "light is %s, light status is %s\n",
5609 str_supported(tp_features.light),
5610 str_supported(tp_features.light_status));
5611
5612 if (!tp_features.light)
5613 return 1;
5614
5615 rc = led_classdev_register(&tpacpi_pdev->dev,
5616 &tpacpi_led_thinklight.led_classdev);
5617
5618 if (rc < 0) {
5619 tp_features.light = 0;
5620 tp_features.light_status = 0;
5621 } else {
5622 rc = 0;
5623 }
5624
5625 return rc;
5626 }
5627
5628 static void light_exit(void)
5629 {
5630 led_classdev_unregister(&tpacpi_led_thinklight.led_classdev);
5631 }
5632
5633 static int light_read(struct seq_file *m)
5634 {
5635 int status;
5636
5637 if (!tp_features.light) {
5638 seq_printf(m, "status:\t\tnot supported\n");
5639 } else if (!tp_features.light_status) {
5640 seq_printf(m, "status:\t\tunknown\n");
5641 seq_printf(m, "commands:\ton, off\n");
5642 } else {
5643 status = light_get_status();
5644 if (status < 0)
5645 return status;
5646 seq_printf(m, "status:\t\t%s\n", onoff(status, 0));
5647 seq_printf(m, "commands:\ton, off\n");
5648 }
5649
5650 return 0;
5651 }
5652
5653 static int light_write(char *buf)
5654 {
5655 char *cmd;
5656 int newstatus = 0;
5657
5658 if (!tp_features.light)
5659 return -ENODEV;
5660
5661 while ((cmd = next_cmd(&buf))) {
5662 if (strlencmp(cmd, "on") == 0) {
5663 newstatus = 1;
5664 } else if (strlencmp(cmd, "off") == 0) {
5665 newstatus = 0;
5666 } else
5667 return -EINVAL;
5668 }
5669
5670 return light_set_status(newstatus);
5671 }
5672
5673 static struct ibm_struct light_driver_data = {
5674 .name = "light",
5675 .read = light_read,
5676 .write = light_write,
5677 .exit = light_exit,
5678 };
5679
5680
5681
5682
5683
5684
5685 static ssize_t cmos_command_store(struct device *dev,
5686 struct device_attribute *attr,
5687 const char *buf, size_t count)
5688 {
5689 unsigned long cmos_cmd;
5690 int res;
5691
5692 if (parse_strtoul(buf, 21, &cmos_cmd))
5693 return -EINVAL;
5694
5695 res = issue_thinkpad_cmos_command(cmos_cmd);
5696 return (res) ? res : count;
5697 }
5698
5699 static DEVICE_ATTR_WO(cmos_command);
5700
5701
5702
5703 static int __init cmos_init(struct ibm_init_struct *iibm)
5704 {
5705 int res;
5706
5707 vdbg_printk(TPACPI_DBG_INIT,
5708 "initializing cmos commands subdriver\n");
5709
5710 TPACPI_ACPIHANDLE_INIT(cmos);
5711
5712 vdbg_printk(TPACPI_DBG_INIT, "cmos commands are %s\n",
5713 str_supported(cmos_handle != NULL));
5714
5715 res = device_create_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
5716 if (res)
5717 return res;
5718
5719 return (cmos_handle) ? 0 : 1;
5720 }
5721
5722 static void cmos_exit(void)
5723 {
5724 device_remove_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
5725 }
5726
5727 static int cmos_read(struct seq_file *m)
5728 {
5729
5730
5731 if (!cmos_handle)
5732 seq_printf(m, "status:\t\tnot supported\n");
5733 else {
5734 seq_printf(m, "status:\t\tsupported\n");
5735 seq_printf(m, "commands:\t<cmd> (<cmd> is 0-21)\n");
5736 }
5737
5738 return 0;
5739 }
5740
5741 static int cmos_write(char *buf)
5742 {
5743 char *cmd;
5744 int cmos_cmd, res;
5745
5746 while ((cmd = next_cmd(&buf))) {
5747 if (sscanf(cmd, "%u", &cmos_cmd) == 1 &&
5748 cmos_cmd >= 0 && cmos_cmd <= 21) {
5749
5750 } else
5751 return -EINVAL;
5752
5753 res = issue_thinkpad_cmos_command(cmos_cmd);
5754 if (res)
5755 return res;
5756 }
5757
5758 return 0;
5759 }
5760
5761 static struct ibm_struct cmos_driver_data = {
5762 .name = "cmos",
5763 .read = cmos_read,
5764 .write = cmos_write,
5765 .exit = cmos_exit,
5766 };
5767
5768
5769
5770
5771
5772 enum led_access_mode {
5773 TPACPI_LED_NONE = 0,
5774 TPACPI_LED_570,
5775 TPACPI_LED_OLD,
5776 TPACPI_LED_NEW,
5777 };
5778
5779 enum {
5780 TPACPI_LED_EC_HLCL = 0x0c,
5781 TPACPI_LED_EC_HLBL = 0x0d,
5782 TPACPI_LED_EC_HLMS = 0x0e,
5783 };
5784
5785 static enum led_access_mode led_supported;
5786
5787 static acpi_handle led_handle;
5788
5789 #define TPACPI_LED_NUMLEDS 16
5790 static struct tpacpi_led_classdev *tpacpi_leds;
5791 static enum led_status_t tpacpi_led_state_cache[TPACPI_LED_NUMLEDS];
5792 static const char * const tpacpi_led_names[TPACPI_LED_NUMLEDS] = {
5793
5794 "tpacpi::power",
5795 "tpacpi:orange:batt",
5796 "tpacpi:green:batt",
5797 "tpacpi::dock_active",
5798 "tpacpi::bay_active",
5799 "tpacpi::dock_batt",
5800 "tpacpi::unknown_led",
5801 "tpacpi::standby",
5802 "tpacpi::dock_status1",
5803 "tpacpi::dock_status2",
5804 "tpacpi::unknown_led2",
5805 "tpacpi::unknown_led3",
5806 "tpacpi::thinkvantage",
5807 };
5808 #define TPACPI_SAFE_LEDS 0x1081U
5809
5810 static inline bool tpacpi_is_led_restricted(const unsigned int led)
5811 {
5812 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
5813 return false;
5814 #else
5815 return (1U & (TPACPI_SAFE_LEDS >> led)) == 0;
5816 #endif
5817 }
5818
5819 static int led_get_status(const unsigned int led)
5820 {
5821 int status;
5822 enum led_status_t led_s;
5823
5824 switch (led_supported) {
5825 case TPACPI_LED_570:
5826 if (!acpi_evalf(ec_handle,
5827 &status, "GLED", "dd", 1 << led))
5828 return -EIO;
5829 led_s = (status == 0) ?
5830 TPACPI_LED_OFF :
5831 ((status == 1) ?
5832 TPACPI_LED_ON :
5833 TPACPI_LED_BLINK);
5834 tpacpi_led_state_cache[led] = led_s;
5835 return led_s;
5836 default:
5837 return -ENXIO;
5838 }
5839
5840
5841 }
5842
5843 static int led_set_status(const unsigned int led,
5844 const enum led_status_t ledstatus)
5845 {
5846
5847 static const unsigned int led_sled_arg1[] = { 0, 1, 3 };
5848 static const unsigned int led_led_arg1[] = { 0, 0x80, 0xc0 };
5849
5850 int rc = 0;
5851
5852 switch (led_supported) {
5853 case TPACPI_LED_570:
5854
5855 if (unlikely(led > 7))
5856 return -EINVAL;
5857 if (unlikely(tpacpi_is_led_restricted(led)))
5858 return -EPERM;
5859 if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
5860 (1 << led), led_sled_arg1[ledstatus]))
5861 return -EIO;
5862 break;
5863 case TPACPI_LED_OLD:
5864
5865 if (unlikely(led > 7))
5866 return -EINVAL;
5867 if (unlikely(tpacpi_is_led_restricted(led)))
5868 return -EPERM;
5869 rc = ec_write(TPACPI_LED_EC_HLMS, (1 << led));
5870 if (rc >= 0)
5871 rc = ec_write(TPACPI_LED_EC_HLBL,
5872 (ledstatus == TPACPI_LED_BLINK) << led);
5873 if (rc >= 0)
5874 rc = ec_write(TPACPI_LED_EC_HLCL,
5875 (ledstatus != TPACPI_LED_OFF) << led);
5876 break;
5877 case TPACPI_LED_NEW:
5878
5879 if (unlikely(led >= TPACPI_LED_NUMLEDS))
5880 return -EINVAL;
5881 if (unlikely(tpacpi_is_led_restricted(led)))
5882 return -EPERM;
5883 if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
5884 led, led_led_arg1[ledstatus]))
5885 return -EIO;
5886 break;
5887 default:
5888 return -ENXIO;
5889 }
5890
5891 if (!rc)
5892 tpacpi_led_state_cache[led] = ledstatus;
5893
5894 return rc;
5895 }
5896
5897 static int led_sysfs_set(struct led_classdev *led_cdev,
5898 enum led_brightness brightness)
5899 {
5900 struct tpacpi_led_classdev *data = container_of(led_cdev,
5901 struct tpacpi_led_classdev, led_classdev);
5902 enum led_status_t new_state;
5903
5904 if (brightness == LED_OFF)
5905 new_state = TPACPI_LED_OFF;
5906 else if (tpacpi_led_state_cache[data->led] != TPACPI_LED_BLINK)
5907 new_state = TPACPI_LED_ON;
5908 else
5909 new_state = TPACPI_LED_BLINK;
5910
5911 return led_set_status(data->led, new_state);
5912 }
5913
5914 static int led_sysfs_blink_set(struct led_classdev *led_cdev,
5915 unsigned long *delay_on, unsigned long *delay_off)
5916 {
5917 struct tpacpi_led_classdev *data = container_of(led_cdev,
5918 struct tpacpi_led_classdev, led_classdev);
5919
5920
5921 if (*delay_on == 0 && *delay_off == 0) {
5922
5923 *delay_on = 500;
5924 *delay_off = 500;
5925 } else if ((*delay_on != 500) || (*delay_off != 500))
5926 return -EINVAL;
5927
5928 return led_set_status(data->led, TPACPI_LED_BLINK);
5929 }
5930
5931 static enum led_brightness led_sysfs_get(struct led_classdev *led_cdev)
5932 {
5933 int rc;
5934
5935 struct tpacpi_led_classdev *data = container_of(led_cdev,
5936 struct tpacpi_led_classdev, led_classdev);
5937
5938 rc = led_get_status(data->led);
5939
5940 if (rc == TPACPI_LED_OFF || rc < 0)
5941 rc = LED_OFF;
5942 else
5943 rc = LED_FULL;
5944
5945 return rc;
5946 }
5947
5948 static void led_exit(void)
5949 {
5950 unsigned int i;
5951
5952 for (i = 0; i < TPACPI_LED_NUMLEDS; i++) {
5953 if (tpacpi_leds[i].led_classdev.name)
5954 led_classdev_unregister(&tpacpi_leds[i].led_classdev);
5955 }
5956
5957 kfree(tpacpi_leds);
5958 }
5959
5960 static int __init tpacpi_init_led(unsigned int led)
5961 {
5962 int rc;
5963
5964 tpacpi_leds[led].led = led;
5965
5966
5967 if (!tpacpi_led_names[led])
5968 return 0;
5969
5970 tpacpi_leds[led].led_classdev.brightness_set_blocking = &led_sysfs_set;
5971 tpacpi_leds[led].led_classdev.blink_set = &led_sysfs_blink_set;
5972 if (led_supported == TPACPI_LED_570)
5973 tpacpi_leds[led].led_classdev.brightness_get =
5974 &led_sysfs_get;
5975
5976 tpacpi_leds[led].led_classdev.name = tpacpi_led_names[led];
5977
5978 rc = led_classdev_register(&tpacpi_pdev->dev,
5979 &tpacpi_leds[led].led_classdev);
5980 if (rc < 0)
5981 tpacpi_leds[led].led_classdev.name = NULL;
5982
5983 return rc;
5984 }
5985
5986 static const struct tpacpi_quirk led_useful_qtable[] __initconst = {
5987 TPACPI_Q_IBM('1', 'E', 0x009f),
5988 TPACPI_Q_IBM('1', 'N', 0x009f),
5989 TPACPI_Q_IBM('1', 'G', 0x009f),
5990
5991 TPACPI_Q_IBM('1', 'I', 0x0097),
5992 TPACPI_Q_IBM('1', 'R', 0x0097),
5993 TPACPI_Q_IBM('7', '0', 0x0097),
5994 TPACPI_Q_IBM('1', 'Y', 0x0097),
5995 TPACPI_Q_IBM('1', 'W', 0x0097),
5996 TPACPI_Q_IBM('1', 'V', 0x0097),
5997 TPACPI_Q_IBM('7', '8', 0x0097),
5998 TPACPI_Q_IBM('7', '6', 0x0097),
5999
6000 TPACPI_Q_IBM('1', 'K', 0x00bf),
6001 TPACPI_Q_IBM('1', 'Q', 0x00bf),
6002 TPACPI_Q_IBM('1', 'U', 0x00bf),
6003 TPACPI_Q_IBM('7', '4', 0x00bf),
6004 TPACPI_Q_IBM('7', '5', 0x00bf),
6005
6006 TPACPI_Q_IBM('7', '9', 0x1f97),
6007 TPACPI_Q_IBM('7', '7', 0x1f97),
6008 TPACPI_Q_IBM('7', 'F', 0x1f97),
6009 TPACPI_Q_IBM('7', 'B', 0x1fb7),
6010
6011
6012
6013
6014 {
6015 .vendor = PCI_VENDOR_ID_LENOVO,
6016 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
6017 .quirks = 0x1fffU,
6018 },
6019 {
6020 .vendor = PCI_VENDOR_ID_IBM,
6021 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_UNKNOWN,
6022 .quirks = 0x00ffU,
6023 },
6024 {
6025 .vendor = PCI_VENDOR_ID_IBM,
6026 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
6027 .quirks = 0x00bfU,
6028 },
6029 };
6030
6031 static enum led_access_mode __init led_init_detect_mode(void)
6032 {
6033 acpi_status status;
6034
6035 if (tpacpi_is_ibm()) {
6036
6037 status = acpi_get_handle(ec_handle, "SLED", &led_handle);
6038 if (ACPI_SUCCESS(status))
6039 return TPACPI_LED_570;
6040
6041
6042 status = acpi_get_handle(ec_handle, "SYSL", &led_handle);
6043 if (ACPI_SUCCESS(status))
6044 return TPACPI_LED_OLD;
6045 }
6046
6047
6048 status = acpi_get_handle(ec_handle, "LED", &led_handle);
6049 if (ACPI_SUCCESS(status))
6050 return TPACPI_LED_NEW;
6051
6052
6053 led_handle = NULL;
6054 return TPACPI_LED_NONE;
6055 }
6056
6057 static int __init led_init(struct ibm_init_struct *iibm)
6058 {
6059 unsigned int i;
6060 int rc;
6061 unsigned long useful_leds;
6062
6063 vdbg_printk(TPACPI_DBG_INIT, "initializing LED subdriver\n");
6064
6065 led_supported = led_init_detect_mode();
6066
6067 if (led_supported != TPACPI_LED_NONE) {
6068 useful_leds = tpacpi_check_quirks(led_useful_qtable,
6069 ARRAY_SIZE(led_useful_qtable));
6070
6071 if (!useful_leds) {
6072 led_handle = NULL;
6073 led_supported = TPACPI_LED_NONE;
6074 }
6075 }
6076
6077 vdbg_printk(TPACPI_DBG_INIT, "LED commands are %s, mode %d\n",
6078 str_supported(led_supported), led_supported);
6079
6080 if (led_supported == TPACPI_LED_NONE)
6081 return 1;
6082
6083 tpacpi_leds = kcalloc(TPACPI_LED_NUMLEDS, sizeof(*tpacpi_leds),
6084 GFP_KERNEL);
6085 if (!tpacpi_leds) {
6086 pr_err("Out of memory for LED data\n");
6087 return -ENOMEM;
6088 }
6089
6090 for (i = 0; i < TPACPI_LED_NUMLEDS; i++) {
6091 tpacpi_leds[i].led = -1;
6092
6093 if (!tpacpi_is_led_restricted(i) &&
6094 test_bit(i, &useful_leds)) {
6095 rc = tpacpi_init_led(i);
6096 if (rc < 0) {
6097 led_exit();
6098 return rc;
6099 }
6100 }
6101 }
6102
6103 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
6104 pr_notice("warning: userspace override of important firmware LEDs is enabled\n");
6105 #endif
6106 return 0;
6107 }
6108
6109 #define str_led_status(s) \
6110 ((s) == TPACPI_LED_OFF ? "off" : \
6111 ((s) == TPACPI_LED_ON ? "on" : "blinking"))
6112
6113 static int led_read(struct seq_file *m)
6114 {
6115 if (!led_supported) {
6116 seq_printf(m, "status:\t\tnot supported\n");
6117 return 0;
6118 }
6119 seq_printf(m, "status:\t\tsupported\n");
6120
6121 if (led_supported == TPACPI_LED_570) {
6122
6123 int i, status;
6124 for (i = 0; i < 8; i++) {
6125 status = led_get_status(i);
6126 if (status < 0)
6127 return -EIO;
6128 seq_printf(m, "%d:\t\t%s\n",
6129 i, str_led_status(status));
6130 }
6131 }
6132
6133 seq_printf(m, "commands:\t<led> on, <led> off, <led> blink (<led> is 0-15)\n");
6134
6135 return 0;
6136 }
6137
6138 static int led_write(char *buf)
6139 {
6140 char *cmd;
6141 int led, rc;
6142 enum led_status_t s;
6143
6144 if (!led_supported)
6145 return -ENODEV;
6146
6147 while ((cmd = next_cmd(&buf))) {
6148 if (sscanf(cmd, "%d", &led) != 1)
6149 return -EINVAL;
6150
6151 if (led < 0 || led > (TPACPI_LED_NUMLEDS - 1) ||
6152 tpacpi_leds[led].led < 0)
6153 return -ENODEV;
6154
6155 if (strstr(cmd, "off")) {
6156 s = TPACPI_LED_OFF;
6157 } else if (strstr(cmd, "on")) {
6158 s = TPACPI_LED_ON;
6159 } else if (strstr(cmd, "blink")) {
6160 s = TPACPI_LED_BLINK;
6161 } else {
6162 return -EINVAL;
6163 }
6164
6165 rc = led_set_status(led, s);
6166 if (rc < 0)
6167 return rc;
6168 }
6169
6170 return 0;
6171 }
6172
6173 static struct ibm_struct led_driver_data = {
6174 .name = "led",
6175 .read = led_read,
6176 .write = led_write,
6177 .exit = led_exit,
6178 };
6179
6180
6181
6182
6183
6184 TPACPI_HANDLE(beep, ec, "BEEP");
6185
6186 #define TPACPI_BEEP_Q1 0x0001
6187
6188 static const struct tpacpi_quirk beep_quirk_table[] __initconst = {
6189 TPACPI_Q_IBM('I', 'M', TPACPI_BEEP_Q1),
6190 TPACPI_Q_IBM('I', 'U', TPACPI_BEEP_Q1),
6191 };
6192
6193 static int __init beep_init(struct ibm_init_struct *iibm)
6194 {
6195 unsigned long quirks;
6196
6197 vdbg_printk(TPACPI_DBG_INIT, "initializing beep subdriver\n");
6198
6199 TPACPI_ACPIHANDLE_INIT(beep);
6200
6201 vdbg_printk(TPACPI_DBG_INIT, "beep is %s\n",
6202 str_supported(beep_handle != NULL));
6203
6204 quirks = tpacpi_check_quirks(beep_quirk_table,
6205 ARRAY_SIZE(beep_quirk_table));
6206
6207 tp_features.beep_needs_two_args = !!(quirks & TPACPI_BEEP_Q1);
6208
6209 return (beep_handle) ? 0 : 1;
6210 }
6211
6212 static int beep_read(struct seq_file *m)
6213 {
6214 if (!beep_handle)
6215 seq_printf(m, "status:\t\tnot supported\n");
6216 else {
6217 seq_printf(m, "status:\t\tsupported\n");
6218 seq_printf(m, "commands:\t<cmd> (<cmd> is 0-17)\n");
6219 }
6220
6221 return 0;
6222 }
6223
6224 static int beep_write(char *buf)
6225 {
6226 char *cmd;
6227 int beep_cmd;
6228
6229 if (!beep_handle)
6230 return -ENODEV;
6231
6232 while ((cmd = next_cmd(&buf))) {
6233 if (sscanf(cmd, "%u", &beep_cmd) == 1 &&
6234 beep_cmd >= 0 && beep_cmd <= 17) {
6235
6236 } else
6237 return -EINVAL;
6238 if (tp_features.beep_needs_two_args) {
6239 if (!acpi_evalf(beep_handle, NULL, NULL, "vdd",
6240 beep_cmd, 0))
6241 return -EIO;
6242 } else {
6243 if (!acpi_evalf(beep_handle, NULL, NULL, "vd",
6244 beep_cmd))
6245 return -EIO;
6246 }
6247 }
6248
6249 return 0;
6250 }
6251
6252 static struct ibm_struct beep_driver_data = {
6253 .name = "beep",
6254 .read = beep_read,
6255 .write = beep_write,
6256 };
6257
6258
6259
6260
6261
6262 enum thermal_access_mode {
6263 TPACPI_THERMAL_NONE = 0,
6264 TPACPI_THERMAL_ACPI_TMP07,
6265 TPACPI_THERMAL_ACPI_UPDT,
6266 TPACPI_THERMAL_TPEC_8,
6267 TPACPI_THERMAL_TPEC_16,
6268 };
6269
6270 enum {
6271 TP_EC_THERMAL_TMP0 = 0x78,
6272 TP_EC_THERMAL_TMP8 = 0xC0,
6273 TP_EC_THERMAL_TMP_NA = -128,
6274
6275 TPACPI_THERMAL_SENSOR_NA = -128000,
6276 };
6277
6278
6279 #define TPACPI_MAX_THERMAL_SENSORS 16
6280 struct ibm_thermal_sensors_struct {
6281 s32 temp[TPACPI_MAX_THERMAL_SENSORS];
6282 };
6283
6284 static enum thermal_access_mode thermal_read_mode;
6285
6286
6287 static int thermal_get_sensor(int idx, s32 *value)
6288 {
6289 int t;
6290 s8 tmp;
6291 char tmpi[5];
6292
6293 t = TP_EC_THERMAL_TMP0;
6294
6295 switch (thermal_read_mode) {
6296 #if TPACPI_MAX_THERMAL_SENSORS >= 16
6297 case TPACPI_THERMAL_TPEC_16:
6298 if (idx >= 8 && idx <= 15) {
6299 t = TP_EC_THERMAL_TMP8;
6300 idx -= 8;
6301 }
6302 #endif
6303
6304 case TPACPI_THERMAL_TPEC_8:
6305 if (idx <= 7) {
6306 if (!acpi_ec_read(t + idx, &tmp))
6307 return -EIO;
6308 *value = tmp * 1000;
6309 return 0;
6310 }
6311 break;
6312
6313 case TPACPI_THERMAL_ACPI_UPDT:
6314 if (idx <= 7) {
6315 snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
6316 if (!acpi_evalf(ec_handle, NULL, "UPDT", "v"))
6317 return -EIO;
6318 if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
6319 return -EIO;
6320 *value = (t - 2732) * 100;
6321 return 0;
6322 }
6323 break;
6324
6325 case TPACPI_THERMAL_ACPI_TMP07:
6326 if (idx <= 7) {
6327 snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
6328 if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
6329 return -EIO;
6330 if (t > 127 || t < -127)
6331 t = TP_EC_THERMAL_TMP_NA;
6332 *value = t * 1000;
6333 return 0;
6334 }
6335 break;
6336
6337 case TPACPI_THERMAL_NONE:
6338 default:
6339 return -ENOSYS;
6340 }
6341
6342 return -EINVAL;
6343 }
6344
6345 static int thermal_get_sensors(struct ibm_thermal_sensors_struct *s)
6346 {
6347 int res, i;
6348 int n;
6349
6350 n = 8;
6351 i = 0;
6352
6353 if (!s)
6354 return -EINVAL;
6355
6356 if (thermal_read_mode == TPACPI_THERMAL_TPEC_16)
6357 n = 16;
6358
6359 for (i = 0 ; i < n; i++) {
6360 res = thermal_get_sensor(i, &s->temp[i]);
6361 if (res)
6362 return res;
6363 }
6364
6365 return n;
6366 }
6367
6368 static void thermal_dump_all_sensors(void)
6369 {
6370 int n, i;
6371 struct ibm_thermal_sensors_struct t;
6372
6373 n = thermal_get_sensors(&t);
6374 if (n <= 0)
6375 return;
6376
6377 pr_notice("temperatures (Celsius):");
6378
6379 for (i = 0; i < n; i++) {
6380 if (t.temp[i] != TPACPI_THERMAL_SENSOR_NA)
6381 pr_cont(" %d", (int)(t.temp[i] / 1000));
6382 else
6383 pr_cont(" N/A");
6384 }
6385
6386 pr_cont("\n");
6387 }
6388
6389
6390
6391 static ssize_t thermal_temp_input_show(struct device *dev,
6392 struct device_attribute *attr,
6393 char *buf)
6394 {
6395 struct sensor_device_attribute *sensor_attr =
6396 to_sensor_dev_attr(attr);
6397 int idx = sensor_attr->index;
6398 s32 value;
6399 int res;
6400
6401 res = thermal_get_sensor(idx, &value);
6402 if (res)
6403 return res;
6404 if (value == TPACPI_THERMAL_SENSOR_NA)
6405 return -ENXIO;
6406
6407 return snprintf(buf, PAGE_SIZE, "%d\n", value);
6408 }
6409
6410 #define THERMAL_SENSOR_ATTR_TEMP(_idxA, _idxB) \
6411 SENSOR_ATTR(temp##_idxA##_input, S_IRUGO, \
6412 thermal_temp_input_show, NULL, _idxB)
6413
6414 static struct sensor_device_attribute sensor_dev_attr_thermal_temp_input[] = {
6415 THERMAL_SENSOR_ATTR_TEMP(1, 0),
6416 THERMAL_SENSOR_ATTR_TEMP(2, 1),
6417 THERMAL_SENSOR_ATTR_TEMP(3, 2),
6418 THERMAL_SENSOR_ATTR_TEMP(4, 3),
6419 THERMAL_SENSOR_ATTR_TEMP(5, 4),
6420 THERMAL_SENSOR_ATTR_TEMP(6, 5),
6421 THERMAL_SENSOR_ATTR_TEMP(7, 6),
6422 THERMAL_SENSOR_ATTR_TEMP(8, 7),
6423 THERMAL_SENSOR_ATTR_TEMP(9, 8),
6424 THERMAL_SENSOR_ATTR_TEMP(10, 9),
6425 THERMAL_SENSOR_ATTR_TEMP(11, 10),
6426 THERMAL_SENSOR_ATTR_TEMP(12, 11),
6427 THERMAL_SENSOR_ATTR_TEMP(13, 12),
6428 THERMAL_SENSOR_ATTR_TEMP(14, 13),
6429 THERMAL_SENSOR_ATTR_TEMP(15, 14),
6430 THERMAL_SENSOR_ATTR_TEMP(16, 15),
6431 };
6432
6433 #define THERMAL_ATTRS(X) \
6434 &sensor_dev_attr_thermal_temp_input[X].dev_attr.attr
6435
6436 static struct attribute *thermal_temp_input_attr[] = {
6437 THERMAL_ATTRS(8),
6438 THERMAL_ATTRS(9),
6439 THERMAL_ATTRS(10),
6440 THERMAL_ATTRS(11),
6441 THERMAL_ATTRS(12),
6442 THERMAL_ATTRS(13),
6443 THERMAL_ATTRS(14),
6444 THERMAL_ATTRS(15),
6445 THERMAL_ATTRS(0),
6446 THERMAL_ATTRS(1),
6447 THERMAL_ATTRS(2),
6448 THERMAL_ATTRS(3),
6449 THERMAL_ATTRS(4),
6450 THERMAL_ATTRS(5),
6451 THERMAL_ATTRS(6),
6452 THERMAL_ATTRS(7),
6453 NULL
6454 };
6455
6456 static const struct attribute_group thermal_temp_input16_group = {
6457 .attrs = thermal_temp_input_attr
6458 };
6459
6460 static const struct attribute_group thermal_temp_input8_group = {
6461 .attrs = &thermal_temp_input_attr[8]
6462 };
6463
6464 #undef THERMAL_SENSOR_ATTR_TEMP
6465 #undef THERMAL_ATTRS
6466
6467
6468
6469 static int __init thermal_init(struct ibm_init_struct *iibm)
6470 {
6471 u8 t, ta1, ta2;
6472 int i;
6473 int acpi_tmp7;
6474 int res;
6475
6476 vdbg_printk(TPACPI_DBG_INIT, "initializing thermal subdriver\n");
6477
6478 acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
6479
6480 if (thinkpad_id.ec_model) {
6481
6482
6483
6484
6485
6486
6487
6488 ta1 = ta2 = 0;
6489 for (i = 0; i < 8; i++) {
6490 if (acpi_ec_read(TP_EC_THERMAL_TMP0 + i, &t)) {
6491 ta1 |= t;
6492 } else {
6493 ta1 = 0;
6494 break;
6495 }
6496 if (acpi_ec_read(TP_EC_THERMAL_TMP8 + i, &t)) {
6497 ta2 |= t;
6498 } else {
6499 ta1 = 0;
6500 break;
6501 }
6502 }
6503 if (ta1 == 0) {
6504
6505 if (acpi_tmp7) {
6506 pr_err("ThinkPad ACPI EC access misbehaving, falling back to ACPI TMPx access mode\n");
6507 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
6508 } else {
6509 pr_err("ThinkPad ACPI EC access misbehaving, disabling thermal sensors access\n");
6510 thermal_read_mode = TPACPI_THERMAL_NONE;
6511 }
6512 } else {
6513 thermal_read_mode =
6514 (ta2 != 0) ?
6515 TPACPI_THERMAL_TPEC_16 : TPACPI_THERMAL_TPEC_8;
6516 }
6517 } else if (acpi_tmp7) {
6518 if (tpacpi_is_ibm() &&
6519 acpi_evalf(ec_handle, NULL, "UPDT", "qv")) {
6520
6521 thermal_read_mode = TPACPI_THERMAL_ACPI_UPDT;
6522 } else {
6523
6524 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
6525 }
6526 } else {
6527
6528 thermal_read_mode = TPACPI_THERMAL_NONE;
6529 }
6530
6531 vdbg_printk(TPACPI_DBG_INIT, "thermal is %s, mode %d\n",
6532 str_supported(thermal_read_mode != TPACPI_THERMAL_NONE),
6533 thermal_read_mode);
6534
6535 switch (thermal_read_mode) {
6536 case TPACPI_THERMAL_TPEC_16:
6537 res = sysfs_create_group(&tpacpi_hwmon->kobj,
6538 &thermal_temp_input16_group);
6539 if (res)
6540 return res;
6541 break;
6542 case TPACPI_THERMAL_TPEC_8:
6543 case TPACPI_THERMAL_ACPI_TMP07:
6544 case TPACPI_THERMAL_ACPI_UPDT:
6545 res = sysfs_create_group(&tpacpi_hwmon->kobj,
6546 &thermal_temp_input8_group);
6547 if (res)
6548 return res;
6549 break;
6550 case TPACPI_THERMAL_NONE:
6551 default:
6552 return 1;
6553 }
6554
6555 return 0;
6556 }
6557
6558 static void thermal_exit(void)
6559 {
6560 switch (thermal_read_mode) {
6561 case TPACPI_THERMAL_TPEC_16:
6562 sysfs_remove_group(&tpacpi_hwmon->kobj,
6563 &thermal_temp_input16_group);
6564 break;
6565 case TPACPI_THERMAL_TPEC_8:
6566 case TPACPI_THERMAL_ACPI_TMP07:
6567 case TPACPI_THERMAL_ACPI_UPDT:
6568 sysfs_remove_group(&tpacpi_hwmon->kobj,
6569 &thermal_temp_input8_group);
6570 break;
6571 case TPACPI_THERMAL_NONE:
6572 default:
6573 break;
6574 }
6575 }
6576
6577 static int thermal_read(struct seq_file *m)
6578 {
6579 int n, i;
6580 struct ibm_thermal_sensors_struct t;
6581
6582 n = thermal_get_sensors(&t);
6583 if (unlikely(n < 0))
6584 return n;
6585
6586 seq_printf(m, "temperatures:\t");
6587
6588 if (n > 0) {
6589 for (i = 0; i < (n - 1); i++)
6590 seq_printf(m, "%d ", t.temp[i] / 1000);
6591 seq_printf(m, "%d\n", t.temp[i] / 1000);
6592 } else
6593 seq_printf(m, "not supported\n");
6594
6595 return 0;
6596 }
6597
6598 static struct ibm_struct thermal_driver_data = {
6599 .name = "thermal",
6600 .read = thermal_read,
6601 .exit = thermal_exit,
6602 };
6603
6604
6605
6606
6607
6608 #define TPACPI_BACKLIGHT_DEV_NAME "thinkpad_screen"
6609
6610
6611
6612
6613
6614
6615
6616
6617
6618
6619
6620
6621
6622
6623
6624
6625
6626
6627
6628 enum {
6629 TP_EC_BACKLIGHT = 0x31,
6630
6631
6632 TP_EC_BACKLIGHT_LVLMSK = 0x1F,
6633 TP_EC_BACKLIGHT_CMDMSK = 0xE0,
6634 TP_EC_BACKLIGHT_MAPSW = 0x20,
6635 };
6636
6637 enum tpacpi_brightness_access_mode {
6638 TPACPI_BRGHT_MODE_AUTO = 0,
6639 TPACPI_BRGHT_MODE_EC,
6640 TPACPI_BRGHT_MODE_UCMS_STEP,
6641 TPACPI_BRGHT_MODE_ECNVRAM,
6642 TPACPI_BRGHT_MODE_MAX
6643 };
6644
6645 static struct backlight_device *ibm_backlight_device;
6646
6647 static enum tpacpi_brightness_access_mode brightness_mode =
6648 TPACPI_BRGHT_MODE_MAX;
6649
6650 static unsigned int brightness_enable = 2;
6651
6652 static struct mutex brightness_mutex;
6653
6654
6655
6656 static unsigned int tpacpi_brightness_nvram_get(void)
6657 {
6658 u8 lnvram;
6659
6660 lnvram = (nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS)
6661 & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
6662 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
6663 lnvram &= bright_maxlvl;
6664
6665 return lnvram;
6666 }
6667
6668 static void tpacpi_brightness_checkpoint_nvram(void)
6669 {
6670 u8 lec = 0;
6671 u8 b_nvram;
6672
6673 if (brightness_mode != TPACPI_BRGHT_MODE_ECNVRAM)
6674 return;
6675
6676 vdbg_printk(TPACPI_DBG_BRGHT,
6677 "trying to checkpoint backlight level to NVRAM...\n");
6678
6679 if (mutex_lock_killable(&brightness_mutex) < 0)
6680 return;
6681
6682 if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec)))
6683 goto unlock;
6684 lec &= TP_EC_BACKLIGHT_LVLMSK;
6685 b_nvram = nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS);
6686
6687 if (lec != ((b_nvram & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
6688 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS)) {
6689
6690 b_nvram &= ~(TP_NVRAM_MASK_LEVEL_BRIGHTNESS <<
6691 TP_NVRAM_POS_LEVEL_BRIGHTNESS);
6692 b_nvram |= lec;
6693 nvram_write_byte(b_nvram, TP_NVRAM_ADDR_BRIGHTNESS);
6694 dbg_printk(TPACPI_DBG_BRGHT,
6695 "updated NVRAM backlight level to %u (0x%02x)\n",
6696 (unsigned int) lec, (unsigned int) b_nvram);
6697 } else
6698 vdbg_printk(TPACPI_DBG_BRGHT,
6699 "NVRAM backlight level already is %u (0x%02x)\n",
6700 (unsigned int) lec, (unsigned int) b_nvram);
6701
6702 unlock:
6703 mutex_unlock(&brightness_mutex);
6704 }
6705
6706
6707
6708 static int tpacpi_brightness_get_raw(int *status)
6709 {
6710 u8 lec = 0;
6711
6712 switch (brightness_mode) {
6713 case TPACPI_BRGHT_MODE_UCMS_STEP:
6714 *status = tpacpi_brightness_nvram_get();
6715 return 0;
6716 case TPACPI_BRGHT_MODE_EC:
6717 case TPACPI_BRGHT_MODE_ECNVRAM:
6718 if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec)))
6719 return -EIO;
6720 *status = lec;
6721 return 0;
6722 default:
6723 return -ENXIO;
6724 }
6725 }
6726
6727
6728
6729 static int tpacpi_brightness_set_ec(unsigned int value)
6730 {
6731 u8 lec = 0;
6732
6733 if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec)))
6734 return -EIO;
6735
6736 if (unlikely(!acpi_ec_write(TP_EC_BACKLIGHT,
6737 (lec & TP_EC_BACKLIGHT_CMDMSK) |
6738 (value & TP_EC_BACKLIGHT_LVLMSK))))
6739 return -EIO;
6740
6741 return 0;
6742 }
6743
6744
6745 static int tpacpi_brightness_set_ucmsstep(unsigned int value)
6746 {
6747 int cmos_cmd, inc;
6748 unsigned int current_value, i;
6749
6750 current_value = tpacpi_brightness_nvram_get();
6751
6752 if (value == current_value)
6753 return 0;
6754
6755 cmos_cmd = (value > current_value) ?
6756 TP_CMOS_BRIGHTNESS_UP :
6757 TP_CMOS_BRIGHTNESS_DOWN;
6758 inc = (value > current_value) ? 1 : -1;
6759
6760 for (i = current_value; i != value; i += inc)
6761 if (issue_thinkpad_cmos_command(cmos_cmd))
6762 return -EIO;
6763
6764 return 0;
6765 }
6766
6767
6768 static int brightness_set(unsigned int value)
6769 {
6770 int res;
6771
6772 if (value > bright_maxlvl)
6773 return -EINVAL;
6774
6775 vdbg_printk(TPACPI_DBG_BRGHT,
6776 "set backlight level to %d\n", value);
6777
6778 res = mutex_lock_killable(&brightness_mutex);
6779 if (res < 0)
6780 return res;
6781
6782 switch (brightness_mode) {
6783 case TPACPI_BRGHT_MODE_EC:
6784 case TPACPI_BRGHT_MODE_ECNVRAM:
6785 res = tpacpi_brightness_set_ec(value);
6786 break;
6787 case TPACPI_BRGHT_MODE_UCMS_STEP:
6788 res = tpacpi_brightness_set_ucmsstep(value);
6789 break;
6790 default:
6791 res = -ENXIO;
6792 }
6793
6794 mutex_unlock(&brightness_mutex);
6795 return res;
6796 }
6797
6798
6799
6800 static int brightness_update_status(struct backlight_device *bd)
6801 {
6802 unsigned int level =
6803 (bd->props.fb_blank == FB_BLANK_UNBLANK &&
6804 bd->props.power == FB_BLANK_UNBLANK) ?
6805 bd->props.brightness : 0;
6806
6807 dbg_printk(TPACPI_DBG_BRGHT,
6808 "backlight: attempt to set level to %d\n",
6809 level);
6810
6811
6812
6813 return brightness_set(level);
6814 }
6815
6816 static int brightness_get(struct backlight_device *bd)
6817 {
6818 int status, res;
6819
6820 res = mutex_lock_killable(&brightness_mutex);
6821 if (res < 0)
6822 return 0;
6823
6824 res = tpacpi_brightness_get_raw(&status);
6825
6826 mutex_unlock(&brightness_mutex);
6827
6828 if (res < 0)
6829 return 0;
6830
6831 return status & TP_EC_BACKLIGHT_LVLMSK;
6832 }
6833
6834 static void tpacpi_brightness_notify_change(void)
6835 {
6836 backlight_force_update(ibm_backlight_device,
6837 BACKLIGHT_UPDATE_HOTKEY);
6838 }
6839
6840 static const struct backlight_ops ibm_backlight_data = {
6841 .get_brightness = brightness_get,
6842 .update_status = brightness_update_status,
6843 };
6844
6845
6846
6847
6848
6849
6850
6851
6852 static int __init tpacpi_query_bcl_levels(acpi_handle handle)
6853 {
6854 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
6855 union acpi_object *obj;
6856 struct acpi_device *device, *child;
6857 int rc;
6858
6859 if (acpi_bus_get_device(handle, &device))
6860 return 0;
6861
6862 rc = 0;
6863 list_for_each_entry(child, &device->children, node) {
6864 acpi_status status = acpi_evaluate_object(child->handle, "_BCL",
6865 NULL, &buffer);
6866 if (ACPI_FAILURE(status))
6867 continue;
6868
6869 obj = (union acpi_object *)buffer.pointer;
6870 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
6871 pr_err("Unknown _BCL data, please report this to %s\n",
6872 TPACPI_MAIL);
6873 rc = 0;
6874 } else {
6875 rc = obj->package.count;
6876 }
6877 break;
6878 }
6879
6880 kfree(buffer.pointer);
6881 return rc;
6882 }
6883
6884
6885
6886
6887
6888 static unsigned int __init tpacpi_check_std_acpi_brightness_support(void)
6889 {
6890 acpi_handle video_device;
6891 int bcl_levels = 0;
6892
6893 tpacpi_acpi_handle_locate("video", NULL, &video_device);
6894 if (video_device)
6895 bcl_levels = tpacpi_query_bcl_levels(video_device);
6896
6897 tp_features.bright_acpimode = (bcl_levels > 0);
6898
6899 return (bcl_levels > 2) ? (bcl_levels - 2) : 0;
6900 }
6901
6902
6903
6904
6905
6906
6907 #define TPACPI_BRGHT_Q_NOEC 0x0001
6908 #define TPACPI_BRGHT_Q_EC 0x0002
6909 #define TPACPI_BRGHT_Q_ASK 0x8000
6910
6911 static const struct tpacpi_quirk brightness_quirk_table[] __initconst = {
6912
6913 TPACPI_Q_IBM('1', 'Y', TPACPI_BRGHT_Q_EC),
6914
6915
6916 TPACPI_Q_IBM('1', 'R', TPACPI_BRGHT_Q_EC),
6917 TPACPI_Q_IBM('1', 'Q', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC),
6918 TPACPI_Q_IBM('7', '6', TPACPI_BRGHT_Q_EC),
6919 TPACPI_Q_IBM('7', '8', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC),
6920
6921
6922 TPACPI_Q_IBM('1', 'U', TPACPI_BRGHT_Q_NOEC),
6923 TPACPI_Q_IBM('1', 'V', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC),
6924 TPACPI_Q_IBM('1', 'W', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC),
6925
6926
6927 TPACPI_Q_IBM('7', '0', TPACPI_BRGHT_Q_NOEC),
6928 TPACPI_Q_IBM('7', '4', TPACPI_BRGHT_Q_NOEC),
6929 TPACPI_Q_IBM('7', '5', TPACPI_BRGHT_Q_NOEC),
6930 };
6931
6932
6933
6934
6935
6936 static void __init tpacpi_detect_brightness_capabilities(void)
6937 {
6938 unsigned int b;
6939
6940 vdbg_printk(TPACPI_DBG_INIT,
6941 "detecting firmware brightness interface capabilities\n");
6942
6943
6944
6945
6946
6947
6948
6949
6950
6951 b = tpacpi_check_std_acpi_brightness_support();
6952 switch (b) {
6953 case 16:
6954 bright_maxlvl = 15;
6955 break;
6956 case 8:
6957 case 0:
6958 bright_maxlvl = 7;
6959 break;
6960 default:
6961 tp_features.bright_unkfw = 1;
6962 bright_maxlvl = b - 1;
6963 }
6964 pr_debug("detected %u brightness levels\n", bright_maxlvl + 1);
6965 }
6966
6967 static int __init brightness_init(struct ibm_init_struct *iibm)
6968 {
6969 struct backlight_properties props;
6970 int b;
6971 unsigned long quirks;
6972
6973 vdbg_printk(TPACPI_DBG_INIT, "initializing brightness subdriver\n");
6974
6975 mutex_init(&brightness_mutex);
6976
6977 quirks = tpacpi_check_quirks(brightness_quirk_table,
6978 ARRAY_SIZE(brightness_quirk_table));
6979
6980
6981
6982
6983 if (tp_features.bright_unkfw)
6984 return 1;
6985
6986 if (!brightness_enable) {
6987 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT,
6988 "brightness support disabled by module parameter\n");
6989 return 1;
6990 }
6991
6992 if (acpi_video_get_backlight_type() != acpi_backlight_vendor) {
6993 if (brightness_enable > 1) {
6994 pr_info("Standard ACPI backlight interface available, not loading native one\n");
6995 return 1;
6996 } else if (brightness_enable == 1) {
6997 pr_warn("Cannot enable backlight brightness support, ACPI is already handling it. Refer to the acpi_backlight kernel parameter.\n");
6998 return 1;
6999 }
7000 } else if (tp_features.bright_acpimode && brightness_enable > 1) {
7001 pr_notice("Standard ACPI backlight interface not available, thinkpad_acpi native brightness control enabled\n");
7002 }
7003
7004
7005
7006
7007
7008
7009 if (brightness_mode > TPACPI_BRGHT_MODE_MAX)
7010 return -EINVAL;
7011
7012
7013 if (brightness_mode == TPACPI_BRGHT_MODE_AUTO ||
7014 brightness_mode == TPACPI_BRGHT_MODE_MAX) {
7015 if (quirks & TPACPI_BRGHT_Q_EC)
7016 brightness_mode = TPACPI_BRGHT_MODE_ECNVRAM;
7017 else
7018 brightness_mode = TPACPI_BRGHT_MODE_UCMS_STEP;
7019
7020 dbg_printk(TPACPI_DBG_BRGHT,
7021 "driver auto-selected brightness_mode=%d\n",
7022 brightness_mode);
7023 }
7024
7025
7026 if (!tpacpi_is_ibm() &&
7027 (brightness_mode == TPACPI_BRGHT_MODE_ECNVRAM ||
7028 brightness_mode == TPACPI_BRGHT_MODE_EC))
7029 return -EINVAL;
7030
7031 if (tpacpi_brightness_get_raw(&b) < 0)
7032 return 1;
7033
7034 memset(&props, 0, sizeof(struct backlight_properties));
7035 props.type = BACKLIGHT_PLATFORM;
7036 props.max_brightness = bright_maxlvl;
7037 props.brightness = b & TP_EC_BACKLIGHT_LVLMSK;
7038 ibm_backlight_device = backlight_device_register(TPACPI_BACKLIGHT_DEV_NAME,
7039 NULL, NULL,
7040 &ibm_backlight_data,
7041 &props);
7042 if (IS_ERR(ibm_backlight_device)) {
7043 int rc = PTR_ERR(ibm_backlight_device);
7044 ibm_backlight_device = NULL;
7045 pr_err("Could not register backlight device\n");
7046 return rc;
7047 }
7048 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT,
7049 "brightness is supported\n");
7050
7051 if (quirks & TPACPI_BRGHT_Q_ASK) {
7052 pr_notice("brightness: will use unverified default: brightness_mode=%d\n",
7053 brightness_mode);
7054 pr_notice("brightness: please report to %s whether it works well or not on your ThinkPad\n",
7055 TPACPI_MAIL);
7056 }
7057
7058
7059
7060
7061
7062 backlight_update_status(ibm_backlight_device);
7063
7064 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT,
7065 "brightness: registering brightness hotkeys as change notification\n");
7066 tpacpi_hotkey_driver_mask_set(hotkey_driver_mask
7067 | TP_ACPI_HKEY_BRGHTUP_MASK
7068 | TP_ACPI_HKEY_BRGHTDWN_MASK);
7069 return 0;
7070 }
7071
7072 static void brightness_suspend(void)
7073 {
7074 tpacpi_brightness_checkpoint_nvram();
7075 }
7076
7077 static void brightness_shutdown(void)
7078 {
7079 tpacpi_brightness_checkpoint_nvram();
7080 }
7081
7082 static void brightness_exit(void)
7083 {
7084 if (ibm_backlight_device) {
7085 vdbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_BRGHT,
7086 "calling backlight_device_unregister()\n");
7087 backlight_device_unregister(ibm_backlight_device);
7088 }
7089
7090 tpacpi_brightness_checkpoint_nvram();
7091 }
7092
7093 static int brightness_read(struct seq_file *m)
7094 {
7095 int level;
7096
7097 level = brightness_get(NULL);
7098 if (level < 0) {
7099 seq_printf(m, "level:\t\tunreadable\n");
7100 } else {
7101 seq_printf(m, "level:\t\t%d\n", level);
7102 seq_printf(m, "commands:\tup, down\n");
7103 seq_printf(m, "commands:\tlevel <level> (<level> is 0-%d)\n",
7104 bright_maxlvl);
7105 }
7106
7107 return 0;
7108 }
7109
7110 static int brightness_write(char *buf)
7111 {
7112 int level;
7113 int rc;
7114 char *cmd;
7115
7116 level = brightness_get(NULL);
7117 if (level < 0)
7118 return level;
7119
7120 while ((cmd = next_cmd(&buf))) {
7121 if (strlencmp(cmd, "up") == 0) {
7122 if (level < bright_maxlvl)
7123 level++;
7124 } else if (strlencmp(cmd, "down") == 0) {
7125 if (level > 0)
7126 level--;
7127 } else if (sscanf(cmd, "level %d", &level) == 1 &&
7128 level >= 0 && level <= bright_maxlvl) {
7129
7130 } else
7131 return -EINVAL;
7132 }
7133
7134 tpacpi_disclose_usertask("procfs brightness",
7135 "set level to %d\n", level);
7136
7137
7138
7139
7140
7141 rc = brightness_set(level);
7142 if (!rc && ibm_backlight_device)
7143 backlight_force_update(ibm_backlight_device,
7144 BACKLIGHT_UPDATE_SYSFS);
7145 return (rc == -EINTR) ? -ERESTARTSYS : rc;
7146 }
7147
7148 static struct ibm_struct brightness_driver_data = {
7149 .name = "brightness",
7150 .read = brightness_read,
7151 .write = brightness_write,
7152 .exit = brightness_exit,
7153 .suspend = brightness_suspend,
7154 .shutdown = brightness_shutdown,
7155 };
7156
7157
7158
7159
7160
7161
7162
7163
7164
7165
7166
7167
7168
7169
7170
7171
7172
7173
7174
7175
7176
7177
7178
7179
7180
7181
7182
7183
7184
7185
7186
7187
7188
7189
7190 #ifdef CONFIG_THINKPAD_ACPI_ALSA_SUPPORT
7191
7192 #define TPACPI_ALSA_DRVNAME "ThinkPad EC"
7193 #define TPACPI_ALSA_SHRTNAME "ThinkPad Console Audio Control"
7194 #define TPACPI_ALSA_MIXERNAME TPACPI_ALSA_SHRTNAME
7195
7196 #if SNDRV_CARDS <= 32
7197 #define DEFAULT_ALSA_IDX ~((1 << (SNDRV_CARDS - 3)) - 1)
7198 #else
7199 #define DEFAULT_ALSA_IDX ~((1 << (32 - 3)) - 1)
7200 #endif
7201 static int alsa_index = DEFAULT_ALSA_IDX;
7202 static char *alsa_id = "ThinkPadEC";
7203 static bool alsa_enable = SNDRV_DEFAULT_ENABLE1;
7204
7205 struct tpacpi_alsa_data {
7206 struct snd_card *card;
7207 struct snd_ctl_elem_id *ctl_mute_id;
7208 struct snd_ctl_elem_id *ctl_vol_id;
7209 };
7210
7211 static struct snd_card *alsa_card;
7212
7213 enum {
7214 TP_EC_AUDIO = 0x30,
7215
7216
7217 TP_EC_AUDIO_MUTESW = 6,
7218
7219
7220 TP_EC_AUDIO_LVL_MSK = 0x0F,
7221 TP_EC_AUDIO_MUTESW_MSK = (1 << TP_EC_AUDIO_MUTESW),
7222
7223
7224 TP_EC_VOLUME_MAX = 14,
7225 };
7226
7227 enum tpacpi_volume_access_mode {
7228 TPACPI_VOL_MODE_AUTO = 0,
7229 TPACPI_VOL_MODE_EC,
7230 TPACPI_VOL_MODE_UCMS_STEP,
7231 TPACPI_VOL_MODE_ECNVRAM,
7232 TPACPI_VOL_MODE_MAX
7233 };
7234
7235 enum tpacpi_volume_capabilities {
7236 TPACPI_VOL_CAP_AUTO = 0,
7237 TPACPI_VOL_CAP_VOLMUTE,
7238 TPACPI_VOL_CAP_MUTEONLY,
7239 TPACPI_VOL_CAP_MAX
7240 };
7241
7242 enum tpacpi_mute_btn_mode {
7243 TP_EC_MUTE_BTN_LATCH = 0,
7244
7245 TP_EC_MUTE_BTN_NONE = 2,
7246 TP_EC_MUTE_BTN_TOGGLE = 3,
7247 };
7248
7249 static enum tpacpi_volume_access_mode volume_mode =
7250 TPACPI_VOL_MODE_MAX;
7251
7252 static enum tpacpi_volume_capabilities volume_capabilities;
7253 static bool volume_control_allowed;
7254 static bool software_mute_requested = true;
7255 static bool software_mute_active;
7256 static int software_mute_orig_mode;
7257
7258
7259
7260
7261
7262 static struct mutex volume_mutex;
7263
7264 static void tpacpi_volume_checkpoint_nvram(void)
7265 {
7266 u8 lec = 0;
7267 u8 b_nvram;
7268 u8 ec_mask;
7269
7270 if (volume_mode != TPACPI_VOL_MODE_ECNVRAM)
7271 return;
7272 if (!volume_control_allowed)
7273 return;
7274 if (software_mute_active)
7275 return;
7276
7277 vdbg_printk(TPACPI_DBG_MIXER,
7278 "trying to checkpoint mixer state to NVRAM...\n");
7279
7280 if (tp_features.mixer_no_level_control)
7281 ec_mask = TP_EC_AUDIO_MUTESW_MSK;
7282 else
7283 ec_mask = TP_EC_AUDIO_MUTESW_MSK | TP_EC_AUDIO_LVL_MSK;
7284
7285 if (mutex_lock_killable(&volume_mutex) < 0)
7286 return;
7287
7288 if (unlikely(!acpi_ec_read(TP_EC_AUDIO, &lec)))
7289 goto unlock;
7290 lec &= ec_mask;
7291 b_nvram = nvram_read_byte(TP_NVRAM_ADDR_MIXER);
7292
7293 if (lec != (b_nvram & ec_mask)) {
7294
7295 b_nvram &= ~ec_mask;
7296 b_nvram |= lec;
7297 nvram_write_byte(b_nvram, TP_NVRAM_ADDR_MIXER);
7298 dbg_printk(TPACPI_DBG_MIXER,
7299 "updated NVRAM mixer status to 0x%02x (0x%02x)\n",
7300 (unsigned int) lec, (unsigned int) b_nvram);
7301 } else {
7302 vdbg_printk(TPACPI_DBG_MIXER,
7303 "NVRAM mixer status already is 0x%02x (0x%02x)\n",
7304 (unsigned int) lec, (unsigned int) b_nvram);
7305 }
7306
7307 unlock:
7308 mutex_unlock(&volume_mutex);
7309 }
7310
7311 static int volume_get_status_ec(u8 *status)
7312 {
7313 u8 s;
7314
7315 if (!acpi_ec_read(TP_EC_AUDIO, &s))
7316 return -EIO;
7317
7318 *status = s;
7319
7320 dbg_printk(TPACPI_DBG_MIXER, "status 0x%02x\n", s);
7321
7322 return 0;
7323 }
7324
7325 static int volume_get_status(u8 *status)
7326 {
7327 return volume_get_status_ec(status);
7328 }
7329
7330 static int volume_set_status_ec(const u8 status)
7331 {
7332 if (!acpi_ec_write(TP_EC_AUDIO, status))
7333 return -EIO;
7334
7335 dbg_printk(TPACPI_DBG_MIXER, "set EC mixer to 0x%02x\n", status);
7336
7337
7338
7339
7340
7341 msleep(1);
7342
7343 return 0;
7344 }
7345
7346 static int volume_set_status(const u8 status)
7347 {
7348 return volume_set_status_ec(status);
7349 }
7350
7351
7352 static int __volume_set_mute_ec(const bool mute)
7353 {
7354 int rc;
7355 u8 s, n;
7356
7357 if (mutex_lock_killable(&volume_mutex) < 0)
7358 return -EINTR;
7359
7360 rc = volume_get_status_ec(&s);
7361 if (rc)
7362 goto unlock;
7363
7364 n = (mute) ? s | TP_EC_AUDIO_MUTESW_MSK :
7365 s & ~TP_EC_AUDIO_MUTESW_MSK;
7366
7367 if (n != s) {
7368 rc = volume_set_status_ec(n);
7369 if (!rc)
7370 rc = 1;
7371 }
7372
7373 unlock:
7374 mutex_unlock(&volume_mutex);
7375 return rc;
7376 }
7377
7378 static int volume_alsa_set_mute(const bool mute)
7379 {
7380 dbg_printk(TPACPI_DBG_MIXER, "ALSA: trying to %smute\n",
7381 (mute) ? "" : "un");
7382 return __volume_set_mute_ec(mute);
7383 }
7384
7385 static int volume_set_mute(const bool mute)
7386 {
7387 int rc;
7388
7389 dbg_printk(TPACPI_DBG_MIXER, "trying to %smute\n",
7390 (mute) ? "" : "un");
7391
7392 rc = __volume_set_mute_ec(mute);
7393 return (rc < 0) ? rc : 0;
7394 }
7395
7396
7397 static int __volume_set_volume_ec(const u8 vol)
7398 {
7399 int rc;
7400 u8 s, n;
7401
7402 if (vol > TP_EC_VOLUME_MAX)
7403 return -EINVAL;
7404
7405 if (mutex_lock_killable(&volume_mutex) < 0)
7406 return -EINTR;
7407
7408 rc = volume_get_status_ec(&s);
7409 if (rc)
7410 goto unlock;
7411
7412 n = (s & ~TP_EC_AUDIO_LVL_MSK) | vol;
7413
7414 if (n != s) {
7415 rc = volume_set_status_ec(n);
7416 if (!rc)
7417 rc = 1;
7418 }
7419
7420 unlock:
7421 mutex_unlock(&volume_mutex);
7422 return rc;
7423 }
7424
7425 static int volume_set_software_mute(bool startup)
7426 {
7427 int result;
7428
7429 if (!tpacpi_is_lenovo())
7430 return -ENODEV;
7431
7432 if (startup) {
7433 if (!acpi_evalf(ec_handle, &software_mute_orig_mode,
7434 "HAUM", "qd"))
7435 return -EIO;
7436
7437 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
7438 "Initial HAUM setting was %d\n",
7439 software_mute_orig_mode);
7440 }
7441
7442 if (!acpi_evalf(ec_handle, &result, "SAUM", "qdd",
7443 (int)TP_EC_MUTE_BTN_NONE))
7444 return -EIO;
7445
7446 if (result != TP_EC_MUTE_BTN_NONE)
7447 pr_warn("Unexpected SAUM result %d\n",
7448 result);
7449
7450
7451
7452
7453
7454
7455
7456 if (tp_features.mixer_no_level_control)
7457 result = volume_set_mute(false);
7458 else
7459 result = volume_set_status(TP_EC_VOLUME_MAX);
7460
7461 if (result != 0)
7462 pr_warn("Failed to unmute the HW mute switch\n");
7463
7464 return 0;
7465 }
7466
7467 static void volume_exit_software_mute(void)
7468 {
7469 int r;
7470
7471 if (!acpi_evalf(ec_handle, &r, "SAUM", "qdd", software_mute_orig_mode)
7472 || r != software_mute_orig_mode)
7473 pr_warn("Failed to restore mute mode\n");
7474 }
7475
7476 static int volume_alsa_set_volume(const u8 vol)
7477 {
7478 dbg_printk(TPACPI_DBG_MIXER,
7479 "ALSA: trying to set volume level to %hu\n", vol);
7480 return __volume_set_volume_ec(vol);
7481 }
7482
7483 static void volume_alsa_notify_change(void)
7484 {
7485 struct tpacpi_alsa_data *d;
7486
7487 if (alsa_card && alsa_card->private_data) {
7488 d = alsa_card->private_data;
7489 if (d->ctl_mute_id)
7490 snd_ctl_notify(alsa_card,
7491 SNDRV_CTL_EVENT_MASK_VALUE,
7492 d->ctl_mute_id);
7493 if (d->ctl_vol_id)
7494 snd_ctl_notify(alsa_card,
7495 SNDRV_CTL_EVENT_MASK_VALUE,
7496 d->ctl_vol_id);
7497 }
7498 }
7499
7500 static int volume_alsa_vol_info(struct snd_kcontrol *kcontrol,
7501 struct snd_ctl_elem_info *uinfo)
7502 {
7503 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
7504 uinfo->count = 1;
7505 uinfo->value.integer.min = 0;
7506 uinfo->value.integer.max = TP_EC_VOLUME_MAX;
7507 return 0;
7508 }
7509
7510 static int volume_alsa_vol_get(struct snd_kcontrol *kcontrol,
7511 struct snd_ctl_elem_value *ucontrol)
7512 {
7513 u8 s;
7514 int rc;
7515
7516 rc = volume_get_status(&s);
7517 if (rc < 0)
7518 return rc;
7519
7520 ucontrol->value.integer.value[0] = s & TP_EC_AUDIO_LVL_MSK;
7521 return 0;
7522 }
7523
7524 static int volume_alsa_vol_put(struct snd_kcontrol *kcontrol,
7525 struct snd_ctl_elem_value *ucontrol)
7526 {
7527 tpacpi_disclose_usertask("ALSA", "set volume to %ld\n",
7528 ucontrol->value.integer.value[0]);
7529 return volume_alsa_set_volume(ucontrol->value.integer.value[0]);
7530 }
7531
7532 #define volume_alsa_mute_info snd_ctl_boolean_mono_info
7533
7534 static int volume_alsa_mute_get(struct snd_kcontrol *kcontrol,
7535 struct snd_ctl_elem_value *ucontrol)
7536 {
7537 u8 s;
7538 int rc;
7539
7540 rc = volume_get_status(&s);
7541 if (rc < 0)
7542 return rc;
7543
7544 ucontrol->value.integer.value[0] =
7545 (s & TP_EC_AUDIO_MUTESW_MSK) ? 0 : 1;
7546 return 0;
7547 }
7548
7549 static int volume_alsa_mute_put(struct snd_kcontrol *kcontrol,
7550 struct snd_ctl_elem_value *ucontrol)
7551 {
7552 tpacpi_disclose_usertask("ALSA", "%smute\n",
7553 ucontrol->value.integer.value[0] ?
7554 "un" : "");
7555 return volume_alsa_set_mute(!ucontrol->value.integer.value[0]);
7556 }
7557
7558 static struct snd_kcontrol_new volume_alsa_control_vol __initdata = {
7559 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7560 .name = "Console Playback Volume",
7561 .index = 0,
7562 .access = SNDRV_CTL_ELEM_ACCESS_READ,
7563 .info = volume_alsa_vol_info,
7564 .get = volume_alsa_vol_get,
7565 };
7566
7567 static struct snd_kcontrol_new volume_alsa_control_mute __initdata = {
7568 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7569 .name = "Console Playback Switch",
7570 .index = 0,
7571 .access = SNDRV_CTL_ELEM_ACCESS_READ,
7572 .info = volume_alsa_mute_info,
7573 .get = volume_alsa_mute_get,
7574 };
7575
7576 static void volume_suspend(void)
7577 {
7578 tpacpi_volume_checkpoint_nvram();
7579 }
7580
7581 static void volume_resume(void)
7582 {
7583 if (software_mute_active) {
7584 if (volume_set_software_mute(false) < 0)
7585 pr_warn("Failed to restore software mute\n");
7586 } else {
7587 volume_alsa_notify_change();
7588 }
7589 }
7590
7591 static void volume_shutdown(void)
7592 {
7593 tpacpi_volume_checkpoint_nvram();
7594 }
7595
7596 static void volume_exit(void)
7597 {
7598 if (alsa_card) {
7599 snd_card_free(alsa_card);
7600 alsa_card = NULL;
7601 }
7602
7603 tpacpi_volume_checkpoint_nvram();
7604
7605 if (software_mute_active)
7606 volume_exit_software_mute();
7607 }
7608
7609 static int __init volume_create_alsa_mixer(void)
7610 {
7611 struct snd_card *card;
7612 struct tpacpi_alsa_data *data;
7613 struct snd_kcontrol *ctl_vol;
7614 struct snd_kcontrol *ctl_mute;
7615 int rc;
7616
7617 rc = snd_card_new(&tpacpi_pdev->dev,
7618 alsa_index, alsa_id, THIS_MODULE,
7619 sizeof(struct tpacpi_alsa_data), &card);
7620 if (rc < 0 || !card) {
7621 pr_err("Failed to create ALSA card structures: %d\n", rc);
7622 return 1;
7623 }
7624
7625 BUG_ON(!card->private_data);
7626 data = card->private_data;
7627 data->card = card;
7628
7629 strlcpy(card->driver, TPACPI_ALSA_DRVNAME,
7630 sizeof(card->driver));
7631 strlcpy(card->shortname, TPACPI_ALSA_SHRTNAME,
7632 sizeof(card->shortname));
7633 snprintf(card->mixername, sizeof(card->mixername), "ThinkPad EC %s",
7634 (thinkpad_id.ec_version_str) ?
7635 thinkpad_id.ec_version_str : "(unknown)");
7636 snprintf(card->longname, sizeof(card->longname),
7637 "%s at EC reg 0x%02x, fw %s", card->shortname, TP_EC_AUDIO,
7638 (thinkpad_id.ec_version_str) ?
7639 thinkpad_id.ec_version_str : "unknown");
7640
7641 if (volume_control_allowed) {
7642 volume_alsa_control_vol.put = volume_alsa_vol_put;
7643 volume_alsa_control_vol.access =
7644 SNDRV_CTL_ELEM_ACCESS_READWRITE;
7645
7646 volume_alsa_control_mute.put = volume_alsa_mute_put;
7647 volume_alsa_control_mute.access =
7648 SNDRV_CTL_ELEM_ACCESS_READWRITE;
7649 }
7650
7651 if (!tp_features.mixer_no_level_control) {
7652 ctl_vol = snd_ctl_new1(&volume_alsa_control_vol, NULL);
7653 rc = snd_ctl_add(card, ctl_vol);
7654 if (rc < 0) {
7655 pr_err("Failed to create ALSA volume control: %d\n",
7656 rc);
7657 goto err_exit;
7658 }
7659 data->ctl_vol_id = &ctl_vol->id;
7660 }
7661
7662 ctl_mute = snd_ctl_new1(&volume_alsa_control_mute, NULL);
7663 rc = snd_ctl_add(card, ctl_mute);
7664 if (rc < 0) {
7665 pr_err("Failed to create ALSA mute control: %d\n", rc);
7666 goto err_exit;
7667 }
7668 data->ctl_mute_id = &ctl_mute->id;
7669
7670 rc = snd_card_register(card);
7671 if (rc < 0) {
7672 pr_err("Failed to register ALSA card: %d\n", rc);
7673 goto err_exit;
7674 }
7675
7676 alsa_card = card;
7677 return 0;
7678
7679 err_exit:
7680 snd_card_free(card);
7681 return 1;
7682 }
7683
7684 #define TPACPI_VOL_Q_MUTEONLY 0x0001
7685 #define TPACPI_VOL_Q_LEVEL 0x0002
7686
7687 static const struct tpacpi_quirk volume_quirk_table[] __initconst = {
7688
7689 { .vendor = PCI_VENDOR_ID_IBM,
7690 .bios = TPACPI_MATCH_ANY,
7691 .ec = TPACPI_MATCH_ANY,
7692 .quirks = TPACPI_VOL_Q_LEVEL },
7693
7694
7695 TPACPI_QEC_LNV('7', 'C', TPACPI_VOL_Q_LEVEL),
7696 TPACPI_QEC_LNV('7', 'E', TPACPI_VOL_Q_LEVEL),
7697 TPACPI_QEC_LNV('7', '9', TPACPI_VOL_Q_LEVEL),
7698 TPACPI_QEC_LNV('7', 'B', TPACPI_VOL_Q_LEVEL),
7699 TPACPI_QEC_LNV('7', 'J', TPACPI_VOL_Q_LEVEL),
7700 TPACPI_QEC_LNV('7', '7', TPACPI_VOL_Q_LEVEL),
7701 TPACPI_QEC_LNV('7', 'F', TPACPI_VOL_Q_LEVEL),
7702
7703
7704 { .vendor = PCI_VENDOR_ID_LENOVO,
7705 .bios = TPACPI_MATCH_ANY,
7706 .ec = TPACPI_MATCH_ANY,
7707 .quirks = TPACPI_VOL_Q_MUTEONLY }
7708 };
7709
7710 static int __init volume_init(struct ibm_init_struct *iibm)
7711 {
7712 unsigned long quirks;
7713 int rc;
7714
7715 vdbg_printk(TPACPI_DBG_INIT, "initializing volume subdriver\n");
7716
7717 mutex_init(&volume_mutex);
7718
7719
7720
7721
7722
7723
7724 if (volume_mode > TPACPI_VOL_MODE_MAX)
7725 return -EINVAL;
7726
7727 if (volume_mode == TPACPI_VOL_MODE_UCMS_STEP) {
7728 pr_err("UCMS step volume mode not implemented, please contact %s\n",
7729 TPACPI_MAIL);
7730 return 1;
7731 }
7732
7733 if (volume_capabilities >= TPACPI_VOL_CAP_MAX)
7734 return -EINVAL;
7735
7736
7737
7738
7739
7740 if (!alsa_enable) {
7741 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
7742 "ALSA mixer disabled by parameter, not loading volume subdriver...\n");
7743 return 1;
7744 }
7745
7746 quirks = tpacpi_check_quirks(volume_quirk_table,
7747 ARRAY_SIZE(volume_quirk_table));
7748
7749 switch (volume_capabilities) {
7750 case TPACPI_VOL_CAP_AUTO:
7751 if (quirks & TPACPI_VOL_Q_MUTEONLY)
7752 tp_features.mixer_no_level_control = 1;
7753 else if (quirks & TPACPI_VOL_Q_LEVEL)
7754 tp_features.mixer_no_level_control = 0;
7755 else
7756 return 1;
7757 break;
7758 case TPACPI_VOL_CAP_VOLMUTE:
7759 tp_features.mixer_no_level_control = 0;
7760 break;
7761 case TPACPI_VOL_CAP_MUTEONLY:
7762 tp_features.mixer_no_level_control = 1;
7763 break;
7764 default:
7765 return 1;
7766 }
7767
7768 if (volume_capabilities != TPACPI_VOL_CAP_AUTO)
7769 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
7770 "using user-supplied volume_capabilities=%d\n",
7771 volume_capabilities);
7772
7773 if (volume_mode == TPACPI_VOL_MODE_AUTO ||
7774 volume_mode == TPACPI_VOL_MODE_MAX) {
7775 volume_mode = TPACPI_VOL_MODE_ECNVRAM;
7776
7777 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
7778 "driver auto-selected volume_mode=%d\n",
7779 volume_mode);
7780 } else {
7781 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
7782 "using user-supplied volume_mode=%d\n",
7783 volume_mode);
7784 }
7785
7786 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
7787 "mute is supported, volume control is %s\n",
7788 str_supported(!tp_features.mixer_no_level_control));
7789
7790 if (software_mute_requested && volume_set_software_mute(true) == 0) {
7791 software_mute_active = true;
7792 } else {
7793 rc = volume_create_alsa_mixer();
7794 if (rc) {
7795 pr_err("Could not create the ALSA mixer interface\n");
7796 return rc;
7797 }
7798
7799 pr_info("Console audio control enabled, mode: %s\n",
7800 (volume_control_allowed) ?
7801 "override (read/write)" :
7802 "monitor (read only)");
7803 }
7804
7805 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
7806 "registering volume hotkeys as change notification\n");
7807 tpacpi_hotkey_driver_mask_set(hotkey_driver_mask
7808 | TP_ACPI_HKEY_VOLUP_MASK
7809 | TP_ACPI_HKEY_VOLDWN_MASK
7810 | TP_ACPI_HKEY_MUTE_MASK);
7811
7812 return 0;
7813 }
7814
7815 static int volume_read(struct seq_file *m)
7816 {
7817 u8 status;
7818
7819 if (volume_get_status(&status) < 0) {
7820 seq_printf(m, "level:\t\tunreadable\n");
7821 } else {
7822 if (tp_features.mixer_no_level_control)
7823 seq_printf(m, "level:\t\tunsupported\n");
7824 else
7825 seq_printf(m, "level:\t\t%d\n",
7826 status & TP_EC_AUDIO_LVL_MSK);
7827
7828 seq_printf(m, "mute:\t\t%s\n",
7829 onoff(status, TP_EC_AUDIO_MUTESW));
7830
7831 if (volume_control_allowed) {
7832 seq_printf(m, "commands:\tunmute, mute\n");
7833 if (!tp_features.mixer_no_level_control) {
7834 seq_printf(m, "commands:\tup, down\n");
7835 seq_printf(m, "commands:\tlevel <level> (<level> is 0-%d)\n",
7836 TP_EC_VOLUME_MAX);
7837 }
7838 }
7839 }
7840
7841 return 0;
7842 }
7843
7844 static int volume_write(char *buf)
7845 {
7846 u8 s;
7847 u8 new_level, new_mute;
7848 int l;
7849 char *cmd;
7850 int rc;
7851
7852
7853
7854
7855
7856 if (!volume_control_allowed && tpacpi_lifecycle != TPACPI_LIFE_INIT) {
7857 if (unlikely(!tp_warned.volume_ctrl_forbidden)) {
7858 tp_warned.volume_ctrl_forbidden = 1;
7859 pr_notice("Console audio control in monitor mode, changes are not allowed\n");
7860 pr_notice("Use the volume_control=1 module parameter to enable volume control\n");
7861 }
7862 return -EPERM;
7863 }
7864
7865 rc = volume_get_status(&s);
7866 if (rc < 0)
7867 return rc;
7868
7869 new_level = s & TP_EC_AUDIO_LVL_MSK;
7870 new_mute = s & TP_EC_AUDIO_MUTESW_MSK;
7871
7872 while ((cmd = next_cmd(&buf))) {
7873 if (!tp_features.mixer_no_level_control) {
7874 if (strlencmp(cmd, "up") == 0) {
7875 if (new_mute)
7876 new_mute = 0;
7877 else if (new_level < TP_EC_VOLUME_MAX)
7878 new_level++;
7879 continue;
7880 } else if (strlencmp(cmd, "down") == 0) {
7881 if (new_mute)
7882 new_mute = 0;
7883 else if (new_level > 0)
7884 new_level--;
7885 continue;
7886 } else if (sscanf(cmd, "level %u", &l) == 1 &&
7887 l >= 0 && l <= TP_EC_VOLUME_MAX) {
7888 new_level = l;
7889 continue;
7890 }
7891 }
7892 if (strlencmp(cmd, "mute") == 0)
7893 new_mute = TP_EC_AUDIO_MUTESW_MSK;
7894 else if (strlencmp(cmd, "unmute") == 0)
7895 new_mute = 0;
7896 else
7897 return -EINVAL;
7898 }
7899
7900 if (tp_features.mixer_no_level_control) {
7901 tpacpi_disclose_usertask("procfs volume", "%smute\n",
7902 new_mute ? "" : "un");
7903 rc = volume_set_mute(!!new_mute);
7904 } else {
7905 tpacpi_disclose_usertask("procfs volume",
7906 "%smute and set level to %d\n",
7907 new_mute ? "" : "un", new_level);
7908 rc = volume_set_status(new_mute | new_level);
7909 }
7910 volume_alsa_notify_change();
7911
7912 return (rc == -EINTR) ? -ERESTARTSYS : rc;
7913 }
7914
7915 static struct ibm_struct volume_driver_data = {
7916 .name = "volume",
7917 .read = volume_read,
7918 .write = volume_write,
7919 .exit = volume_exit,
7920 .suspend = volume_suspend,
7921 .resume = volume_resume,
7922 .shutdown = volume_shutdown,
7923 };
7924
7925 #else
7926
7927 #define alsa_card NULL
7928
7929 static inline void volume_alsa_notify_change(void)
7930 {
7931 }
7932
7933 static int __init volume_init(struct ibm_init_struct *iibm)
7934 {
7935 pr_info("volume: disabled as there is no ALSA support in this kernel\n");
7936
7937 return 1;
7938 }
7939
7940 static struct ibm_struct volume_driver_data = {
7941 .name = "volume",
7942 };
7943
7944 #endif
7945
7946
7947
7948
7949
7950
7951
7952
7953
7954
7955
7956
7957
7958
7959
7960
7961
7962
7963
7964
7965
7966
7967
7968
7969
7970
7971
7972
7973
7974
7975
7976
7977
7978
7979
7980
7981
7982
7983
7984
7985
7986
7987
7988
7989
7990
7991
7992
7993
7994
7995
7996
7997
7998
7999
8000
8001
8002
8003
8004
8005
8006
8007
8008
8009
8010
8011
8012
8013
8014
8015
8016
8017
8018
8019
8020
8021
8022
8023
8024
8025
8026
8027
8028
8029
8030
8031
8032
8033
8034
8035
8036
8037
8038
8039
8040
8041
8042
8043
8044
8045
8046
8047
8048
8049
8050
8051
8052
8053
8054
8055
8056
8057
8058
8059
8060
8061
8062
8063
8064
8065
8066 enum {
8067 fan_status_offset = 0x2f,
8068 fan_rpm_offset = 0x84,
8069
8070 fan_select_offset = 0x31,
8071
8072
8073 TP_EC_FAN_FULLSPEED = 0x40,
8074 TP_EC_FAN_AUTO = 0x80,
8075
8076 TPACPI_FAN_LAST_LEVEL = 0x100,
8077 };
8078
8079 enum fan_status_access_mode {
8080 TPACPI_FAN_NONE = 0,
8081 TPACPI_FAN_RD_ACPI_GFAN,
8082 TPACPI_FAN_RD_TPEC,
8083 };
8084
8085 enum fan_control_access_mode {
8086 TPACPI_FAN_WR_NONE = 0,
8087 TPACPI_FAN_WR_ACPI_SFAN,
8088 TPACPI_FAN_WR_TPEC,
8089 TPACPI_FAN_WR_ACPI_FANS,
8090 };
8091
8092 enum fan_control_commands {
8093 TPACPI_FAN_CMD_SPEED = 0x0001,
8094 TPACPI_FAN_CMD_LEVEL = 0x0002,
8095 TPACPI_FAN_CMD_ENABLE = 0x0004,
8096
8097 };
8098
8099 static bool fan_control_allowed;
8100
8101 static enum fan_status_access_mode fan_status_access_mode;
8102 static enum fan_control_access_mode fan_control_access_mode;
8103 static enum fan_control_commands fan_control_commands;
8104
8105 static u8 fan_control_initial_status;
8106 static u8 fan_control_desired_level;
8107 static u8 fan_control_resume_level;
8108 static int fan_watchdog_maxinterval;
8109
8110 static struct mutex fan_mutex;
8111
8112 static void fan_watchdog_fire(struct work_struct *ignored);
8113 static DECLARE_DELAYED_WORK(fan_watchdog_task, fan_watchdog_fire);
8114
8115 TPACPI_HANDLE(fans, ec, "FANS");
8116 TPACPI_HANDLE(gfan, ec, "GFAN",
8117 "\\FSPD",
8118 );
8119 TPACPI_HANDLE(sfan, ec, "SFAN",
8120 "JFNS",
8121 );
8122
8123
8124
8125
8126
8127
8128
8129
8130
8131
8132
8133
8134
8135
8136
8137
8138
8139 static void fan_quirk1_setup(void)
8140 {
8141 if (fan_control_initial_status == 0x07) {
8142 pr_notice("fan_init: initial fan status is unknown, assuming it is in auto mode\n");
8143 tp_features.fan_ctrl_status_undef = 1;
8144 }
8145 }
8146
8147 static void fan_quirk1_handle(u8 *fan_status)
8148 {
8149 if (unlikely(tp_features.fan_ctrl_status_undef)) {
8150 if (*fan_status != fan_control_initial_status) {
8151
8152
8153
8154 tp_features.fan_ctrl_status_undef = 0;
8155 } else {
8156
8157
8158 *fan_status = TP_EC_FAN_AUTO;
8159 }
8160 }
8161 }
8162
8163
8164 static bool fan_select_fan1(void)
8165 {
8166 if (tp_features.second_fan) {
8167 u8 val;
8168
8169 if (ec_read(fan_select_offset, &val) < 0)
8170 return false;
8171 val &= 0xFEU;
8172 if (ec_write(fan_select_offset, val) < 0)
8173 return false;
8174 }
8175 return true;
8176 }
8177
8178
8179 static bool fan_select_fan2(void)
8180 {
8181 u8 val;
8182
8183 if (!tp_features.second_fan)
8184 return false;
8185
8186 if (ec_read(fan_select_offset, &val) < 0)
8187 return false;
8188 val |= 0x01U;
8189 if (ec_write(fan_select_offset, val) < 0)
8190 return false;
8191
8192 return true;
8193 }
8194
8195
8196
8197
8198 static void fan_update_desired_level(u8 status)
8199 {
8200 if ((status &
8201 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) {
8202 if (status > 7)
8203 fan_control_desired_level = 7;
8204 else
8205 fan_control_desired_level = status;
8206 }
8207 }
8208
8209 static int fan_get_status(u8 *status)
8210 {
8211 u8 s;
8212
8213
8214
8215
8216 switch (fan_status_access_mode) {
8217 case TPACPI_FAN_RD_ACPI_GFAN: {
8218
8219 int res;
8220
8221 if (unlikely(!acpi_evalf(gfan_handle, &res, NULL, "d")))
8222 return -EIO;
8223
8224 if (likely(status))
8225 *status = res & 0x07;
8226
8227 break;
8228 }
8229 case TPACPI_FAN_RD_TPEC:
8230
8231 if (unlikely(!acpi_ec_read(fan_status_offset, &s)))
8232 return -EIO;
8233
8234 if (likely(status)) {
8235 *status = s;
8236 fan_quirk1_handle(status);
8237 }
8238
8239 break;
8240
8241 default:
8242 return -ENXIO;
8243 }
8244
8245 return 0;
8246 }
8247
8248 static int fan_get_status_safe(u8 *status)
8249 {
8250 int rc;
8251 u8 s;
8252
8253 if (mutex_lock_killable(&fan_mutex))
8254 return -ERESTARTSYS;
8255 rc = fan_get_status(&s);
8256 if (!rc)
8257 fan_update_desired_level(s);
8258 mutex_unlock(&fan_mutex);
8259
8260 if (rc)
8261 return rc;
8262 if (status)
8263 *status = s;
8264
8265 return 0;
8266 }
8267
8268 static int fan_get_speed(unsigned int *speed)
8269 {
8270 u8 hi, lo;
8271
8272 switch (fan_status_access_mode) {
8273 case TPACPI_FAN_RD_TPEC:
8274
8275 if (unlikely(!fan_select_fan1()))
8276 return -EIO;
8277 if (unlikely(!acpi_ec_read(fan_rpm_offset, &lo) ||
8278 !acpi_ec_read(fan_rpm_offset + 1, &hi)))
8279 return -EIO;
8280
8281 if (likely(speed))
8282 *speed = (hi << 8) | lo;
8283
8284 break;
8285
8286 default:
8287 return -ENXIO;
8288 }
8289
8290 return 0;
8291 }
8292
8293 static int fan2_get_speed(unsigned int *speed)
8294 {
8295 u8 hi, lo;
8296 bool rc;
8297
8298 switch (fan_status_access_mode) {
8299 case TPACPI_FAN_RD_TPEC:
8300
8301 if (unlikely(!fan_select_fan2()))
8302 return -EIO;
8303 rc = !acpi_ec_read(fan_rpm_offset, &lo) ||
8304 !acpi_ec_read(fan_rpm_offset + 1, &hi);
8305 fan_select_fan1();
8306 if (rc)
8307 return -EIO;
8308
8309 if (likely(speed))
8310 *speed = (hi << 8) | lo;
8311
8312 break;
8313
8314 default:
8315 return -ENXIO;
8316 }
8317
8318 return 0;
8319 }
8320
8321 static int fan_set_level(int level)
8322 {
8323 if (!fan_control_allowed)
8324 return -EPERM;
8325
8326 switch (fan_control_access_mode) {
8327 case TPACPI_FAN_WR_ACPI_SFAN:
8328 if (level >= 0 && level <= 7) {
8329 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", level))
8330 return -EIO;
8331 } else
8332 return -EINVAL;
8333 break;
8334
8335 case TPACPI_FAN_WR_ACPI_FANS:
8336 case TPACPI_FAN_WR_TPEC:
8337 if (!(level & TP_EC_FAN_AUTO) &&
8338 !(level & TP_EC_FAN_FULLSPEED) &&
8339 ((level < 0) || (level > 7)))
8340 return -EINVAL;
8341
8342
8343
8344 if (level & TP_EC_FAN_FULLSPEED)
8345 level |= 7;
8346 else if (level & TP_EC_FAN_AUTO)
8347 level |= 4;
8348
8349 if (!acpi_ec_write(fan_status_offset, level))
8350 return -EIO;
8351 else
8352 tp_features.fan_ctrl_status_undef = 0;
8353 break;
8354
8355 default:
8356 return -ENXIO;
8357 }
8358
8359 vdbg_printk(TPACPI_DBG_FAN,
8360 "fan control: set fan control register to 0x%02x\n", level);
8361 return 0;
8362 }
8363
8364 static int fan_set_level_safe(int level)
8365 {
8366 int rc;
8367
8368 if (!fan_control_allowed)
8369 return -EPERM;
8370
8371 if (mutex_lock_killable(&fan_mutex))
8372 return -ERESTARTSYS;
8373
8374 if (level == TPACPI_FAN_LAST_LEVEL)
8375 level = fan_control_desired_level;
8376
8377 rc = fan_set_level(level);
8378 if (!rc)
8379 fan_update_desired_level(level);
8380
8381 mutex_unlock(&fan_mutex);
8382 return rc;
8383 }
8384
8385 static int fan_set_enable(void)
8386 {
8387 u8 s;
8388 int rc;
8389
8390 if (!fan_control_allowed)
8391 return -EPERM;
8392
8393 if (mutex_lock_killable(&fan_mutex))
8394 return -ERESTARTSYS;
8395
8396 switch (fan_control_access_mode) {
8397 case TPACPI_FAN_WR_ACPI_FANS:
8398 case TPACPI_FAN_WR_TPEC:
8399 rc = fan_get_status(&s);
8400 if (rc < 0)
8401 break;
8402
8403
8404 if (s != 7) {
8405 s &= 0x07;
8406 s |= TP_EC_FAN_AUTO | 4;
8407 }
8408
8409 if (!acpi_ec_write(fan_status_offset, s))
8410 rc = -EIO;
8411 else {
8412 tp_features.fan_ctrl_status_undef = 0;
8413 rc = 0;
8414 }
8415 break;
8416
8417 case TPACPI_FAN_WR_ACPI_SFAN:
8418 rc = fan_get_status(&s);
8419 if (rc < 0)
8420 break;
8421
8422 s &= 0x07;
8423
8424
8425 s |= 4;
8426
8427 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", s))
8428 rc = -EIO;
8429 else
8430 rc = 0;
8431 break;
8432
8433 default:
8434 rc = -ENXIO;
8435 }
8436
8437 mutex_unlock(&fan_mutex);
8438
8439 if (!rc)
8440 vdbg_printk(TPACPI_DBG_FAN,
8441 "fan control: set fan control register to 0x%02x\n",
8442 s);
8443 return rc;
8444 }
8445
8446 static int fan_set_disable(void)
8447 {
8448 int rc;
8449
8450 if (!fan_control_allowed)
8451 return -EPERM;
8452
8453 if (mutex_lock_killable(&fan_mutex))
8454 return -ERESTARTSYS;
8455
8456 rc = 0;
8457 switch (fan_control_access_mode) {
8458 case TPACPI_FAN_WR_ACPI_FANS:
8459 case TPACPI_FAN_WR_TPEC:
8460 if (!acpi_ec_write(fan_status_offset, 0x00))
8461 rc = -EIO;
8462 else {
8463 fan_control_desired_level = 0;
8464 tp_features.fan_ctrl_status_undef = 0;
8465 }
8466 break;
8467
8468 case TPACPI_FAN_WR_ACPI_SFAN:
8469 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", 0x00))
8470 rc = -EIO;
8471 else
8472 fan_control_desired_level = 0;
8473 break;
8474
8475 default:
8476 rc = -ENXIO;
8477 }
8478
8479 if (!rc)
8480 vdbg_printk(TPACPI_DBG_FAN,
8481 "fan control: set fan control register to 0\n");
8482
8483 mutex_unlock(&fan_mutex);
8484 return rc;
8485 }
8486
8487 static int fan_set_speed(int speed)
8488 {
8489 int rc;
8490
8491 if (!fan_control_allowed)
8492 return -EPERM;
8493
8494 if (mutex_lock_killable(&fan_mutex))
8495 return -ERESTARTSYS;
8496
8497 rc = 0;
8498 switch (fan_control_access_mode) {
8499 case TPACPI_FAN_WR_ACPI_FANS:
8500 if (speed >= 0 && speed <= 65535) {
8501 if (!acpi_evalf(fans_handle, NULL, NULL, "vddd",
8502 speed, speed, speed))
8503 rc = -EIO;
8504 } else
8505 rc = -EINVAL;
8506 break;
8507
8508 default:
8509 rc = -ENXIO;
8510 }
8511
8512 mutex_unlock(&fan_mutex);
8513 return rc;
8514 }
8515
8516 static void fan_watchdog_reset(void)
8517 {
8518 if (fan_control_access_mode == TPACPI_FAN_WR_NONE)
8519 return;
8520
8521 if (fan_watchdog_maxinterval > 0 &&
8522 tpacpi_lifecycle != TPACPI_LIFE_EXITING)
8523 mod_delayed_work(tpacpi_wq, &fan_watchdog_task,
8524 msecs_to_jiffies(fan_watchdog_maxinterval * 1000));
8525 else
8526 cancel_delayed_work(&fan_watchdog_task);
8527 }
8528
8529 static void fan_watchdog_fire(struct work_struct *ignored)
8530 {
8531 int rc;
8532
8533 if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
8534 return;
8535
8536 pr_notice("fan watchdog: enabling fan\n");
8537 rc = fan_set_enable();
8538 if (rc < 0) {
8539 pr_err("fan watchdog: error %d while enabling fan, will try again later...\n",
8540 rc);
8541
8542 fan_watchdog_reset();
8543 }
8544 }
8545
8546
8547
8548
8549
8550
8551
8552
8553
8554
8555
8556
8557
8558
8559
8560
8561
8562
8563
8564
8565
8566
8567
8568 static ssize_t fan_pwm1_enable_show(struct device *dev,
8569 struct device_attribute *attr,
8570 char *buf)
8571 {
8572 int res, mode;
8573 u8 status;
8574
8575 res = fan_get_status_safe(&status);
8576 if (res)
8577 return res;
8578
8579 if (status & TP_EC_FAN_FULLSPEED) {
8580 mode = 0;
8581 } else if (status & TP_EC_FAN_AUTO) {
8582 mode = 2;
8583 } else
8584 mode = 1;
8585
8586 return snprintf(buf, PAGE_SIZE, "%d\n", mode);
8587 }
8588
8589 static ssize_t fan_pwm1_enable_store(struct device *dev,
8590 struct device_attribute *attr,
8591 const char *buf, size_t count)
8592 {
8593 unsigned long t;
8594 int res, level;
8595
8596 if (parse_strtoul(buf, 2, &t))
8597 return -EINVAL;
8598
8599 tpacpi_disclose_usertask("hwmon pwm1_enable",
8600 "set fan mode to %lu\n", t);
8601
8602 switch (t) {
8603 case 0:
8604 level = TP_EC_FAN_FULLSPEED;
8605 break;
8606 case 1:
8607 level = TPACPI_FAN_LAST_LEVEL;
8608 break;
8609 case 2:
8610 level = TP_EC_FAN_AUTO;
8611 break;
8612 case 3:
8613
8614 return -ENOSYS;
8615 default:
8616 return -EINVAL;
8617 }
8618
8619 res = fan_set_level_safe(level);
8620 if (res == -ENXIO)
8621 return -EINVAL;
8622 else if (res < 0)
8623 return res;
8624
8625 fan_watchdog_reset();
8626
8627 return count;
8628 }
8629
8630 static DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
8631 fan_pwm1_enable_show, fan_pwm1_enable_store);
8632
8633
8634 static ssize_t fan_pwm1_show(struct device *dev,
8635 struct device_attribute *attr,
8636 char *buf)
8637 {
8638 int res;
8639 u8 status;
8640
8641 res = fan_get_status_safe(&status);
8642 if (res)
8643 return res;
8644
8645 if ((status &
8646 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) != 0)
8647 status = fan_control_desired_level;
8648
8649 if (status > 7)
8650 status = 7;
8651
8652 return snprintf(buf, PAGE_SIZE, "%u\n", (status * 255) / 7);
8653 }
8654
8655 static ssize_t fan_pwm1_store(struct device *dev,
8656 struct device_attribute *attr,
8657 const char *buf, size_t count)
8658 {
8659 unsigned long s;
8660 int rc;
8661 u8 status, newlevel;
8662
8663 if (parse_strtoul(buf, 255, &s))
8664 return -EINVAL;
8665
8666 tpacpi_disclose_usertask("hwmon pwm1",
8667 "set fan speed to %lu\n", s);
8668
8669
8670 newlevel = (s >> 5) & 0x07;
8671
8672 if (mutex_lock_killable(&fan_mutex))
8673 return -ERESTARTSYS;
8674
8675 rc = fan_get_status(&status);
8676 if (!rc && (status &
8677 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) {
8678 rc = fan_set_level(newlevel);
8679 if (rc == -ENXIO)
8680 rc = -EINVAL;
8681 else if (!rc) {
8682 fan_update_desired_level(newlevel);
8683 fan_watchdog_reset();
8684 }
8685 }
8686
8687 mutex_unlock(&fan_mutex);
8688 return (rc) ? rc : count;
8689 }
8690
8691 static DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, fan_pwm1_show, fan_pwm1_store);
8692
8693
8694 static ssize_t fan_fan1_input_show(struct device *dev,
8695 struct device_attribute *attr,
8696 char *buf)
8697 {
8698 int res;
8699 unsigned int speed;
8700
8701 res = fan_get_speed(&speed);
8702 if (res < 0)
8703 return res;
8704
8705 return snprintf(buf, PAGE_SIZE, "%u\n", speed);
8706 }
8707
8708 static DEVICE_ATTR(fan1_input, S_IRUGO, fan_fan1_input_show, NULL);
8709
8710
8711 static ssize_t fan_fan2_input_show(struct device *dev,
8712 struct device_attribute *attr,
8713 char *buf)
8714 {
8715 int res;
8716 unsigned int speed;
8717
8718 res = fan2_get_speed(&speed);
8719 if (res < 0)
8720 return res;
8721
8722 return snprintf(buf, PAGE_SIZE, "%u\n", speed);
8723 }
8724
8725 static DEVICE_ATTR(fan2_input, S_IRUGO, fan_fan2_input_show, NULL);
8726
8727
8728 static ssize_t fan_watchdog_show(struct device_driver *drv, char *buf)
8729 {
8730 return snprintf(buf, PAGE_SIZE, "%u\n", fan_watchdog_maxinterval);
8731 }
8732
8733 static ssize_t fan_watchdog_store(struct device_driver *drv, const char *buf,
8734 size_t count)
8735 {
8736 unsigned long t;
8737
8738 if (parse_strtoul(buf, 120, &t))
8739 return -EINVAL;
8740
8741 if (!fan_control_allowed)
8742 return -EPERM;
8743
8744 fan_watchdog_maxinterval = t;
8745 fan_watchdog_reset();
8746
8747 tpacpi_disclose_usertask("fan_watchdog", "set to %lu\n", t);
8748
8749 return count;
8750 }
8751 static DRIVER_ATTR_RW(fan_watchdog);
8752
8753
8754 static struct attribute *fan_attributes[] = {
8755 &dev_attr_pwm1_enable.attr, &dev_attr_pwm1.attr,
8756 &dev_attr_fan1_input.attr,
8757 NULL,
8758 NULL
8759 };
8760
8761 static const struct attribute_group fan_attr_group = {
8762 .attrs = fan_attributes,
8763 };
8764
8765 #define TPACPI_FAN_Q1 0x0001
8766 #define TPACPI_FAN_2FAN 0x0002
8767
8768 static const struct tpacpi_quirk fan_quirk_table[] __initconst = {
8769 TPACPI_QEC_IBM('1', 'Y', TPACPI_FAN_Q1),
8770 TPACPI_QEC_IBM('7', '8', TPACPI_FAN_Q1),
8771 TPACPI_QEC_IBM('7', '6', TPACPI_FAN_Q1),
8772 TPACPI_QEC_IBM('7', '0', TPACPI_FAN_Q1),
8773 TPACPI_QEC_LNV('7', 'M', TPACPI_FAN_2FAN),
8774 TPACPI_Q_LNV('N', '1', TPACPI_FAN_2FAN),
8775 };
8776
8777 static int __init fan_init(struct ibm_init_struct *iibm)
8778 {
8779 int rc;
8780 unsigned long quirks;
8781
8782 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN,
8783 "initializing fan subdriver\n");
8784
8785 mutex_init(&fan_mutex);
8786 fan_status_access_mode = TPACPI_FAN_NONE;
8787 fan_control_access_mode = TPACPI_FAN_WR_NONE;
8788 fan_control_commands = 0;
8789 fan_watchdog_maxinterval = 0;
8790 tp_features.fan_ctrl_status_undef = 0;
8791 tp_features.second_fan = 0;
8792 fan_control_desired_level = 7;
8793
8794 if (tpacpi_is_ibm()) {
8795 TPACPI_ACPIHANDLE_INIT(fans);
8796 TPACPI_ACPIHANDLE_INIT(gfan);
8797 TPACPI_ACPIHANDLE_INIT(sfan);
8798 }
8799
8800 quirks = tpacpi_check_quirks(fan_quirk_table,
8801 ARRAY_SIZE(fan_quirk_table));
8802
8803 if (gfan_handle) {
8804
8805 fan_status_access_mode = TPACPI_FAN_RD_ACPI_GFAN;
8806 } else {
8807
8808
8809 if (likely(acpi_ec_read(fan_status_offset,
8810 &fan_control_initial_status))) {
8811 fan_status_access_mode = TPACPI_FAN_RD_TPEC;
8812 if (quirks & TPACPI_FAN_Q1)
8813 fan_quirk1_setup();
8814 if (quirks & TPACPI_FAN_2FAN) {
8815 tp_features.second_fan = 1;
8816 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN,
8817 "secondary fan support enabled\n");
8818 }
8819 } else {
8820 pr_err("ThinkPad ACPI EC access misbehaving, fan status and control unavailable\n");
8821 return 1;
8822 }
8823 }
8824
8825 if (sfan_handle) {
8826
8827 fan_control_access_mode = TPACPI_FAN_WR_ACPI_SFAN;
8828 fan_control_commands |=
8829 TPACPI_FAN_CMD_LEVEL | TPACPI_FAN_CMD_ENABLE;
8830 } else {
8831 if (!gfan_handle) {
8832
8833
8834
8835 if (fans_handle) {
8836
8837 fan_control_access_mode =
8838 TPACPI_FAN_WR_ACPI_FANS;
8839 fan_control_commands |=
8840 TPACPI_FAN_CMD_SPEED |
8841 TPACPI_FAN_CMD_LEVEL |
8842 TPACPI_FAN_CMD_ENABLE;
8843 } else {
8844 fan_control_access_mode = TPACPI_FAN_WR_TPEC;
8845 fan_control_commands |=
8846 TPACPI_FAN_CMD_LEVEL |
8847 TPACPI_FAN_CMD_ENABLE;
8848 }
8849 }
8850 }
8851
8852 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN,
8853 "fan is %s, modes %d, %d\n",
8854 str_supported(fan_status_access_mode != TPACPI_FAN_NONE ||
8855 fan_control_access_mode != TPACPI_FAN_WR_NONE),
8856 fan_status_access_mode, fan_control_access_mode);
8857
8858
8859 if (!fan_control_allowed) {
8860 fan_control_access_mode = TPACPI_FAN_WR_NONE;
8861 fan_control_commands = 0;
8862 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN,
8863 "fan control features disabled by parameter\n");
8864 }
8865
8866
8867 if (fan_status_access_mode != TPACPI_FAN_NONE)
8868 fan_get_status_safe(NULL);
8869
8870 if (fan_status_access_mode != TPACPI_FAN_NONE ||
8871 fan_control_access_mode != TPACPI_FAN_WR_NONE) {
8872 if (tp_features.second_fan) {
8873
8874 fan_attributes[ARRAY_SIZE(fan_attributes)-2] =
8875 &dev_attr_fan2_input.attr;
8876 }
8877 rc = sysfs_create_group(&tpacpi_hwmon->kobj,
8878 &fan_attr_group);
8879 if (rc < 0)
8880 return rc;
8881
8882 rc = driver_create_file(&tpacpi_hwmon_pdriver.driver,
8883 &driver_attr_fan_watchdog);
8884 if (rc < 0) {
8885 sysfs_remove_group(&tpacpi_hwmon->kobj,
8886 &fan_attr_group);
8887 return rc;
8888 }
8889 return 0;
8890 } else
8891 return 1;
8892 }
8893
8894 static void fan_exit(void)
8895 {
8896 vdbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_FAN,
8897 "cancelling any pending fan watchdog tasks\n");
8898
8899
8900 sysfs_remove_group(&tpacpi_hwmon->kobj, &fan_attr_group);
8901 driver_remove_file(&tpacpi_hwmon_pdriver.driver,
8902 &driver_attr_fan_watchdog);
8903
8904 cancel_delayed_work(&fan_watchdog_task);
8905 flush_workqueue(tpacpi_wq);
8906 }
8907
8908 static void fan_suspend(void)
8909 {
8910 int rc;
8911
8912 if (!fan_control_allowed)
8913 return;
8914
8915
8916 fan_control_resume_level = 0;
8917 rc = fan_get_status_safe(&fan_control_resume_level);
8918 if (rc < 0)
8919 pr_notice("failed to read fan level for later restore during resume: %d\n",
8920 rc);
8921
8922
8923
8924 if (tp_features.fan_ctrl_status_undef)
8925 fan_control_resume_level = 0;
8926 }
8927
8928 static void fan_resume(void)
8929 {
8930 u8 current_level = 7;
8931 bool do_set = false;
8932 int rc;
8933
8934
8935 tp_features.fan_ctrl_status_undef = 0;
8936
8937 if (!fan_control_allowed ||
8938 !fan_control_resume_level ||
8939 (fan_get_status_safe(¤t_level) < 0))
8940 return;
8941
8942 switch (fan_control_access_mode) {
8943 case TPACPI_FAN_WR_ACPI_SFAN:
8944
8945 do_set = (fan_control_resume_level > current_level);
8946 break;
8947 case TPACPI_FAN_WR_ACPI_FANS:
8948 case TPACPI_FAN_WR_TPEC:
8949
8950
8951
8952
8953
8954
8955
8956
8957
8958
8959
8960
8961
8962
8963
8964 if (fan_control_resume_level != 7 &&
8965 !(fan_control_resume_level & TP_EC_FAN_FULLSPEED))
8966 return;
8967 else
8968 do_set = !(current_level & TP_EC_FAN_FULLSPEED) &&
8969 (current_level != fan_control_resume_level);
8970 break;
8971 default:
8972 return;
8973 }
8974 if (do_set) {
8975 pr_notice("restoring fan level to 0x%02x\n",
8976 fan_control_resume_level);
8977 rc = fan_set_level_safe(fan_control_resume_level);
8978 if (rc < 0)
8979 pr_notice("failed to restore fan level: %d\n", rc);
8980 }
8981 }
8982
8983 static int fan_read(struct seq_file *m)
8984 {
8985 int rc;
8986 u8 status;
8987 unsigned int speed = 0;
8988
8989 switch (fan_status_access_mode) {
8990 case TPACPI_FAN_RD_ACPI_GFAN:
8991
8992 rc = fan_get_status_safe(&status);
8993 if (rc < 0)
8994 return rc;
8995
8996 seq_printf(m, "status:\t\t%s\n"
8997 "level:\t\t%d\n",
8998 (status != 0) ? "enabled" : "disabled", status);
8999 break;
9000
9001 case TPACPI_FAN_RD_TPEC:
9002
9003 rc = fan_get_status_safe(&status);
9004 if (rc < 0)
9005 return rc;
9006
9007 seq_printf(m, "status:\t\t%s\n",
9008 (status != 0) ? "enabled" : "disabled");
9009
9010 rc = fan_get_speed(&speed);
9011 if (rc < 0)
9012 return rc;
9013
9014 seq_printf(m, "speed:\t\t%d\n", speed);
9015
9016 if (status & TP_EC_FAN_FULLSPEED)
9017
9018 seq_printf(m, "level:\t\tdisengaged\n");
9019 else if (status & TP_EC_FAN_AUTO)
9020 seq_printf(m, "level:\t\tauto\n");
9021 else
9022 seq_printf(m, "level:\t\t%d\n", status);
9023 break;
9024
9025 case TPACPI_FAN_NONE:
9026 default:
9027 seq_printf(m, "status:\t\tnot supported\n");
9028 }
9029
9030 if (fan_control_commands & TPACPI_FAN_CMD_LEVEL) {
9031 seq_printf(m, "commands:\tlevel <level>");
9032
9033 switch (fan_control_access_mode) {
9034 case TPACPI_FAN_WR_ACPI_SFAN:
9035 seq_printf(m, " (<level> is 0-7)\n");
9036 break;
9037
9038 default:
9039 seq_printf(m, " (<level> is 0-7, auto, disengaged, full-speed)\n");
9040 break;
9041 }
9042 }
9043
9044 if (fan_control_commands & TPACPI_FAN_CMD_ENABLE)
9045 seq_printf(m, "commands:\tenable, disable\n"
9046 "commands:\twatchdog <timeout> (<timeout> is 0 (off), 1-120 (seconds))\n");
9047
9048 if (fan_control_commands & TPACPI_FAN_CMD_SPEED)
9049 seq_printf(m, "commands:\tspeed <speed> (<speed> is 0-65535)\n");
9050
9051 return 0;
9052 }
9053
9054 static int fan_write_cmd_level(const char *cmd, int *rc)
9055 {
9056 int level;
9057
9058 if (strlencmp(cmd, "level auto") == 0)
9059 level = TP_EC_FAN_AUTO;
9060 else if ((strlencmp(cmd, "level disengaged") == 0) |
9061 (strlencmp(cmd, "level full-speed") == 0))
9062 level = TP_EC_FAN_FULLSPEED;
9063 else if (sscanf(cmd, "level %d", &level) != 1)
9064 return 0;
9065
9066 *rc = fan_set_level_safe(level);
9067 if (*rc == -ENXIO)
9068 pr_err("level command accepted for unsupported access mode %d\n",
9069 fan_control_access_mode);
9070 else if (!*rc)
9071 tpacpi_disclose_usertask("procfs fan",
9072 "set level to %d\n", level);
9073
9074 return 1;
9075 }
9076
9077 static int fan_write_cmd_enable(const char *cmd, int *rc)
9078 {
9079 if (strlencmp(cmd, "enable") != 0)
9080 return 0;
9081
9082 *rc = fan_set_enable();
9083 if (*rc == -ENXIO)
9084 pr_err("enable command accepted for unsupported access mode %d\n",
9085 fan_control_access_mode);
9086 else if (!*rc)
9087 tpacpi_disclose_usertask("procfs fan", "enable\n");
9088
9089 return 1;
9090 }
9091
9092 static int fan_write_cmd_disable(const char *cmd, int *rc)
9093 {
9094 if (strlencmp(cmd, "disable") != 0)
9095 return 0;
9096
9097 *rc = fan_set_disable();
9098 if (*rc == -ENXIO)
9099 pr_err("disable command accepted for unsupported access mode %d\n",
9100 fan_control_access_mode);
9101 else if (!*rc)
9102 tpacpi_disclose_usertask("procfs fan", "disable\n");
9103
9104 return 1;
9105 }
9106
9107 static int fan_write_cmd_speed(const char *cmd, int *rc)
9108 {
9109 int speed;
9110
9111
9112
9113
9114 if (sscanf(cmd, "speed %d", &speed) != 1)
9115 return 0;
9116
9117 *rc = fan_set_speed(speed);
9118 if (*rc == -ENXIO)
9119 pr_err("speed command accepted for unsupported access mode %d\n",
9120 fan_control_access_mode);
9121 else if (!*rc)
9122 tpacpi_disclose_usertask("procfs fan",
9123 "set speed to %d\n", speed);
9124
9125 return 1;
9126 }
9127
9128 static int fan_write_cmd_watchdog(const char *cmd, int *rc)
9129 {
9130 int interval;
9131
9132 if (sscanf(cmd, "watchdog %d", &interval) != 1)
9133 return 0;
9134
9135 if (interval < 0 || interval > 120)
9136 *rc = -EINVAL;
9137 else {
9138 fan_watchdog_maxinterval = interval;
9139 tpacpi_disclose_usertask("procfs fan",
9140 "set watchdog timer to %d\n",
9141 interval);
9142 }
9143
9144 return 1;
9145 }
9146
9147 static int fan_write(char *buf)
9148 {
9149 char *cmd;
9150 int rc = 0;
9151
9152 while (!rc && (cmd = next_cmd(&buf))) {
9153 if (!((fan_control_commands & TPACPI_FAN_CMD_LEVEL) &&
9154 fan_write_cmd_level(cmd, &rc)) &&
9155 !((fan_control_commands & TPACPI_FAN_CMD_ENABLE) &&
9156 (fan_write_cmd_enable(cmd, &rc) ||
9157 fan_write_cmd_disable(cmd, &rc) ||
9158 fan_write_cmd_watchdog(cmd, &rc))) &&
9159 !((fan_control_commands & TPACPI_FAN_CMD_SPEED) &&
9160 fan_write_cmd_speed(cmd, &rc))
9161 )
9162 rc = -EINVAL;
9163 else if (!rc)
9164 fan_watchdog_reset();
9165 }
9166
9167 return rc;
9168 }
9169
9170 static struct ibm_struct fan_driver_data = {
9171 .name = "fan",
9172 .read = fan_read,
9173 .write = fan_write,
9174 .exit = fan_exit,
9175 .suspend = fan_suspend,
9176 .resume = fan_resume,
9177 };
9178
9179
9180
9181
9182
9183 #define TPACPI_LED_MAX 2
9184
9185 struct tp_led_table {
9186 acpi_string name;
9187 int on_value;
9188 int off_value;
9189 int state;
9190 };
9191
9192 static struct tp_led_table led_tables[TPACPI_LED_MAX] = {
9193 [LED_AUDIO_MUTE] = {
9194 .name = "SSMS",
9195 .on_value = 1,
9196 .off_value = 0,
9197 },
9198 [LED_AUDIO_MICMUTE] = {
9199 .name = "MMTS",
9200 .on_value = 2,
9201 .off_value = 0,
9202 },
9203 };
9204
9205 static int mute_led_on_off(struct tp_led_table *t, bool state)
9206 {
9207 acpi_handle temp;
9208 int output;
9209
9210 if (ACPI_FAILURE(acpi_get_handle(hkey_handle, t->name, &temp))) {
9211 pr_warn("Thinkpad ACPI has no %s interface.\n", t->name);
9212 return -EIO;
9213 }
9214
9215 if (!acpi_evalf(hkey_handle, &output, t->name, "dd",
9216 state ? t->on_value : t->off_value))
9217 return -EIO;
9218
9219 t->state = state;
9220 return state;
9221 }
9222
9223 static int tpacpi_led_set(int whichled, bool on)
9224 {
9225 struct tp_led_table *t;
9226
9227 t = &led_tables[whichled];
9228 if (t->state < 0 || t->state == on)
9229 return t->state;
9230 return mute_led_on_off(t, on);
9231 }
9232
9233 static int tpacpi_led_mute_set(struct led_classdev *led_cdev,
9234 enum led_brightness brightness)
9235 {
9236 return tpacpi_led_set(LED_AUDIO_MUTE, brightness != LED_OFF);
9237 }
9238
9239 static int tpacpi_led_micmute_set(struct led_classdev *led_cdev,
9240 enum led_brightness brightness)
9241 {
9242 return tpacpi_led_set(LED_AUDIO_MICMUTE, brightness != LED_OFF);
9243 }
9244
9245 static struct led_classdev mute_led_cdev[TPACPI_LED_MAX] = {
9246 [LED_AUDIO_MUTE] = {
9247 .name = "platform::mute",
9248 .max_brightness = 1,
9249 .brightness_set_blocking = tpacpi_led_mute_set,
9250 .default_trigger = "audio-mute",
9251 },
9252 [LED_AUDIO_MICMUTE] = {
9253 .name = "platform::micmute",
9254 .max_brightness = 1,
9255 .brightness_set_blocking = tpacpi_led_micmute_set,
9256 .default_trigger = "audio-micmute",
9257 },
9258 };
9259
9260 static int mute_led_init(struct ibm_init_struct *iibm)
9261 {
9262 acpi_handle temp;
9263 int i, err;
9264
9265 for (i = 0; i < TPACPI_LED_MAX; i++) {
9266 struct tp_led_table *t = &led_tables[i];
9267 if (ACPI_FAILURE(acpi_get_handle(hkey_handle, t->name, &temp))) {
9268 t->state = -ENODEV;
9269 continue;
9270 }
9271
9272 mute_led_cdev[i].brightness = ledtrig_audio_get(i);
9273 err = led_classdev_register(&tpacpi_pdev->dev, &mute_led_cdev[i]);
9274 if (err < 0) {
9275 while (i--) {
9276 if (led_tables[i].state >= 0)
9277 led_classdev_unregister(&mute_led_cdev[i]);
9278 }
9279 return err;
9280 }
9281 }
9282 return 0;
9283 }
9284
9285 static void mute_led_exit(void)
9286 {
9287 int i;
9288
9289 for (i = 0; i < TPACPI_LED_MAX; i++) {
9290 if (led_tables[i].state >= 0) {
9291 led_classdev_unregister(&mute_led_cdev[i]);
9292 tpacpi_led_set(i, false);
9293 }
9294 }
9295 }
9296
9297 static void mute_led_resume(void)
9298 {
9299 int i;
9300
9301 for (i = 0; i < TPACPI_LED_MAX; i++) {
9302 struct tp_led_table *t = &led_tables[i];
9303 if (t->state >= 0)
9304 mute_led_on_off(t, t->state);
9305 }
9306 }
9307
9308 static struct ibm_struct mute_led_driver_data = {
9309 .name = "mute_led",
9310 .exit = mute_led_exit,
9311 .resume = mute_led_resume,
9312 };
9313
9314
9315
9316
9317
9318
9319
9320
9321 #define GET_START "BCTG"
9322 #define SET_START "BCCS"
9323 #define GET_STOP "BCSG"
9324 #define SET_STOP "BCSS"
9325
9326 #define START_ATTR "charge_start_threshold"
9327 #define STOP_ATTR "charge_stop_threshold"
9328
9329 enum {
9330 BAT_ANY = 0,
9331 BAT_PRIMARY = 1,
9332 BAT_SECONDARY = 2
9333 };
9334
9335 enum {
9336
9337 METHOD_ERR = BIT(31),
9338 };
9339
9340 enum {
9341
9342 THRESHOLD_START,
9343 THRESHOLD_STOP,
9344 };
9345
9346 struct tpacpi_battery_data {
9347 int charge_start;
9348 int start_support;
9349 int charge_stop;
9350 int stop_support;
9351 };
9352
9353 struct tpacpi_battery_driver_data {
9354 struct tpacpi_battery_data batteries[3];
9355 int individual_addressing;
9356 };
9357
9358 static struct tpacpi_battery_driver_data battery_info;
9359
9360
9361
9362
9363
9364
9365
9366
9367 static acpi_status tpacpi_battery_acpi_eval(char *method, int *ret, int param)
9368 {
9369 int response;
9370
9371 if (!acpi_evalf(hkey_handle, &response, method, "dd", param)) {
9372 acpi_handle_err(hkey_handle, "%s: evaluate failed", method);
9373 return AE_ERROR;
9374 }
9375 if (response & METHOD_ERR) {
9376 acpi_handle_err(hkey_handle,
9377 "%s evaluated but flagged as error", method);
9378 return AE_ERROR;
9379 }
9380 *ret = response;
9381 return AE_OK;
9382 }
9383
9384 static int tpacpi_battery_get(int what, int battery, int *ret)
9385 {
9386 switch (what) {
9387 case THRESHOLD_START:
9388 if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_START, ret, battery))
9389 return -ENODEV;
9390
9391
9392 *ret = *ret & 0xFF;
9393 return 0;
9394 case THRESHOLD_STOP:
9395 if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_STOP, ret, battery))
9396 return -ENODEV;
9397
9398 *ret = *ret & 0xFF;
9399
9400
9401
9402
9403
9404
9405 if (*ret == 0)
9406 *ret = 100;
9407 return 0;
9408 default:
9409 pr_crit("wrong parameter: %d", what);
9410 return -EINVAL;
9411 }
9412 }
9413
9414 static int tpacpi_battery_set(int what, int battery, int value)
9415 {
9416 int param, ret;
9417
9418 param = value;
9419
9420 param |= battery << 8;
9421
9422 switch (what) {
9423 case THRESHOLD_START:
9424 if ACPI_FAILURE(tpacpi_battery_acpi_eval(SET_START, &ret, param)) {
9425 pr_err("failed to set charge threshold on battery %d",
9426 battery);
9427 return -ENODEV;
9428 }
9429 return 0;
9430 case THRESHOLD_STOP:
9431 if ACPI_FAILURE(tpacpi_battery_acpi_eval(SET_STOP, &ret, param)) {
9432 pr_err("failed to set stop threshold: %d", battery);
9433 return -ENODEV;
9434 }
9435 return 0;
9436 default:
9437 pr_crit("wrong parameter: %d", what);
9438 return -EINVAL;
9439 }
9440 }
9441
9442 static int tpacpi_battery_probe(int battery)
9443 {
9444 int ret = 0;
9445
9446 memset(&battery_info.batteries[battery], 0,
9447 sizeof(battery_info.batteries[battery]));
9448
9449
9450
9451
9452
9453
9454
9455 if (acpi_has_method(hkey_handle, GET_START)) {
9456 if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_START, &ret, battery)) {
9457 pr_err("Error probing battery %d\n", battery);
9458 return -ENODEV;
9459 }
9460
9461 if (ret & BIT(9))
9462 battery_info.individual_addressing = true;
9463
9464 if (ret & BIT(8))
9465 battery_info.batteries[battery].start_support = 1;
9466 else
9467 return -ENODEV;
9468 if (tpacpi_battery_get(THRESHOLD_START, battery,
9469 &battery_info.batteries[battery].charge_start)) {
9470 pr_err("Error probing battery %d\n", battery);
9471 return -ENODEV;
9472 }
9473 }
9474 if (acpi_has_method(hkey_handle, GET_STOP)) {
9475 if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_STOP, &ret, battery)) {
9476 pr_err("Error probing battery stop; %d\n", battery);
9477 return -ENODEV;
9478 }
9479
9480 if (ret & BIT(8))
9481 battery_info.batteries[battery].stop_support = 1;
9482 else
9483 return -ENODEV;
9484 if (tpacpi_battery_get(THRESHOLD_STOP, battery,
9485 &battery_info.batteries[battery].charge_stop)) {
9486 pr_err("Error probing battery stop: %d\n", battery);
9487 return -ENODEV;
9488 }
9489 }
9490 pr_info("battery %d registered (start %d, stop %d)",
9491 battery,
9492 battery_info.batteries[battery].charge_start,
9493 battery_info.batteries[battery].charge_stop);
9494
9495 return 0;
9496 }
9497
9498
9499
9500 static int tpacpi_battery_get_id(const char *battery_name)
9501 {
9502
9503 if (strcmp(battery_name, "BAT0") == 0 ||
9504 tp_features.battery_force_primary)
9505 return BAT_PRIMARY;
9506 if (strcmp(battery_name, "BAT1") == 0)
9507 return BAT_SECONDARY;
9508
9509
9510
9511
9512
9513 pr_warn("unknown battery %s, assuming primary", battery_name);
9514 return BAT_PRIMARY;
9515 }
9516
9517
9518
9519 static ssize_t tpacpi_battery_store(int what,
9520 struct device *dev,
9521 const char *buf, size_t count)
9522 {
9523 struct power_supply *supply = to_power_supply(dev);
9524 unsigned long value;
9525 int battery, rval;
9526
9527
9528
9529
9530
9531
9532
9533
9534
9535
9536
9537 if (battery_info.individual_addressing)
9538
9539 battery = tpacpi_battery_get_id(supply->desc->name);
9540 else
9541 battery = BAT_PRIMARY;
9542
9543 rval = kstrtoul(buf, 10, &value);
9544 if (rval)
9545 return rval;
9546
9547 switch (what) {
9548 case THRESHOLD_START:
9549 if (!battery_info.batteries[battery].start_support)
9550 return -ENODEV;
9551
9552 if (value < 0 || value > 99)
9553 return -EINVAL;
9554 if (value > battery_info.batteries[battery].charge_stop)
9555 return -EINVAL;
9556 if (tpacpi_battery_set(THRESHOLD_START, battery, value))
9557 return -ENODEV;
9558 battery_info.batteries[battery].charge_start = value;
9559 return count;
9560
9561 case THRESHOLD_STOP:
9562 if (!battery_info.batteries[battery].stop_support)
9563 return -ENODEV;
9564
9565 if (value < 1 || value > 100)
9566 return -EINVAL;
9567 if (value < battery_info.batteries[battery].charge_start)
9568 return -EINVAL;
9569 battery_info.batteries[battery].charge_stop = value;
9570
9571
9572
9573
9574
9575 if (value == 100)
9576 value = 0;
9577 if (tpacpi_battery_set(THRESHOLD_STOP, battery, value))
9578 return -EINVAL;
9579 return count;
9580 default:
9581 pr_crit("Wrong parameter: %d", what);
9582 return -EINVAL;
9583 }
9584 return count;
9585 }
9586
9587 static ssize_t tpacpi_battery_show(int what,
9588 struct device *dev,
9589 char *buf)
9590 {
9591 struct power_supply *supply = to_power_supply(dev);
9592 int ret, battery;
9593
9594
9595
9596
9597
9598
9599
9600
9601
9602
9603
9604 if (battery_info.individual_addressing)
9605
9606 battery = tpacpi_battery_get_id(supply->desc->name);
9607 else
9608 battery = BAT_PRIMARY;
9609 if (tpacpi_battery_get(what, battery, &ret))
9610 return -ENODEV;
9611 return sprintf(buf, "%d\n", ret);
9612 }
9613
9614 static ssize_t charge_start_threshold_show(struct device *device,
9615 struct device_attribute *attr,
9616 char *buf)
9617 {
9618 return tpacpi_battery_show(THRESHOLD_START, device, buf);
9619 }
9620
9621 static ssize_t charge_stop_threshold_show(struct device *device,
9622 struct device_attribute *attr,
9623 char *buf)
9624 {
9625 return tpacpi_battery_show(THRESHOLD_STOP, device, buf);
9626 }
9627
9628 static ssize_t charge_start_threshold_store(struct device *dev,
9629 struct device_attribute *attr,
9630 const char *buf, size_t count)
9631 {
9632 return tpacpi_battery_store(THRESHOLD_START, dev, buf, count);
9633 }
9634
9635 static ssize_t charge_stop_threshold_store(struct device *dev,
9636 struct device_attribute *attr,
9637 const char *buf, size_t count)
9638 {
9639 return tpacpi_battery_store(THRESHOLD_STOP, dev, buf, count);
9640 }
9641
9642 static DEVICE_ATTR_RW(charge_start_threshold);
9643 static DEVICE_ATTR_RW(charge_stop_threshold);
9644
9645 static struct attribute *tpacpi_battery_attrs[] = {
9646 &dev_attr_charge_start_threshold.attr,
9647 &dev_attr_charge_stop_threshold.attr,
9648 NULL,
9649 };
9650
9651 ATTRIBUTE_GROUPS(tpacpi_battery);
9652
9653
9654
9655 static int tpacpi_battery_add(struct power_supply *battery)
9656 {
9657 int batteryid = tpacpi_battery_get_id(battery->desc->name);
9658
9659 if (tpacpi_battery_probe(batteryid))
9660 return -ENODEV;
9661 if (device_add_groups(&battery->dev, tpacpi_battery_groups))
9662 return -ENODEV;
9663 return 0;
9664 }
9665
9666 static int tpacpi_battery_remove(struct power_supply *battery)
9667 {
9668 device_remove_groups(&battery->dev, tpacpi_battery_groups);
9669 return 0;
9670 }
9671
9672 static struct acpi_battery_hook battery_hook = {
9673 .add_battery = tpacpi_battery_add,
9674 .remove_battery = tpacpi_battery_remove,
9675 .name = "ThinkPad Battery Extension",
9676 };
9677
9678
9679
9680 static const struct tpacpi_quirk battery_quirk_table[] __initconst = {
9681
9682
9683
9684
9685 TPACPI_Q_LNV('J', '7', true),
9686 TPACPI_Q_LNV('J', 'I', true),
9687 TPACPI_Q_LNV3('R', '0', 'B', true),
9688 TPACPI_Q_LNV3('R', '0', 'C', true),
9689 TPACPI_Q_LNV3('R', '0', 'J', true),
9690 };
9691
9692 static int __init tpacpi_battery_init(struct ibm_init_struct *ibm)
9693 {
9694 memset(&battery_info, 0, sizeof(battery_info));
9695
9696 tp_features.battery_force_primary = tpacpi_check_quirks(
9697 battery_quirk_table,
9698 ARRAY_SIZE(battery_quirk_table));
9699
9700 battery_hook_register(&battery_hook);
9701 return 0;
9702 }
9703
9704 static void tpacpi_battery_exit(void)
9705 {
9706 battery_hook_unregister(&battery_hook);
9707 }
9708
9709 static struct ibm_struct battery_driver_data = {
9710 .name = "battery",
9711 .exit = tpacpi_battery_exit,
9712 };
9713
9714
9715
9716
9717
9718 static int lcdshadow_state;
9719
9720 static int lcdshadow_on_off(bool state)
9721 {
9722 acpi_handle set_shadow_handle;
9723 int output;
9724
9725 if (ACPI_FAILURE(acpi_get_handle(hkey_handle, "SSSS", &set_shadow_handle))) {
9726 pr_warn("Thinkpad ACPI has no %s interface.\n", "SSSS");
9727 return -EIO;
9728 }
9729
9730 if (!acpi_evalf(set_shadow_handle, &output, NULL, "dd", (int)state))
9731 return -EIO;
9732
9733 lcdshadow_state = state;
9734 return 0;
9735 }
9736
9737 static int lcdshadow_set(bool on)
9738 {
9739 if (lcdshadow_state < 0)
9740 return lcdshadow_state;
9741 if (lcdshadow_state == on)
9742 return 0;
9743 return lcdshadow_on_off(on);
9744 }
9745
9746 static int tpacpi_lcdshadow_init(struct ibm_init_struct *iibm)
9747 {
9748 acpi_handle get_shadow_handle;
9749 int output;
9750
9751 if (ACPI_FAILURE(acpi_get_handle(hkey_handle, "GSSS", &get_shadow_handle))) {
9752 lcdshadow_state = -ENODEV;
9753 return 0;
9754 }
9755
9756 if (!acpi_evalf(get_shadow_handle, &output, NULL, "dd", 0)) {
9757 lcdshadow_state = -EIO;
9758 return -EIO;
9759 }
9760 if (!(output & 0x10000)) {
9761 lcdshadow_state = -ENODEV;
9762 return 0;
9763 }
9764 lcdshadow_state = output & 0x1;
9765
9766 return 0;
9767 }
9768
9769 static void lcdshadow_resume(void)
9770 {
9771 if (lcdshadow_state >= 0)
9772 lcdshadow_on_off(lcdshadow_state);
9773 }
9774
9775 static int lcdshadow_read(struct seq_file *m)
9776 {
9777 if (lcdshadow_state < 0) {
9778 seq_puts(m, "status:\t\tnot supported\n");
9779 } else {
9780 seq_printf(m, "status:\t\t%d\n", lcdshadow_state);
9781 seq_puts(m, "commands:\t0, 1\n");
9782 }
9783
9784 return 0;
9785 }
9786
9787 static int lcdshadow_write(char *buf)
9788 {
9789 char *cmd;
9790 int state = -1;
9791
9792 if (lcdshadow_state < 0)
9793 return -ENODEV;
9794
9795 while ((cmd = next_cmd(&buf))) {
9796 if (strlencmp(cmd, "0") == 0)
9797 state = 0;
9798 else if (strlencmp(cmd, "1") == 0)
9799 state = 1;
9800 }
9801
9802 if (state == -1)
9803 return -EINVAL;
9804
9805 return lcdshadow_set(state);
9806 }
9807
9808 static struct ibm_struct lcdshadow_driver_data = {
9809 .name = "lcdshadow",
9810 .resume = lcdshadow_resume,
9811 .read = lcdshadow_read,
9812 .write = lcdshadow_write,
9813 };
9814
9815
9816
9817
9818
9819
9820
9821
9822
9823
9824
9825
9826
9827 static void tpacpi_driver_event(const unsigned int hkey_event)
9828 {
9829 if (ibm_backlight_device) {
9830 switch (hkey_event) {
9831 case TP_HKEY_EV_BRGHT_UP:
9832 case TP_HKEY_EV_BRGHT_DOWN:
9833 tpacpi_brightness_notify_change();
9834 }
9835 }
9836 if (alsa_card) {
9837 switch (hkey_event) {
9838 case TP_HKEY_EV_VOL_UP:
9839 case TP_HKEY_EV_VOL_DOWN:
9840 case TP_HKEY_EV_VOL_MUTE:
9841 volume_alsa_notify_change();
9842 }
9843 }
9844 if (tp_features.kbdlight && hkey_event == TP_HKEY_EV_KBD_LIGHT) {
9845 enum led_brightness brightness;
9846
9847 mutex_lock(&kbdlight_mutex);
9848
9849
9850
9851
9852
9853 brightness = kbdlight_sysfs_get(NULL);
9854 if (kbdlight_brightness != brightness) {
9855 kbdlight_brightness = brightness;
9856 led_classdev_notify_brightness_hw_changed(
9857 &tpacpi_led_kbdlight.led_classdev, brightness);
9858 }
9859
9860 mutex_unlock(&kbdlight_mutex);
9861 }
9862 }
9863
9864 static void hotkey_driver_event(const unsigned int scancode)
9865 {
9866 tpacpi_driver_event(TP_HKEY_EV_HOTKEY_BASE + scancode);
9867 }
9868
9869
9870
9871
9872 static struct proc_dir_entry *proc_dir;
9873
9874
9875
9876
9877
9878 static bool force_load;
9879
9880 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
9881 static const char * __init str_supported(int is_supported)
9882 {
9883 static char text_unsupported[] __initdata = "not supported";
9884
9885 return (is_supported) ? &text_unsupported[4] : &text_unsupported[0];
9886 }
9887 #endif
9888
9889 static void ibm_exit(struct ibm_struct *ibm)
9890 {
9891 dbg_printk(TPACPI_DBG_EXIT, "removing %s\n", ibm->name);
9892
9893 list_del_init(&ibm->all_drivers);
9894
9895 if (ibm->flags.acpi_notify_installed) {
9896 dbg_printk(TPACPI_DBG_EXIT,
9897 "%s: acpi_remove_notify_handler\n", ibm->name);
9898 BUG_ON(!ibm->acpi);
9899 acpi_remove_notify_handler(*ibm->acpi->handle,
9900 ibm->acpi->type,
9901 dispatch_acpi_notify);
9902 ibm->flags.acpi_notify_installed = 0;
9903 }
9904
9905 if (ibm->flags.proc_created) {
9906 dbg_printk(TPACPI_DBG_EXIT,
9907 "%s: remove_proc_entry\n", ibm->name);
9908 remove_proc_entry(ibm->name, proc_dir);
9909 ibm->flags.proc_created = 0;
9910 }
9911
9912 if (ibm->flags.acpi_driver_registered) {
9913 dbg_printk(TPACPI_DBG_EXIT,
9914 "%s: acpi_bus_unregister_driver\n", ibm->name);
9915 BUG_ON(!ibm->acpi);
9916 acpi_bus_unregister_driver(ibm->acpi->driver);
9917 kfree(ibm->acpi->driver);
9918 ibm->acpi->driver = NULL;
9919 ibm->flags.acpi_driver_registered = 0;
9920 }
9921
9922 if (ibm->flags.init_called && ibm->exit) {
9923 ibm->exit();
9924 ibm->flags.init_called = 0;
9925 }
9926
9927 dbg_printk(TPACPI_DBG_INIT, "finished removing %s\n", ibm->name);
9928 }
9929
9930 static int __init ibm_init(struct ibm_init_struct *iibm)
9931 {
9932 int ret;
9933 struct ibm_struct *ibm = iibm->data;
9934 struct proc_dir_entry *entry;
9935
9936 BUG_ON(ibm == NULL);
9937
9938 INIT_LIST_HEAD(&ibm->all_drivers);
9939
9940 if (ibm->flags.experimental && !experimental)
9941 return 0;
9942
9943 dbg_printk(TPACPI_DBG_INIT,
9944 "probing for %s\n", ibm->name);
9945
9946 if (iibm->init) {
9947 ret = iibm->init(iibm);
9948 if (ret > 0)
9949 return 0;
9950 if (ret)
9951 return ret;
9952
9953 ibm->flags.init_called = 1;
9954 }
9955
9956 if (ibm->acpi) {
9957 if (ibm->acpi->hid) {
9958 ret = register_tpacpi_subdriver(ibm);
9959 if (ret)
9960 goto err_out;
9961 }
9962
9963 if (ibm->acpi->notify) {
9964 ret = setup_acpi_notify(ibm);
9965 if (ret == -ENODEV) {
9966 pr_notice("disabling subdriver %s\n",
9967 ibm->name);
9968 ret = 0;
9969 goto err_out;
9970 }
9971 if (ret < 0)
9972 goto err_out;
9973 }
9974 }
9975
9976 dbg_printk(TPACPI_DBG_INIT,
9977 "%s installed\n", ibm->name);
9978
9979 if (ibm->read) {
9980 umode_t mode = iibm->base_procfs_mode;
9981
9982 if (!mode)
9983 mode = S_IRUGO;
9984 if (ibm->write)
9985 mode |= S_IWUSR;
9986 entry = proc_create_data(ibm->name, mode, proc_dir,
9987 &dispatch_proc_fops, ibm);
9988 if (!entry) {
9989 pr_err("unable to create proc entry %s\n", ibm->name);
9990 ret = -ENODEV;
9991 goto err_out;
9992 }
9993 ibm->flags.proc_created = 1;
9994 }
9995
9996 list_add_tail(&ibm->all_drivers, &tpacpi_all_drivers);
9997
9998 return 0;
9999
10000 err_out:
10001 dbg_printk(TPACPI_DBG_INIT,
10002 "%s: at error exit path with result %d\n",
10003 ibm->name, ret);
10004
10005 ibm_exit(ibm);
10006 return (ret < 0) ? ret : 0;
10007 }
10008
10009
10010
10011 static char __init tpacpi_parse_fw_id(const char * const s,
10012 u32 *model, u16 *release)
10013 {
10014 int i;
10015
10016 if (!s || strlen(s) < 8)
10017 goto invalid;
10018
10019 for (i = 0; i < 8; i++)
10020 if (!((s[i] >= '0' && s[i] <= '9') ||
10021 (s[i] >= 'A' && s[i] <= 'Z')))
10022 goto invalid;
10023
10024
10025
10026
10027
10028 if (s[3] == 'T' || s[3] == 'N') {
10029 *model = TPID(s[0], s[1]);
10030 *release = TPVER(s[4], s[5]);
10031 return s[2];
10032
10033
10034 } else if (s[4] == 'T' || s[4] == 'N') {
10035 *model = TPID3(s[0], s[1], s[2]);
10036 *release = TPVER(s[5], s[6]);
10037 return s[3];
10038 }
10039
10040 invalid:
10041 return '\0';
10042 }
10043
10044 static void find_new_ec_fwstr(const struct dmi_header *dm, void *private)
10045 {
10046 char *ec_fw_string = (char *) private;
10047 const char *dmi_data = (const char *)dm;
10048
10049
10050
10051
10052
10053
10054
10055
10056
10057
10058
10059
10060
10061
10062
10063
10064
10065 if (dm->type != 140 || dm->length < 0x0F ||
10066 memcmp(dmi_data + 4, "LENOVO", 6) != 0 ||
10067 dmi_data[0x0A] != 0x0B || dmi_data[0x0B] != 0x07 ||
10068 dmi_data[0x0C] != 0x01)
10069 return;
10070
10071
10072 strncpy(ec_fw_string, dmi_data + 0x0F, 8);
10073 }
10074
10075
10076
10077
10078 static int __must_check __init get_thinkpad_model_data(
10079 struct thinkpad_id_data *tp)
10080 {
10081 const struct dmi_device *dev = NULL;
10082 char ec_fw_string[18] = {0};
10083 char const *s;
10084 char t;
10085
10086 if (!tp)
10087 return -EINVAL;
10088
10089 memset(tp, 0, sizeof(*tp));
10090
10091 if (dmi_name_in_vendors("IBM"))
10092 tp->vendor = PCI_VENDOR_ID_IBM;
10093 else if (dmi_name_in_vendors("LENOVO"))
10094 tp->vendor = PCI_VENDOR_ID_LENOVO;
10095 else
10096 return 0;
10097
10098 s = dmi_get_system_info(DMI_BIOS_VERSION);
10099 tp->bios_version_str = kstrdup(s, GFP_KERNEL);
10100 if (s && !tp->bios_version_str)
10101 return -ENOMEM;
10102
10103
10104 t = tpacpi_parse_fw_id(tp->bios_version_str,
10105 &tp->bios_model, &tp->bios_release);
10106 if (t != 'E' && t != 'C')
10107 return 0;
10108
10109
10110
10111
10112
10113
10114
10115
10116 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
10117 if (sscanf(dev->name,
10118 "IBM ThinkPad Embedded Controller -[%17c",
10119 ec_fw_string) == 1) {
10120 ec_fw_string[sizeof(ec_fw_string) - 1] = 0;
10121 ec_fw_string[strcspn(ec_fw_string, " ]")] = 0;
10122 break;
10123 }
10124 }
10125
10126
10127 if (!ec_fw_string[0])
10128 dmi_walk(find_new_ec_fwstr, &ec_fw_string);
10129
10130 if (ec_fw_string[0]) {
10131 tp->ec_version_str = kstrdup(ec_fw_string, GFP_KERNEL);
10132 if (!tp->ec_version_str)
10133 return -ENOMEM;
10134
10135 t = tpacpi_parse_fw_id(ec_fw_string,
10136 &tp->ec_model, &tp->ec_release);
10137 if (t != 'H') {
10138 pr_notice("ThinkPad firmware release %s doesn't match the known patterns\n",
10139 ec_fw_string);
10140 pr_notice("please report this to %s\n", TPACPI_MAIL);
10141 }
10142 }
10143
10144 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
10145 if (s && !(strncasecmp(s, "ThinkPad", 8) && strncasecmp(s, "Lenovo", 6))) {
10146 tp->model_str = kstrdup(s, GFP_KERNEL);
10147 if (!tp->model_str)
10148 return -ENOMEM;
10149 } else {
10150 s = dmi_get_system_info(DMI_BIOS_VENDOR);
10151 if (s && !(strncasecmp(s, "Lenovo", 6))) {
10152 tp->model_str = kstrdup(s, GFP_KERNEL);
10153 if (!tp->model_str)
10154 return -ENOMEM;
10155 }
10156 }
10157
10158 s = dmi_get_system_info(DMI_PRODUCT_NAME);
10159 tp->nummodel_str = kstrdup(s, GFP_KERNEL);
10160 if (s && !tp->nummodel_str)
10161 return -ENOMEM;
10162
10163 return 0;
10164 }
10165
10166 static int __init probe_for_thinkpad(void)
10167 {
10168 int is_thinkpad;
10169
10170 if (acpi_disabled)
10171 return -ENODEV;
10172
10173
10174 if (!tpacpi_is_ibm() && !tpacpi_is_lenovo())
10175 return -ENODEV;
10176
10177
10178
10179
10180
10181 is_thinkpad = (thinkpad_id.model_str != NULL) ||
10182 (thinkpad_id.ec_model != 0) ||
10183 tpacpi_is_fw_known();
10184
10185
10186 tpacpi_acpi_handle_locate("ec", TPACPI_ACPI_EC_HID, &ec_handle);
10187 if (!ec_handle) {
10188 if (is_thinkpad)
10189 pr_err("Not yet supported ThinkPad detected!\n");
10190 return -ENODEV;
10191 }
10192
10193 if (!is_thinkpad && !force_load)
10194 return -ENODEV;
10195
10196 return 0;
10197 }
10198
10199 static void __init thinkpad_acpi_init_banner(void)
10200 {
10201 pr_info("%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
10202 pr_info("%s\n", TPACPI_URL);
10203
10204 pr_info("ThinkPad BIOS %s, EC %s\n",
10205 (thinkpad_id.bios_version_str) ?
10206 thinkpad_id.bios_version_str : "unknown",
10207 (thinkpad_id.ec_version_str) ?
10208 thinkpad_id.ec_version_str : "unknown");
10209
10210 BUG_ON(!thinkpad_id.vendor);
10211
10212 if (thinkpad_id.model_str)
10213 pr_info("%s %s, model %s\n",
10214 (thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ?
10215 "IBM" : ((thinkpad_id.vendor ==
10216 PCI_VENDOR_ID_LENOVO) ?
10217 "Lenovo" : "Unknown vendor"),
10218 thinkpad_id.model_str,
10219 (thinkpad_id.nummodel_str) ?
10220 thinkpad_id.nummodel_str : "unknown");
10221 }
10222
10223
10224
10225 static struct ibm_init_struct ibms_init[] __initdata = {
10226 {
10227 .data = &thinkpad_acpi_driver_data,
10228 },
10229 {
10230 .init = hotkey_init,
10231 .data = &hotkey_driver_data,
10232 },
10233 {
10234 .init = bluetooth_init,
10235 .data = &bluetooth_driver_data,
10236 },
10237 {
10238 .init = wan_init,
10239 .data = &wan_driver_data,
10240 },
10241 {
10242 .init = uwb_init,
10243 .data = &uwb_driver_data,
10244 },
10245 #ifdef CONFIG_THINKPAD_ACPI_VIDEO
10246 {
10247 .init = video_init,
10248 .base_procfs_mode = S_IRUSR,
10249 .data = &video_driver_data,
10250 },
10251 #endif
10252 {
10253 .init = kbdlight_init,
10254 .data = &kbdlight_driver_data,
10255 },
10256 {
10257 .init = light_init,
10258 .data = &light_driver_data,
10259 },
10260 {
10261 .init = cmos_init,
10262 .data = &cmos_driver_data,
10263 },
10264 {
10265 .init = led_init,
10266 .data = &led_driver_data,
10267 },
10268 {
10269 .init = beep_init,
10270 .data = &beep_driver_data,
10271 },
10272 {
10273 .init = thermal_init,
10274 .data = &thermal_driver_data,
10275 },
10276 {
10277 .init = brightness_init,
10278 .data = &brightness_driver_data,
10279 },
10280 {
10281 .init = volume_init,
10282 .data = &volume_driver_data,
10283 },
10284 {
10285 .init = fan_init,
10286 .data = &fan_driver_data,
10287 },
10288 {
10289 .init = mute_led_init,
10290 .data = &mute_led_driver_data,
10291 },
10292 {
10293 .init = tpacpi_battery_init,
10294 .data = &battery_driver_data,
10295 },
10296 {
10297 .init = tpacpi_lcdshadow_init,
10298 .data = &lcdshadow_driver_data,
10299 },
10300 };
10301
10302 static int __init set_ibm_param(const char *val, const struct kernel_param *kp)
10303 {
10304 unsigned int i;
10305 struct ibm_struct *ibm;
10306
10307 if (!kp || !kp->name || !val)
10308 return -EINVAL;
10309
10310 for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
10311 ibm = ibms_init[i].data;
10312 WARN_ON(ibm == NULL);
10313
10314 if (!ibm || !ibm->name)
10315 continue;
10316
10317 if (strcmp(ibm->name, kp->name) == 0 && ibm->write) {
10318 if (strlen(val) > sizeof(ibms_init[i].param) - 2)
10319 return -ENOSPC;
10320 strcpy(ibms_init[i].param, val);
10321 strcat(ibms_init[i].param, ",");
10322 return 0;
10323 }
10324 }
10325
10326 return -EINVAL;
10327 }
10328
10329 module_param(experimental, int, 0444);
10330 MODULE_PARM_DESC(experimental,
10331 "Enables experimental features when non-zero");
10332
10333 module_param_named(debug, dbg_level, uint, 0);
10334 MODULE_PARM_DESC(debug, "Sets debug level bit-mask");
10335
10336 module_param(force_load, bool, 0444);
10337 MODULE_PARM_DESC(force_load,
10338 "Attempts to load the driver even on a mis-identified ThinkPad when true");
10339
10340 module_param_named(fan_control, fan_control_allowed, bool, 0444);
10341 MODULE_PARM_DESC(fan_control,
10342 "Enables setting fan parameters features when true");
10343
10344 module_param_named(brightness_mode, brightness_mode, uint, 0444);
10345 MODULE_PARM_DESC(brightness_mode,
10346 "Selects brightness control strategy: 0=auto, 1=EC, 2=UCMS, 3=EC+NVRAM");
10347
10348 module_param(brightness_enable, uint, 0444);
10349 MODULE_PARM_DESC(brightness_enable,
10350 "Enables backlight control when 1, disables when 0");
10351
10352 #ifdef CONFIG_THINKPAD_ACPI_ALSA_SUPPORT
10353 module_param_named(volume_mode, volume_mode, uint, 0444);
10354 MODULE_PARM_DESC(volume_mode,
10355 "Selects volume control strategy: 0=auto, 1=EC, 2=N/A, 3=EC+NVRAM");
10356
10357 module_param_named(volume_capabilities, volume_capabilities, uint, 0444);
10358 MODULE_PARM_DESC(volume_capabilities,
10359 "Selects the mixer capabilities: 0=auto, 1=volume and mute, 2=mute only");
10360
10361 module_param_named(volume_control, volume_control_allowed, bool, 0444);
10362 MODULE_PARM_DESC(volume_control,
10363 "Enables software override for the console audio control when true");
10364
10365 module_param_named(software_mute, software_mute_requested, bool, 0444);
10366 MODULE_PARM_DESC(software_mute,
10367 "Request full software mute control");
10368
10369
10370 module_param_named(index, alsa_index, int, 0444);
10371 MODULE_PARM_DESC(index, "ALSA index for the ACPI EC Mixer");
10372 module_param_named(id, alsa_id, charp, 0444);
10373 MODULE_PARM_DESC(id, "ALSA id for the ACPI EC Mixer");
10374 module_param_named(enable, alsa_enable, bool, 0444);
10375 MODULE_PARM_DESC(enable, "Enable the ALSA interface for the ACPI EC Mixer");
10376 #endif
10377
10378
10379 #define TPACPI_PARAM(feature) \
10380 module_param_call(feature, set_ibm_param, NULL, NULL, 0); \
10381 MODULE_PARM_DESC(feature, "Simulates thinkpad-acpi procfs command at module load, see documentation")
10382
10383 TPACPI_PARAM(hotkey);
10384 TPACPI_PARAM(bluetooth);
10385 TPACPI_PARAM(video);
10386 TPACPI_PARAM(light);
10387 TPACPI_PARAM(cmos);
10388 TPACPI_PARAM(led);
10389 TPACPI_PARAM(beep);
10390 TPACPI_PARAM(brightness);
10391 TPACPI_PARAM(volume);
10392 TPACPI_PARAM(fan);
10393
10394 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
10395 module_param(dbg_wlswemul, uint, 0444);
10396 MODULE_PARM_DESC(dbg_wlswemul, "Enables WLSW emulation");
10397 module_param_named(wlsw_state, tpacpi_wlsw_emulstate, bool, 0);
10398 MODULE_PARM_DESC(wlsw_state,
10399 "Initial state of the emulated WLSW switch");
10400
10401 module_param(dbg_bluetoothemul, uint, 0444);
10402 MODULE_PARM_DESC(dbg_bluetoothemul, "Enables bluetooth switch emulation");
10403 module_param_named(bluetooth_state, tpacpi_bluetooth_emulstate, bool, 0);
10404 MODULE_PARM_DESC(bluetooth_state,
10405 "Initial state of the emulated bluetooth switch");
10406
10407 module_param(dbg_wwanemul, uint, 0444);
10408 MODULE_PARM_DESC(dbg_wwanemul, "Enables WWAN switch emulation");
10409 module_param_named(wwan_state, tpacpi_wwan_emulstate, bool, 0);
10410 MODULE_PARM_DESC(wwan_state,
10411 "Initial state of the emulated WWAN switch");
10412
10413 module_param(dbg_uwbemul, uint, 0444);
10414 MODULE_PARM_DESC(dbg_uwbemul, "Enables UWB switch emulation");
10415 module_param_named(uwb_state, tpacpi_uwb_emulstate, bool, 0);
10416 MODULE_PARM_DESC(uwb_state,
10417 "Initial state of the emulated UWB switch");
10418 #endif
10419
10420 static void thinkpad_acpi_module_exit(void)
10421 {
10422 struct ibm_struct *ibm, *itmp;
10423
10424 tpacpi_lifecycle = TPACPI_LIFE_EXITING;
10425
10426 list_for_each_entry_safe_reverse(ibm, itmp,
10427 &tpacpi_all_drivers,
10428 all_drivers) {
10429 ibm_exit(ibm);
10430 }
10431
10432 dbg_printk(TPACPI_DBG_INIT, "finished subdriver exit path...\n");
10433
10434 if (tpacpi_inputdev) {
10435 if (tp_features.input_device_registered)
10436 input_unregister_device(tpacpi_inputdev);
10437 else
10438 input_free_device(tpacpi_inputdev);
10439 kfree(hotkey_keycode_map);
10440 }
10441
10442 if (tpacpi_hwmon)
10443 hwmon_device_unregister(tpacpi_hwmon);
10444
10445 if (tpacpi_sensors_pdev)
10446 platform_device_unregister(tpacpi_sensors_pdev);
10447 if (tpacpi_pdev)
10448 platform_device_unregister(tpacpi_pdev);
10449
10450 if (tp_features.sensors_pdrv_attrs_registered)
10451 tpacpi_remove_driver_attributes(&tpacpi_hwmon_pdriver.driver);
10452 if (tp_features.platform_drv_attrs_registered)
10453 tpacpi_remove_driver_attributes(&tpacpi_pdriver.driver);
10454
10455 if (tp_features.sensors_pdrv_registered)
10456 platform_driver_unregister(&tpacpi_hwmon_pdriver);
10457
10458 if (tp_features.platform_drv_registered)
10459 platform_driver_unregister(&tpacpi_pdriver);
10460
10461 if (proc_dir)
10462 remove_proc_entry(TPACPI_PROC_DIR, acpi_root_dir);
10463
10464 if (tpacpi_wq)
10465 destroy_workqueue(tpacpi_wq);
10466
10467 kfree(thinkpad_id.bios_version_str);
10468 kfree(thinkpad_id.ec_version_str);
10469 kfree(thinkpad_id.model_str);
10470 kfree(thinkpad_id.nummodel_str);
10471 }
10472
10473
10474 static int __init thinkpad_acpi_module_init(void)
10475 {
10476 int ret, i;
10477
10478 tpacpi_lifecycle = TPACPI_LIFE_INIT;
10479
10480
10481
10482 ret = get_thinkpad_model_data(&thinkpad_id);
10483 if (ret) {
10484 pr_err("unable to get DMI data: %d\n", ret);
10485 thinkpad_acpi_module_exit();
10486 return ret;
10487 }
10488 ret = probe_for_thinkpad();
10489 if (ret) {
10490 thinkpad_acpi_module_exit();
10491 return ret;
10492 }
10493
10494
10495
10496 thinkpad_acpi_init_banner();
10497 tpacpi_check_outdated_fw();
10498
10499 TPACPI_ACPIHANDLE_INIT(ecrd);
10500 TPACPI_ACPIHANDLE_INIT(ecwr);
10501
10502 tpacpi_wq = create_singlethread_workqueue(TPACPI_WORKQUEUE_NAME);
10503 if (!tpacpi_wq) {
10504 thinkpad_acpi_module_exit();
10505 return -ENOMEM;
10506 }
10507
10508 proc_dir = proc_mkdir(TPACPI_PROC_DIR, acpi_root_dir);
10509 if (!proc_dir) {
10510 pr_err("unable to create proc dir " TPACPI_PROC_DIR "\n");
10511 thinkpad_acpi_module_exit();
10512 return -ENODEV;
10513 }
10514
10515 ret = platform_driver_register(&tpacpi_pdriver);
10516 if (ret) {
10517 pr_err("unable to register main platform driver\n");
10518 thinkpad_acpi_module_exit();
10519 return ret;
10520 }
10521 tp_features.platform_drv_registered = 1;
10522
10523 ret = platform_driver_register(&tpacpi_hwmon_pdriver);
10524 if (ret) {
10525 pr_err("unable to register hwmon platform driver\n");
10526 thinkpad_acpi_module_exit();
10527 return ret;
10528 }
10529 tp_features.sensors_pdrv_registered = 1;
10530
10531 ret = tpacpi_create_driver_attributes(&tpacpi_pdriver.driver);
10532 if (!ret) {
10533 tp_features.platform_drv_attrs_registered = 1;
10534 ret = tpacpi_create_driver_attributes(
10535 &tpacpi_hwmon_pdriver.driver);
10536 }
10537 if (ret) {
10538 pr_err("unable to create sysfs driver attributes\n");
10539 thinkpad_acpi_module_exit();
10540 return ret;
10541 }
10542 tp_features.sensors_pdrv_attrs_registered = 1;
10543
10544
10545
10546 tpacpi_pdev = platform_device_register_simple(TPACPI_DRVR_NAME, -1,
10547 NULL, 0);
10548 if (IS_ERR(tpacpi_pdev)) {
10549 ret = PTR_ERR(tpacpi_pdev);
10550 tpacpi_pdev = NULL;
10551 pr_err("unable to register platform device\n");
10552 thinkpad_acpi_module_exit();
10553 return ret;
10554 }
10555 tpacpi_sensors_pdev = platform_device_register_simple(
10556 TPACPI_HWMON_DRVR_NAME,
10557 -1, NULL, 0);
10558 if (IS_ERR(tpacpi_sensors_pdev)) {
10559 ret = PTR_ERR(tpacpi_sensors_pdev);
10560 tpacpi_sensors_pdev = NULL;
10561 pr_err("unable to register hwmon platform device\n");
10562 thinkpad_acpi_module_exit();
10563 return ret;
10564 }
10565 tp_features.sensors_pdev_attrs_registered = 1;
10566 tpacpi_hwmon = hwmon_device_register_with_groups(
10567 &tpacpi_sensors_pdev->dev, TPACPI_NAME, NULL, NULL);
10568
10569 if (IS_ERR(tpacpi_hwmon)) {
10570 ret = PTR_ERR(tpacpi_hwmon);
10571 tpacpi_hwmon = NULL;
10572 pr_err("unable to register hwmon device\n");
10573 thinkpad_acpi_module_exit();
10574 return ret;
10575 }
10576 mutex_init(&tpacpi_inputdev_send_mutex);
10577 tpacpi_inputdev = input_allocate_device();
10578 if (!tpacpi_inputdev) {
10579 thinkpad_acpi_module_exit();
10580 return -ENOMEM;
10581 } else {
10582
10583 tpacpi_inputdev->name = "ThinkPad Extra Buttons";
10584 tpacpi_inputdev->phys = TPACPI_DRVR_NAME "/input0";
10585 tpacpi_inputdev->id.bustype = BUS_HOST;
10586 tpacpi_inputdev->id.vendor = thinkpad_id.vendor;
10587 tpacpi_inputdev->id.product = TPACPI_HKEY_INPUT_PRODUCT;
10588 tpacpi_inputdev->id.version = TPACPI_HKEY_INPUT_VERSION;
10589 tpacpi_inputdev->dev.parent = &tpacpi_pdev->dev;
10590 }
10591
10592
10593 tpacpi_detect_brightness_capabilities();
10594
10595
10596 for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
10597 ret = ibm_init(&ibms_init[i]);
10598 if (ret >= 0 && *ibms_init[i].param)
10599 ret = ibms_init[i].data->write(ibms_init[i].param);
10600 if (ret < 0) {
10601 thinkpad_acpi_module_exit();
10602 return ret;
10603 }
10604 }
10605
10606 tpacpi_lifecycle = TPACPI_LIFE_RUNNING;
10607
10608 ret = input_register_device(tpacpi_inputdev);
10609 if (ret < 0) {
10610 pr_err("unable to register input device\n");
10611 thinkpad_acpi_module_exit();
10612 return ret;
10613 } else {
10614 tp_features.input_device_registered = 1;
10615 }
10616
10617 return 0;
10618 }
10619
10620 MODULE_ALIAS(TPACPI_DRVR_SHORTNAME);
10621
10622
10623
10624
10625
10626
10627
10628
10629 MODULE_DEVICE_TABLE(acpi, ibm_htk_device_ids);
10630
10631
10632
10633
10634
10635
10636
10637
10638
10639
10640 #define IBM_BIOS_MODULE_ALIAS(__type) \
10641 MODULE_ALIAS("dmi:bvnIBM:bvr" __type "ET??WW*")
10642
10643
10644
10645
10646 IBM_BIOS_MODULE_ALIAS("I[MU]");
10647
10648 MODULE_AUTHOR("Borislav Deianov <borislav@users.sf.net>");
10649 MODULE_AUTHOR("Henrique de Moraes Holschuh <hmh@hmh.eng.br>");
10650 MODULE_DESCRIPTION(TPACPI_DESC);
10651 MODULE_VERSION(TPACPI_VERSION);
10652 MODULE_LICENSE("GPL");
10653
10654 module_init(thinkpad_acpi_module_init);
10655 module_exit(thinkpad_acpi_module_exit);