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