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