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