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 static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn, 2325 struct tp_nvram_state *newn, 2326 const u32 event_mask) 2327 { 2328 2329 #define TPACPI_COMPARE_KEY(__scancode, __member) \ 2330 do { \ 2331 if ((event_mask & (1 << __scancode)) && \ 2332 oldn->__member != newn->__member) \ 2333 tpacpi_hotkey_send_key(__scancode); \ 2334 } while (0) 2335 2336 #define TPACPI_MAY_SEND_KEY(__scancode) \ 2337 do { \ 2338 if (event_mask & (1 << __scancode)) \ 2339 tpacpi_hotkey_send_key(__scancode); \ 2340 } while (0) 2341 2342 void issue_volchange(const unsigned int oldvol, 2343 const unsigned int newvol) 2344 { 2345 unsigned int i = oldvol; 2346 2347 while (i > newvol) { 2348 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN); 2349 i--; 2350 } 2351 while (i < newvol) { 2352 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP); 2353 i++; 2354 } 2355 } 2356 2357 void issue_brightnesschange(const unsigned int oldbrt, 2358 const unsigned int newbrt) 2359 { 2360 unsigned int i = oldbrt; 2361 2362 while (i > newbrt) { 2363 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND); 2364 i--; 2365 } 2366 while (i < newbrt) { 2367 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME); 2368 i++; 2369 } 2370 } 2371 2372 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_THINKPAD, thinkpad_toggle); 2373 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNSPACE, zoom_toggle); 2374 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF7, display_toggle); 2375 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF12, hibernate_toggle); 2376 2377 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNPAGEUP, thinklight_toggle); 2378 2379 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF8, displayexp_toggle); 2380 2381 /* 2382 * Handle volume 2383 * 2384 * This code is supposed to duplicate the IBM firmware behaviour: 2385 * - Pressing MUTE issues mute hotkey message, even when already mute 2386 * - Pressing Volume up/down issues volume up/down hotkey messages, 2387 * even when already at maximum or minimum volume 2388 * - The act of unmuting issues volume up/down notification, 2389 * depending which key was used to unmute 2390 * 2391 * We are constrained to what the NVRAM can tell us, which is not much 2392 * and certainly not enough if more than one volume hotkey was pressed 2393 * since the last poll cycle. 2394 * 2395 * Just to make our life interesting, some newer Lenovo ThinkPads have 2396 * bugs in the BIOS and may fail to update volume_toggle properly. 2397 */ 2398 if (newn->mute) { 2399 /* muted */ 2400 if (!oldn->mute || 2401 oldn->volume_toggle != newn->volume_toggle || 2402 oldn->volume_level != newn->volume_level) { 2403 /* recently muted, or repeated mute keypress, or 2404 * multiple presses ending in mute */ 2405 issue_volchange(oldn->volume_level, newn->volume_level); 2406 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE); 2407 } 2408 } else { 2409 /* unmute */ 2410 if (oldn->mute) { 2411 /* recently unmuted, issue 'unmute' keypress */ 2412 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP); 2413 } 2414 if (oldn->volume_level != newn->volume_level) { 2415 issue_volchange(oldn->volume_level, newn->volume_level); 2416 } else if (oldn->volume_toggle != newn->volume_toggle) { 2417 /* repeated vol up/down keypress at end of scale ? */ 2418 if (newn->volume_level == 0) 2419 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN); 2420 else if (newn->volume_level >= TP_NVRAM_LEVEL_VOLUME_MAX) 2421 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP); 2422 } 2423 } 2424 2425 /* handle brightness */ 2426 if (oldn->brightness_level != newn->brightness_level) { 2427 issue_brightnesschange(oldn->brightness_level, 2428 newn->brightness_level); 2429 } else if (oldn->brightness_toggle != newn->brightness_toggle) { 2430 /* repeated key presses that didn't change state */ 2431 if (newn->brightness_level == 0) 2432 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND); 2433 else if (newn->brightness_level >= bright_maxlvl 2434 && !tp_features.bright_unkfw) 2435 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME); 2436 } 2437 2438 #undef TPACPI_COMPARE_KEY 2439 #undef TPACPI_MAY_SEND_KEY 2440 } 2441 2442 /* 2443 * Polling driver 2444 * 2445 * We track all events in hotkey_source_mask all the time, since 2446 * most of them are edge-based. We only issue those requested by 2447 * hotkey_user_mask or hotkey_driver_mask, though. 2448 */ 2449 static int hotkey_kthread(void *data) 2450 { 2451 struct tp_nvram_state s[2]; 2452 u32 poll_mask, event_mask; 2453 unsigned int si, so; 2454 unsigned long t; 2455 unsigned int change_detector; 2456 unsigned int poll_freq; 2457 bool was_frozen; 2458 2459 if (tpacpi_lifecycle == TPACPI_LIFE_EXITING) 2460 goto exit; 2461 2462 set_freezable(); 2463 2464 so = 0; 2465 si = 1; 2466 t = 0; 2467 2468 /* Initial state for compares */ 2469 mutex_lock(&hotkey_thread_data_mutex); 2470 change_detector = hotkey_config_change; 2471 poll_mask = hotkey_source_mask; 2472 event_mask = hotkey_source_mask & 2473 (hotkey_driver_mask | hotkey_user_mask); 2474 poll_freq = hotkey_poll_freq; 2475 mutex_unlock(&hotkey_thread_data_mutex); 2476 hotkey_read_nvram(&s[so], poll_mask); 2477 2478 while (!kthread_should_stop()) { 2479 if (t == 0) { 2480 if (likely(poll_freq)) 2481 t = 1000/poll_freq; 2482 else 2483 t = 100; /* should never happen... */ 2484 } 2485 t = msleep_interruptible(t); 2486 if (unlikely(kthread_freezable_should_stop(&was_frozen))) 2487 break; 2488 2489 if (t > 0 && !was_frozen) 2490 continue; 2491 2492 mutex_lock(&hotkey_thread_data_mutex); 2493 if (was_frozen || hotkey_config_change != change_detector) { 2494 /* forget old state on thaw or config change */ 2495 si = so; 2496 t = 0; 2497 change_detector = hotkey_config_change; 2498 } 2499 poll_mask = hotkey_source_mask; 2500 event_mask = hotkey_source_mask & 2501 (hotkey_driver_mask | hotkey_user_mask); 2502 poll_freq = hotkey_poll_freq; 2503 mutex_unlock(&hotkey_thread_data_mutex); 2504 2505 if (likely(poll_mask)) { 2506 hotkey_read_nvram(&s[si], poll_mask); 2507 if (likely(si != so)) { 2508 hotkey_compare_and_issue_event(&s[so], &s[si], 2509 event_mask); 2510 } 2511 } 2512 2513 so = si; 2514 si ^= 1; 2515 } 2516 2517 exit: 2518 return 0; 2519 } 2520 2521 /* call with hotkey_mutex held */ 2522 static void hotkey_poll_stop_sync(void) 2523 { 2524 if (tpacpi_hotkey_task) { 2525 kthread_stop(tpacpi_hotkey_task); 2526 tpacpi_hotkey_task = NULL; 2527 } 2528 } 2529 2530 /* call with hotkey_mutex held */ 2531 static void hotkey_poll_setup(const bool may_warn) 2532 { 2533 const u32 poll_driver_mask = hotkey_driver_mask & hotkey_source_mask; 2534 const u32 poll_user_mask = hotkey_user_mask & hotkey_source_mask; 2535 2536 if (hotkey_poll_freq > 0 && 2537 (poll_driver_mask || 2538 (poll_user_mask && tpacpi_inputdev->users > 0))) { 2539 if (!tpacpi_hotkey_task) { 2540 tpacpi_hotkey_task = kthread_run(hotkey_kthread, 2541 NULL, TPACPI_NVRAM_KTHREAD_NAME); 2542 if (IS_ERR(tpacpi_hotkey_task)) { 2543 tpacpi_hotkey_task = NULL; 2544 pr_err("could not create kernel thread " 2545 "for hotkey polling\n"); 2546 } 2547 } 2548 } else { 2549 hotkey_poll_stop_sync(); 2550 if (may_warn && (poll_driver_mask || poll_user_mask) && 2551 hotkey_poll_freq == 0) { 2552 pr_notice("hot keys 0x%08x and/or events 0x%08x " 2553 "require polling, which is currently " 2554 "disabled\n", 2555 poll_user_mask, poll_driver_mask); 2556 } 2557 } 2558 } 2559 2560 static void hotkey_poll_setup_safe(const bool may_warn) 2561 { 2562 mutex_lock(&hotkey_mutex); 2563 hotkey_poll_setup(may_warn); 2564 mutex_unlock(&hotkey_mutex); 2565 } 2566 2567 /* call with hotkey_mutex held */ 2568 static void hotkey_poll_set_freq(unsigned int freq) 2569 { 2570 if (!freq) 2571 hotkey_poll_stop_sync(); 2572 2573 hotkey_poll_freq = freq; 2574 } 2575 2576 #else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */ 2577 2578 static void hotkey_poll_setup(const bool __unused) 2579 { 2580 } 2581 2582 static void hotkey_poll_setup_safe(const bool __unused) 2583 { 2584 } 2585 2586 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */ 2587 2588 static int hotkey_inputdev_open(struct input_dev *dev) 2589 { 2590 switch (tpacpi_lifecycle) { 2591 case TPACPI_LIFE_INIT: 2592 case TPACPI_LIFE_RUNNING: 2593 hotkey_poll_setup_safe(false); 2594 return 0; 2595 case TPACPI_LIFE_EXITING: 2596 return -EBUSY; 2597 } 2598 2599 /* Should only happen if tpacpi_lifecycle is corrupt */ 2600 BUG(); 2601 return -EBUSY; 2602 } 2603 2604 static void hotkey_inputdev_close(struct input_dev *dev) 2605 { 2606 /* disable hotkey polling when possible */ 2607 if (tpacpi_lifecycle != TPACPI_LIFE_EXITING && 2608 !(hotkey_source_mask & hotkey_driver_mask)) 2609 hotkey_poll_setup_safe(false); 2610 } 2611 2612 /* sysfs hotkey enable ------------------------------------------------- */ 2613 static ssize_t hotkey_enable_show(struct device *dev, 2614 struct device_attribute *attr, 2615 char *buf) 2616 { 2617 int res, status; 2618 2619 printk_deprecated_attribute("hotkey_enable", 2620 "Hotkey reporting is always enabled"); 2621 2622 res = hotkey_status_get(&status); 2623 if (res) 2624 return res; 2625 2626 return snprintf(buf, PAGE_SIZE, "%d\n", status); 2627 } 2628 2629 static ssize_t hotkey_enable_store(struct device *dev, 2630 struct device_attribute *attr, 2631 const char *buf, size_t count) 2632 { 2633 unsigned long t; 2634 2635 printk_deprecated_attribute("hotkey_enable", 2636 "Hotkeys can be disabled through hotkey_mask"); 2637 2638 if (parse_strtoul(buf, 1, &t)) 2639 return -EINVAL; 2640 2641 if (t == 0) 2642 return -EPERM; 2643 2644 return count; 2645 } 2646 2647 static struct device_attribute dev_attr_hotkey_enable = 2648 __ATTR(hotkey_enable, S_IWUSR | S_IRUGO, 2649 hotkey_enable_show, hotkey_enable_store); 2650 2651 /* sysfs hotkey mask --------------------------------------------------- */ 2652 static ssize_t hotkey_mask_show(struct device *dev, 2653 struct device_attribute *attr, 2654 char *buf) 2655 { 2656 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_user_mask); 2657 } 2658 2659 static ssize_t hotkey_mask_store(struct device *dev, 2660 struct device_attribute *attr, 2661 const char *buf, size_t count) 2662 { 2663 unsigned long t; 2664 int res; 2665 2666 if (parse_strtoul(buf, 0xffffffffUL, &t)) 2667 return -EINVAL; 2668 2669 if (mutex_lock_killable(&hotkey_mutex)) 2670 return -ERESTARTSYS; 2671 2672 res = hotkey_user_mask_set(t); 2673 2674 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL 2675 hotkey_poll_setup(true); 2676 #endif 2677 2678 mutex_unlock(&hotkey_mutex); 2679 2680 tpacpi_disclose_usertask("hotkey_mask", "set to 0x%08lx\n", t); 2681 2682 return (res) ? res : count; 2683 } 2684 2685 static struct device_attribute dev_attr_hotkey_mask = 2686 __ATTR(hotkey_mask, S_IWUSR | S_IRUGO, 2687 hotkey_mask_show, hotkey_mask_store); 2688 2689 /* sysfs hotkey bios_enabled ------------------------------------------- */ 2690 static ssize_t hotkey_bios_enabled_show(struct device *dev, 2691 struct device_attribute *attr, 2692 char *buf) 2693 { 2694 return sprintf(buf, "0\n"); 2695 } 2696 2697 static struct device_attribute dev_attr_hotkey_bios_enabled = 2698 __ATTR(hotkey_bios_enabled, S_IRUGO, hotkey_bios_enabled_show, NULL); 2699 2700 /* sysfs hotkey bios_mask ---------------------------------------------- */ 2701 static ssize_t hotkey_bios_mask_show(struct device *dev, 2702 struct device_attribute *attr, 2703 char *buf) 2704 { 2705 printk_deprecated_attribute("hotkey_bios_mask", 2706 "This attribute is useless."); 2707 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask); 2708 } 2709 2710 static struct device_attribute dev_attr_hotkey_bios_mask = 2711 __ATTR(hotkey_bios_mask, S_IRUGO, hotkey_bios_mask_show, NULL); 2712 2713 /* sysfs hotkey all_mask ----------------------------------------------- */ 2714 static ssize_t hotkey_all_mask_show(struct device *dev, 2715 struct device_attribute *attr, 2716 char *buf) 2717 { 2718 return snprintf(buf, PAGE_SIZE, "0x%08x\n", 2719 hotkey_all_mask | hotkey_source_mask); 2720 } 2721 2722 static struct device_attribute dev_attr_hotkey_all_mask = 2723 __ATTR(hotkey_all_mask, S_IRUGO, hotkey_all_mask_show, NULL); 2724 2725 /* sysfs hotkey recommended_mask --------------------------------------- */ 2726 static ssize_t hotkey_recommended_mask_show(struct device *dev, 2727 struct device_attribute *attr, 2728 char *buf) 2729 { 2730 return snprintf(buf, PAGE_SIZE, "0x%08x\n", 2731 (hotkey_all_mask | hotkey_source_mask) 2732 & ~hotkey_reserved_mask); 2733 } 2734 2735 static struct device_attribute dev_attr_hotkey_recommended_mask = 2736 __ATTR(hotkey_recommended_mask, S_IRUGO, 2737 hotkey_recommended_mask_show, NULL); 2738 2739 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL 2740 2741 /* sysfs hotkey hotkey_source_mask ------------------------------------- */ 2742 static ssize_t hotkey_source_mask_show(struct device *dev, 2743 struct device_attribute *attr, 2744 char *buf) 2745 { 2746 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_source_mask); 2747 } 2748 2749 static ssize_t hotkey_source_mask_store(struct device *dev, 2750 struct device_attribute *attr, 2751 const char *buf, size_t count) 2752 { 2753 unsigned long t; 2754 u32 r_ev; 2755 int rc; 2756 2757 if (parse_strtoul(buf, 0xffffffffUL, &t) || 2758 ((t & ~TPACPI_HKEY_NVRAM_KNOWN_MASK) != 0)) 2759 return -EINVAL; 2760 2761 if (mutex_lock_killable(&hotkey_mutex)) 2762 return -ERESTARTSYS; 2763 2764 HOTKEY_CONFIG_CRITICAL_START 2765 hotkey_source_mask = t; 2766 HOTKEY_CONFIG_CRITICAL_END 2767 2768 rc = hotkey_mask_set((hotkey_user_mask | hotkey_driver_mask) & 2769 ~hotkey_source_mask); 2770 hotkey_poll_setup(true); 2771 2772 /* check if events needed by the driver got disabled */ 2773 r_ev = hotkey_driver_mask & ~(hotkey_acpi_mask & hotkey_all_mask) 2774 & ~hotkey_source_mask & TPACPI_HKEY_NVRAM_KNOWN_MASK; 2775 2776 mutex_unlock(&hotkey_mutex); 2777 2778 if (rc < 0) 2779 pr_err("hotkey_source_mask: " 2780 "failed to update the firmware event mask!\n"); 2781 2782 if (r_ev) 2783 pr_notice("hotkey_source_mask: " 2784 "some important events were disabled: 0x%04x\n", 2785 r_ev); 2786 2787 tpacpi_disclose_usertask("hotkey_source_mask", "set to 0x%08lx\n", t); 2788 2789 return (rc < 0) ? rc : count; 2790 } 2791 2792 static struct device_attribute dev_attr_hotkey_source_mask = 2793 __ATTR(hotkey_source_mask, S_IWUSR | S_IRUGO, 2794 hotkey_source_mask_show, hotkey_source_mask_store); 2795 2796 /* sysfs hotkey hotkey_poll_freq --------------------------------------- */ 2797 static ssize_t hotkey_poll_freq_show(struct device *dev, 2798 struct device_attribute *attr, 2799 char *buf) 2800 { 2801 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_poll_freq); 2802 } 2803 2804 static ssize_t hotkey_poll_freq_store(struct device *dev, 2805 struct device_attribute *attr, 2806 const char *buf, size_t count) 2807 { 2808 unsigned long t; 2809 2810 if (parse_strtoul(buf, 25, &t)) 2811 return -EINVAL; 2812 2813 if (mutex_lock_killable(&hotkey_mutex)) 2814 return -ERESTARTSYS; 2815 2816 hotkey_poll_set_freq(t); 2817 hotkey_poll_setup(true); 2818 2819 mutex_unlock(&hotkey_mutex); 2820 2821 tpacpi_disclose_usertask("hotkey_poll_freq", "set to %lu\n", t); 2822 2823 return count; 2824 } 2825 2826 static struct device_attribute dev_attr_hotkey_poll_freq = 2827 __ATTR(hotkey_poll_freq, S_IWUSR | S_IRUGO, 2828 hotkey_poll_freq_show, hotkey_poll_freq_store); 2829 2830 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */ 2831 2832 /* sysfs hotkey radio_sw (pollable) ------------------------------------ */ 2833 static ssize_t hotkey_radio_sw_show(struct device *dev, 2834 struct device_attribute *attr, 2835 char *buf) 2836 { 2837 int res; 2838 res = hotkey_get_wlsw(); 2839 if (res < 0) 2840 return res; 2841 2842 /* Opportunistic update */ 2843 tpacpi_rfk_update_hwblock_state((res == TPACPI_RFK_RADIO_OFF)); 2844 2845 return snprintf(buf, PAGE_SIZE, "%d\n", 2846 (res == TPACPI_RFK_RADIO_OFF) ? 0 : 1); 2847 } 2848 2849 static struct device_attribute dev_attr_hotkey_radio_sw = 2850 __ATTR(hotkey_radio_sw, S_IRUGO, hotkey_radio_sw_show, NULL); 2851 2852 static void hotkey_radio_sw_notify_change(void) 2853 { 2854 if (tp_features.hotkey_wlsw) 2855 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL, 2856 "hotkey_radio_sw"); 2857 } 2858 2859 /* sysfs hotkey tablet mode (pollable) --------------------------------- */ 2860 static ssize_t hotkey_tablet_mode_show(struct device *dev, 2861 struct device_attribute *attr, 2862 char *buf) 2863 { 2864 int res, s; 2865 res = hotkey_get_tablet_mode(&s); 2866 if (res < 0) 2867 return res; 2868 2869 return snprintf(buf, PAGE_SIZE, "%d\n", !!s); 2870 } 2871 2872 static struct device_attribute dev_attr_hotkey_tablet_mode = 2873 __ATTR(hotkey_tablet_mode, S_IRUGO, hotkey_tablet_mode_show, NULL); 2874 2875 static void hotkey_tablet_mode_notify_change(void) 2876 { 2877 if (tp_features.hotkey_tablet) 2878 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL, 2879 "hotkey_tablet_mode"); 2880 } 2881 2882 /* sysfs wakeup reason (pollable) -------------------------------------- */ 2883 static ssize_t hotkey_wakeup_reason_show(struct device *dev, 2884 struct device_attribute *attr, 2885 char *buf) 2886 { 2887 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_wakeup_reason); 2888 } 2889 2890 static struct device_attribute dev_attr_hotkey_wakeup_reason = 2891 __ATTR(wakeup_reason, S_IRUGO, hotkey_wakeup_reason_show, NULL); 2892 2893 static void hotkey_wakeup_reason_notify_change(void) 2894 { 2895 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL, 2896 "wakeup_reason"); 2897 } 2898 2899 /* sysfs wakeup hotunplug_complete (pollable) -------------------------- */ 2900 static ssize_t hotkey_wakeup_hotunplug_complete_show(struct device *dev, 2901 struct device_attribute *attr, 2902 char *buf) 2903 { 2904 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_autosleep_ack); 2905 } 2906 2907 static struct device_attribute dev_attr_hotkey_wakeup_hotunplug_complete = 2908 __ATTR(wakeup_hotunplug_complete, S_IRUGO, 2909 hotkey_wakeup_hotunplug_complete_show, NULL); 2910 2911 static void hotkey_wakeup_hotunplug_complete_notify_change(void) 2912 { 2913 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL, 2914 "wakeup_hotunplug_complete"); 2915 } 2916 2917 /* --------------------------------------------------------------------- */ 2918 2919 static struct attribute *hotkey_attributes[] __initdata = { 2920 &dev_attr_hotkey_enable.attr, 2921 &dev_attr_hotkey_bios_enabled.attr, 2922 &dev_attr_hotkey_bios_mask.attr, 2923 &dev_attr_hotkey_wakeup_reason.attr, 2924 &dev_attr_hotkey_wakeup_hotunplug_complete.attr, 2925 &dev_attr_hotkey_mask.attr, 2926 &dev_attr_hotkey_all_mask.attr, 2927 &dev_attr_hotkey_recommended_mask.attr, 2928 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL 2929 &dev_attr_hotkey_source_mask.attr, 2930 &dev_attr_hotkey_poll_freq.attr, 2931 #endif 2932 }; 2933 2934 /* 2935 * Sync both the hw and sw blocking state of all switches 2936 */ 2937 static void tpacpi_send_radiosw_update(void) 2938 { 2939 int wlsw; 2940 2941 /* 2942 * We must sync all rfkill controllers *before* issuing any 2943 * rfkill input events, or we will race the rfkill core input 2944 * handler. 2945 * 2946 * tpacpi_inputdev_send_mutex works as a synchronization point 2947 * for the above. 2948 * 2949 * We optimize to avoid numerous calls to hotkey_get_wlsw. 2950 */ 2951 2952 wlsw = hotkey_get_wlsw(); 2953 2954 /* Sync hw blocking state first if it is hw-blocked */ 2955 if (wlsw == TPACPI_RFK_RADIO_OFF) 2956 tpacpi_rfk_update_hwblock_state(true); 2957 2958 /* Sync sw blocking state */ 2959 tpacpi_rfk_update_swstate_all(); 2960 2961 /* Sync hw blocking state last if it is hw-unblocked */ 2962 if (wlsw == TPACPI_RFK_RADIO_ON) 2963 tpacpi_rfk_update_hwblock_state(false); 2964 2965 /* Issue rfkill input event for WLSW switch */ 2966 if (!(wlsw < 0)) { 2967 mutex_lock(&tpacpi_inputdev_send_mutex); 2968 2969 input_report_switch(tpacpi_inputdev, 2970 SW_RFKILL_ALL, (wlsw > 0)); 2971 input_sync(tpacpi_inputdev); 2972 2973 mutex_unlock(&tpacpi_inputdev_send_mutex); 2974 } 2975 2976 /* 2977 * this can be unconditional, as we will poll state again 2978 * if userspace uses the notify to read data 2979 */ 2980 hotkey_radio_sw_notify_change(); 2981 } 2982 2983 static void hotkey_exit(void) 2984 { 2985 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL 2986 mutex_lock(&hotkey_mutex); 2987 hotkey_poll_stop_sync(); 2988 mutex_unlock(&hotkey_mutex); 2989 #endif 2990 2991 if (hotkey_dev_attributes) 2992 delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj); 2993 2994 dbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_HKEY, 2995 "restoring original HKEY status and mask\n"); 2996 /* yes, there is a bitwise or below, we want the 2997 * functions to be called even if one of them fail */ 2998 if (((tp_features.hotkey_mask && 2999 hotkey_mask_set(hotkey_orig_mask)) | 3000 hotkey_status_set(false)) != 0) 3001 pr_err("failed to restore hot key mask " 3002 "to BIOS defaults\n"); 3003 } 3004 3005 static void __init hotkey_unmap(const unsigned int scancode) 3006 { 3007 if (hotkey_keycode_map[scancode] != KEY_RESERVED) { 3008 clear_bit(hotkey_keycode_map[scancode], 3009 tpacpi_inputdev->keybit); 3010 hotkey_keycode_map[scancode] = KEY_RESERVED; 3011 } 3012 } 3013 3014 /* 3015 * HKEY quirks: 3016 * TPACPI_HK_Q_INIMASK: Supports FN+F3,FN+F4,FN+F12 3017 */ 3018 3019 #define TPACPI_HK_Q_INIMASK 0x0001 3020 3021 static const struct tpacpi_quirk tpacpi_hotkey_qtable[] __initconst = { 3022 TPACPI_Q_IBM('I', 'H', TPACPI_HK_Q_INIMASK), /* 600E */ 3023 TPACPI_Q_IBM('I', 'N', TPACPI_HK_Q_INIMASK), /* 600E */ 3024 TPACPI_Q_IBM('I', 'D', TPACPI_HK_Q_INIMASK), /* 770, 770E, 770ED */ 3025 TPACPI_Q_IBM('I', 'W', TPACPI_HK_Q_INIMASK), /* A20m */ 3026 TPACPI_Q_IBM('I', 'V', TPACPI_HK_Q_INIMASK), /* A20p */ 3027 TPACPI_Q_IBM('1', '0', TPACPI_HK_Q_INIMASK), /* A21e, A22e */ 3028 TPACPI_Q_IBM('K', 'U', TPACPI_HK_Q_INIMASK), /* A21e */ 3029 TPACPI_Q_IBM('K', 'X', TPACPI_HK_Q_INIMASK), /* A21m, A22m */ 3030 TPACPI_Q_IBM('K', 'Y', TPACPI_HK_Q_INIMASK), /* A21p, A22p */ 3031 TPACPI_Q_IBM('1', 'B', TPACPI_HK_Q_INIMASK), /* A22e */ 3032 TPACPI_Q_IBM('1', '3', TPACPI_HK_Q_INIMASK), /* A22m */ 3033 TPACPI_Q_IBM('1', 'E', TPACPI_HK_Q_INIMASK), /* A30/p (0) */ 3034 TPACPI_Q_IBM('1', 'C', TPACPI_HK_Q_INIMASK), /* R30 */ 3035 TPACPI_Q_IBM('1', 'F', TPACPI_HK_Q_INIMASK), /* R31 */ 3036 TPACPI_Q_IBM('I', 'Y', TPACPI_HK_Q_INIMASK), /* T20 */ 3037 TPACPI_Q_IBM('K', 'Z', TPACPI_HK_Q_INIMASK), /* T21 */ 3038 TPACPI_Q_IBM('1', '6', TPACPI_HK_Q_INIMASK), /* T22 */ 3039 TPACPI_Q_IBM('I', 'Z', TPACPI_HK_Q_INIMASK), /* X20, X21 */ 3040 TPACPI_Q_IBM('1', 'D', TPACPI_HK_Q_INIMASK), /* X22, X23, X24 */ 3041 }; 3042 3043 typedef u16 tpacpi_keymap_entry_t; 3044 typedef tpacpi_keymap_entry_t tpacpi_keymap_t[TPACPI_HOTKEY_MAP_LEN]; 3045 3046 static int __init hotkey_init(struct ibm_init_struct *iibm) 3047 { 3048 /* Requirements for changing the default keymaps: 3049 * 3050 * 1. Many of the keys are mapped to KEY_RESERVED for very 3051 * good reasons. Do not change them unless you have deep 3052 * knowledge on the IBM and Lenovo ThinkPad firmware for 3053 * the various ThinkPad models. The driver behaves 3054 * differently for KEY_RESERVED: such keys have their 3055 * hot key mask *unset* in mask_recommended, and also 3056 * in the initial hot key mask programmed into the 3057 * firmware at driver load time, which means the firm- 3058 * ware may react very differently if you change them to 3059 * something else; 3060 * 3061 * 2. You must be subscribed to the linux-thinkpad and 3062 * ibm-acpi-devel mailing lists, and you should read the 3063 * list archives since 2007 if you want to change the 3064 * keymaps. This requirement exists so that you will 3065 * know the past history of problems with the thinkpad- 3066 * acpi driver keymaps, and also that you will be 3067 * listening to any bug reports; 3068 * 3069 * 3. Do not send thinkpad-acpi specific patches directly to 3070 * for merging, *ever*. Send them to the linux-acpi 3071 * mailinglist for comments. Merging is to be done only 3072 * through acpi-test and the ACPI maintainer. 3073 * 3074 * If the above is too much to ask, don't change the keymap. 3075 * Ask the thinkpad-acpi maintainer to do it, instead. 3076 */ 3077 3078 enum keymap_index { 3079 TPACPI_KEYMAP_IBM_GENERIC = 0, 3080 TPACPI_KEYMAP_LENOVO_GENERIC, 3081 }; 3082 3083 static const tpacpi_keymap_t tpacpi_keymaps[] __initconst = { 3084 /* Generic keymap for IBM ThinkPads */ 3085 [TPACPI_KEYMAP_IBM_GENERIC] = { 3086 /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */ 3087 KEY_FN_F1, KEY_BATTERY, KEY_COFFEE, KEY_SLEEP, 3088 KEY_WLAN, KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8, 3089 KEY_FN_F9, KEY_FN_F10, KEY_FN_F11, KEY_SUSPEND, 3090 3091 /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */ 3092 KEY_UNKNOWN, /* 0x0C: FN+BACKSPACE */ 3093 KEY_UNKNOWN, /* 0x0D: FN+INSERT */ 3094 KEY_UNKNOWN, /* 0x0E: FN+DELETE */ 3095 3096 /* brightness: firmware always reacts to them */ 3097 KEY_RESERVED, /* 0x0F: FN+HOME (brightness up) */ 3098 KEY_RESERVED, /* 0x10: FN+END (brightness down) */ 3099 3100 /* Thinklight: firmware always react to it */ 3101 KEY_RESERVED, /* 0x11: FN+PGUP (thinklight toggle) */ 3102 3103 KEY_UNKNOWN, /* 0x12: FN+PGDOWN */ 3104 KEY_ZOOM, /* 0x13: FN+SPACE (zoom) */ 3105 3106 /* Volume: firmware always react to it and reprograms 3107 * the built-in *extra* mixer. Never map it to control 3108 * another mixer by default. */ 3109 KEY_RESERVED, /* 0x14: VOLUME UP */ 3110 KEY_RESERVED, /* 0x15: VOLUME DOWN */ 3111 KEY_RESERVED, /* 0x16: MUTE */ 3112 3113 KEY_VENDOR, /* 0x17: Thinkpad/AccessIBM/Lenovo */ 3114 3115 /* (assignments unknown, please report if found) */ 3116 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, 3117 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, 3118 }, 3119 3120 /* Generic keymap for Lenovo ThinkPads */ 3121 [TPACPI_KEYMAP_LENOVO_GENERIC] = { 3122 /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */ 3123 KEY_FN_F1, KEY_COFFEE, KEY_BATTERY, KEY_SLEEP, 3124 KEY_WLAN, KEY_CAMERA, KEY_SWITCHVIDEOMODE, KEY_FN_F8, 3125 KEY_FN_F9, KEY_FN_F10, KEY_FN_F11, KEY_SUSPEND, 3126 3127 /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */ 3128 KEY_UNKNOWN, /* 0x0C: FN+BACKSPACE */ 3129 KEY_UNKNOWN, /* 0x0D: FN+INSERT */ 3130 KEY_UNKNOWN, /* 0x0E: FN+DELETE */ 3131 3132 /* These should be enabled --only-- when ACPI video 3133 * is disabled (i.e. in "vendor" mode), and are handled 3134 * in a special way by the init code */ 3135 KEY_BRIGHTNESSUP, /* 0x0F: FN+HOME (brightness up) */ 3136 KEY_BRIGHTNESSDOWN, /* 0x10: FN+END (brightness down) */ 3137 3138 KEY_RESERVED, /* 0x11: FN+PGUP (thinklight toggle) */ 3139 3140 KEY_UNKNOWN, /* 0x12: FN+PGDOWN */ 3141 KEY_ZOOM, /* 0x13: FN+SPACE (zoom) */ 3142 3143 /* Volume: z60/z61, T60 (BIOS version?): firmware always 3144 * react to it and reprograms the built-in *extra* mixer. 3145 * Never map it to control another mixer by default. 3146 * 3147 * T60?, T61, R60?, R61: firmware and EC tries to send 3148 * these over the regular keyboard, so these are no-ops, 3149 * but there are still weird bugs re. MUTE, so do not 3150 * change unless you get test reports from all Lenovo 3151 * models. May cause the BIOS to interfere with the 3152 * HDA mixer. 3153 */ 3154 KEY_RESERVED, /* 0x14: VOLUME UP */ 3155 KEY_RESERVED, /* 0x15: VOLUME DOWN */ 3156 KEY_RESERVED, /* 0x16: MUTE */ 3157 3158 KEY_VENDOR, /* 0x17: Thinkpad/AccessIBM/Lenovo */ 3159 3160 /* (assignments unknown, please report if found) */ 3161 KEY_UNKNOWN, KEY_UNKNOWN, 3162 3163 /* 3164 * The mic mute button only sends 0x1a. It does not 3165 * automatically mute the mic or change the mute light. 3166 */ 3167 KEY_MICMUTE, /* 0x1a: Mic mute (since ?400 or so) */ 3168 3169 /* (assignments unknown, please report if found) */ 3170 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, 3171 KEY_UNKNOWN, 3172 }, 3173 }; 3174 3175 static const struct tpacpi_quirk tpacpi_keymap_qtable[] __initconst = { 3176 /* Generic maps (fallback) */ 3177 { 3178 .vendor = PCI_VENDOR_ID_IBM, 3179 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY, 3180 .quirks = TPACPI_KEYMAP_IBM_GENERIC, 3181 }, 3182 { 3183 .vendor = PCI_VENDOR_ID_LENOVO, 3184 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY, 3185 .quirks = TPACPI_KEYMAP_LENOVO_GENERIC, 3186 }, 3187 }; 3188 3189 #define TPACPI_HOTKEY_MAP_SIZE sizeof(tpacpi_keymap_t) 3190 #define TPACPI_HOTKEY_MAP_TYPESIZE sizeof(tpacpi_keymap_entry_t) 3191 3192 int res, i; 3193 int status; 3194 int hkeyv; 3195 bool radiosw_state = false; 3196 bool tabletsw_state = false; 3197 3198 unsigned long quirks; 3199 unsigned long keymap_id; 3200 3201 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY, 3202 "initializing hotkey subdriver\n"); 3203 3204 BUG_ON(!tpacpi_inputdev); 3205 BUG_ON(tpacpi_inputdev->open != NULL || 3206 tpacpi_inputdev->close != NULL); 3207 3208 TPACPI_ACPIHANDLE_INIT(hkey); 3209 mutex_init(&hotkey_mutex); 3210 3211 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL 3212 mutex_init(&hotkey_thread_data_mutex); 3213 #endif 3214 3215 /* hotkey not supported on 570 */ 3216 tp_features.hotkey = hkey_handle != NULL; 3217 3218 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY, 3219 "hotkeys are %s\n", 3220 str_supported(tp_features.hotkey)); 3221 3222 if (!tp_features.hotkey) 3223 return 1; 3224 3225 quirks = tpacpi_check_quirks(tpacpi_hotkey_qtable, 3226 ARRAY_SIZE(tpacpi_hotkey_qtable)); 3227 3228 tpacpi_disable_brightness_delay(); 3229 3230 /* MUST have enough space for all attributes to be added to 3231 * hotkey_dev_attributes */ 3232 hotkey_dev_attributes = create_attr_set( 3233 ARRAY_SIZE(hotkey_attributes) + 2, 3234 NULL); 3235 if (!hotkey_dev_attributes) 3236 return -ENOMEM; 3237 res = add_many_to_attr_set(hotkey_dev_attributes, 3238 hotkey_attributes, 3239 ARRAY_SIZE(hotkey_attributes)); 3240 if (res) 3241 goto err_exit; 3242 3243 /* mask not supported on 600e/x, 770e, 770x, A21e, A2xm/p, 3244 A30, R30, R31, T20-22, X20-21, X22-24. Detected by checking 3245 for HKEY interface version 0x100 */ 3246 if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) { 3247 if ((hkeyv >> 8) != 1) { 3248 pr_err("unknown version of the HKEY interface: 0x%x\n", 3249 hkeyv); 3250 pr_err("please report this to %s\n", TPACPI_MAIL); 3251 } else { 3252 /* 3253 * MHKV 0x100 in A31, R40, R40e, 3254 * T4x, X31, and later 3255 */ 3256 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY, 3257 "firmware HKEY interface version: 0x%x\n", 3258 hkeyv); 3259 3260 /* Paranoia check AND init hotkey_all_mask */ 3261 if (!acpi_evalf(hkey_handle, &hotkey_all_mask, 3262 "MHKA", "qd")) { 3263 pr_err("missing MHKA handler, " 3264 "please report this to %s\n", 3265 TPACPI_MAIL); 3266 /* Fallback: pre-init for FN+F3,F4,F12 */ 3267 hotkey_all_mask = 0x080cU; 3268 } else { 3269 tp_features.hotkey_mask = 1; 3270 } 3271 } 3272 } 3273 3274 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY, 3275 "hotkey masks are %s\n", 3276 str_supported(tp_features.hotkey_mask)); 3277 3278 /* Init hotkey_all_mask if not initialized yet */ 3279 if (!tp_features.hotkey_mask && !hotkey_all_mask && 3280 (quirks & TPACPI_HK_Q_INIMASK)) 3281 hotkey_all_mask = 0x080cU; /* FN+F12, FN+F4, FN+F3 */ 3282 3283 /* Init hotkey_acpi_mask and hotkey_orig_mask */ 3284 if (tp_features.hotkey_mask) { 3285 /* hotkey_source_mask *must* be zero for 3286 * the first hotkey_mask_get to return hotkey_orig_mask */ 3287 res = hotkey_mask_get(); 3288 if (res) 3289 goto err_exit; 3290 3291 hotkey_orig_mask = hotkey_acpi_mask; 3292 } else { 3293 hotkey_orig_mask = hotkey_all_mask; 3294 hotkey_acpi_mask = hotkey_all_mask; 3295 } 3296 3297 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 3298 if (dbg_wlswemul) { 3299 tp_features.hotkey_wlsw = 1; 3300 radiosw_state = !!tpacpi_wlsw_emulstate; 3301 pr_info("radio switch emulation enabled\n"); 3302 } else 3303 #endif 3304 /* Not all thinkpads have a hardware radio switch */ 3305 if (acpi_evalf(hkey_handle, &status, "WLSW", "qd")) { 3306 tp_features.hotkey_wlsw = 1; 3307 radiosw_state = !!status; 3308 pr_info("radio switch found; radios are %s\n", 3309 enabled(status, 0)); 3310 } 3311 if (tp_features.hotkey_wlsw) 3312 res = add_to_attr_set(hotkey_dev_attributes, 3313 &dev_attr_hotkey_radio_sw.attr); 3314 3315 /* For X41t, X60t, X61t Tablets... */ 3316 if (!res && acpi_evalf(hkey_handle, &status, "MHKG", "qd")) { 3317 tp_features.hotkey_tablet = 1; 3318 tabletsw_state = !!(status & TP_HOTKEY_TABLET_MASK); 3319 pr_info("possible tablet mode switch found; " 3320 "ThinkPad in %s mode\n", 3321 (tabletsw_state) ? "tablet" : "laptop"); 3322 res = add_to_attr_set(hotkey_dev_attributes, 3323 &dev_attr_hotkey_tablet_mode.attr); 3324 } 3325 3326 if (!res) 3327 res = register_attr_set_with_sysfs( 3328 hotkey_dev_attributes, 3329 &tpacpi_pdev->dev.kobj); 3330 if (res) 3331 goto err_exit; 3332 3333 /* Set up key map */ 3334 hotkey_keycode_map = kmalloc(TPACPI_HOTKEY_MAP_SIZE, 3335 GFP_KERNEL); 3336 if (!hotkey_keycode_map) { 3337 pr_err("failed to allocate memory for key map\n"); 3338 res = -ENOMEM; 3339 goto err_exit; 3340 } 3341 3342 keymap_id = tpacpi_check_quirks(tpacpi_keymap_qtable, 3343 ARRAY_SIZE(tpacpi_keymap_qtable)); 3344 BUG_ON(keymap_id >= ARRAY_SIZE(tpacpi_keymaps)); 3345 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY, 3346 "using keymap number %lu\n", keymap_id); 3347 3348 memcpy(hotkey_keycode_map, &tpacpi_keymaps[keymap_id], 3349 TPACPI_HOTKEY_MAP_SIZE); 3350 3351 input_set_capability(tpacpi_inputdev, EV_MSC, MSC_SCAN); 3352 tpacpi_inputdev->keycodesize = TPACPI_HOTKEY_MAP_TYPESIZE; 3353 tpacpi_inputdev->keycodemax = TPACPI_HOTKEY_MAP_LEN; 3354 tpacpi_inputdev->keycode = hotkey_keycode_map; 3355 for (i = 0; i < TPACPI_HOTKEY_MAP_LEN; i++) { 3356 if (hotkey_keycode_map[i] != KEY_RESERVED) { 3357 input_set_capability(tpacpi_inputdev, EV_KEY, 3358 hotkey_keycode_map[i]); 3359 } else { 3360 if (i < sizeof(hotkey_reserved_mask)*8) 3361 hotkey_reserved_mask |= 1 << i; 3362 } 3363 } 3364 3365 if (tp_features.hotkey_wlsw) { 3366 input_set_capability(tpacpi_inputdev, EV_SW, SW_RFKILL_ALL); 3367 input_report_switch(tpacpi_inputdev, 3368 SW_RFKILL_ALL, radiosw_state); 3369 } 3370 if (tp_features.hotkey_tablet) { 3371 input_set_capability(tpacpi_inputdev, EV_SW, SW_TABLET_MODE); 3372 input_report_switch(tpacpi_inputdev, 3373 SW_TABLET_MODE, tabletsw_state); 3374 } 3375 3376 /* Do not issue duplicate brightness change events to 3377 * userspace. tpacpi_detect_brightness_capabilities() must have 3378 * been called before this point */ 3379 if (acpi_video_backlight_support()) { 3380 pr_info("This ThinkPad has standard ACPI backlight " 3381 "brightness control, supported by the ACPI " 3382 "video driver\n"); 3383 pr_notice("Disabling thinkpad-acpi brightness events " 3384 "by default...\n"); 3385 3386 /* Disable brightness up/down on Lenovo thinkpads when 3387 * ACPI is handling them, otherwise it is plain impossible 3388 * for userspace to do something even remotely sane */ 3389 hotkey_reserved_mask |= 3390 (1 << TP_ACPI_HOTKEYSCAN_FNHOME) 3391 | (1 << TP_ACPI_HOTKEYSCAN_FNEND); 3392 hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNHOME); 3393 hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNEND); 3394 } 3395 3396 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL 3397 hotkey_source_mask = TPACPI_HKEY_NVRAM_GOOD_MASK 3398 & ~hotkey_all_mask 3399 & ~hotkey_reserved_mask; 3400 3401 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY, 3402 "hotkey source mask 0x%08x, polling freq %u\n", 3403 hotkey_source_mask, hotkey_poll_freq); 3404 #endif 3405 3406 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY, 3407 "enabling firmware HKEY event interface...\n"); 3408 res = hotkey_status_set(true); 3409 if (res) { 3410 hotkey_exit(); 3411 return res; 3412 } 3413 res = hotkey_mask_set(((hotkey_all_mask & ~hotkey_reserved_mask) 3414 | hotkey_driver_mask) 3415 & ~hotkey_source_mask); 3416 if (res < 0 && res != -ENXIO) { 3417 hotkey_exit(); 3418 return res; 3419 } 3420 hotkey_user_mask = (hotkey_acpi_mask | hotkey_source_mask) 3421 & ~hotkey_reserved_mask; 3422 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY, 3423 "initial masks: user=0x%08x, fw=0x%08x, poll=0x%08x\n", 3424 hotkey_user_mask, hotkey_acpi_mask, hotkey_source_mask); 3425 3426 tpacpi_inputdev->open = &hotkey_inputdev_open; 3427 tpacpi_inputdev->close = &hotkey_inputdev_close; 3428 3429 hotkey_poll_setup_safe(true); 3430 3431 return 0; 3432 3433 err_exit: 3434 delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj); 3435 hotkey_dev_attributes = NULL; 3436 3437 return (res < 0)? res : 1; 3438 } 3439 3440 static bool hotkey_notify_hotkey(const u32 hkey, 3441 bool *send_acpi_ev, 3442 bool *ignore_acpi_ev) 3443 { 3444 /* 0x1000-0x1FFF: key presses */ 3445 unsigned int scancode = hkey & 0xfff; 3446 *send_acpi_ev = true; 3447 *ignore_acpi_ev = false; 3448 3449 /* HKEY event 0x1001 is scancode 0x00 */ 3450 if (scancode > 0 && scancode <= TPACPI_HOTKEY_MAP_LEN) { 3451 scancode--; 3452 if (!(hotkey_source_mask & (1 << scancode))) { 3453 tpacpi_input_send_key_masked(scancode); 3454 *send_acpi_ev = false; 3455 } else { 3456 *ignore_acpi_ev = true; 3457 } 3458 return true; 3459 } 3460 return false; 3461 } 3462 3463 static bool hotkey_notify_wakeup(const u32 hkey, 3464 bool *send_acpi_ev, 3465 bool *ignore_acpi_ev) 3466 { 3467 /* 0x2000-0x2FFF: Wakeup reason */ 3468 *send_acpi_ev = true; 3469 *ignore_acpi_ev = false; 3470 3471 switch (hkey) { 3472 case TP_HKEY_EV_WKUP_S3_UNDOCK: /* suspend, undock */ 3473 case TP_HKEY_EV_WKUP_S4_UNDOCK: /* hibernation, undock */ 3474 hotkey_wakeup_reason = TP_ACPI_WAKEUP_UNDOCK; 3475 *ignore_acpi_ev = true; 3476 break; 3477 3478 case TP_HKEY_EV_WKUP_S3_BAYEJ: /* suspend, bay eject */ 3479 case TP_HKEY_EV_WKUP_S4_BAYEJ: /* hibernation, bay eject */ 3480 hotkey_wakeup_reason = TP_ACPI_WAKEUP_BAYEJ; 3481 *ignore_acpi_ev = true; 3482 break; 3483 3484 case TP_HKEY_EV_WKUP_S3_BATLOW: /* Battery on critical low level/S3 */ 3485 case TP_HKEY_EV_WKUP_S4_BATLOW: /* Battery on critical low level/S4 */ 3486 pr_alert("EMERGENCY WAKEUP: battery almost empty\n"); 3487 /* how to auto-heal: */ 3488 /* 2313: woke up from S3, go to S4/S5 */ 3489 /* 2413: woke up from S4, go to S5 */ 3490 break; 3491 3492 default: 3493 return false; 3494 } 3495 3496 if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) { 3497 pr_info("woke up due to a hot-unplug request...\n"); 3498 hotkey_wakeup_reason_notify_change(); 3499 } 3500 return true; 3501 } 3502 3503 static bool hotkey_notify_dockevent(const u32 hkey, 3504 bool *send_acpi_ev, 3505 bool *ignore_acpi_ev) 3506 { 3507 /* 0x4000-0x4FFF: dock-related events */ 3508 *send_acpi_ev = true; 3509 *ignore_acpi_ev = false; 3510 3511 switch (hkey) { 3512 case TP_HKEY_EV_UNDOCK_ACK: 3513 /* ACPI undock operation completed after wakeup */ 3514 hotkey_autosleep_ack = 1; 3515 pr_info("undocked\n"); 3516 hotkey_wakeup_hotunplug_complete_notify_change(); 3517 return true; 3518 3519 case TP_HKEY_EV_HOTPLUG_DOCK: /* docked to port replicator */ 3520 pr_info("docked into hotplug port replicator\n"); 3521 return true; 3522 case TP_HKEY_EV_HOTPLUG_UNDOCK: /* undocked from port replicator */ 3523 pr_info("undocked from hotplug port replicator\n"); 3524 return true; 3525 3526 default: 3527 return false; 3528 } 3529 } 3530 3531 static bool hotkey_notify_usrevent(const u32 hkey, 3532 bool *send_acpi_ev, 3533 bool *ignore_acpi_ev) 3534 { 3535 /* 0x5000-0x5FFF: human interface helpers */ 3536 *send_acpi_ev = true; 3537 *ignore_acpi_ev = false; 3538 3539 switch (hkey) { 3540 case TP_HKEY_EV_PEN_INSERTED: /* X61t: tablet pen inserted into bay */ 3541 case TP_HKEY_EV_PEN_REMOVED: /* X61t: tablet pen removed from bay */ 3542 return true; 3543 3544 case TP_HKEY_EV_TABLET_TABLET: /* X41t-X61t: tablet mode */ 3545 case TP_HKEY_EV_TABLET_NOTEBOOK: /* X41t-X61t: normal mode */ 3546 tpacpi_input_send_tabletsw(); 3547 hotkey_tablet_mode_notify_change(); 3548 *send_acpi_ev = false; 3549 return true; 3550 3551 case TP_HKEY_EV_LID_CLOSE: /* Lid closed */ 3552 case TP_HKEY_EV_LID_OPEN: /* Lid opened */ 3553 case TP_HKEY_EV_BRGHT_CHANGED: /* brightness changed */ 3554 /* do not propagate these events */ 3555 *ignore_acpi_ev = true; 3556 return true; 3557 3558 default: 3559 return false; 3560 } 3561 } 3562 3563 static void thermal_dump_all_sensors(void); 3564 3565 static bool hotkey_notify_6xxx(const u32 hkey, 3566 bool *send_acpi_ev, 3567 bool *ignore_acpi_ev) 3568 { 3569 bool known = true; 3570 3571 /* 0x6000-0x6FFF: thermal alarms/notices and keyboard events */ 3572 *send_acpi_ev = true; 3573 *ignore_acpi_ev = false; 3574 3575 switch (hkey) { 3576 case TP_HKEY_EV_THM_TABLE_CHANGED: 3577 pr_info("EC reports that Thermal Table has changed\n"); 3578 /* recommended action: do nothing, we don't have 3579 * Lenovo ATM information */ 3580 return true; 3581 case TP_HKEY_EV_ALARM_BAT_HOT: 3582 pr_crit("THERMAL ALARM: battery is too hot!\n"); 3583 /* recommended action: warn user through gui */ 3584 break; 3585 case TP_HKEY_EV_ALARM_BAT_XHOT: 3586 pr_alert("THERMAL EMERGENCY: battery is extremely hot!\n"); 3587 /* recommended action: immediate sleep/hibernate */ 3588 break; 3589 case TP_HKEY_EV_ALARM_SENSOR_HOT: 3590 pr_crit("THERMAL ALARM: " 3591 "a sensor reports something is too hot!\n"); 3592 /* recommended action: warn user through gui, that */ 3593 /* some internal component is too hot */ 3594 break; 3595 case TP_HKEY_EV_ALARM_SENSOR_XHOT: 3596 pr_alert("THERMAL EMERGENCY: " 3597 "a sensor reports something is extremely hot!\n"); 3598 /* recommended action: immediate sleep/hibernate */ 3599 break; 3600 case TP_HKEY_EV_AC_CHANGED: 3601 /* X120e, X121e, X220, X220i, X220t, X230, T420, T420s, W520: 3602 * AC status changed; can be triggered by plugging or 3603 * unplugging AC adapter, docking or undocking. */ 3604 3605 /* fallthrough */ 3606 3607 case TP_HKEY_EV_KEY_NUMLOCK: 3608 case TP_HKEY_EV_KEY_FN: 3609 /* key press events, we just ignore them as long as the EC 3610 * is still reporting them in the normal keyboard stream */ 3611 *send_acpi_ev = false; 3612 *ignore_acpi_ev = true; 3613 return true; 3614 3615 default: 3616 pr_warn("unknown possible thermal alarm or keyboard event received\n"); 3617 known = false; 3618 } 3619 3620 thermal_dump_all_sensors(); 3621 3622 return known; 3623 } 3624 3625 static void hotkey_notify(struct ibm_struct *ibm, u32 event) 3626 { 3627 u32 hkey; 3628 bool send_acpi_ev; 3629 bool ignore_acpi_ev; 3630 bool known_ev; 3631 3632 if (event != 0x80) { 3633 pr_err("unknown HKEY notification event %d\n", event); 3634 /* forward it to userspace, maybe it knows how to handle it */ 3635 acpi_bus_generate_netlink_event( 3636 ibm->acpi->device->pnp.device_class, 3637 dev_name(&ibm->acpi->device->dev), 3638 event, 0); 3639 return; 3640 } 3641 3642 while (1) { 3643 if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) { 3644 pr_err("failed to retrieve HKEY event\n"); 3645 return; 3646 } 3647 3648 if (hkey == 0) { 3649 /* queue empty */ 3650 return; 3651 } 3652 3653 send_acpi_ev = true; 3654 ignore_acpi_ev = false; 3655 3656 switch (hkey >> 12) { 3657 case 1: 3658 /* 0x1000-0x1FFF: key presses */ 3659 known_ev = hotkey_notify_hotkey(hkey, &send_acpi_ev, 3660 &ignore_acpi_ev); 3661 break; 3662 case 2: 3663 /* 0x2000-0x2FFF: Wakeup reason */ 3664 known_ev = hotkey_notify_wakeup(hkey, &send_acpi_ev, 3665 &ignore_acpi_ev); 3666 break; 3667 case 3: 3668 /* 0x3000-0x3FFF: bay-related wakeups */ 3669 switch (hkey) { 3670 case TP_HKEY_EV_BAYEJ_ACK: 3671 hotkey_autosleep_ack = 1; 3672 pr_info("bay ejected\n"); 3673 hotkey_wakeup_hotunplug_complete_notify_change(); 3674 known_ev = true; 3675 break; 3676 case TP_HKEY_EV_OPTDRV_EJ: 3677 /* FIXME: kick libata if SATA link offline */ 3678 known_ev = true; 3679 break; 3680 default: 3681 known_ev = false; 3682 } 3683 break; 3684 case 4: 3685 /* 0x4000-0x4FFF: dock-related events */ 3686 known_ev = hotkey_notify_dockevent(hkey, &send_acpi_ev, 3687 &ignore_acpi_ev); 3688 break; 3689 case 5: 3690 /* 0x5000-0x5FFF: human interface helpers */ 3691 known_ev = hotkey_notify_usrevent(hkey, &send_acpi_ev, 3692 &ignore_acpi_ev); 3693 break; 3694 case 6: 3695 /* 0x6000-0x6FFF: thermal alarms/notices and 3696 * keyboard events */ 3697 known_ev = hotkey_notify_6xxx(hkey, &send_acpi_ev, 3698 &ignore_acpi_ev); 3699 break; 3700 case 7: 3701 /* 0x7000-0x7FFF: misc */ 3702 if (tp_features.hotkey_wlsw && 3703 hkey == TP_HKEY_EV_RFKILL_CHANGED) { 3704 tpacpi_send_radiosw_update(); 3705 send_acpi_ev = 0; 3706 known_ev = true; 3707 break; 3708 } 3709 /* fallthrough to default */ 3710 default: 3711 known_ev = false; 3712 } 3713 if (!known_ev) { 3714 pr_notice("unhandled HKEY event 0x%04x\n", hkey); 3715 pr_notice("please report the conditions when this " 3716 "event happened to %s\n", TPACPI_MAIL); 3717 } 3718 3719 /* netlink events */ 3720 if (!ignore_acpi_ev && send_acpi_ev) { 3721 acpi_bus_generate_netlink_event( 3722 ibm->acpi->device->pnp.device_class, 3723 dev_name(&ibm->acpi->device->dev), 3724 event, hkey); 3725 } 3726 } 3727 } 3728 3729 static void hotkey_suspend(void) 3730 { 3731 /* Do these on suspend, we get the events on early resume! */ 3732 hotkey_wakeup_reason = TP_ACPI_WAKEUP_NONE; 3733 hotkey_autosleep_ack = 0; 3734 } 3735 3736 static void hotkey_resume(void) 3737 { 3738 tpacpi_disable_brightness_delay(); 3739 3740 if (hotkey_status_set(true) < 0 || 3741 hotkey_mask_set(hotkey_acpi_mask) < 0) 3742 pr_err("error while attempting to reset the event " 3743 "firmware interface\n"); 3744 3745 tpacpi_send_radiosw_update(); 3746 hotkey_tablet_mode_notify_change(); 3747 hotkey_wakeup_reason_notify_change(); 3748 hotkey_wakeup_hotunplug_complete_notify_change(); 3749 hotkey_poll_setup_safe(false); 3750 } 3751 3752 /* procfs -------------------------------------------------------------- */ 3753 static int hotkey_read(struct seq_file *m) 3754 { 3755 int res, status; 3756 3757 if (!tp_features.hotkey) { 3758 seq_printf(m, "status:\t\tnot supported\n"); 3759 return 0; 3760 } 3761 3762 if (mutex_lock_killable(&hotkey_mutex)) 3763 return -ERESTARTSYS; 3764 res = hotkey_status_get(&status); 3765 if (!res) 3766 res = hotkey_mask_get(); 3767 mutex_unlock(&hotkey_mutex); 3768 if (res) 3769 return res; 3770 3771 seq_printf(m, "status:\t\t%s\n", enabled(status, 0)); 3772 if (hotkey_all_mask) { 3773 seq_printf(m, "mask:\t\t0x%08x\n", hotkey_user_mask); 3774 seq_printf(m, "commands:\tenable, disable, reset, <mask>\n"); 3775 } else { 3776 seq_printf(m, "mask:\t\tnot supported\n"); 3777 seq_printf(m, "commands:\tenable, disable, reset\n"); 3778 } 3779 3780 return 0; 3781 } 3782 3783 static void hotkey_enabledisable_warn(bool enable) 3784 { 3785 tpacpi_log_usertask("procfs hotkey enable/disable"); 3786 if (!WARN((tpacpi_lifecycle == TPACPI_LIFE_RUNNING || !enable), 3787 pr_fmt("hotkey enable/disable functionality has been " 3788 "removed from the driver. " 3789 "Hotkeys are always enabled.\n"))) 3790 pr_err("Please remove the hotkey=enable module " 3791 "parameter, it is deprecated. " 3792 "Hotkeys are always enabled.\n"); 3793 } 3794 3795 static int hotkey_write(char *buf) 3796 { 3797 int res; 3798 u32 mask; 3799 char *cmd; 3800 3801 if (!tp_features.hotkey) 3802 return -ENODEV; 3803 3804 if (mutex_lock_killable(&hotkey_mutex)) 3805 return -ERESTARTSYS; 3806 3807 mask = hotkey_user_mask; 3808 3809 res = 0; 3810 while ((cmd = next_cmd(&buf))) { 3811 if (strlencmp(cmd, "enable") == 0) { 3812 hotkey_enabledisable_warn(1); 3813 } else if (strlencmp(cmd, "disable") == 0) { 3814 hotkey_enabledisable_warn(0); 3815 res = -EPERM; 3816 } else if (strlencmp(cmd, "reset") == 0) { 3817 mask = (hotkey_all_mask | hotkey_source_mask) 3818 & ~hotkey_reserved_mask; 3819 } else if (sscanf(cmd, "0x%x", &mask) == 1) { 3820 /* mask set */ 3821 } else if (sscanf(cmd, "%x", &mask) == 1) { 3822 /* mask set */ 3823 } else { 3824 res = -EINVAL; 3825 goto errexit; 3826 } 3827 } 3828 3829 if (!res) { 3830 tpacpi_disclose_usertask("procfs hotkey", 3831 "set mask to 0x%08x\n", mask); 3832 res = hotkey_user_mask_set(mask); 3833 } 3834 3835 errexit: 3836 mutex_unlock(&hotkey_mutex); 3837 return res; 3838 } 3839 3840 static const struct acpi_device_id ibm_htk_device_ids[] = { 3841 {TPACPI_ACPI_IBM_HKEY_HID, 0}, 3842 {TPACPI_ACPI_LENOVO_HKEY_HID, 0}, 3843 {"", 0}, 3844 }; 3845 3846 static struct tp_acpi_drv_struct ibm_hotkey_acpidriver = { 3847 .hid = ibm_htk_device_ids, 3848 .notify = hotkey_notify, 3849 .handle = &hkey_handle, 3850 .type = ACPI_DEVICE_NOTIFY, 3851 }; 3852 3853 static struct ibm_struct hotkey_driver_data = { 3854 .name = "hotkey", 3855 .read = hotkey_read, 3856 .write = hotkey_write, 3857 .exit = hotkey_exit, 3858 .resume = hotkey_resume, 3859 .suspend = hotkey_suspend, 3860 .acpi = &ibm_hotkey_acpidriver, 3861 }; 3862 3863 /************************************************************************* 3864 * Bluetooth subdriver 3865 */ 3866 3867 enum { 3868 /* ACPI GBDC/SBDC bits */ 3869 TP_ACPI_BLUETOOTH_HWPRESENT = 0x01, /* Bluetooth hw available */ 3870 TP_ACPI_BLUETOOTH_RADIOSSW = 0x02, /* Bluetooth radio enabled */ 3871 TP_ACPI_BLUETOOTH_RESUMECTRL = 0x04, /* Bluetooth state at resume: 3872 0 = disable, 1 = enable */ 3873 }; 3874 3875 enum { 3876 /* ACPI \BLTH commands */ 3877 TP_ACPI_BLTH_GET_ULTRAPORT_ID = 0x00, /* Get Ultraport BT ID */ 3878 TP_ACPI_BLTH_GET_PWR_ON_RESUME = 0x01, /* Get power-on-resume state */ 3879 TP_ACPI_BLTH_PWR_ON_ON_RESUME = 0x02, /* Resume powered on */ 3880 TP_ACPI_BLTH_PWR_OFF_ON_RESUME = 0x03, /* Resume powered off */ 3881 TP_ACPI_BLTH_SAVE_STATE = 0x05, /* Save state for S4/S5 */ 3882 }; 3883 3884 #define TPACPI_RFK_BLUETOOTH_SW_NAME "tpacpi_bluetooth_sw" 3885 3886 static int bluetooth_get_status(void) 3887 { 3888 int status; 3889 3890 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 3891 if (dbg_bluetoothemul) 3892 return (tpacpi_bluetooth_emulstate) ? 3893 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF; 3894 #endif 3895 3896 if (!acpi_evalf(hkey_handle, &status, "GBDC", "d")) 3897 return -EIO; 3898 3899 return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0) ? 3900 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF; 3901 } 3902 3903 static int bluetooth_set_status(enum tpacpi_rfkill_state state) 3904 { 3905 int status; 3906 3907 vdbg_printk(TPACPI_DBG_RFKILL, 3908 "will attempt to %s bluetooth\n", 3909 (state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable"); 3910 3911 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 3912 if (dbg_bluetoothemul) { 3913 tpacpi_bluetooth_emulstate = (state == TPACPI_RFK_RADIO_ON); 3914 return 0; 3915 } 3916 #endif 3917 3918 if (state == TPACPI_RFK_RADIO_ON) 3919 status = TP_ACPI_BLUETOOTH_RADIOSSW 3920 | TP_ACPI_BLUETOOTH_RESUMECTRL; 3921 else 3922 status = 0; 3923 3924 if (!acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status)) 3925 return -EIO; 3926 3927 return 0; 3928 } 3929 3930 /* sysfs bluetooth enable ---------------------------------------------- */ 3931 static ssize_t bluetooth_enable_show(struct device *dev, 3932 struct device_attribute *attr, 3933 char *buf) 3934 { 3935 return tpacpi_rfk_sysfs_enable_show(TPACPI_RFK_BLUETOOTH_SW_ID, 3936 attr, buf); 3937 } 3938 3939 static ssize_t bluetooth_enable_store(struct device *dev, 3940 struct device_attribute *attr, 3941 const char *buf, size_t count) 3942 { 3943 return tpacpi_rfk_sysfs_enable_store(TPACPI_RFK_BLUETOOTH_SW_ID, 3944 attr, buf, count); 3945 } 3946 3947 static struct device_attribute dev_attr_bluetooth_enable = 3948 __ATTR(bluetooth_enable, S_IWUSR | S_IRUGO, 3949 bluetooth_enable_show, bluetooth_enable_store); 3950 3951 /* --------------------------------------------------------------------- */ 3952 3953 static struct attribute *bluetooth_attributes[] = { 3954 &dev_attr_bluetooth_enable.attr, 3955 NULL 3956 }; 3957 3958 static const struct attribute_group bluetooth_attr_group = { 3959 .attrs = bluetooth_attributes, 3960 }; 3961 3962 static const struct tpacpi_rfk_ops bluetooth_tprfk_ops = { 3963 .get_status = bluetooth_get_status, 3964 .set_status = bluetooth_set_status, 3965 }; 3966 3967 static void bluetooth_shutdown(void) 3968 { 3969 /* Order firmware to save current state to NVRAM */ 3970 if (!acpi_evalf(NULL, NULL, "\\BLTH", "vd", 3971 TP_ACPI_BLTH_SAVE_STATE)) 3972 pr_notice("failed to save bluetooth state to NVRAM\n"); 3973 else 3974 vdbg_printk(TPACPI_DBG_RFKILL, 3975 "bluetooth state saved to NVRAM\n"); 3976 } 3977 3978 static void bluetooth_exit(void) 3979 { 3980 sysfs_remove_group(&tpacpi_pdev->dev.kobj, 3981 &bluetooth_attr_group); 3982 3983 tpacpi_destroy_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID); 3984 3985 bluetooth_shutdown(); 3986 } 3987 3988 static int __init bluetooth_init(struct ibm_init_struct *iibm) 3989 { 3990 int res; 3991 int status = 0; 3992 3993 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL, 3994 "initializing bluetooth subdriver\n"); 3995 3996 TPACPI_ACPIHANDLE_INIT(hkey); 3997 3998 /* bluetooth not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p, 3999 G4x, R30, R31, R40e, R50e, T20-22, X20-21 */ 4000 tp_features.bluetooth = hkey_handle && 4001 acpi_evalf(hkey_handle, &status, "GBDC", "qd"); 4002 4003 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL, 4004 "bluetooth is %s, status 0x%02x\n", 4005 str_supported(tp_features.bluetooth), 4006 status); 4007 4008 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 4009 if (dbg_bluetoothemul) { 4010 tp_features.bluetooth = 1; 4011 pr_info("bluetooth switch emulation enabled\n"); 4012 } else 4013 #endif 4014 if (tp_features.bluetooth && 4015 !(status & TP_ACPI_BLUETOOTH_HWPRESENT)) { 4016 /* no bluetooth hardware present in system */ 4017 tp_features.bluetooth = 0; 4018 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL, 4019 "bluetooth hardware not installed\n"); 4020 } 4021 4022 if (!tp_features.bluetooth) 4023 return 1; 4024 4025 res = tpacpi_new_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID, 4026 &bluetooth_tprfk_ops, 4027 RFKILL_TYPE_BLUETOOTH, 4028 TPACPI_RFK_BLUETOOTH_SW_NAME, 4029 true); 4030 if (res) 4031 return res; 4032 4033 res = sysfs_create_group(&tpacpi_pdev->dev.kobj, 4034 &bluetooth_attr_group); 4035 if (res) { 4036 tpacpi_destroy_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID); 4037 return res; 4038 } 4039 4040 return 0; 4041 } 4042 4043 /* procfs -------------------------------------------------------------- */ 4044 static int bluetooth_read(struct seq_file *m) 4045 { 4046 return tpacpi_rfk_procfs_read(TPACPI_RFK_BLUETOOTH_SW_ID, m); 4047 } 4048 4049 static int bluetooth_write(char *buf) 4050 { 4051 return tpacpi_rfk_procfs_write(TPACPI_RFK_BLUETOOTH_SW_ID, buf); 4052 } 4053 4054 static struct ibm_struct bluetooth_driver_data = { 4055 .name = "bluetooth", 4056 .read = bluetooth_read, 4057 .write = bluetooth_write, 4058 .exit = bluetooth_exit, 4059 .shutdown = bluetooth_shutdown, 4060 }; 4061 4062 /************************************************************************* 4063 * Wan subdriver 4064 */ 4065 4066 enum { 4067 /* ACPI GWAN/SWAN bits */ 4068 TP_ACPI_WANCARD_HWPRESENT = 0x01, /* Wan hw available */ 4069 TP_ACPI_WANCARD_RADIOSSW = 0x02, /* Wan radio enabled */ 4070 TP_ACPI_WANCARD_RESUMECTRL = 0x04, /* Wan state at resume: 4071 0 = disable, 1 = enable */ 4072 }; 4073 4074 #define TPACPI_RFK_WWAN_SW_NAME "tpacpi_wwan_sw" 4075 4076 static int wan_get_status(void) 4077 { 4078 int status; 4079 4080 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 4081 if (dbg_wwanemul) 4082 return (tpacpi_wwan_emulstate) ? 4083 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF; 4084 #endif 4085 4086 if (!acpi_evalf(hkey_handle, &status, "GWAN", "d")) 4087 return -EIO; 4088 4089 return ((status & TP_ACPI_WANCARD_RADIOSSW) != 0) ? 4090 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF; 4091 } 4092 4093 static int wan_set_status(enum tpacpi_rfkill_state state) 4094 { 4095 int status; 4096 4097 vdbg_printk(TPACPI_DBG_RFKILL, 4098 "will attempt to %s wwan\n", 4099 (state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable"); 4100 4101 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 4102 if (dbg_wwanemul) { 4103 tpacpi_wwan_emulstate = (state == TPACPI_RFK_RADIO_ON); 4104 return 0; 4105 } 4106 #endif 4107 4108 if (state == TPACPI_RFK_RADIO_ON) 4109 status = TP_ACPI_WANCARD_RADIOSSW 4110 | TP_ACPI_WANCARD_RESUMECTRL; 4111 else 4112 status = 0; 4113 4114 if (!acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status)) 4115 return -EIO; 4116 4117 return 0; 4118 } 4119 4120 /* sysfs wan enable ---------------------------------------------------- */ 4121 static ssize_t wan_enable_show(struct device *dev, 4122 struct device_attribute *attr, 4123 char *buf) 4124 { 4125 return tpacpi_rfk_sysfs_enable_show(TPACPI_RFK_WWAN_SW_ID, 4126 attr, buf); 4127 } 4128 4129 static ssize_t wan_enable_store(struct device *dev, 4130 struct device_attribute *attr, 4131 const char *buf, size_t count) 4132 { 4133 return tpacpi_rfk_sysfs_enable_store(TPACPI_RFK_WWAN_SW_ID, 4134 attr, buf, count); 4135 } 4136 4137 static struct device_attribute dev_attr_wan_enable = 4138 __ATTR(wwan_enable, S_IWUSR | S_IRUGO, 4139 wan_enable_show, wan_enable_store); 4140 4141 /* --------------------------------------------------------------------- */ 4142 4143 static struct attribute *wan_attributes[] = { 4144 &dev_attr_wan_enable.attr, 4145 NULL 4146 }; 4147 4148 static const struct attribute_group wan_attr_group = { 4149 .attrs = wan_attributes, 4150 }; 4151 4152 static const struct tpacpi_rfk_ops wan_tprfk_ops = { 4153 .get_status = wan_get_status, 4154 .set_status = wan_set_status, 4155 }; 4156 4157 static void wan_shutdown(void) 4158 { 4159 /* Order firmware to save current state to NVRAM */ 4160 if (!acpi_evalf(NULL, NULL, "\\WGSV", "vd", 4161 TP_ACPI_WGSV_SAVE_STATE)) 4162 pr_notice("failed to save WWAN state to NVRAM\n"); 4163 else 4164 vdbg_printk(TPACPI_DBG_RFKILL, 4165 "WWAN state saved to NVRAM\n"); 4166 } 4167 4168 static void wan_exit(void) 4169 { 4170 sysfs_remove_group(&tpacpi_pdev->dev.kobj, 4171 &wan_attr_group); 4172 4173 tpacpi_destroy_rfkill(TPACPI_RFK_WWAN_SW_ID); 4174 4175 wan_shutdown(); 4176 } 4177 4178 static int __init wan_init(struct ibm_init_struct *iibm) 4179 { 4180 int res; 4181 int status = 0; 4182 4183 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL, 4184 "initializing wan subdriver\n"); 4185 4186 TPACPI_ACPIHANDLE_INIT(hkey); 4187 4188 tp_features.wan = hkey_handle && 4189 acpi_evalf(hkey_handle, &status, "GWAN", "qd"); 4190 4191 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL, 4192 "wan is %s, status 0x%02x\n", 4193 str_supported(tp_features.wan), 4194 status); 4195 4196 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 4197 if (dbg_wwanemul) { 4198 tp_features.wan = 1; 4199 pr_info("wwan switch emulation enabled\n"); 4200 } else 4201 #endif 4202 if (tp_features.wan && 4203 !(status & TP_ACPI_WANCARD_HWPRESENT)) { 4204 /* no wan hardware present in system */ 4205 tp_features.wan = 0; 4206 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL, 4207 "wan hardware not installed\n"); 4208 } 4209 4210 if (!tp_features.wan) 4211 return 1; 4212 4213 res = tpacpi_new_rfkill(TPACPI_RFK_WWAN_SW_ID, 4214 &wan_tprfk_ops, 4215 RFKILL_TYPE_WWAN, 4216 TPACPI_RFK_WWAN_SW_NAME, 4217 true); 4218 if (res) 4219 return res; 4220 4221 res = sysfs_create_group(&tpacpi_pdev->dev.kobj, 4222 &wan_attr_group); 4223 4224 if (res) { 4225 tpacpi_destroy_rfkill(TPACPI_RFK_WWAN_SW_ID); 4226 return res; 4227 } 4228 4229 return 0; 4230 } 4231 4232 /* procfs -------------------------------------------------------------- */ 4233 static int wan_read(struct seq_file *m) 4234 { 4235 return tpacpi_rfk_procfs_read(TPACPI_RFK_WWAN_SW_ID, m); 4236 } 4237 4238 static int wan_write(char *buf) 4239 { 4240 return tpacpi_rfk_procfs_write(TPACPI_RFK_WWAN_SW_ID, buf); 4241 } 4242 4243 static struct ibm_struct wan_driver_data = { 4244 .name = "wan", 4245 .read = wan_read, 4246 .write = wan_write, 4247 .exit = wan_exit, 4248 .shutdown = wan_shutdown, 4249 }; 4250 4251 /************************************************************************* 4252 * UWB subdriver 4253 */ 4254 4255 enum { 4256 /* ACPI GUWB/SUWB bits */ 4257 TP_ACPI_UWB_HWPRESENT = 0x01, /* UWB hw available */ 4258 TP_ACPI_UWB_RADIOSSW = 0x02, /* UWB radio enabled */ 4259 }; 4260 4261 #define TPACPI_RFK_UWB_SW_NAME "tpacpi_uwb_sw" 4262 4263 static int uwb_get_status(void) 4264 { 4265 int status; 4266 4267 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 4268 if (dbg_uwbemul) 4269 return (tpacpi_uwb_emulstate) ? 4270 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF; 4271 #endif 4272 4273 if (!acpi_evalf(hkey_handle, &status, "GUWB", "d")) 4274 return -EIO; 4275 4276 return ((status & TP_ACPI_UWB_RADIOSSW) != 0) ? 4277 TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF; 4278 } 4279 4280 static int uwb_set_status(enum tpacpi_rfkill_state state) 4281 { 4282 int status; 4283 4284 vdbg_printk(TPACPI_DBG_RFKILL, 4285 "will attempt to %s UWB\n", 4286 (state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable"); 4287 4288 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 4289 if (dbg_uwbemul) { 4290 tpacpi_uwb_emulstate = (state == TPACPI_RFK_RADIO_ON); 4291 return 0; 4292 } 4293 #endif 4294 4295 if (state == TPACPI_RFK_RADIO_ON) 4296 status = TP_ACPI_UWB_RADIOSSW; 4297 else 4298 status = 0; 4299 4300 if (!acpi_evalf(hkey_handle, NULL, "SUWB", "vd", status)) 4301 return -EIO; 4302 4303 return 0; 4304 } 4305 4306 /* --------------------------------------------------------------------- */ 4307 4308 static const struct tpacpi_rfk_ops uwb_tprfk_ops = { 4309 .get_status = uwb_get_status, 4310 .set_status = uwb_set_status, 4311 }; 4312 4313 static void uwb_exit(void) 4314 { 4315 tpacpi_destroy_rfkill(TPACPI_RFK_UWB_SW_ID); 4316 } 4317 4318 static int __init uwb_init(struct ibm_init_struct *iibm) 4319 { 4320 int res; 4321 int status = 0; 4322 4323 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL, 4324 "initializing uwb subdriver\n"); 4325 4326 TPACPI_ACPIHANDLE_INIT(hkey); 4327 4328 tp_features.uwb = hkey_handle && 4329 acpi_evalf(hkey_handle, &status, "GUWB", "qd"); 4330 4331 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL, 4332 "uwb is %s, status 0x%02x\n", 4333 str_supported(tp_features.uwb), 4334 status); 4335 4336 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 4337 if (dbg_uwbemul) { 4338 tp_features.uwb = 1; 4339 pr_info("uwb switch emulation enabled\n"); 4340 } else 4341 #endif 4342 if (tp_features.uwb && 4343 !(status & TP_ACPI_UWB_HWPRESENT)) { 4344 /* no uwb hardware present in system */ 4345 tp_features.uwb = 0; 4346 dbg_printk(TPACPI_DBG_INIT, 4347 "uwb hardware not installed\n"); 4348 } 4349 4350 if (!tp_features.uwb) 4351 return 1; 4352 4353 res = tpacpi_new_rfkill(TPACPI_RFK_UWB_SW_ID, 4354 &uwb_tprfk_ops, 4355 RFKILL_TYPE_UWB, 4356 TPACPI_RFK_UWB_SW_NAME, 4357 false); 4358 return res; 4359 } 4360 4361 static struct ibm_struct uwb_driver_data = { 4362 .name = "uwb", 4363 .exit = uwb_exit, 4364 .flags.experimental = 1, 4365 }; 4366 4367 /************************************************************************* 4368 * Video subdriver 4369 */ 4370 4371 #ifdef CONFIG_THINKPAD_ACPI_VIDEO 4372 4373 enum video_access_mode { 4374 TPACPI_VIDEO_NONE = 0, 4375 TPACPI_VIDEO_570, /* 570 */ 4376 TPACPI_VIDEO_770, /* 600e/x, 770e, 770x */ 4377 TPACPI_VIDEO_NEW, /* all others */ 4378 }; 4379 4380 enum { /* video status flags, based on VIDEO_570 */ 4381 TP_ACPI_VIDEO_S_LCD = 0x01, /* LCD output enabled */ 4382 TP_ACPI_VIDEO_S_CRT = 0x02, /* CRT output enabled */ 4383 TP_ACPI_VIDEO_S_DVI = 0x08, /* DVI output enabled */ 4384 }; 4385 4386 enum { /* TPACPI_VIDEO_570 constants */ 4387 TP_ACPI_VIDEO_570_PHSCMD = 0x87, /* unknown magic constant :( */ 4388 TP_ACPI_VIDEO_570_PHSMASK = 0x03, /* PHS bits that map to 4389 * video_status_flags */ 4390 TP_ACPI_VIDEO_570_PHS2CMD = 0x8b, /* unknown magic constant :( */ 4391 TP_ACPI_VIDEO_570_PHS2SET = 0x80, /* unknown magic constant :( */ 4392 }; 4393 4394 static enum video_access_mode video_supported; 4395 static int video_orig_autosw; 4396 4397 static int video_autosw_get(void); 4398 static int video_autosw_set(int enable); 4399 4400 TPACPI_HANDLE(vid, root, 4401 "\\_SB.PCI.AGP.VGA", /* 570 */ 4402 "\\_SB.PCI0.AGP0.VID0", /* 600e/x, 770x */ 4403 "\\_SB.PCI0.VID0", /* 770e */ 4404 "\\_SB.PCI0.VID", /* A21e, G4x, R50e, X30, X40 */ 4405 "\\_SB.PCI0.AGP.VGA", /* X100e and a few others */ 4406 "\\_SB.PCI0.AGP.VID", /* all others */ 4407 ); /* R30, R31 */ 4408 4409 TPACPI_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID"); /* G41 */ 4410 4411 static int __init video_init(struct ibm_init_struct *iibm) 4412 { 4413 int ivga; 4414 4415 vdbg_printk(TPACPI_DBG_INIT, "initializing video subdriver\n"); 4416 4417 TPACPI_ACPIHANDLE_INIT(vid); 4418 if (tpacpi_is_ibm()) 4419 TPACPI_ACPIHANDLE_INIT(vid2); 4420 4421 if (vid2_handle && acpi_evalf(NULL, &ivga, "\\IVGA", "d") && ivga) 4422 /* G41, assume IVGA doesn't change */ 4423 vid_handle = vid2_handle; 4424 4425 if (!vid_handle) 4426 /* video switching not supported on R30, R31 */ 4427 video_supported = TPACPI_VIDEO_NONE; 4428 else if (tpacpi_is_ibm() && 4429 acpi_evalf(vid_handle, &video_orig_autosw, "SWIT", "qd")) 4430 /* 570 */ 4431 video_supported = TPACPI_VIDEO_570; 4432 else if (tpacpi_is_ibm() && 4433 acpi_evalf(vid_handle, &video_orig_autosw, "^VADL", "qd")) 4434 /* 600e/x, 770e, 770x */ 4435 video_supported = TPACPI_VIDEO_770; 4436 else 4437 /* all others */ 4438 video_supported = TPACPI_VIDEO_NEW; 4439 4440 vdbg_printk(TPACPI_DBG_INIT, "video is %s, mode %d\n", 4441 str_supported(video_supported != TPACPI_VIDEO_NONE), 4442 video_supported); 4443 4444 return (video_supported != TPACPI_VIDEO_NONE)? 0 : 1; 4445 } 4446 4447 static void video_exit(void) 4448 { 4449 dbg_printk(TPACPI_DBG_EXIT, 4450 "restoring original video autoswitch mode\n"); 4451 if (video_autosw_set(video_orig_autosw)) 4452 pr_err("error while trying to restore original " 4453 "video autoswitch mode\n"); 4454 } 4455 4456 static int video_outputsw_get(void) 4457 { 4458 int status = 0; 4459 int i; 4460 4461 switch (video_supported) { 4462 case TPACPI_VIDEO_570: 4463 if (!acpi_evalf(NULL, &i, "\\_SB.PHS", "dd", 4464 TP_ACPI_VIDEO_570_PHSCMD)) 4465 return -EIO; 4466 status = i & TP_ACPI_VIDEO_570_PHSMASK; 4467 break; 4468 case TPACPI_VIDEO_770: 4469 if (!acpi_evalf(NULL, &i, "\\VCDL", "d")) 4470 return -EIO; 4471 if (i) 4472 status |= TP_ACPI_VIDEO_S_LCD; 4473 if (!acpi_evalf(NULL, &i, "\\VCDC", "d")) 4474 return -EIO; 4475 if (i) 4476 status |= TP_ACPI_VIDEO_S_CRT; 4477 break; 4478 case TPACPI_VIDEO_NEW: 4479 if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 1) || 4480 !acpi_evalf(NULL, &i, "\\VCDC", "d")) 4481 return -EIO; 4482 if (i) 4483 status |= TP_ACPI_VIDEO_S_CRT; 4484 4485 if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0) || 4486 !acpi_evalf(NULL, &i, "\\VCDL", "d")) 4487 return -EIO; 4488 if (i) 4489 status |= TP_ACPI_VIDEO_S_LCD; 4490 if (!acpi_evalf(NULL, &i, "\\VCDD", "d")) 4491 return -EIO; 4492 if (i) 4493 status |= TP_ACPI_VIDEO_S_DVI; 4494 break; 4495 default: 4496 return -ENOSYS; 4497 } 4498 4499 return status; 4500 } 4501 4502 static int video_outputsw_set(int status) 4503 { 4504 int autosw; 4505 int res = 0; 4506 4507 switch (video_supported) { 4508 case TPACPI_VIDEO_570: 4509 res = acpi_evalf(NULL, NULL, 4510 "\\_SB.PHS2", "vdd", 4511 TP_ACPI_VIDEO_570_PHS2CMD, 4512 status | TP_ACPI_VIDEO_570_PHS2SET); 4513 break; 4514 case TPACPI_VIDEO_770: 4515 autosw = video_autosw_get(); 4516 if (autosw < 0) 4517 return autosw; 4518 4519 res = video_autosw_set(1); 4520 if (res) 4521 return res; 4522 res = acpi_evalf(vid_handle, NULL, 4523 "ASWT", "vdd", status * 0x100, 0); 4524 if (!autosw && video_autosw_set(autosw)) { 4525 pr_err("video auto-switch left enabled due to error\n"); 4526 return -EIO; 4527 } 4528 break; 4529 case TPACPI_VIDEO_NEW: 4530 res = acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0x80) && 4531 acpi_evalf(NULL, NULL, "\\VSDS", "vdd", status, 1); 4532 break; 4533 default: 4534 return -ENOSYS; 4535 } 4536 4537 return (res)? 0 : -EIO; 4538 } 4539 4540 static int video_autosw_get(void) 4541 { 4542 int autosw = 0; 4543 4544 switch (video_supported) { 4545 case TPACPI_VIDEO_570: 4546 if (!acpi_evalf(vid_handle, &autosw, "SWIT", "d")) 4547 return -EIO; 4548 break; 4549 case TPACPI_VIDEO_770: 4550 case TPACPI_VIDEO_NEW: 4551 if (!acpi_evalf(vid_handle, &autosw, "^VDEE", "d")) 4552 return -EIO; 4553 break; 4554 default: 4555 return -ENOSYS; 4556 } 4557 4558 return autosw & 1; 4559 } 4560 4561 static int video_autosw_set(int enable) 4562 { 4563 if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", (enable)? 1 : 0)) 4564 return -EIO; 4565 return 0; 4566 } 4567 4568 static int video_outputsw_cycle(void) 4569 { 4570 int autosw = video_autosw_get(); 4571 int res; 4572 4573 if (autosw < 0) 4574 return autosw; 4575 4576 switch (video_supported) { 4577 case TPACPI_VIDEO_570: 4578 res = video_autosw_set(1); 4579 if (res) 4580 return res; 4581 res = acpi_evalf(ec_handle, NULL, "_Q16", "v"); 4582 break; 4583 case TPACPI_VIDEO_770: 4584 case TPACPI_VIDEO_NEW: 4585 res = video_autosw_set(1); 4586 if (res) 4587 return res; 4588 res = acpi_evalf(vid_handle, NULL, "VSWT", "v"); 4589 break; 4590 default: 4591 return -ENOSYS; 4592 } 4593 if (!autosw && video_autosw_set(autosw)) { 4594 pr_err("video auto-switch left enabled due to error\n"); 4595 return -EIO; 4596 } 4597 4598 return (res)? 0 : -EIO; 4599 } 4600 4601 static int video_expand_toggle(void) 4602 { 4603 switch (video_supported) { 4604 case TPACPI_VIDEO_570: 4605 return acpi_evalf(ec_handle, NULL, "_Q17", "v")? 4606 0 : -EIO; 4607 case TPACPI_VIDEO_770: 4608 return acpi_evalf(vid_handle, NULL, "VEXP", "v")? 4609 0 : -EIO; 4610 case TPACPI_VIDEO_NEW: 4611 return acpi_evalf(NULL, NULL, "\\VEXP", "v")? 4612 0 : -EIO; 4613 default: 4614 return -ENOSYS; 4615 } 4616 /* not reached */ 4617 } 4618 4619 static int video_read(struct seq_file *m) 4620 { 4621 int status, autosw; 4622 4623 if (video_supported == TPACPI_VIDEO_NONE) { 4624 seq_printf(m, "status:\t\tnot supported\n"); 4625 return 0; 4626 } 4627 4628 /* Even reads can crash X.org, so... */ 4629 if (!capable(CAP_SYS_ADMIN)) 4630 return -EPERM; 4631 4632 status = video_outputsw_get(); 4633 if (status < 0) 4634 return status; 4635 4636 autosw = video_autosw_get(); 4637 if (autosw < 0) 4638 return autosw; 4639 4640 seq_printf(m, "status:\t\tsupported\n"); 4641 seq_printf(m, "lcd:\t\t%s\n", enabled(status, 0)); 4642 seq_printf(m, "crt:\t\t%s\n", enabled(status, 1)); 4643 if (video_supported == TPACPI_VIDEO_NEW) 4644 seq_printf(m, "dvi:\t\t%s\n", enabled(status, 3)); 4645 seq_printf(m, "auto:\t\t%s\n", enabled(autosw, 0)); 4646 seq_printf(m, "commands:\tlcd_enable, lcd_disable\n"); 4647 seq_printf(m, "commands:\tcrt_enable, crt_disable\n"); 4648 if (video_supported == TPACPI_VIDEO_NEW) 4649 seq_printf(m, "commands:\tdvi_enable, dvi_disable\n"); 4650 seq_printf(m, "commands:\tauto_enable, auto_disable\n"); 4651 seq_printf(m, "commands:\tvideo_switch, expand_toggle\n"); 4652 4653 return 0; 4654 } 4655 4656 static int video_write(char *buf) 4657 { 4658 char *cmd; 4659 int enable, disable, status; 4660 int res; 4661 4662 if (video_supported == TPACPI_VIDEO_NONE) 4663 return -ENODEV; 4664 4665 /* Even reads can crash X.org, let alone writes... */ 4666 if (!capable(CAP_SYS_ADMIN)) 4667 return -EPERM; 4668 4669 enable = 0; 4670 disable = 0; 4671 4672 while ((cmd = next_cmd(&buf))) { 4673 if (strlencmp(cmd, "lcd_enable") == 0) { 4674 enable |= TP_ACPI_VIDEO_S_LCD; 4675 } else if (strlencmp(cmd, "lcd_disable") == 0) { 4676 disable |= TP_ACPI_VIDEO_S_LCD; 4677 } else if (strlencmp(cmd, "crt_enable") == 0) { 4678 enable |= TP_ACPI_VIDEO_S_CRT; 4679 } else if (strlencmp(cmd, "crt_disable") == 0) { 4680 disable |= TP_ACPI_VIDEO_S_CRT; 4681 } else if (video_supported == TPACPI_VIDEO_NEW && 4682 strlencmp(cmd, "dvi_enable") == 0) { 4683 enable |= TP_ACPI_VIDEO_S_DVI; 4684 } else if (video_supported == TPACPI_VIDEO_NEW && 4685 strlencmp(cmd, "dvi_disable") == 0) { 4686 disable |= TP_ACPI_VIDEO_S_DVI; 4687 } else if (strlencmp(cmd, "auto_enable") == 0) { 4688 res = video_autosw_set(1); 4689 if (res) 4690 return res; 4691 } else if (strlencmp(cmd, "auto_disable") == 0) { 4692 res = video_autosw_set(0); 4693 if (res) 4694 return res; 4695 } else if (strlencmp(cmd, "video_switch") == 0) { 4696 res = video_outputsw_cycle(); 4697 if (res) 4698 return res; 4699 } else if (strlencmp(cmd, "expand_toggle") == 0) { 4700 res = video_expand_toggle(); 4701 if (res) 4702 return res; 4703 } else 4704 return -EINVAL; 4705 } 4706 4707 if (enable || disable) { 4708 status = video_outputsw_get(); 4709 if (status < 0) 4710 return status; 4711 res = video_outputsw_set((status & ~disable) | enable); 4712 if (res) 4713 return res; 4714 } 4715 4716 return 0; 4717 } 4718 4719 static struct ibm_struct video_driver_data = { 4720 .name = "video", 4721 .read = video_read, 4722 .write = video_write, 4723 .exit = video_exit, 4724 }; 4725 4726 #endif /* CONFIG_THINKPAD_ACPI_VIDEO */ 4727 4728 /************************************************************************* 4729 * Light (thinklight) subdriver 4730 */ 4731 4732 TPACPI_HANDLE(lght, root, "\\LGHT"); /* A21e, A2xm/p, T20-22, X20-21 */ 4733 TPACPI_HANDLE(ledb, ec, "LEDB"); /* G4x */ 4734 4735 static int light_get_status(void) 4736 { 4737 int status = 0; 4738 4739 if (tp_features.light_status) { 4740 if (!acpi_evalf(ec_handle, &status, "KBLT", "d")) 4741 return -EIO; 4742 return (!!status); 4743 } 4744 4745 return -ENXIO; 4746 } 4747 4748 static int light_set_status(int status) 4749 { 4750 int rc; 4751 4752 if (tp_features.light) { 4753 if (cmos_handle) { 4754 rc = acpi_evalf(cmos_handle, NULL, NULL, "vd", 4755 (status)? 4756 TP_CMOS_THINKLIGHT_ON : 4757 TP_CMOS_THINKLIGHT_OFF); 4758 } else { 4759 rc = acpi_evalf(lght_handle, NULL, NULL, "vd", 4760 (status)? 1 : 0); 4761 } 4762 return (rc)? 0 : -EIO; 4763 } 4764 4765 return -ENXIO; 4766 } 4767 4768 static void light_set_status_worker(struct work_struct *work) 4769 { 4770 struct tpacpi_led_classdev *data = 4771 container_of(work, struct tpacpi_led_classdev, work); 4772 4773 if (likely(tpacpi_lifecycle == TPACPI_LIFE_RUNNING)) 4774 light_set_status((data->new_state != TPACPI_LED_OFF)); 4775 } 4776 4777 static void light_sysfs_set(struct led_classdev *led_cdev, 4778 enum led_brightness brightness) 4779 { 4780 struct tpacpi_led_classdev *data = 4781 container_of(led_cdev, 4782 struct tpacpi_led_classdev, 4783 led_classdev); 4784 data->new_state = (brightness != LED_OFF) ? 4785 TPACPI_LED_ON : TPACPI_LED_OFF; 4786 queue_work(tpacpi_wq, &data->work); 4787 } 4788 4789 static enum led_brightness light_sysfs_get(struct led_classdev *led_cdev) 4790 { 4791 return (light_get_status() == 1)? LED_FULL : LED_OFF; 4792 } 4793 4794 static struct tpacpi_led_classdev tpacpi_led_thinklight = { 4795 .led_classdev = { 4796 .name = "tpacpi::thinklight", 4797 .brightness_set = &light_sysfs_set, 4798 .brightness_get = &light_sysfs_get, 4799 } 4800 }; 4801 4802 static int __init light_init(struct ibm_init_struct *iibm) 4803 { 4804 int rc; 4805 4806 vdbg_printk(TPACPI_DBG_INIT, "initializing light subdriver\n"); 4807 4808 if (tpacpi_is_ibm()) { 4809 TPACPI_ACPIHANDLE_INIT(ledb); 4810 TPACPI_ACPIHANDLE_INIT(lght); 4811 } 4812 TPACPI_ACPIHANDLE_INIT(cmos); 4813 INIT_WORK(&tpacpi_led_thinklight.work, light_set_status_worker); 4814 4815 /* light not supported on 570, 600e/x, 770e, 770x, G4x, R30, R31 */ 4816 tp_features.light = (cmos_handle || lght_handle) && !ledb_handle; 4817 4818 if (tp_features.light) 4819 /* light status not supported on 4820 570, 600e/x, 770e, 770x, G4x, R30, R31, R32, X20 */ 4821 tp_features.light_status = 4822 acpi_evalf(ec_handle, NULL, "KBLT", "qv"); 4823 4824 vdbg_printk(TPACPI_DBG_INIT, "light is %s, light status is %s\n", 4825 str_supported(tp_features.light), 4826 str_supported(tp_features.light_status)); 4827 4828 if (!tp_features.light) 4829 return 1; 4830 4831 rc = led_classdev_register(&tpacpi_pdev->dev, 4832 &tpacpi_led_thinklight.led_classdev); 4833 4834 if (rc < 0) { 4835 tp_features.light = 0; 4836 tp_features.light_status = 0; 4837 } else { 4838 rc = 0; 4839 } 4840 4841 return rc; 4842 } 4843 4844 static void light_exit(void) 4845 { 4846 led_classdev_unregister(&tpacpi_led_thinklight.led_classdev); 4847 flush_workqueue(tpacpi_wq); 4848 } 4849 4850 static int light_read(struct seq_file *m) 4851 { 4852 int status; 4853 4854 if (!tp_features.light) { 4855 seq_printf(m, "status:\t\tnot supported\n"); 4856 } else if (!tp_features.light_status) { 4857 seq_printf(m, "status:\t\tunknown\n"); 4858 seq_printf(m, "commands:\ton, off\n"); 4859 } else { 4860 status = light_get_status(); 4861 if (status < 0) 4862 return status; 4863 seq_printf(m, "status:\t\t%s\n", onoff(status, 0)); 4864 seq_printf(m, "commands:\ton, off\n"); 4865 } 4866 4867 return 0; 4868 } 4869 4870 static int light_write(char *buf) 4871 { 4872 char *cmd; 4873 int newstatus = 0; 4874 4875 if (!tp_features.light) 4876 return -ENODEV; 4877 4878 while ((cmd = next_cmd(&buf))) { 4879 if (strlencmp(cmd, "on") == 0) { 4880 newstatus = 1; 4881 } else if (strlencmp(cmd, "off") == 0) { 4882 newstatus = 0; 4883 } else 4884 return -EINVAL; 4885 } 4886 4887 return light_set_status(newstatus); 4888 } 4889 4890 static struct ibm_struct light_driver_data = { 4891 .name = "light", 4892 .read = light_read, 4893 .write = light_write, 4894 .exit = light_exit, 4895 }; 4896 4897 /************************************************************************* 4898 * CMOS subdriver 4899 */ 4900 4901 /* sysfs cmos_command -------------------------------------------------- */ 4902 static ssize_t cmos_command_store(struct device *dev, 4903 struct device_attribute *attr, 4904 const char *buf, size_t count) 4905 { 4906 unsigned long cmos_cmd; 4907 int res; 4908 4909 if (parse_strtoul(buf, 21, &cmos_cmd)) 4910 return -EINVAL; 4911 4912 res = issue_thinkpad_cmos_command(cmos_cmd); 4913 return (res)? res : count; 4914 } 4915 4916 static struct device_attribute dev_attr_cmos_command = 4917 __ATTR(cmos_command, S_IWUSR, NULL, cmos_command_store); 4918 4919 /* --------------------------------------------------------------------- */ 4920 4921 static int __init cmos_init(struct ibm_init_struct *iibm) 4922 { 4923 int res; 4924 4925 vdbg_printk(TPACPI_DBG_INIT, 4926 "initializing cmos commands subdriver\n"); 4927 4928 TPACPI_ACPIHANDLE_INIT(cmos); 4929 4930 vdbg_printk(TPACPI_DBG_INIT, "cmos commands are %s\n", 4931 str_supported(cmos_handle != NULL)); 4932 4933 res = device_create_file(&tpacpi_pdev->dev, &dev_attr_cmos_command); 4934 if (res) 4935 return res; 4936 4937 return (cmos_handle)? 0 : 1; 4938 } 4939 4940 static void cmos_exit(void) 4941 { 4942 device_remove_file(&tpacpi_pdev->dev, &dev_attr_cmos_command); 4943 } 4944 4945 static int cmos_read(struct seq_file *m) 4946 { 4947 /* cmos not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p, 4948 R30, R31, T20-22, X20-21 */ 4949 if (!cmos_handle) 4950 seq_printf(m, "status:\t\tnot supported\n"); 4951 else { 4952 seq_printf(m, "status:\t\tsupported\n"); 4953 seq_printf(m, "commands:\t<cmd> (<cmd> is 0-21)\n"); 4954 } 4955 4956 return 0; 4957 } 4958 4959 static int cmos_write(char *buf) 4960 { 4961 char *cmd; 4962 int cmos_cmd, res; 4963 4964 while ((cmd = next_cmd(&buf))) { 4965 if (sscanf(cmd, "%u", &cmos_cmd) == 1 && 4966 cmos_cmd >= 0 && cmos_cmd <= 21) { 4967 /* cmos_cmd set */ 4968 } else 4969 return -EINVAL; 4970 4971 res = issue_thinkpad_cmos_command(cmos_cmd); 4972 if (res) 4973 return res; 4974 } 4975 4976 return 0; 4977 } 4978 4979 static struct ibm_struct cmos_driver_data = { 4980 .name = "cmos", 4981 .read = cmos_read, 4982 .write = cmos_write, 4983 .exit = cmos_exit, 4984 }; 4985 4986 /************************************************************************* 4987 * LED subdriver 4988 */ 4989 4990 enum led_access_mode { 4991 TPACPI_LED_NONE = 0, 4992 TPACPI_LED_570, /* 570 */ 4993 TPACPI_LED_OLD, /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */ 4994 TPACPI_LED_NEW, /* all others */ 4995 }; 4996 4997 enum { /* For TPACPI_LED_OLD */ 4998 TPACPI_LED_EC_HLCL = 0x0c, /* EC reg to get led to power on */ 4999 TPACPI_LED_EC_HLBL = 0x0d, /* EC reg to blink a lit led */ 5000 TPACPI_LED_EC_HLMS = 0x0e, /* EC reg to select led to command */ 5001 }; 5002 5003 static enum led_access_mode led_supported; 5004 5005 static acpi_handle led_handle; 5006 5007 #define TPACPI_LED_NUMLEDS 16 5008 static struct tpacpi_led_classdev *tpacpi_leds; 5009 static enum led_status_t tpacpi_led_state_cache[TPACPI_LED_NUMLEDS]; 5010 static const char * const tpacpi_led_names[TPACPI_LED_NUMLEDS] = { 5011 /* there's a limit of 19 chars + NULL before 2.6.26 */ 5012 "tpacpi::power", 5013 "tpacpi:orange:batt", 5014 "tpacpi:green:batt", 5015 "tpacpi::dock_active", 5016 "tpacpi::bay_active", 5017 "tpacpi::dock_batt", 5018 "tpacpi::unknown_led", 5019 "tpacpi::standby", 5020 "tpacpi::dock_status1", 5021 "tpacpi::dock_status2", 5022 "tpacpi::unknown_led2", 5023 "tpacpi::unknown_led3", 5024 "tpacpi::thinkvantage", 5025 }; 5026 #define TPACPI_SAFE_LEDS 0x1081U 5027 5028 static inline bool tpacpi_is_led_restricted(const unsigned int led) 5029 { 5030 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS 5031 return false; 5032 #else 5033 return (1U & (TPACPI_SAFE_LEDS >> led)) == 0; 5034 #endif 5035 } 5036 5037 static int led_get_status(const unsigned int led) 5038 { 5039 int status; 5040 enum led_status_t led_s; 5041 5042 switch (led_supported) { 5043 case TPACPI_LED_570: 5044 if (!acpi_evalf(ec_handle, 5045 &status, "GLED", "dd", 1 << led)) 5046 return -EIO; 5047 led_s = (status == 0)? 5048 TPACPI_LED_OFF : 5049 ((status == 1)? 5050 TPACPI_LED_ON : 5051 TPACPI_LED_BLINK); 5052 tpacpi_led_state_cache[led] = led_s; 5053 return led_s; 5054 default: 5055 return -ENXIO; 5056 } 5057 5058 /* not reached */ 5059 } 5060 5061 static int led_set_status(const unsigned int led, 5062 const enum led_status_t ledstatus) 5063 { 5064 /* off, on, blink. Index is led_status_t */ 5065 static const unsigned int led_sled_arg1[] = { 0, 1, 3 }; 5066 static const unsigned int led_led_arg1[] = { 0, 0x80, 0xc0 }; 5067 5068 int rc = 0; 5069 5070 switch (led_supported) { 5071 case TPACPI_LED_570: 5072 /* 570 */ 5073 if (unlikely(led > 7)) 5074 return -EINVAL; 5075 if (unlikely(tpacpi_is_led_restricted(led))) 5076 return -EPERM; 5077 if (!acpi_evalf(led_handle, NULL, NULL, "vdd", 5078 (1 << led), led_sled_arg1[ledstatus])) 5079 rc = -EIO; 5080 break; 5081 case TPACPI_LED_OLD: 5082 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20 */ 5083 if (unlikely(led > 7)) 5084 return -EINVAL; 5085 if (unlikely(tpacpi_is_led_restricted(led))) 5086 return -EPERM; 5087 rc = ec_write(TPACPI_LED_EC_HLMS, (1 << led)); 5088 if (rc >= 0) 5089 rc = ec_write(TPACPI_LED_EC_HLBL, 5090 (ledstatus == TPACPI_LED_BLINK) << led); 5091 if (rc >= 0) 5092 rc = ec_write(TPACPI_LED_EC_HLCL, 5093 (ledstatus != TPACPI_LED_OFF) << led); 5094 break; 5095 case TPACPI_LED_NEW: 5096 /* all others */ 5097 if (unlikely(led >= TPACPI_LED_NUMLEDS)) 5098 return -EINVAL; 5099 if (unlikely(tpacpi_is_led_restricted(led))) 5100 return -EPERM; 5101 if (!acpi_evalf(led_handle, NULL, NULL, "vdd", 5102 led, led_led_arg1[ledstatus])) 5103 rc = -EIO; 5104 break; 5105 default: 5106 rc = -ENXIO; 5107 } 5108 5109 if (!rc) 5110 tpacpi_led_state_cache[led] = ledstatus; 5111 5112 return rc; 5113 } 5114 5115 static void led_set_status_worker(struct work_struct *work) 5116 { 5117 struct tpacpi_led_classdev *data = 5118 container_of(work, struct tpacpi_led_classdev, work); 5119 5120 if (likely(tpacpi_lifecycle == TPACPI_LIFE_RUNNING)) 5121 led_set_status(data->led, data->new_state); 5122 } 5123 5124 static void led_sysfs_set(struct led_classdev *led_cdev, 5125 enum led_brightness brightness) 5126 { 5127 struct tpacpi_led_classdev *data = container_of(led_cdev, 5128 struct tpacpi_led_classdev, led_classdev); 5129 5130 if (brightness == LED_OFF) 5131 data->new_state = TPACPI_LED_OFF; 5132 else if (tpacpi_led_state_cache[data->led] != TPACPI_LED_BLINK) 5133 data->new_state = TPACPI_LED_ON; 5134 else 5135 data->new_state = TPACPI_LED_BLINK; 5136 5137 queue_work(tpacpi_wq, &data->work); 5138 } 5139 5140 static int led_sysfs_blink_set(struct led_classdev *led_cdev, 5141 unsigned long *delay_on, unsigned long *delay_off) 5142 { 5143 struct tpacpi_led_classdev *data = container_of(led_cdev, 5144 struct tpacpi_led_classdev, led_classdev); 5145 5146 /* Can we choose the flash rate? */ 5147 if (*delay_on == 0 && *delay_off == 0) { 5148 /* yes. set them to the hardware blink rate (1 Hz) */ 5149 *delay_on = 500; /* ms */ 5150 *delay_off = 500; /* ms */ 5151 } else if ((*delay_on != 500) || (*delay_off != 500)) 5152 return -EINVAL; 5153 5154 data->new_state = TPACPI_LED_BLINK; 5155 queue_work(tpacpi_wq, &data->work); 5156 5157 return 0; 5158 } 5159 5160 static enum led_brightness led_sysfs_get(struct led_classdev *led_cdev) 5161 { 5162 int rc; 5163 5164 struct tpacpi_led_classdev *data = container_of(led_cdev, 5165 struct tpacpi_led_classdev, led_classdev); 5166 5167 rc = led_get_status(data->led); 5168 5169 if (rc == TPACPI_LED_OFF || rc < 0) 5170 rc = LED_OFF; /* no error handling in led class :( */ 5171 else 5172 rc = LED_FULL; 5173 5174 return rc; 5175 } 5176 5177 static void led_exit(void) 5178 { 5179 unsigned int i; 5180 5181 for (i = 0; i < TPACPI_LED_NUMLEDS; i++) { 5182 if (tpacpi_leds[i].led_classdev.name) 5183 led_classdev_unregister(&tpacpi_leds[i].led_classdev); 5184 } 5185 5186 flush_workqueue(tpacpi_wq); 5187 kfree(tpacpi_leds); 5188 } 5189 5190 static int __init tpacpi_init_led(unsigned int led) 5191 { 5192 int rc; 5193 5194 tpacpi_leds[led].led = led; 5195 5196 /* LEDs with no name don't get registered */ 5197 if (!tpacpi_led_names[led]) 5198 return 0; 5199 5200 tpacpi_leds[led].led_classdev.brightness_set = &led_sysfs_set; 5201 tpacpi_leds[led].led_classdev.blink_set = &led_sysfs_blink_set; 5202 if (led_supported == TPACPI_LED_570) 5203 tpacpi_leds[led].led_classdev.brightness_get = 5204 &led_sysfs_get; 5205 5206 tpacpi_leds[led].led_classdev.name = tpacpi_led_names[led]; 5207 5208 INIT_WORK(&tpacpi_leds[led].work, led_set_status_worker); 5209 5210 rc = led_classdev_register(&tpacpi_pdev->dev, 5211 &tpacpi_leds[led].led_classdev); 5212 if (rc < 0) 5213 tpacpi_leds[led].led_classdev.name = NULL; 5214 5215 return rc; 5216 } 5217 5218 static const struct tpacpi_quirk led_useful_qtable[] __initconst = { 5219 TPACPI_Q_IBM('1', 'E', 0x009f), /* A30 */ 5220 TPACPI_Q_IBM('1', 'N', 0x009f), /* A31 */ 5221 TPACPI_Q_IBM('1', 'G', 0x009f), /* A31 */ 5222 5223 TPACPI_Q_IBM('1', 'I', 0x0097), /* T30 */ 5224 TPACPI_Q_IBM('1', 'R', 0x0097), /* T40, T41, T42, R50, R51 */ 5225 TPACPI_Q_IBM('7', '0', 0x0097), /* T43, R52 */ 5226 TPACPI_Q_IBM('1', 'Y', 0x0097), /* T43 */ 5227 TPACPI_Q_IBM('1', 'W', 0x0097), /* R50e */ 5228 TPACPI_Q_IBM('1', 'V', 0x0097), /* R51 */ 5229 TPACPI_Q_IBM('7', '8', 0x0097), /* R51e */ 5230 TPACPI_Q_IBM('7', '6', 0x0097), /* R52 */ 5231 5232 TPACPI_Q_IBM('1', 'K', 0x00bf), /* X30 */ 5233 TPACPI_Q_IBM('1', 'Q', 0x00bf), /* X31, X32 */ 5234 TPACPI_Q_IBM('1', 'U', 0x00bf), /* X40 */ 5235 TPACPI_Q_IBM('7', '4', 0x00bf), /* X41 */ 5236 TPACPI_Q_IBM('7', '5', 0x00bf), /* X41t */ 5237 5238 TPACPI_Q_IBM('7', '9', 0x1f97), /* T60 (1) */ 5239 TPACPI_Q_IBM('7', '7', 0x1f97), /* Z60* (1) */ 5240 TPACPI_Q_IBM('7', 'F', 0x1f97), /* Z61* (1) */ 5241 TPACPI_Q_IBM('7', 'B', 0x1fb7), /* X60 (1) */ 5242 5243 /* (1) - may have excess leds enabled on MSB */ 5244 5245 /* Defaults (order matters, keep last, don't reorder!) */ 5246 { /* Lenovo */ 5247 .vendor = PCI_VENDOR_ID_LENOVO, 5248 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY, 5249 .quirks = 0x1fffU, 5250 }, 5251 { /* IBM ThinkPads with no EC version string */ 5252 .vendor = PCI_VENDOR_ID_IBM, 5253 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_UNKNOWN, 5254 .quirks = 0x00ffU, 5255 }, 5256 { /* IBM ThinkPads with EC version string */ 5257 .vendor = PCI_VENDOR_ID_IBM, 5258 .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY, 5259 .quirks = 0x00bfU, 5260 }, 5261 }; 5262 5263 #undef TPACPI_LEDQ_IBM 5264 #undef TPACPI_LEDQ_LNV 5265 5266 static enum led_access_mode __init led_init_detect_mode(void) 5267 { 5268 acpi_status status; 5269 5270 if (tpacpi_is_ibm()) { 5271 /* 570 */ 5272 status = acpi_get_handle(ec_handle, "SLED", &led_handle); 5273 if (ACPI_SUCCESS(status)) 5274 return TPACPI_LED_570; 5275 5276 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */ 5277 status = acpi_get_handle(ec_handle, "SYSL", &led_handle); 5278 if (ACPI_SUCCESS(status)) 5279 return TPACPI_LED_OLD; 5280 } 5281 5282 /* most others */ 5283 status = acpi_get_handle(ec_handle, "LED", &led_handle); 5284 if (ACPI_SUCCESS(status)) 5285 return TPACPI_LED_NEW; 5286 5287 /* R30, R31, and unknown firmwares */ 5288 led_handle = NULL; 5289 return TPACPI_LED_NONE; 5290 } 5291 5292 static int __init led_init(struct ibm_init_struct *iibm) 5293 { 5294 unsigned int i; 5295 int rc; 5296 unsigned long useful_leds; 5297 5298 vdbg_printk(TPACPI_DBG_INIT, "initializing LED subdriver\n"); 5299 5300 led_supported = led_init_detect_mode(); 5301 5302 if (led_supported != TPACPI_LED_NONE) { 5303 useful_leds = tpacpi_check_quirks(led_useful_qtable, 5304 ARRAY_SIZE(led_useful_qtable)); 5305 5306 if (!useful_leds) { 5307 led_handle = NULL; 5308 led_supported = TPACPI_LED_NONE; 5309 } 5310 } 5311 5312 vdbg_printk(TPACPI_DBG_INIT, "LED commands are %s, mode %d\n", 5313 str_supported(led_supported), led_supported); 5314 5315 if (led_supported == TPACPI_LED_NONE) 5316 return 1; 5317 5318 tpacpi_leds = kzalloc(sizeof(*tpacpi_leds) * TPACPI_LED_NUMLEDS, 5319 GFP_KERNEL); 5320 if (!tpacpi_leds) { 5321 pr_err("Out of memory for LED data\n"); 5322 return -ENOMEM; 5323 } 5324 5325 for (i = 0; i < TPACPI_LED_NUMLEDS; i++) { 5326 tpacpi_leds[i].led = -1; 5327 5328 if (!tpacpi_is_led_restricted(i) && 5329 test_bit(i, &useful_leds)) { 5330 rc = tpacpi_init_led(i); 5331 if (rc < 0) { 5332 led_exit(); 5333 return rc; 5334 } 5335 } 5336 } 5337 5338 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS 5339 pr_notice("warning: userspace override of important " 5340 "firmware LEDs is enabled\n"); 5341 #endif 5342 return 0; 5343 } 5344 5345 #define str_led_status(s) \ 5346 ((s) == TPACPI_LED_OFF ? "off" : \ 5347 ((s) == TPACPI_LED_ON ? "on" : "blinking")) 5348 5349 static int led_read(struct seq_file *m) 5350 { 5351 if (!led_supported) { 5352 seq_printf(m, "status:\t\tnot supported\n"); 5353 return 0; 5354 } 5355 seq_printf(m, "status:\t\tsupported\n"); 5356 5357 if (led_supported == TPACPI_LED_570) { 5358 /* 570 */ 5359 int i, status; 5360 for (i = 0; i < 8; i++) { 5361 status = led_get_status(i); 5362 if (status < 0) 5363 return -EIO; 5364 seq_printf(m, "%d:\t\t%s\n", 5365 i, str_led_status(status)); 5366 } 5367 } 5368 5369 seq_printf(m, "commands:\t" 5370 "<led> on, <led> off, <led> blink (<led> is 0-15)\n"); 5371 5372 return 0; 5373 } 5374 5375 static int led_write(char *buf) 5376 { 5377 char *cmd; 5378 int led, rc; 5379 enum led_status_t s; 5380 5381 if (!led_supported) 5382 return -ENODEV; 5383 5384 while ((cmd = next_cmd(&buf))) { 5385 if (sscanf(cmd, "%d", &led) != 1) 5386 return -EINVAL; 5387 5388 if (led < 0 || led > (TPACPI_LED_NUMLEDS - 1) || 5389 tpacpi_leds[led].led < 0) 5390 return -ENODEV; 5391 5392 if (strstr(cmd, "off")) { 5393 s = TPACPI_LED_OFF; 5394 } else if (strstr(cmd, "on")) { 5395 s = TPACPI_LED_ON; 5396 } else if (strstr(cmd, "blink")) { 5397 s = TPACPI_LED_BLINK; 5398 } else { 5399 return -EINVAL; 5400 } 5401 5402 rc = led_set_status(led, s); 5403 if (rc < 0) 5404 return rc; 5405 } 5406 5407 return 0; 5408 } 5409 5410 static struct ibm_struct led_driver_data = { 5411 .name = "led", 5412 .read = led_read, 5413 .write = led_write, 5414 .exit = led_exit, 5415 }; 5416 5417 /************************************************************************* 5418 * Beep subdriver 5419 */ 5420 5421 TPACPI_HANDLE(beep, ec, "BEEP"); /* all except R30, R31 */ 5422 5423 #define TPACPI_BEEP_Q1 0x0001 5424 5425 static const struct tpacpi_quirk beep_quirk_table[] __initconst = { 5426 TPACPI_Q_IBM('I', 'M', TPACPI_BEEP_Q1), /* 570 */ 5427 TPACPI_Q_IBM('I', 'U', TPACPI_BEEP_Q1), /* 570E - unverified */ 5428 }; 5429 5430 static int __init beep_init(struct ibm_init_struct *iibm) 5431 { 5432 unsigned long quirks; 5433 5434 vdbg_printk(TPACPI_DBG_INIT, "initializing beep subdriver\n"); 5435 5436 TPACPI_ACPIHANDLE_INIT(beep); 5437 5438 vdbg_printk(TPACPI_DBG_INIT, "beep is %s\n", 5439 str_supported(beep_handle != NULL)); 5440 5441 quirks = tpacpi_check_quirks(beep_quirk_table, 5442 ARRAY_SIZE(beep_quirk_table)); 5443 5444 tp_features.beep_needs_two_args = !!(quirks & TPACPI_BEEP_Q1); 5445 5446 return (beep_handle)? 0 : 1; 5447 } 5448 5449 static int beep_read(struct seq_file *m) 5450 { 5451 if (!beep_handle) 5452 seq_printf(m, "status:\t\tnot supported\n"); 5453 else { 5454 seq_printf(m, "status:\t\tsupported\n"); 5455 seq_printf(m, "commands:\t<cmd> (<cmd> is 0-17)\n"); 5456 } 5457 5458 return 0; 5459 } 5460 5461 static int beep_write(char *buf) 5462 { 5463 char *cmd; 5464 int beep_cmd; 5465 5466 if (!beep_handle) 5467 return -ENODEV; 5468 5469 while ((cmd = next_cmd(&buf))) { 5470 if (sscanf(cmd, "%u", &beep_cmd) == 1 && 5471 beep_cmd >= 0 && beep_cmd <= 17) { 5472 /* beep_cmd set */ 5473 } else 5474 return -EINVAL; 5475 if (tp_features.beep_needs_two_args) { 5476 if (!acpi_evalf(beep_handle, NULL, NULL, "vdd", 5477 beep_cmd, 0)) 5478 return -EIO; 5479 } else { 5480 if (!acpi_evalf(beep_handle, NULL, NULL, "vd", 5481 beep_cmd)) 5482 return -EIO; 5483 } 5484 } 5485 5486 return 0; 5487 } 5488 5489 static struct ibm_struct beep_driver_data = { 5490 .name = "beep", 5491 .read = beep_read, 5492 .write = beep_write, 5493 }; 5494 5495 /************************************************************************* 5496 * Thermal subdriver 5497 */ 5498 5499 enum thermal_access_mode { 5500 TPACPI_THERMAL_NONE = 0, /* No thermal support */ 5501 TPACPI_THERMAL_ACPI_TMP07, /* Use ACPI TMP0-7 */ 5502 TPACPI_THERMAL_ACPI_UPDT, /* Use ACPI TMP0-7 with UPDT */ 5503 TPACPI_THERMAL_TPEC_8, /* Use ACPI EC regs, 8 sensors */ 5504 TPACPI_THERMAL_TPEC_16, /* Use ACPI EC regs, 16 sensors */ 5505 }; 5506 5507 enum { /* TPACPI_THERMAL_TPEC_* */ 5508 TP_EC_THERMAL_TMP0 = 0x78, /* ACPI EC regs TMP 0..7 */ 5509 TP_EC_THERMAL_TMP8 = 0xC0, /* ACPI EC regs TMP 8..15 */ 5510 TP_EC_THERMAL_TMP_NA = -128, /* ACPI EC sensor not available */ 5511 5512 TPACPI_THERMAL_SENSOR_NA = -128000, /* Sensor not available */ 5513 }; 5514 5515 5516 #define TPACPI_MAX_THERMAL_SENSORS 16 /* Max thermal sensors supported */ 5517 struct ibm_thermal_sensors_struct { 5518 s32 temp[TPACPI_MAX_THERMAL_SENSORS]; 5519 }; 5520 5521 static enum thermal_access_mode thermal_read_mode; 5522 5523 /* idx is zero-based */ 5524 static int thermal_get_sensor(int idx, s32 *value) 5525 { 5526 int t; 5527 s8 tmp; 5528 char tmpi[5]; 5529 5530 t = TP_EC_THERMAL_TMP0; 5531 5532 switch (thermal_read_mode) { 5533 #if TPACPI_MAX_THERMAL_SENSORS >= 16 5534 case TPACPI_THERMAL_TPEC_16: 5535 if (idx >= 8 && idx <= 15) { 5536 t = TP_EC_THERMAL_TMP8; 5537 idx -= 8; 5538 } 5539 /* fallthrough */ 5540 #endif 5541 case TPACPI_THERMAL_TPEC_8: 5542 if (idx <= 7) { 5543 if (!acpi_ec_read(t + idx, &tmp)) 5544 return -EIO; 5545 *value = tmp * 1000; 5546 return 0; 5547 } 5548 break; 5549 5550 case TPACPI_THERMAL_ACPI_UPDT: 5551 if (idx <= 7) { 5552 snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx); 5553 if (!acpi_evalf(ec_handle, NULL, "UPDT", "v")) 5554 return -EIO; 5555 if (!acpi_evalf(ec_handle, &t, tmpi, "d")) 5556 return -EIO; 5557 *value = (t - 2732) * 100; 5558 return 0; 5559 } 5560 break; 5561 5562 case TPACPI_THERMAL_ACPI_TMP07: 5563 if (idx <= 7) { 5564 snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx); 5565 if (!acpi_evalf(ec_handle, &t, tmpi, "d")) 5566 return -EIO; 5567 if (t > 127 || t < -127) 5568 t = TP_EC_THERMAL_TMP_NA; 5569 *value = t * 1000; 5570 return 0; 5571 } 5572 break; 5573 5574 case TPACPI_THERMAL_NONE: 5575 default: 5576 return -ENOSYS; 5577 } 5578 5579 return -EINVAL; 5580 } 5581 5582 static int thermal_get_sensors(struct ibm_thermal_sensors_struct *s) 5583 { 5584 int res, i; 5585 int n; 5586 5587 n = 8; 5588 i = 0; 5589 5590 if (!s) 5591 return -EINVAL; 5592 5593 if (thermal_read_mode == TPACPI_THERMAL_TPEC_16) 5594 n = 16; 5595 5596 for (i = 0 ; i < n; i++) { 5597 res = thermal_get_sensor(i, &s->temp[i]); 5598 if (res) 5599 return res; 5600 } 5601 5602 return n; 5603 } 5604 5605 static void thermal_dump_all_sensors(void) 5606 { 5607 int n, i; 5608 struct ibm_thermal_sensors_struct t; 5609 5610 n = thermal_get_sensors(&t); 5611 if (n <= 0) 5612 return; 5613 5614 pr_notice("temperatures (Celsius):"); 5615 5616 for (i = 0; i < n; i++) { 5617 if (t.temp[i] != TPACPI_THERMAL_SENSOR_NA) 5618 pr_cont(" %d", (int)(t.temp[i] / 1000)); 5619 else 5620 pr_cont(" N/A"); 5621 } 5622 5623 pr_cont("\n"); 5624 } 5625 5626 /* sysfs temp##_input -------------------------------------------------- */ 5627 5628 static ssize_t thermal_temp_input_show(struct device *dev, 5629 struct device_attribute *attr, 5630 char *buf) 5631 { 5632 struct sensor_device_attribute *sensor_attr = 5633 to_sensor_dev_attr(attr); 5634 int idx = sensor_attr->index; 5635 s32 value; 5636 int res; 5637 5638 res = thermal_get_sensor(idx, &value); 5639 if (res) 5640 return res; 5641 if (value == TPACPI_THERMAL_SENSOR_NA) 5642 return -ENXIO; 5643 5644 return snprintf(buf, PAGE_SIZE, "%d\n", value); 5645 } 5646 5647 #define THERMAL_SENSOR_ATTR_TEMP(_idxA, _idxB) \ 5648 SENSOR_ATTR(temp##_idxA##_input, S_IRUGO, \ 5649 thermal_temp_input_show, NULL, _idxB) 5650 5651 static struct sensor_device_attribute sensor_dev_attr_thermal_temp_input[] = { 5652 THERMAL_SENSOR_ATTR_TEMP(1, 0), 5653 THERMAL_SENSOR_ATTR_TEMP(2, 1), 5654 THERMAL_SENSOR_ATTR_TEMP(3, 2), 5655 THERMAL_SENSOR_ATTR_TEMP(4, 3), 5656 THERMAL_SENSOR_ATTR_TEMP(5, 4), 5657 THERMAL_SENSOR_ATTR_TEMP(6, 5), 5658 THERMAL_SENSOR_ATTR_TEMP(7, 6), 5659 THERMAL_SENSOR_ATTR_TEMP(8, 7), 5660 THERMAL_SENSOR_ATTR_TEMP(9, 8), 5661 THERMAL_SENSOR_ATTR_TEMP(10, 9), 5662 THERMAL_SENSOR_ATTR_TEMP(11, 10), 5663 THERMAL_SENSOR_ATTR_TEMP(12, 11), 5664 THERMAL_SENSOR_ATTR_TEMP(13, 12), 5665 THERMAL_SENSOR_ATTR_TEMP(14, 13), 5666 THERMAL_SENSOR_ATTR_TEMP(15, 14), 5667 THERMAL_SENSOR_ATTR_TEMP(16, 15), 5668 }; 5669 5670 #define THERMAL_ATTRS(X) \ 5671 &sensor_dev_attr_thermal_temp_input[X].dev_attr.attr 5672 5673 static struct attribute *thermal_temp_input_attr[] = { 5674 THERMAL_ATTRS(8), 5675 THERMAL_ATTRS(9), 5676 THERMAL_ATTRS(10), 5677 THERMAL_ATTRS(11), 5678 THERMAL_ATTRS(12), 5679 THERMAL_ATTRS(13), 5680 THERMAL_ATTRS(14), 5681 THERMAL_ATTRS(15), 5682 THERMAL_ATTRS(0), 5683 THERMAL_ATTRS(1), 5684 THERMAL_ATTRS(2), 5685 THERMAL_ATTRS(3), 5686 THERMAL_ATTRS(4), 5687 THERMAL_ATTRS(5), 5688 THERMAL_ATTRS(6), 5689 THERMAL_ATTRS(7), 5690 NULL 5691 }; 5692 5693 static const struct attribute_group thermal_temp_input16_group = { 5694 .attrs = thermal_temp_input_attr 5695 }; 5696 5697 static const struct attribute_group thermal_temp_input8_group = { 5698 .attrs = &thermal_temp_input_attr[8] 5699 }; 5700 5701 #undef THERMAL_SENSOR_ATTR_TEMP 5702 #undef THERMAL_ATTRS 5703 5704 /* --------------------------------------------------------------------- */ 5705 5706 static int __init thermal_init(struct ibm_init_struct *iibm) 5707 { 5708 u8 t, ta1, ta2; 5709 int i; 5710 int acpi_tmp7; 5711 int res; 5712 5713 vdbg_printk(TPACPI_DBG_INIT, "initializing thermal subdriver\n"); 5714 5715 acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv"); 5716 5717 if (thinkpad_id.ec_model) { 5718 /* 5719 * Direct EC access mode: sensors at registers 5720 * 0x78-0x7F, 0xC0-0xC7. Registers return 0x00 for 5721 * non-implemented, thermal sensors return 0x80 when 5722 * not available 5723 */ 5724 5725 ta1 = ta2 = 0; 5726 for (i = 0; i < 8; i++) { 5727 if (acpi_ec_read(TP_EC_THERMAL_TMP0 + i, &t)) { 5728 ta1 |= t; 5729 } else { 5730 ta1 = 0; 5731 break; 5732 } 5733 if (acpi_ec_read(TP_EC_THERMAL_TMP8 + i, &t)) { 5734 ta2 |= t; 5735 } else { 5736 ta1 = 0; 5737 break; 5738 } 5739 } 5740 if (ta1 == 0) { 5741 /* This is sheer paranoia, but we handle it anyway */ 5742 if (acpi_tmp7) { 5743 pr_err("ThinkPad ACPI EC access misbehaving, " 5744 "falling back to ACPI TMPx access " 5745 "mode\n"); 5746 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07; 5747 } else { 5748 pr_err("ThinkPad ACPI EC access misbehaving, " 5749 "disabling thermal sensors access\n"); 5750 thermal_read_mode = TPACPI_THERMAL_NONE; 5751 } 5752 } else { 5753 thermal_read_mode = 5754 (ta2 != 0) ? 5755 TPACPI_THERMAL_TPEC_16 : TPACPI_THERMAL_TPEC_8; 5756 } 5757 } else if (acpi_tmp7) { 5758 if (tpacpi_is_ibm() && 5759 acpi_evalf(ec_handle, NULL, "UPDT", "qv")) { 5760 /* 600e/x, 770e, 770x */ 5761 thermal_read_mode = TPACPI_THERMAL_ACPI_UPDT; 5762 } else { 5763 /* IBM/LENOVO DSDT EC.TMPx access, max 8 sensors */ 5764 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07; 5765 } 5766 } else { 5767 /* temperatures not supported on 570, G4x, R30, R31, R32 */ 5768 thermal_read_mode = TPACPI_THERMAL_NONE; 5769 } 5770 5771 vdbg_printk(TPACPI_DBG_INIT, "thermal is %s, mode %d\n", 5772 str_supported(thermal_read_mode != TPACPI_THERMAL_NONE), 5773 thermal_read_mode); 5774 5775 switch (thermal_read_mode) { 5776 case TPACPI_THERMAL_TPEC_16: 5777 res = sysfs_create_group(&tpacpi_sensors_pdev->dev.kobj, 5778 &thermal_temp_input16_group); 5779 if (res) 5780 return res; 5781 break; 5782 case TPACPI_THERMAL_TPEC_8: 5783 case TPACPI_THERMAL_ACPI_TMP07: 5784 case TPACPI_THERMAL_ACPI_UPDT: 5785 res = sysfs_create_group(&tpacpi_sensors_pdev->dev.kobj, 5786 &thermal_temp_input8_group); 5787 if (res) 5788 return res; 5789 break; 5790 case TPACPI_THERMAL_NONE: 5791 default: 5792 return 1; 5793 } 5794 5795 return 0; 5796 } 5797 5798 static void thermal_exit(void) 5799 { 5800 switch (thermal_read_mode) { 5801 case TPACPI_THERMAL_TPEC_16: 5802 sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj, 5803 &thermal_temp_input16_group); 5804 break; 5805 case TPACPI_THERMAL_TPEC_8: 5806 case TPACPI_THERMAL_ACPI_TMP07: 5807 case TPACPI_THERMAL_ACPI_UPDT: 5808 sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj, 5809 &thermal_temp_input8_group); 5810 break; 5811 case TPACPI_THERMAL_NONE: 5812 default: 5813 break; 5814 } 5815 } 5816 5817 static int thermal_read(struct seq_file *m) 5818 { 5819 int n, i; 5820 struct ibm_thermal_sensors_struct t; 5821 5822 n = thermal_get_sensors(&t); 5823 if (unlikely(n < 0)) 5824 return n; 5825 5826 seq_printf(m, "temperatures:\t"); 5827 5828 if (n > 0) { 5829 for (i = 0; i < (n - 1); i++) 5830 seq_printf(m, "%d ", t.temp[i] / 1000); 5831 seq_printf(m, "%d\n", t.temp[i] / 1000); 5832 } else 5833 seq_printf(m, "not supported\n"); 5834 5835 return 0; 5836 } 5837 5838 static struct ibm_struct thermal_driver_data = { 5839 .name = "thermal", 5840 .read = thermal_read, 5841 .exit = thermal_exit, 5842 }; 5843 5844 /************************************************************************* 5845 * Backlight/brightness subdriver 5846 */ 5847 5848 #define TPACPI_BACKLIGHT_DEV_NAME "thinkpad_screen" 5849 5850 /* 5851 * ThinkPads can read brightness from two places: EC HBRV (0x31), or 5852 * CMOS NVRAM byte 0x5E, bits 0-3. 5853 * 5854 * EC HBRV (0x31) has the following layout 5855 * Bit 7: unknown function 5856 * Bit 6: unknown function 5857 * Bit 5: Z: honour scale changes, NZ: ignore scale changes 5858 * Bit 4: must be set to zero to avoid problems 5859 * Bit 3-0: backlight brightness level 5860 * 5861 * brightness_get_raw returns status data in the HBRV layout 5862 * 5863 * WARNING: The X61 has been verified to use HBRV for something else, so 5864 * this should be used _only_ on IBM ThinkPads, and maybe with some careful 5865 * testing on the very early *60 Lenovo models... 5866 */ 5867 5868 enum { 5869 TP_EC_BACKLIGHT = 0x31, 5870 5871 /* TP_EC_BACKLIGHT bitmasks */ 5872 TP_EC_BACKLIGHT_LVLMSK = 0x1F, 5873 TP_EC_BACKLIGHT_CMDMSK = 0xE0, 5874 TP_EC_BACKLIGHT_MAPSW = 0x20, 5875 }; 5876 5877 enum tpacpi_brightness_access_mode { 5878 TPACPI_BRGHT_MODE_AUTO = 0, /* Not implemented yet */ 5879 TPACPI_BRGHT_MODE_EC, /* EC control */ 5880 TPACPI_BRGHT_MODE_UCMS_STEP, /* UCMS step-based control */ 5881 TPACPI_BRGHT_MODE_ECNVRAM, /* EC control w/ NVRAM store */ 5882 TPACPI_BRGHT_MODE_MAX 5883 }; 5884 5885 static struct backlight_device *ibm_backlight_device; 5886 5887 static enum tpacpi_brightness_access_mode brightness_mode = 5888 TPACPI_BRGHT_MODE_MAX; 5889 5890 static unsigned int brightness_enable = 2; /* 2 = auto, 0 = no, 1 = yes */ 5891 5892 static struct mutex brightness_mutex; 5893 5894 /* NVRAM brightness access, 5895 * call with brightness_mutex held! */ 5896 static unsigned int tpacpi_brightness_nvram_get(void) 5897 { 5898 u8 lnvram; 5899 5900 lnvram = (nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS) 5901 & TP_NVRAM_MASK_LEVEL_BRIGHTNESS) 5902 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS; 5903 lnvram &= bright_maxlvl; 5904 5905 return lnvram; 5906 } 5907 5908 static void tpacpi_brightness_checkpoint_nvram(void) 5909 { 5910 u8 lec = 0; 5911 u8 b_nvram; 5912 5913 if (brightness_mode != TPACPI_BRGHT_MODE_ECNVRAM) 5914 return; 5915 5916 vdbg_printk(TPACPI_DBG_BRGHT, 5917 "trying to checkpoint backlight level to NVRAM...\n"); 5918 5919 if (mutex_lock_killable(&brightness_mutex) < 0) 5920 return; 5921 5922 if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec))) 5923 goto unlock; 5924 lec &= TP_EC_BACKLIGHT_LVLMSK; 5925 b_nvram = nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS); 5926 5927 if (lec != ((b_nvram & TP_NVRAM_MASK_LEVEL_BRIGHTNESS) 5928 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS)) { 5929 /* NVRAM needs update */ 5930 b_nvram &= ~(TP_NVRAM_MASK_LEVEL_BRIGHTNESS << 5931 TP_NVRAM_POS_LEVEL_BRIGHTNESS); 5932 b_nvram |= lec; 5933 nvram_write_byte(b_nvram, TP_NVRAM_ADDR_BRIGHTNESS); 5934 dbg_printk(TPACPI_DBG_BRGHT, 5935 "updated NVRAM backlight level to %u (0x%02x)\n", 5936 (unsigned int) lec, (unsigned int) b_nvram); 5937 } else 5938 vdbg_printk(TPACPI_DBG_BRGHT, 5939 "NVRAM backlight level already is %u (0x%02x)\n", 5940 (unsigned int) lec, (unsigned int) b_nvram); 5941 5942 unlock: 5943 mutex_unlock(&brightness_mutex); 5944 } 5945 5946 5947 /* call with brightness_mutex held! */ 5948 static int tpacpi_brightness_get_raw(int *status) 5949 { 5950 u8 lec = 0; 5951 5952 switch (brightness_mode) { 5953 case TPACPI_BRGHT_MODE_UCMS_STEP: 5954 *status = tpacpi_brightness_nvram_get(); 5955 return 0; 5956 case TPACPI_BRGHT_MODE_EC: 5957 case TPACPI_BRGHT_MODE_ECNVRAM: 5958 if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec))) 5959 return -EIO; 5960 *status = lec; 5961 return 0; 5962 default: 5963 return -ENXIO; 5964 } 5965 } 5966 5967 /* call with brightness_mutex held! */ 5968 /* do NOT call with illegal backlight level value */ 5969 static int tpacpi_brightness_set_ec(unsigned int value) 5970 { 5971 u8 lec = 0; 5972 5973 if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec))) 5974 return -EIO; 5975 5976 if (unlikely(!acpi_ec_write(TP_EC_BACKLIGHT, 5977 (lec & TP_EC_BACKLIGHT_CMDMSK) | 5978 (value & TP_EC_BACKLIGHT_LVLMSK)))) 5979 return -EIO; 5980 5981 return 0; 5982 } 5983 5984 /* call with brightness_mutex held! */ 5985 static int tpacpi_brightness_set_ucmsstep(unsigned int value) 5986 { 5987 int cmos_cmd, inc; 5988 unsigned int current_value, i; 5989 5990 current_value = tpacpi_brightness_nvram_get(); 5991 5992 if (value == current_value) 5993 return 0; 5994 5995 cmos_cmd = (value > current_value) ? 5996 TP_CMOS_BRIGHTNESS_UP : 5997 TP_CMOS_BRIGHTNESS_DOWN; 5998 inc = (value > current_value) ? 1 : -1; 5999 6000 for (i = current_value; i != value; i += inc) 6001 if (issue_thinkpad_cmos_command(cmos_cmd)) 6002 return -EIO; 6003 6004 return 0; 6005 } 6006 6007 /* May return EINTR which can always be mapped to ERESTARTSYS */ 6008 static int brightness_set(unsigned int value) 6009 { 6010 int res; 6011 6012 if (value > bright_maxlvl || value < 0) 6013 return -EINVAL; 6014 6015 vdbg_printk(TPACPI_DBG_BRGHT, 6016 "set backlight level to %d\n", value); 6017 6018 res = mutex_lock_killable(&brightness_mutex); 6019 if (res < 0) 6020 return res; 6021 6022 switch (brightness_mode) { 6023 case TPACPI_BRGHT_MODE_EC: 6024 case TPACPI_BRGHT_MODE_ECNVRAM: 6025 res = tpacpi_brightness_set_ec(value); 6026 break; 6027 case TPACPI_BRGHT_MODE_UCMS_STEP: 6028 res = tpacpi_brightness_set_ucmsstep(value); 6029 break; 6030 default: 6031 res = -ENXIO; 6032 } 6033 6034 mutex_unlock(&brightness_mutex); 6035 return res; 6036 } 6037 6038 /* sysfs backlight class ----------------------------------------------- */ 6039 6040 static int brightness_update_status(struct backlight_device *bd) 6041 { 6042 unsigned int level = 6043 (bd->props.fb_blank == FB_BLANK_UNBLANK && 6044 bd->props.power == FB_BLANK_UNBLANK) ? 6045 bd->props.brightness : 0; 6046 6047 dbg_printk(TPACPI_DBG_BRGHT, 6048 "backlight: attempt to set level to %d\n", 6049 level); 6050 6051 /* it is the backlight class's job (caller) to handle 6052 * EINTR and other errors properly */ 6053 return brightness_set(level); 6054 } 6055 6056 static int brightness_get(struct backlight_device *bd) 6057 { 6058 int status, res; 6059 6060 res = mutex_lock_killable(&brightness_mutex); 6061 if (res < 0) 6062 return 0; 6063 6064 res = tpacpi_brightness_get_raw(&status); 6065 6066 mutex_unlock(&brightness_mutex); 6067 6068 if (res < 0) 6069 return 0; 6070 6071 return status & TP_EC_BACKLIGHT_LVLMSK; 6072 } 6073 6074 static void tpacpi_brightness_notify_change(void) 6075 { 6076 backlight_force_update(ibm_backlight_device, 6077 BACKLIGHT_UPDATE_HOTKEY); 6078 } 6079 6080 static const struct backlight_ops ibm_backlight_data = { 6081 .get_brightness = brightness_get, 6082 .update_status = brightness_update_status, 6083 }; 6084 6085 /* --------------------------------------------------------------------- */ 6086 6087 /* 6088 * Call _BCL method of video device. On some ThinkPads this will 6089 * switch the firmware to the ACPI brightness control mode. 6090 */ 6091 6092 static int __init tpacpi_query_bcl_levels(acpi_handle handle) 6093 { 6094 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 6095 union acpi_object *obj; 6096 struct acpi_device *device, *child; 6097 int rc; 6098 6099 if (acpi_bus_get_device(handle, &device)) 6100 return 0; 6101 6102 rc = 0; 6103 list_for_each_entry(child, &device->children, node) { 6104 acpi_status status = acpi_evaluate_object(child->handle, "_BCL", 6105 NULL, &buffer); 6106 if (ACPI_FAILURE(status)) 6107 continue; 6108 6109 obj = (union acpi_object *)buffer.pointer; 6110 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) { 6111 pr_err("Unknown _BCL data, please report this to %s\n", 6112 TPACPI_MAIL); 6113 rc = 0; 6114 } else { 6115 rc = obj->package.count; 6116 } 6117 break; 6118 } 6119 6120 kfree(buffer.pointer); 6121 return rc; 6122 } 6123 6124 6125 /* 6126 * Returns 0 (no ACPI _BCL or _BCL invalid), or size of brightness map 6127 */ 6128 static unsigned int __init tpacpi_check_std_acpi_brightness_support(void) 6129 { 6130 acpi_handle video_device; 6131 int bcl_levels = 0; 6132 6133 tpacpi_acpi_handle_locate("video", NULL, &video_device); 6134 if (video_device) 6135 bcl_levels = tpacpi_query_bcl_levels(video_device); 6136 6137 tp_features.bright_acpimode = (bcl_levels > 0); 6138 6139 return (bcl_levels > 2) ? (bcl_levels - 2) : 0; 6140 } 6141 6142 /* 6143 * These are only useful for models that have only one possibility 6144 * of GPU. If the BIOS model handles both ATI and Intel, don't use 6145 * these quirks. 6146 */ 6147 #define TPACPI_BRGHT_Q_NOEC 0x0001 /* Must NOT use EC HBRV */ 6148 #define TPACPI_BRGHT_Q_EC 0x0002 /* Should or must use EC HBRV */ 6149 #define TPACPI_BRGHT_Q_ASK 0x8000 /* Ask for user report */ 6150 6151 static const struct tpacpi_quirk brightness_quirk_table[] __initconst = { 6152 /* Models with ATI GPUs known to require ECNVRAM mode */ 6153 TPACPI_Q_IBM('1', 'Y', TPACPI_BRGHT_Q_EC), /* T43/p ATI */ 6154 6155 /* Models with ATI GPUs that can use ECNVRAM */ 6156 TPACPI_Q_IBM('1', 'R', TPACPI_BRGHT_Q_EC), /* R50,51 T40-42 */ 6157 TPACPI_Q_IBM('1', 'Q', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC), 6158 TPACPI_Q_IBM('7', '6', TPACPI_BRGHT_Q_EC), /* R52 */ 6159 TPACPI_Q_IBM('7', '8', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC), 6160 6161 /* Models with Intel Extreme Graphics 2 */ 6162 TPACPI_Q_IBM('1', 'U', TPACPI_BRGHT_Q_NOEC), /* X40 */ 6163 TPACPI_Q_IBM('1', 'V', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC), 6164 TPACPI_Q_IBM('1', 'W', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC), 6165 6166 /* Models with Intel GMA900 */ 6167 TPACPI_Q_IBM('7', '0', TPACPI_BRGHT_Q_NOEC), /* T43, R52 */ 6168 TPACPI_Q_IBM('7', '4', TPACPI_BRGHT_Q_NOEC), /* X41 */ 6169 TPACPI_Q_IBM('7', '5', TPACPI_BRGHT_Q_NOEC), /* X41 Tablet */ 6170 }; 6171 6172 /* 6173 * Returns < 0 for error, otherwise sets tp_features.bright_* 6174 * and bright_maxlvl. 6175 */ 6176 static void __init tpacpi_detect_brightness_capabilities(void) 6177 { 6178 unsigned int b; 6179 6180 vdbg_printk(TPACPI_DBG_INIT, 6181 "detecting firmware brightness interface capabilities\n"); 6182 6183 /* we could run a quirks check here (same table used by 6184 * brightness_init) if needed */ 6185 6186 /* 6187 * We always attempt to detect acpi support, so as to switch 6188 * Lenovo Vista BIOS to ACPI brightness mode even if we are not 6189 * going to publish a backlight interface 6190 */ 6191 b = tpacpi_check_std_acpi_brightness_support(); 6192 switch (b) { 6193 case 16: 6194 bright_maxlvl = 15; 6195 pr_info("detected a 16-level brightness capable ThinkPad\n"); 6196 break; 6197 case 8: 6198 case 0: 6199 bright_maxlvl = 7; 6200 pr_info("detected a 8-level brightness capable ThinkPad\n"); 6201 break; 6202 default: 6203 pr_err("Unsupported brightness interface, " 6204 "please contact %s\n", TPACPI_MAIL); 6205 tp_features.bright_unkfw = 1; 6206 bright_maxlvl = b - 1; 6207 } 6208 } 6209 6210 static int __init brightness_init(struct ibm_init_struct *iibm) 6211 { 6212 struct backlight_properties props; 6213 int b; 6214 unsigned long quirks; 6215 6216 vdbg_printk(TPACPI_DBG_INIT, "initializing brightness subdriver\n"); 6217 6218 mutex_init(&brightness_mutex); 6219 6220 quirks = tpacpi_check_quirks(brightness_quirk_table, 6221 ARRAY_SIZE(brightness_quirk_table)); 6222 6223 /* tpacpi_detect_brightness_capabilities() must have run already */ 6224 6225 /* if it is unknown, we don't handle it: it wouldn't be safe */ 6226 if (tp_features.bright_unkfw) 6227 return 1; 6228 6229 if (!brightness_enable) { 6230 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT, 6231 "brightness support disabled by " 6232 "module parameter\n"); 6233 return 1; 6234 } 6235 6236 if (acpi_video_backlight_support()) { 6237 if (brightness_enable > 1) { 6238 pr_info("Standard ACPI backlight interface " 6239 "available, not loading native one\n"); 6240 return 1; 6241 } else if (brightness_enable == 1) { 6242 pr_warn("Cannot enable backlight brightness support, " 6243 "ACPI is already handling it. Refer to the " 6244 "acpi_backlight kernel parameter.\n"); 6245 return 1; 6246 } 6247 } else if (tp_features.bright_acpimode && brightness_enable > 1) { 6248 pr_notice("Standard ACPI backlight interface not " 6249 "available, thinkpad_acpi native " 6250 "brightness control enabled\n"); 6251 } 6252 6253 /* 6254 * Check for module parameter bogosity, note that we 6255 * init brightness_mode to TPACPI_BRGHT_MODE_MAX in order to be 6256 * able to detect "unspecified" 6257 */ 6258 if (brightness_mode > TPACPI_BRGHT_MODE_MAX) 6259 return -EINVAL; 6260 6261 /* TPACPI_BRGHT_MODE_AUTO not implemented yet, just use default */ 6262 if (brightness_mode == TPACPI_BRGHT_MODE_AUTO || 6263 brightness_mode == TPACPI_BRGHT_MODE_MAX) { 6264 if (quirks & TPACPI_BRGHT_Q_EC) 6265 brightness_mode = TPACPI_BRGHT_MODE_ECNVRAM; 6266 else 6267 brightness_mode = TPACPI_BRGHT_MODE_UCMS_STEP; 6268 6269 dbg_printk(TPACPI_DBG_BRGHT, 6270 "driver auto-selected brightness_mode=%d\n", 6271 brightness_mode); 6272 } 6273 6274 /* Safety */ 6275 if (!tpacpi_is_ibm() && 6276 (brightness_mode == TPACPI_BRGHT_MODE_ECNVRAM || 6277 brightness_mode == TPACPI_BRGHT_MODE_EC)) 6278 return -EINVAL; 6279 6280 if (tpacpi_brightness_get_raw(&b) < 0) 6281 return 1; 6282 6283 memset(&props, 0, sizeof(struct backlight_properties)); 6284 props.type = BACKLIGHT_PLATFORM; 6285 props.max_brightness = bright_maxlvl; 6286 props.brightness = b & TP_EC_BACKLIGHT_LVLMSK; 6287 ibm_backlight_device = backlight_device_register(TPACPI_BACKLIGHT_DEV_NAME, 6288 NULL, NULL, 6289 &ibm_backlight_data, 6290 &props); 6291 if (IS_ERR(ibm_backlight_device)) { 6292 int rc = PTR_ERR(ibm_backlight_device); 6293 ibm_backlight_device = NULL; 6294 pr_err("Could not register backlight device\n"); 6295 return rc; 6296 } 6297 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT, 6298 "brightness is supported\n"); 6299 6300 if (quirks & TPACPI_BRGHT_Q_ASK) { 6301 pr_notice("brightness: will use unverified default: " 6302 "brightness_mode=%d\n", brightness_mode); 6303 pr_notice("brightness: please report to %s whether it works well " 6304 "or not on your ThinkPad\n", TPACPI_MAIL); 6305 } 6306 6307 /* Added by mistake in early 2007. Probably useless, but it could 6308 * be working around some unknown firmware problem where the value 6309 * read at startup doesn't match the real hardware state... so leave 6310 * it in place just in case */ 6311 backlight_update_status(ibm_backlight_device); 6312 6313 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT, 6314 "brightness: registering brightness hotkeys " 6315 "as change notification\n"); 6316 tpacpi_hotkey_driver_mask_set(hotkey_driver_mask 6317 | TP_ACPI_HKEY_BRGHTUP_MASK 6318 | TP_ACPI_HKEY_BRGHTDWN_MASK); 6319 return 0; 6320 } 6321 6322 static void brightness_suspend(void) 6323 { 6324 tpacpi_brightness_checkpoint_nvram(); 6325 } 6326 6327 static void brightness_shutdown(void) 6328 { 6329 tpacpi_brightness_checkpoint_nvram(); 6330 } 6331 6332 static void brightness_exit(void) 6333 { 6334 if (ibm_backlight_device) { 6335 vdbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_BRGHT, 6336 "calling backlight_device_unregister()\n"); 6337 backlight_device_unregister(ibm_backlight_device); 6338 } 6339 6340 tpacpi_brightness_checkpoint_nvram(); 6341 } 6342 6343 static int brightness_read(struct seq_file *m) 6344 { 6345 int level; 6346 6347 level = brightness_get(NULL); 6348 if (level < 0) { 6349 seq_printf(m, "level:\t\tunreadable\n"); 6350 } else { 6351 seq_printf(m, "level:\t\t%d\n", level); 6352 seq_printf(m, "commands:\tup, down\n"); 6353 seq_printf(m, "commands:\tlevel <level> (<level> is 0-%d)\n", 6354 bright_maxlvl); 6355 } 6356 6357 return 0; 6358 } 6359 6360 static int brightness_write(char *buf) 6361 { 6362 int level; 6363 int rc; 6364 char *cmd; 6365 6366 level = brightness_get(NULL); 6367 if (level < 0) 6368 return level; 6369 6370 while ((cmd = next_cmd(&buf))) { 6371 if (strlencmp(cmd, "up") == 0) { 6372 if (level < bright_maxlvl) 6373 level++; 6374 } else if (strlencmp(cmd, "down") == 0) { 6375 if (level > 0) 6376 level--; 6377 } else if (sscanf(cmd, "level %d", &level) == 1 && 6378 level >= 0 && level <= bright_maxlvl) { 6379 /* new level set */ 6380 } else 6381 return -EINVAL; 6382 } 6383 6384 tpacpi_disclose_usertask("procfs brightness", 6385 "set level to %d\n", level); 6386 6387 /* 6388 * Now we know what the final level should be, so we try to set it. 6389 * Doing it this way makes the syscall restartable in case of EINTR 6390 */ 6391 rc = brightness_set(level); 6392 if (!rc && ibm_backlight_device) 6393 backlight_force_update(ibm_backlight_device, 6394 BACKLIGHT_UPDATE_SYSFS); 6395 return (rc == -EINTR)? -ERESTARTSYS : rc; 6396 } 6397 6398 static struct ibm_struct brightness_driver_data = { 6399 .name = "brightness", 6400 .read = brightness_read, 6401 .write = brightness_write, 6402 .exit = brightness_exit, 6403 .suspend = brightness_suspend, 6404 .shutdown = brightness_shutdown, 6405 }; 6406 6407 /************************************************************************* 6408 * Volume subdriver 6409 */ 6410 6411 /* 6412 * IBM ThinkPads have a simple volume controller with MUTE gating. 6413 * Very early Lenovo ThinkPads follow the IBM ThinkPad spec. 6414 * 6415 * Since the *61 series (and probably also the later *60 series), Lenovo 6416 * ThinkPads only implement the MUTE gate. 6417 * 6418 * EC register 0x30 6419 * Bit 6: MUTE (1 mutes sound) 6420 * Bit 3-0: Volume 6421 * Other bits should be zero as far as we know. 6422 * 6423 * This is also stored in CMOS NVRAM, byte 0x60, bit 6 (MUTE), and 6424 * bits 3-0 (volume). Other bits in NVRAM may have other functions, 6425 * such as bit 7 which is used to detect repeated presses of MUTE, 6426 * and we leave them unchanged. 6427 */ 6428 6429 #ifdef CONFIG_THINKPAD_ACPI_ALSA_SUPPORT 6430 6431 #define TPACPI_ALSA_DRVNAME "ThinkPad EC" 6432 #define TPACPI_ALSA_SHRTNAME "ThinkPad Console Audio Control" 6433 #define TPACPI_ALSA_MIXERNAME TPACPI_ALSA_SHRTNAME 6434 6435 #if SNDRV_CARDS <= 32 6436 #define DEFAULT_ALSA_IDX ~((1 << (SNDRV_CARDS - 3)) - 1) 6437 #else 6438 #define DEFAULT_ALSA_IDX ~((1 << (32 - 3)) - 1) 6439 #endif 6440 static int alsa_index = DEFAULT_ALSA_IDX; /* last three slots */ 6441 static char *alsa_id = "ThinkPadEC"; 6442 static bool alsa_enable = SNDRV_DEFAULT_ENABLE1; 6443 6444 struct tpacpi_alsa_data { 6445 struct snd_card *card; 6446 struct snd_ctl_elem_id *ctl_mute_id; 6447 struct snd_ctl_elem_id *ctl_vol_id; 6448 }; 6449 6450 static struct snd_card *alsa_card; 6451 6452 enum { 6453 TP_EC_AUDIO = 0x30, 6454 6455 /* TP_EC_AUDIO bits */ 6456 TP_EC_AUDIO_MUTESW = 6, 6457 6458 /* TP_EC_AUDIO bitmasks */ 6459 TP_EC_AUDIO_LVL_MSK = 0x0F, 6460 TP_EC_AUDIO_MUTESW_MSK = (1 << TP_EC_AUDIO_MUTESW), 6461 6462 /* Maximum volume */ 6463 TP_EC_VOLUME_MAX = 14, 6464 }; 6465 6466 enum tpacpi_volume_access_mode { 6467 TPACPI_VOL_MODE_AUTO = 0, /* Not implemented yet */ 6468 TPACPI_VOL_MODE_EC, /* Pure EC control */ 6469 TPACPI_VOL_MODE_UCMS_STEP, /* UCMS step-based control: N/A */ 6470 TPACPI_VOL_MODE_ECNVRAM, /* EC control w/ NVRAM store */ 6471 TPACPI_VOL_MODE_MAX 6472 }; 6473 6474 enum tpacpi_volume_capabilities { 6475 TPACPI_VOL_CAP_AUTO = 0, /* Use white/blacklist */ 6476 TPACPI_VOL_CAP_VOLMUTE, /* Output vol and mute */ 6477 TPACPI_VOL_CAP_MUTEONLY, /* Output mute only */ 6478 TPACPI_VOL_CAP_MAX 6479 }; 6480 6481 static enum tpacpi_volume_access_mode volume_mode = 6482 TPACPI_VOL_MODE_MAX; 6483 6484 static enum tpacpi_volume_capabilities volume_capabilities; 6485 static bool volume_control_allowed; 6486 6487 /* 6488 * Used to syncronize writers to TP_EC_AUDIO and 6489 * TP_NVRAM_ADDR_MIXER, as we need to do read-modify-write 6490 */ 6491 static struct mutex volume_mutex; 6492 6493 static void tpacpi_volume_checkpoint_nvram(void) 6494 { 6495 u8 lec = 0; 6496 u8 b_nvram; 6497 u8 ec_mask; 6498 6499 if (volume_mode != TPACPI_VOL_MODE_ECNVRAM) 6500 return; 6501 if (!volume_control_allowed) 6502 return; 6503 6504 vdbg_printk(TPACPI_DBG_MIXER, 6505 "trying to checkpoint mixer state to NVRAM...\n"); 6506 6507 if (tp_features.mixer_no_level_control) 6508 ec_mask = TP_EC_AUDIO_MUTESW_MSK; 6509 else 6510 ec_mask = TP_EC_AUDIO_MUTESW_MSK | TP_EC_AUDIO_LVL_MSK; 6511 6512 if (mutex_lock_killable(&volume_mutex) < 0) 6513 return; 6514 6515 if (unlikely(!acpi_ec_read(TP_EC_AUDIO, &lec))) 6516 goto unlock; 6517 lec &= ec_mask; 6518 b_nvram = nvram_read_byte(TP_NVRAM_ADDR_MIXER); 6519 6520 if (lec != (b_nvram & ec_mask)) { 6521 /* NVRAM needs update */ 6522 b_nvram &= ~ec_mask; 6523 b_nvram |= lec; 6524 nvram_write_byte(b_nvram, TP_NVRAM_ADDR_MIXER); 6525 dbg_printk(TPACPI_DBG_MIXER, 6526 "updated NVRAM mixer status to 0x%02x (0x%02x)\n", 6527 (unsigned int) lec, (unsigned int) b_nvram); 6528 } else { 6529 vdbg_printk(TPACPI_DBG_MIXER, 6530 "NVRAM mixer status already is 0x%02x (0x%02x)\n", 6531 (unsigned int) lec, (unsigned int) b_nvram); 6532 } 6533 6534 unlock: 6535 mutex_unlock(&volume_mutex); 6536 } 6537 6538 static int volume_get_status_ec(u8 *status) 6539 { 6540 u8 s; 6541 6542 if (!acpi_ec_read(TP_EC_AUDIO, &s)) 6543 return -EIO; 6544 6545 *status = s; 6546 6547 dbg_printk(TPACPI_DBG_MIXER, "status 0x%02x\n", s); 6548 6549 return 0; 6550 } 6551 6552 static int volume_get_status(u8 *status) 6553 { 6554 return volume_get_status_ec(status); 6555 } 6556 6557 static int volume_set_status_ec(const u8 status) 6558 { 6559 if (!acpi_ec_write(TP_EC_AUDIO, status)) 6560 return -EIO; 6561 6562 dbg_printk(TPACPI_DBG_MIXER, "set EC mixer to 0x%02x\n", status); 6563 6564 return 0; 6565 } 6566 6567 static int volume_set_status(const u8 status) 6568 { 6569 return volume_set_status_ec(status); 6570 } 6571 6572 /* returns < 0 on error, 0 on no change, 1 on change */ 6573 static int __volume_set_mute_ec(const bool mute) 6574 { 6575 int rc; 6576 u8 s, n; 6577 6578 if (mutex_lock_killable(&volume_mutex) < 0) 6579 return -EINTR; 6580 6581 rc = volume_get_status_ec(&s); 6582 if (rc) 6583 goto unlock; 6584 6585 n = (mute) ? s | TP_EC_AUDIO_MUTESW_MSK : 6586 s & ~TP_EC_AUDIO_MUTESW_MSK; 6587 6588 if (n != s) { 6589 rc = volume_set_status_ec(n); 6590 if (!rc) 6591 rc = 1; 6592 } 6593 6594 unlock: 6595 mutex_unlock(&volume_mutex); 6596 return rc; 6597 } 6598 6599 static int volume_alsa_set_mute(const bool mute) 6600 { 6601 dbg_printk(TPACPI_DBG_MIXER, "ALSA: trying to %smute\n", 6602 (mute) ? "" : "un"); 6603 return __volume_set_mute_ec(mute); 6604 } 6605 6606 static int volume_set_mute(const bool mute) 6607 { 6608 int rc; 6609 6610 dbg_printk(TPACPI_DBG_MIXER, "trying to %smute\n", 6611 (mute) ? "" : "un"); 6612 6613 rc = __volume_set_mute_ec(mute); 6614 return (rc < 0) ? rc : 0; 6615 } 6616 6617 /* returns < 0 on error, 0 on no change, 1 on change */ 6618 static int __volume_set_volume_ec(const u8 vol) 6619 { 6620 int rc; 6621 u8 s, n; 6622 6623 if (vol > TP_EC_VOLUME_MAX) 6624 return -EINVAL; 6625 6626 if (mutex_lock_killable(&volume_mutex) < 0) 6627 return -EINTR; 6628 6629 rc = volume_get_status_ec(&s); 6630 if (rc) 6631 goto unlock; 6632 6633 n = (s & ~TP_EC_AUDIO_LVL_MSK) | vol; 6634 6635 if (n != s) { 6636 rc = volume_set_status_ec(n); 6637 if (!rc) 6638 rc = 1; 6639 } 6640 6641 unlock: 6642 mutex_unlock(&volume_mutex); 6643 return rc; 6644 } 6645 6646 static int volume_alsa_set_volume(const u8 vol) 6647 { 6648 dbg_printk(TPACPI_DBG_MIXER, 6649 "ALSA: trying to set volume level to %hu\n", vol); 6650 return __volume_set_volume_ec(vol); 6651 } 6652 6653 static void volume_alsa_notify_change(void) 6654 { 6655 struct tpacpi_alsa_data *d; 6656 6657 if (alsa_card && alsa_card->private_data) { 6658 d = alsa_card->private_data; 6659 if (d->ctl_mute_id) 6660 snd_ctl_notify(alsa_card, 6661 SNDRV_CTL_EVENT_MASK_VALUE, 6662 d->ctl_mute_id); 6663 if (d->ctl_vol_id) 6664 snd_ctl_notify(alsa_card, 6665 SNDRV_CTL_EVENT_MASK_VALUE, 6666 d->ctl_vol_id); 6667 } 6668 } 6669 6670 static int volume_alsa_vol_info(struct snd_kcontrol *kcontrol, 6671 struct snd_ctl_elem_info *uinfo) 6672 { 6673 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 6674 uinfo->count = 1; 6675 uinfo->value.integer.min = 0; 6676 uinfo->value.integer.max = TP_EC_VOLUME_MAX; 6677 return 0; 6678 } 6679 6680 static int volume_alsa_vol_get(struct snd_kcontrol *kcontrol, 6681 struct snd_ctl_elem_value *ucontrol) 6682 { 6683 u8 s; 6684 int rc; 6685 6686 rc = volume_get_status(&s); 6687 if (rc < 0) 6688 return rc; 6689 6690 ucontrol->value.integer.value[0] = s & TP_EC_AUDIO_LVL_MSK; 6691 return 0; 6692 } 6693 6694 static int volume_alsa_vol_put(struct snd_kcontrol *kcontrol, 6695 struct snd_ctl_elem_value *ucontrol) 6696 { 6697 tpacpi_disclose_usertask("ALSA", "set volume to %ld\n", 6698 ucontrol->value.integer.value[0]); 6699 return volume_alsa_set_volume(ucontrol->value.integer.value[0]); 6700 } 6701 6702 #define volume_alsa_mute_info snd_ctl_boolean_mono_info 6703 6704 static int volume_alsa_mute_get(struct snd_kcontrol *kcontrol, 6705 struct snd_ctl_elem_value *ucontrol) 6706 { 6707 u8 s; 6708 int rc; 6709 6710 rc = volume_get_status(&s); 6711 if (rc < 0) 6712 return rc; 6713 6714 ucontrol->value.integer.value[0] = 6715 (s & TP_EC_AUDIO_MUTESW_MSK) ? 0 : 1; 6716 return 0; 6717 } 6718 6719 static int volume_alsa_mute_put(struct snd_kcontrol *kcontrol, 6720 struct snd_ctl_elem_value *ucontrol) 6721 { 6722 tpacpi_disclose_usertask("ALSA", "%smute\n", 6723 ucontrol->value.integer.value[0] ? 6724 "un" : ""); 6725 return volume_alsa_set_mute(!ucontrol->value.integer.value[0]); 6726 } 6727 6728 static struct snd_kcontrol_new volume_alsa_control_vol = { 6729 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6730 .name = "Console Playback Volume", 6731 .index = 0, 6732 .access = SNDRV_CTL_ELEM_ACCESS_READ, 6733 .info = volume_alsa_vol_info, 6734 .get = volume_alsa_vol_get, 6735 }; 6736 6737 static struct snd_kcontrol_new volume_alsa_control_mute = { 6738 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6739 .name = "Console Playback Switch", 6740 .index = 0, 6741 .access = SNDRV_CTL_ELEM_ACCESS_READ, 6742 .info = volume_alsa_mute_info, 6743 .get = volume_alsa_mute_get, 6744 }; 6745 6746 static void volume_suspend(void) 6747 { 6748 tpacpi_volume_checkpoint_nvram(); 6749 } 6750 6751 static void volume_resume(void) 6752 { 6753 volume_alsa_notify_change(); 6754 } 6755 6756 static void volume_shutdown(void) 6757 { 6758 tpacpi_volume_checkpoint_nvram(); 6759 } 6760 6761 static void volume_exit(void) 6762 { 6763 if (alsa_card) { 6764 snd_card_free(alsa_card); 6765 alsa_card = NULL; 6766 } 6767 6768 tpacpi_volume_checkpoint_nvram(); 6769 } 6770 6771 static int __init volume_create_alsa_mixer(void) 6772 { 6773 struct snd_card *card; 6774 struct tpacpi_alsa_data *data; 6775 struct snd_kcontrol *ctl_vol; 6776 struct snd_kcontrol *ctl_mute; 6777 int rc; 6778 6779 rc = snd_card_create(alsa_index, alsa_id, THIS_MODULE, 6780 sizeof(struct tpacpi_alsa_data), &card); 6781 if (rc < 0 || !card) { 6782 pr_err("Failed to create ALSA card structures: %d\n", rc); 6783 return 1; 6784 } 6785 6786 BUG_ON(!card->private_data); 6787 data = card->private_data; 6788 data->card = card; 6789 6790 strlcpy(card->driver, TPACPI_ALSA_DRVNAME, 6791 sizeof(card->driver)); 6792 strlcpy(card->shortname, TPACPI_ALSA_SHRTNAME, 6793 sizeof(card->shortname)); 6794 snprintf(card->mixername, sizeof(card->mixername), "ThinkPad EC %s", 6795 (thinkpad_id.ec_version_str) ? 6796 thinkpad_id.ec_version_str : "(unknown)"); 6797 snprintf(card->longname, sizeof(card->longname), 6798 "%s at EC reg 0x%02x, fw %s", card->shortname, TP_EC_AUDIO, 6799 (thinkpad_id.ec_version_str) ? 6800 thinkpad_id.ec_version_str : "unknown"); 6801 6802 if (volume_control_allowed) { 6803 volume_alsa_control_vol.put = volume_alsa_vol_put; 6804 volume_alsa_control_vol.access = 6805 SNDRV_CTL_ELEM_ACCESS_READWRITE; 6806 6807 volume_alsa_control_mute.put = volume_alsa_mute_put; 6808 volume_alsa_control_mute.access = 6809 SNDRV_CTL_ELEM_ACCESS_READWRITE; 6810 } 6811 6812 if (!tp_features.mixer_no_level_control) { 6813 ctl_vol = snd_ctl_new1(&volume_alsa_control_vol, NULL); 6814 rc = snd_ctl_add(card, ctl_vol); 6815 if (rc < 0) { 6816 pr_err("Failed to create ALSA volume control: %d\n", 6817 rc); 6818 goto err_exit; 6819 } 6820 data->ctl_vol_id = &ctl_vol->id; 6821 } 6822 6823 ctl_mute = snd_ctl_new1(&volume_alsa_control_mute, NULL); 6824 rc = snd_ctl_add(card, ctl_mute); 6825 if (rc < 0) { 6826 pr_err("Failed to create ALSA mute control: %d\n", rc); 6827 goto err_exit; 6828 } 6829 data->ctl_mute_id = &ctl_mute->id; 6830 6831 snd_card_set_dev(card, &tpacpi_pdev->dev); 6832 rc = snd_card_register(card); 6833 if (rc < 0) { 6834 pr_err("Failed to register ALSA card: %d\n", rc); 6835 goto err_exit; 6836 } 6837 6838 alsa_card = card; 6839 return 0; 6840 6841 err_exit: 6842 snd_card_free(card); 6843 return 1; 6844 } 6845 6846 #define TPACPI_VOL_Q_MUTEONLY 0x0001 /* Mute-only control available */ 6847 #define TPACPI_VOL_Q_LEVEL 0x0002 /* Volume control available */ 6848 6849 static const struct tpacpi_quirk volume_quirk_table[] __initconst = { 6850 /* Whitelist volume level on all IBM by default */ 6851 { .vendor = PCI_VENDOR_ID_IBM, 6852 .bios = TPACPI_MATCH_ANY, 6853 .ec = TPACPI_MATCH_ANY, 6854 .quirks = TPACPI_VOL_Q_LEVEL }, 6855 6856 /* Lenovo models with volume control (needs confirmation) */ 6857 TPACPI_QEC_LNV('7', 'C', TPACPI_VOL_Q_LEVEL), /* R60/i */ 6858 TPACPI_QEC_LNV('7', 'E', TPACPI_VOL_Q_LEVEL), /* R60e/i */ 6859 TPACPI_QEC_LNV('7', '9', TPACPI_VOL_Q_LEVEL), /* T60/p */ 6860 TPACPI_QEC_LNV('7', 'B', TPACPI_VOL_Q_LEVEL), /* X60/s */ 6861 TPACPI_QEC_LNV('7', 'J', TPACPI_VOL_Q_LEVEL), /* X60t */ 6862 TPACPI_QEC_LNV('7', '7', TPACPI_VOL_Q_LEVEL), /* Z60 */ 6863 TPACPI_QEC_LNV('7', 'F', TPACPI_VOL_Q_LEVEL), /* Z61 */ 6864 6865 /* Whitelist mute-only on all Lenovo by default */ 6866 { .vendor = PCI_VENDOR_ID_LENOVO, 6867 .bios = TPACPI_MATCH_ANY, 6868 .ec = TPACPI_MATCH_ANY, 6869 .quirks = TPACPI_VOL_Q_MUTEONLY } 6870 }; 6871 6872 static int __init volume_init(struct ibm_init_struct *iibm) 6873 { 6874 unsigned long quirks; 6875 int rc; 6876 6877 vdbg_printk(TPACPI_DBG_INIT, "initializing volume subdriver\n"); 6878 6879 mutex_init(&volume_mutex); 6880 6881 /* 6882 * Check for module parameter bogosity, note that we 6883 * init volume_mode to TPACPI_VOL_MODE_MAX in order to be 6884 * able to detect "unspecified" 6885 */ 6886 if (volume_mode > TPACPI_VOL_MODE_MAX) 6887 return -EINVAL; 6888 6889 if (volume_mode == TPACPI_VOL_MODE_UCMS_STEP) { 6890 pr_err("UCMS step volume mode not implemented, " 6891 "please contact %s\n", TPACPI_MAIL); 6892 return 1; 6893 } 6894 6895 if (volume_capabilities >= TPACPI_VOL_CAP_MAX) 6896 return -EINVAL; 6897 6898 /* 6899 * The ALSA mixer is our primary interface. 6900 * When disabled, don't install the subdriver at all 6901 */ 6902 if (!alsa_enable) { 6903 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER, 6904 "ALSA mixer disabled by parameter, " 6905 "not loading volume subdriver...\n"); 6906 return 1; 6907 } 6908 6909 quirks = tpacpi_check_quirks(volume_quirk_table, 6910 ARRAY_SIZE(volume_quirk_table)); 6911 6912 switch (volume_capabilities) { 6913 case TPACPI_VOL_CAP_AUTO: 6914 if (quirks & TPACPI_VOL_Q_MUTEONLY) 6915 tp_features.mixer_no_level_control = 1; 6916 else if (quirks & TPACPI_VOL_Q_LEVEL) 6917 tp_features.mixer_no_level_control = 0; 6918 else 6919 return 1; /* no mixer */ 6920 break; 6921 case TPACPI_VOL_CAP_VOLMUTE: 6922 tp_features.mixer_no_level_control = 0; 6923 break; 6924 case TPACPI_VOL_CAP_MUTEONLY: 6925 tp_features.mixer_no_level_control = 1; 6926 break; 6927 default: 6928 return 1; 6929 } 6930 6931 if (volume_capabilities != TPACPI_VOL_CAP_AUTO) 6932 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER, 6933 "using user-supplied volume_capabilities=%d\n", 6934 volume_capabilities); 6935 6936 if (volume_mode == TPACPI_VOL_MODE_AUTO || 6937 volume_mode == TPACPI_VOL_MODE_MAX) { 6938 volume_mode = TPACPI_VOL_MODE_ECNVRAM; 6939 6940 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER, 6941 "driver auto-selected volume_mode=%d\n", 6942 volume_mode); 6943 } else { 6944 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER, 6945 "using user-supplied volume_mode=%d\n", 6946 volume_mode); 6947 } 6948 6949 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER, 6950 "mute is supported, volume control is %s\n", 6951 str_supported(!tp_features.mixer_no_level_control)); 6952 6953 rc = volume_create_alsa_mixer(); 6954 if (rc) { 6955 pr_err("Could not create the ALSA mixer interface\n"); 6956 return rc; 6957 } 6958 6959 pr_info("Console audio control enabled, mode: %s\n", 6960 (volume_control_allowed) ? 6961 "override (read/write)" : 6962 "monitor (read only)"); 6963 6964 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER, 6965 "registering volume hotkeys as change notification\n"); 6966 tpacpi_hotkey_driver_mask_set(hotkey_driver_mask 6967 | TP_ACPI_HKEY_VOLUP_MASK 6968 | TP_ACPI_HKEY_VOLDWN_MASK 6969 | TP_ACPI_HKEY_MUTE_MASK); 6970 6971 return 0; 6972 } 6973 6974 static int volume_read(struct seq_file *m) 6975 { 6976 u8 status; 6977 6978 if (volume_get_status(&status) < 0) { 6979 seq_printf(m, "level:\t\tunreadable\n"); 6980 } else { 6981 if (tp_features.mixer_no_level_control) 6982 seq_printf(m, "level:\t\tunsupported\n"); 6983 else 6984 seq_printf(m, "level:\t\t%d\n", 6985 status & TP_EC_AUDIO_LVL_MSK); 6986 6987 seq_printf(m, "mute:\t\t%s\n", 6988 onoff(status, TP_EC_AUDIO_MUTESW)); 6989 6990 if (volume_control_allowed) { 6991 seq_printf(m, "commands:\tunmute, mute\n"); 6992 if (!tp_features.mixer_no_level_control) { 6993 seq_printf(m, 6994 "commands:\tup, down\n"); 6995 seq_printf(m, 6996 "commands:\tlevel <level>" 6997 " (<level> is 0-%d)\n", 6998 TP_EC_VOLUME_MAX); 6999 } 7000 } 7001 } 7002 7003 return 0; 7004 } 7005 7006 static int volume_write(char *buf) 7007 { 7008 u8 s; 7009 u8 new_level, new_mute; 7010 int l; 7011 char *cmd; 7012 int rc; 7013 7014 /* 7015 * We do allow volume control at driver startup, so that the 7016 * user can set initial state through the volume=... parameter hack. 7017 */ 7018 if (!volume_control_allowed && tpacpi_lifecycle != TPACPI_LIFE_INIT) { 7019 if (unlikely(!tp_warned.volume_ctrl_forbidden)) { 7020 tp_warned.volume_ctrl_forbidden = 1; 7021 pr_notice("Console audio control in monitor mode, " 7022 "changes are not allowed\n"); 7023 pr_notice("Use the volume_control=1 module parameter " 7024 "to enable volume control\n"); 7025 } 7026 return -EPERM; 7027 } 7028 7029 rc = volume_get_status(&s); 7030 if (rc < 0) 7031 return rc; 7032 7033 new_level = s & TP_EC_AUDIO_LVL_MSK; 7034 new_mute = s & TP_EC_AUDIO_MUTESW_MSK; 7035 7036 while ((cmd = next_cmd(&buf))) { 7037 if (!tp_features.mixer_no_level_control) { 7038 if (strlencmp(cmd, "up") == 0) { 7039 if (new_mute) 7040 new_mute = 0; 7041 else if (new_level < TP_EC_VOLUME_MAX) 7042 new_level++; 7043 continue; 7044 } else if (strlencmp(cmd, "down") == 0) { 7045 if (new_mute) 7046 new_mute = 0; 7047 else if (new_level > 0) 7048 new_level--; 7049 continue; 7050 } else if (sscanf(cmd, "level %u", &l) == 1 && 7051 l >= 0 && l <= TP_EC_VOLUME_MAX) { 7052 new_level = l; 7053 continue; 7054 } 7055 } 7056 if (strlencmp(cmd, "mute") == 0) 7057 new_mute = TP_EC_AUDIO_MUTESW_MSK; 7058 else if (strlencmp(cmd, "unmute") == 0) 7059 new_mute = 0; 7060 else 7061 return -EINVAL; 7062 } 7063 7064 if (tp_features.mixer_no_level_control) { 7065 tpacpi_disclose_usertask("procfs volume", "%smute\n", 7066 new_mute ? "" : "un"); 7067 rc = volume_set_mute(!!new_mute); 7068 } else { 7069 tpacpi_disclose_usertask("procfs volume", 7070 "%smute and set level to %d\n", 7071 new_mute ? "" : "un", new_level); 7072 rc = volume_set_status(new_mute | new_level); 7073 } 7074 volume_alsa_notify_change(); 7075 7076 return (rc == -EINTR) ? -ERESTARTSYS : rc; 7077 } 7078 7079 static struct ibm_struct volume_driver_data = { 7080 .name = "volume", 7081 .read = volume_read, 7082 .write = volume_write, 7083 .exit = volume_exit, 7084 .suspend = volume_suspend, 7085 .resume = volume_resume, 7086 .shutdown = volume_shutdown, 7087 }; 7088 7089 #else /* !CONFIG_THINKPAD_ACPI_ALSA_SUPPORT */ 7090 7091 #define alsa_card NULL 7092 7093 static void inline volume_alsa_notify_change(void) 7094 { 7095 } 7096 7097 static int __init volume_init(struct ibm_init_struct *iibm) 7098 { 7099 pr_info("volume: disabled as there is no ALSA support in this kernel\n"); 7100 7101 return 1; 7102 } 7103 7104 static struct ibm_struct volume_driver_data = { 7105 .name = "volume", 7106 }; 7107 7108 #endif /* CONFIG_THINKPAD_ACPI_ALSA_SUPPORT */ 7109 7110 /************************************************************************* 7111 * Fan subdriver 7112 */ 7113 7114 /* 7115 * FAN ACCESS MODES 7116 * 7117 * TPACPI_FAN_RD_ACPI_GFAN: 7118 * ACPI GFAN method: returns fan level 7119 * 7120 * see TPACPI_FAN_WR_ACPI_SFAN 7121 * EC 0x2f (HFSP) not available if GFAN exists 7122 * 7123 * TPACPI_FAN_WR_ACPI_SFAN: 7124 * ACPI SFAN method: sets fan level, 0 (stop) to 7 (max) 7125 * 7126 * EC 0x2f (HFSP) might be available *for reading*, but do not use 7127 * it for writing. 7128 * 7129 * TPACPI_FAN_WR_TPEC: 7130 * ThinkPad EC register 0x2f (HFSP): fan control loop mode 7131 * Supported on almost all ThinkPads 7132 * 7133 * Fan speed changes of any sort (including those caused by the 7134 * disengaged mode) are usually done slowly by the firmware as the 7135 * maximum amount of fan duty cycle change per second seems to be 7136 * limited. 7137 * 7138 * Reading is not available if GFAN exists. 7139 * Writing is not available if SFAN exists. 7140 * 7141 * Bits 7142 * 7 automatic mode engaged; 7143 * (default operation mode of the ThinkPad) 7144 * fan level is ignored in this mode. 7145 * 6 full speed mode (takes precedence over bit 7); 7146 * not available on all thinkpads. May disable 7147 * the tachometer while the fan controller ramps up 7148 * the speed (which can take up to a few *minutes*). 7149 * Speeds up fan to 100% duty-cycle, which is far above 7150 * the standard RPM levels. It is not impossible that 7151 * it could cause hardware damage. 7152 * 5-3 unused in some models. Extra bits for fan level 7153 * in others, but still useless as all values above 7154 * 7 map to the same speed as level 7 in these models. 7155 * 2-0 fan level (0..7 usually) 7156 * 0x00 = stop 7157 * 0x07 = max (set when temperatures critical) 7158 * Some ThinkPads may have other levels, see 7159 * TPACPI_FAN_WR_ACPI_FANS (X31/X40/X41) 7160 * 7161 * FIRMWARE BUG: on some models, EC 0x2f might not be initialized at 7162 * boot. Apparently the EC does not initialize it, so unless ACPI DSDT 7163 * does so, its initial value is meaningless (0x07). 7164 * 7165 * For firmware bugs, refer to: 7166 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues 7167 * 7168 * ---- 7169 * 7170 * ThinkPad EC register 0x84 (LSB), 0x85 (MSB): 7171 * Main fan tachometer reading (in RPM) 7172 * 7173 * This register is present on all ThinkPads with a new-style EC, and 7174 * it is known not to be present on the A21m/e, and T22, as there is 7175 * something else in offset 0x84 according to the ACPI DSDT. Other 7176 * ThinkPads from this same time period (and earlier) probably lack the 7177 * tachometer as well. 7178 * 7179 * Unfortunately a lot of ThinkPads with new-style ECs but whose firmware 7180 * was never fixed by IBM to report the EC firmware version string 7181 * probably support the tachometer (like the early X models), so 7182 * detecting it is quite hard. We need more data to know for sure. 7183 * 7184 * FIRMWARE BUG: always read 0x84 first, otherwise incorrect readings 7185 * might result. 7186 * 7187 * FIRMWARE BUG: may go stale while the EC is switching to full speed 7188 * mode. 7189 * 7190 * For firmware bugs, refer to: 7191 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues 7192 * 7193 * ---- 7194 * 7195 * ThinkPad EC register 0x31 bit 0 (only on select models) 7196 * 7197 * When bit 0 of EC register 0x31 is zero, the tachometer registers 7198 * show the speed of the main fan. When bit 0 of EC register 0x31 7199 * is one, the tachometer registers show the speed of the auxiliary 7200 * fan. 7201 * 7202 * Fan control seems to affect both fans, regardless of the state 7203 * of this bit. 7204 * 7205 * So far, only the firmware for the X60/X61 non-tablet versions 7206 * seem to support this (firmware TP-7M). 7207 * 7208 * TPACPI_FAN_WR_ACPI_FANS: 7209 * ThinkPad X31, X40, X41. Not available in the X60. 7210 * 7211 * FANS ACPI handle: takes three arguments: low speed, medium speed, 7212 * high speed. ACPI DSDT seems to map these three speeds to levels 7213 * as follows: STOP LOW LOW MED MED HIGH HIGH HIGH HIGH 7214 * (this map is stored on FAN0..FAN8 as "0,1,1,2,2,3,3,3,3") 7215 * 7216 * The speeds are stored on handles 7217 * (FANA:FAN9), (FANC:FANB), (FANE:FAND). 7218 * 7219 * There are three default speed sets, accessible as handles: 7220 * FS1L,FS1M,FS1H; FS2L,FS2M,FS2H; FS3L,FS3M,FS3H 7221 * 7222 * ACPI DSDT switches which set is in use depending on various 7223 * factors. 7224 * 7225 * TPACPI_FAN_WR_TPEC is also available and should be used to 7226 * command the fan. The X31/X40/X41 seems to have 8 fan levels, 7227 * but the ACPI tables just mention level 7. 7228 */ 7229 7230 enum { /* Fan control constants */ 7231 fan_status_offset = 0x2f, /* EC register 0x2f */ 7232 fan_rpm_offset = 0x84, /* EC register 0x84: LSB, 0x85 MSB (RPM) 7233 * 0x84 must be read before 0x85 */ 7234 fan_select_offset = 0x31, /* EC register 0x31 (Firmware 7M) 7235 bit 0 selects which fan is active */ 7236 7237 TP_EC_FAN_FULLSPEED = 0x40, /* EC fan mode: full speed */ 7238 TP_EC_FAN_AUTO = 0x80, /* EC fan mode: auto fan control */ 7239 7240 TPACPI_FAN_LAST_LEVEL = 0x100, /* Use cached last-seen fan level */ 7241 }; 7242 7243 enum fan_status_access_mode { 7244 TPACPI_FAN_NONE = 0, /* No fan status or control */ 7245 TPACPI_FAN_RD_ACPI_GFAN, /* Use ACPI GFAN */ 7246 TPACPI_FAN_RD_TPEC, /* Use ACPI EC regs 0x2f, 0x84-0x85 */ 7247 }; 7248 7249 enum fan_control_access_mode { 7250 TPACPI_FAN_WR_NONE = 0, /* No fan control */ 7251 TPACPI_FAN_WR_ACPI_SFAN, /* Use ACPI SFAN */ 7252 TPACPI_FAN_WR_TPEC, /* Use ACPI EC reg 0x2f */ 7253 TPACPI_FAN_WR_ACPI_FANS, /* Use ACPI FANS and EC reg 0x2f */ 7254 }; 7255 7256 enum fan_control_commands { 7257 TPACPI_FAN_CMD_SPEED = 0x0001, /* speed command */ 7258 TPACPI_FAN_CMD_LEVEL = 0x0002, /* level command */ 7259 TPACPI_FAN_CMD_ENABLE = 0x0004, /* enable/disable cmd, 7260 * and also watchdog cmd */ 7261 }; 7262 7263 static bool fan_control_allowed; 7264 7265 static enum fan_status_access_mode fan_status_access_mode; 7266 static enum fan_control_access_mode fan_control_access_mode; 7267 static enum fan_control_commands fan_control_commands; 7268 7269 static u8 fan_control_initial_status; 7270 static u8 fan_control_desired_level; 7271 static u8 fan_control_resume_level; 7272 static int fan_watchdog_maxinterval; 7273 7274 static struct mutex fan_mutex; 7275 7276 static void fan_watchdog_fire(struct work_struct *ignored); 7277 static DECLARE_DELAYED_WORK(fan_watchdog_task, fan_watchdog_fire); 7278 7279 TPACPI_HANDLE(fans, ec, "FANS"); /* X31, X40, X41 */ 7280 TPACPI_HANDLE(gfan, ec, "GFAN", /* 570 */ 7281 "\\FSPD", /* 600e/x, 770e, 770x */ 7282 ); /* all others */ 7283 TPACPI_HANDLE(sfan, ec, "SFAN", /* 570 */ 7284 "JFNS", /* 770x-JL */ 7285 ); /* all others */ 7286 7287 /* 7288 * Unitialized HFSP quirk: ACPI DSDT and EC fail to initialize the 7289 * HFSP register at boot, so it contains 0x07 but the Thinkpad could 7290 * be in auto mode (0x80). 7291 * 7292 * This is corrected by any write to HFSP either by the driver, or 7293 * by the firmware. 7294 * 7295 * We assume 0x07 really means auto mode while this quirk is active, 7296 * as this is far more likely than the ThinkPad being in level 7, 7297 * which is only used by the firmware during thermal emergencies. 7298 * 7299 * Enable for TP-1Y (T43), TP-78 (R51e), TP-76 (R52), 7300 * TP-70 (T43, R52), which are known to be buggy. 7301 */ 7302 7303 static void fan_quirk1_setup(void) 7304 { 7305 if (fan_control_initial_status == 0x07) { 7306 pr_notice("fan_init: initial fan status is unknown, " 7307 "assuming it is in auto mode\n"); 7308 tp_features.fan_ctrl_status_undef = 1; 7309 } 7310 } 7311 7312 static void fan_quirk1_handle(u8 *fan_status) 7313 { 7314 if (unlikely(tp_features.fan_ctrl_status_undef)) { 7315 if (*fan_status != fan_control_initial_status) { 7316 /* something changed the HFSP regisnter since 7317 * driver init time, so it is not undefined 7318 * anymore */ 7319 tp_features.fan_ctrl_status_undef = 0; 7320 } else { 7321 /* Return most likely status. In fact, it 7322 * might be the only possible status */ 7323 *fan_status = TP_EC_FAN_AUTO; 7324 } 7325 } 7326 } 7327 7328 /* Select main fan on X60/X61, NOOP on others */ 7329 static bool fan_select_fan1(void) 7330 { 7331 if (tp_features.second_fan) { 7332 u8 val; 7333 7334 if (ec_read(fan_select_offset, &val) < 0) 7335 return false; 7336 val &= 0xFEU; 7337 if (ec_write(fan_select_offset, val) < 0) 7338 return false; 7339 } 7340 return true; 7341 } 7342 7343 /* Select secondary fan on X60/X61 */ 7344 static bool fan_select_fan2(void) 7345 { 7346 u8 val; 7347 7348 if (!tp_features.second_fan) 7349 return false; 7350 7351 if (ec_read(fan_select_offset, &val) < 0) 7352 return false; 7353 val |= 0x01U; 7354 if (ec_write(fan_select_offset, val) < 0) 7355 return false; 7356 7357 return true; 7358 } 7359 7360 /* 7361 * Call with fan_mutex held 7362 */ 7363 static void fan_update_desired_level(u8 status) 7364 { 7365 if ((status & 7366 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) { 7367 if (status > 7) 7368 fan_control_desired_level = 7; 7369 else 7370 fan_control_desired_level = status; 7371 } 7372 } 7373 7374 static int fan_get_status(u8 *status) 7375 { 7376 u8 s; 7377 7378 /* TODO: 7379 * Add TPACPI_FAN_RD_ACPI_FANS ? */ 7380 7381 switch (fan_status_access_mode) { 7382 case TPACPI_FAN_RD_ACPI_GFAN: { 7383 /* 570, 600e/x, 770e, 770x */ 7384 int res; 7385 7386 if (unlikely(!acpi_evalf(gfan_handle, &res, NULL, "d"))) 7387 return -EIO; 7388 7389 if (likely(status)) 7390 *status = res & 0x07; 7391 7392 break; 7393 } 7394 case TPACPI_FAN_RD_TPEC: 7395 /* all except 570, 600e/x, 770e, 770x */ 7396 if (unlikely(!acpi_ec_read(fan_status_offset, &s))) 7397 return -EIO; 7398 7399 if (likely(status)) { 7400 *status = s; 7401 fan_quirk1_handle(status); 7402 } 7403 7404 break; 7405 7406 default: 7407 return -ENXIO; 7408 } 7409 7410 return 0; 7411 } 7412 7413 static int fan_get_status_safe(u8 *status) 7414 { 7415 int rc; 7416 u8 s; 7417 7418 if (mutex_lock_killable(&fan_mutex)) 7419 return -ERESTARTSYS; 7420 rc = fan_get_status(&s); 7421 if (!rc) 7422 fan_update_desired_level(s); 7423 mutex_unlock(&fan_mutex); 7424 7425 if (status) 7426 *status = s; 7427 7428 return rc; 7429 } 7430 7431 static int fan_get_speed(unsigned int *speed) 7432 { 7433 u8 hi, lo; 7434 7435 switch (fan_status_access_mode) { 7436 case TPACPI_FAN_RD_TPEC: 7437 /* all except 570, 600e/x, 770e, 770x */ 7438 if (unlikely(!fan_select_fan1())) 7439 return -EIO; 7440 if (unlikely(!acpi_ec_read(fan_rpm_offset, &lo) || 7441 !acpi_ec_read(fan_rpm_offset + 1, &hi))) 7442 return -EIO; 7443 7444 if (likely(speed)) 7445 *speed = (hi << 8) | lo; 7446 7447 break; 7448 7449 default: 7450 return -ENXIO; 7451 } 7452 7453 return 0; 7454 } 7455 7456 static int fan2_get_speed(unsigned int *speed) 7457 { 7458 u8 hi, lo; 7459 bool rc; 7460 7461 switch (fan_status_access_mode) { 7462 case TPACPI_FAN_RD_TPEC: 7463 /* all except 570, 600e/x, 770e, 770x */ 7464 if (unlikely(!fan_select_fan2())) 7465 return -EIO; 7466 rc = !acpi_ec_read(fan_rpm_offset, &lo) || 7467 !acpi_ec_read(fan_rpm_offset + 1, &hi); 7468 fan_select_fan1(); /* play it safe */ 7469 if (rc) 7470 return -EIO; 7471 7472 if (likely(speed)) 7473 *speed = (hi << 8) | lo; 7474 7475 break; 7476 7477 default: 7478 return -ENXIO; 7479 } 7480 7481 return 0; 7482 } 7483 7484 static int fan_set_level(int level) 7485 { 7486 if (!fan_control_allowed) 7487 return -EPERM; 7488 7489 switch (fan_control_access_mode) { 7490 case TPACPI_FAN_WR_ACPI_SFAN: 7491 if (level >= 0 && level <= 7) { 7492 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", level)) 7493 return -EIO; 7494 } else 7495 return -EINVAL; 7496 break; 7497 7498 case TPACPI_FAN_WR_ACPI_FANS: 7499 case TPACPI_FAN_WR_TPEC: 7500 if (!(level & TP_EC_FAN_AUTO) && 7501 !(level & TP_EC_FAN_FULLSPEED) && 7502 ((level < 0) || (level > 7))) 7503 return -EINVAL; 7504 7505 /* safety net should the EC not support AUTO 7506 * or FULLSPEED mode bits and just ignore them */ 7507 if (level & TP_EC_FAN_FULLSPEED) 7508 level |= 7; /* safety min speed 7 */ 7509 else if (level & TP_EC_FAN_AUTO) 7510 level |= 4; /* safety min speed 4 */ 7511 7512 if (!acpi_ec_write(fan_status_offset, level)) 7513 return -EIO; 7514 else 7515 tp_features.fan_ctrl_status_undef = 0; 7516 break; 7517 7518 default: 7519 return -ENXIO; 7520 } 7521 7522 vdbg_printk(TPACPI_DBG_FAN, 7523 "fan control: set fan control register to 0x%02x\n", level); 7524 return 0; 7525 } 7526 7527 static int fan_set_level_safe(int level) 7528 { 7529 int rc; 7530 7531 if (!fan_control_allowed) 7532 return -EPERM; 7533 7534 if (mutex_lock_killable(&fan_mutex)) 7535 return -ERESTARTSYS; 7536 7537 if (level == TPACPI_FAN_LAST_LEVEL) 7538 level = fan_control_desired_level; 7539 7540 rc = fan_set_level(level); 7541 if (!rc) 7542 fan_update_desired_level(level); 7543 7544 mutex_unlock(&fan_mutex); 7545 return rc; 7546 } 7547 7548 static int fan_set_enable(void) 7549 { 7550 u8 s; 7551 int rc; 7552 7553 if (!fan_control_allowed) 7554 return -EPERM; 7555 7556 if (mutex_lock_killable(&fan_mutex)) 7557 return -ERESTARTSYS; 7558 7559 switch (fan_control_access_mode) { 7560 case TPACPI_FAN_WR_ACPI_FANS: 7561 case TPACPI_FAN_WR_TPEC: 7562 rc = fan_get_status(&s); 7563 if (rc < 0) 7564 break; 7565 7566 /* Don't go out of emergency fan mode */ 7567 if (s != 7) { 7568 s &= 0x07; 7569 s |= TP_EC_FAN_AUTO | 4; /* min fan speed 4 */ 7570 } 7571 7572 if (!acpi_ec_write(fan_status_offset, s)) 7573 rc = -EIO; 7574 else { 7575 tp_features.fan_ctrl_status_undef = 0; 7576 rc = 0; 7577 } 7578 break; 7579 7580 case TPACPI_FAN_WR_ACPI_SFAN: 7581 rc = fan_get_status(&s); 7582 if (rc < 0) 7583 break; 7584 7585 s &= 0x07; 7586 7587 /* Set fan to at least level 4 */ 7588 s |= 4; 7589 7590 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", s)) 7591 rc = -EIO; 7592 else 7593 rc = 0; 7594 break; 7595 7596 default: 7597 rc = -ENXIO; 7598 } 7599 7600 mutex_unlock(&fan_mutex); 7601 7602 if (!rc) 7603 vdbg_printk(TPACPI_DBG_FAN, 7604 "fan control: set fan control register to 0x%02x\n", 7605 s); 7606 return rc; 7607 } 7608 7609 static int fan_set_disable(void) 7610 { 7611 int rc; 7612 7613 if (!fan_control_allowed) 7614 return -EPERM; 7615 7616 if (mutex_lock_killable(&fan_mutex)) 7617 return -ERESTARTSYS; 7618 7619 rc = 0; 7620 switch (fan_control_access_mode) { 7621 case TPACPI_FAN_WR_ACPI_FANS: 7622 case TPACPI_FAN_WR_TPEC: 7623 if (!acpi_ec_write(fan_status_offset, 0x00)) 7624 rc = -EIO; 7625 else { 7626 fan_control_desired_level = 0; 7627 tp_features.fan_ctrl_status_undef = 0; 7628 } 7629 break; 7630 7631 case TPACPI_FAN_WR_ACPI_SFAN: 7632 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", 0x00)) 7633 rc = -EIO; 7634 else 7635 fan_control_desired_level = 0; 7636 break; 7637 7638 default: 7639 rc = -ENXIO; 7640 } 7641 7642 if (!rc) 7643 vdbg_printk(TPACPI_DBG_FAN, 7644 "fan control: set fan control register to 0\n"); 7645 7646 mutex_unlock(&fan_mutex); 7647 return rc; 7648 } 7649 7650 static int fan_set_speed(int speed) 7651 { 7652 int rc; 7653 7654 if (!fan_control_allowed) 7655 return -EPERM; 7656 7657 if (mutex_lock_killable(&fan_mutex)) 7658 return -ERESTARTSYS; 7659 7660 rc = 0; 7661 switch (fan_control_access_mode) { 7662 case TPACPI_FAN_WR_ACPI_FANS: 7663 if (speed >= 0 && speed <= 65535) { 7664 if (!acpi_evalf(fans_handle, NULL, NULL, "vddd", 7665 speed, speed, speed)) 7666 rc = -EIO; 7667 } else 7668 rc = -EINVAL; 7669 break; 7670 7671 default: 7672 rc = -ENXIO; 7673 } 7674 7675 mutex_unlock(&fan_mutex); 7676 return rc; 7677 } 7678 7679 static void fan_watchdog_reset(void) 7680 { 7681 if (fan_control_access_mode == TPACPI_FAN_WR_NONE) 7682 return; 7683 7684 if (fan_watchdog_maxinterval > 0 && 7685 tpacpi_lifecycle != TPACPI_LIFE_EXITING) 7686 mod_delayed_work(tpacpi_wq, &fan_watchdog_task, 7687 msecs_to_jiffies(fan_watchdog_maxinterval * 1000)); 7688 else 7689 cancel_delayed_work(&fan_watchdog_task); 7690 } 7691 7692 static void fan_watchdog_fire(struct work_struct *ignored) 7693 { 7694 int rc; 7695 7696 if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING) 7697 return; 7698 7699 pr_notice("fan watchdog: enabling fan\n"); 7700 rc = fan_set_enable(); 7701 if (rc < 0) { 7702 pr_err("fan watchdog: error %d while enabling fan, " 7703 "will try again later...\n", -rc); 7704 /* reschedule for later */ 7705 fan_watchdog_reset(); 7706 } 7707 } 7708 7709 /* 7710 * SYSFS fan layout: hwmon compatible (device) 7711 * 7712 * pwm*_enable: 7713 * 0: "disengaged" mode 7714 * 1: manual mode 7715 * 2: native EC "auto" mode (recommended, hardware default) 7716 * 7717 * pwm*: set speed in manual mode, ignored otherwise. 7718 * 0 is level 0; 255 is level 7. Intermediate points done with linear 7719 * interpolation. 7720 * 7721 * fan*_input: tachometer reading, RPM 7722 * 7723 * 7724 * SYSFS fan layout: extensions 7725 * 7726 * fan_watchdog (driver): 7727 * fan watchdog interval in seconds, 0 disables (default), max 120 7728 */ 7729 7730 /* sysfs fan pwm1_enable ----------------------------------------------- */ 7731 static ssize_t fan_pwm1_enable_show(struct device *dev, 7732 struct device_attribute *attr, 7733 char *buf) 7734 { 7735 int res, mode; 7736 u8 status; 7737 7738 res = fan_get_status_safe(&status); 7739 if (res) 7740 return res; 7741 7742 if (status & TP_EC_FAN_FULLSPEED) { 7743 mode = 0; 7744 } else if (status & TP_EC_FAN_AUTO) { 7745 mode = 2; 7746 } else 7747 mode = 1; 7748 7749 return snprintf(buf, PAGE_SIZE, "%d\n", mode); 7750 } 7751 7752 static ssize_t fan_pwm1_enable_store(struct device *dev, 7753 struct device_attribute *attr, 7754 const char *buf, size_t count) 7755 { 7756 unsigned long t; 7757 int res, level; 7758 7759 if (parse_strtoul(buf, 2, &t)) 7760 return -EINVAL; 7761 7762 tpacpi_disclose_usertask("hwmon pwm1_enable", 7763 "set fan mode to %lu\n", t); 7764 7765 switch (t) { 7766 case 0: 7767 level = TP_EC_FAN_FULLSPEED; 7768 break; 7769 case 1: 7770 level = TPACPI_FAN_LAST_LEVEL; 7771 break; 7772 case 2: 7773 level = TP_EC_FAN_AUTO; 7774 break; 7775 case 3: 7776 /* reserved for software-controlled auto mode */ 7777 return -ENOSYS; 7778 default: 7779 return -EINVAL; 7780 } 7781 7782 res = fan_set_level_safe(level); 7783 if (res == -ENXIO) 7784 return -EINVAL; 7785 else if (res < 0) 7786 return res; 7787 7788 fan_watchdog_reset(); 7789 7790 return count; 7791 } 7792 7793 static struct device_attribute dev_attr_fan_pwm1_enable = 7794 __ATTR(pwm1_enable, S_IWUSR | S_IRUGO, 7795 fan_pwm1_enable_show, fan_pwm1_enable_store); 7796 7797 /* sysfs fan pwm1 ------------------------------------------------------ */ 7798 static ssize_t fan_pwm1_show(struct device *dev, 7799 struct device_attribute *attr, 7800 char *buf) 7801 { 7802 int res; 7803 u8 status; 7804 7805 res = fan_get_status_safe(&status); 7806 if (res) 7807 return res; 7808 7809 if ((status & 7810 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) != 0) 7811 status = fan_control_desired_level; 7812 7813 if (status > 7) 7814 status = 7; 7815 7816 return snprintf(buf, PAGE_SIZE, "%u\n", (status * 255) / 7); 7817 } 7818 7819 static ssize_t fan_pwm1_store(struct device *dev, 7820 struct device_attribute *attr, 7821 const char *buf, size_t count) 7822 { 7823 unsigned long s; 7824 int rc; 7825 u8 status, newlevel; 7826 7827 if (parse_strtoul(buf, 255, &s)) 7828 return -EINVAL; 7829 7830 tpacpi_disclose_usertask("hwmon pwm1", 7831 "set fan speed to %lu\n", s); 7832 7833 /* scale down from 0-255 to 0-7 */ 7834 newlevel = (s >> 5) & 0x07; 7835 7836 if (mutex_lock_killable(&fan_mutex)) 7837 return -ERESTARTSYS; 7838 7839 rc = fan_get_status(&status); 7840 if (!rc && (status & 7841 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) { 7842 rc = fan_set_level(newlevel); 7843 if (rc == -ENXIO) 7844 rc = -EINVAL; 7845 else if (!rc) { 7846 fan_update_desired_level(newlevel); 7847 fan_watchdog_reset(); 7848 } 7849 } 7850 7851 mutex_unlock(&fan_mutex); 7852 return (rc)? rc : count; 7853 } 7854 7855 static struct device_attribute dev_attr_fan_pwm1 = 7856 __ATTR(pwm1, S_IWUSR | S_IRUGO, 7857 fan_pwm1_show, fan_pwm1_store); 7858 7859 /* sysfs fan fan1_input ------------------------------------------------ */ 7860 static ssize_t fan_fan1_input_show(struct device *dev, 7861 struct device_attribute *attr, 7862 char *buf) 7863 { 7864 int res; 7865 unsigned int speed; 7866 7867 res = fan_get_speed(&speed); 7868 if (res < 0) 7869 return res; 7870 7871 return snprintf(buf, PAGE_SIZE, "%u\n", speed); 7872 } 7873 7874 static struct device_attribute dev_attr_fan_fan1_input = 7875 __ATTR(fan1_input, S_IRUGO, 7876 fan_fan1_input_show, NULL); 7877 7878 /* sysfs fan fan2_input ------------------------------------------------ */ 7879 static ssize_t fan_fan2_input_show(struct device *dev, 7880 struct device_attribute *attr, 7881 char *buf) 7882 { 7883 int res; 7884 unsigned int speed; 7885 7886 res = fan2_get_speed(&speed); 7887 if (res < 0) 7888 return res; 7889 7890 return snprintf(buf, PAGE_SIZE, "%u\n", speed); 7891 } 7892 7893 static struct device_attribute dev_attr_fan_fan2_input = 7894 __ATTR(fan2_input, S_IRUGO, 7895 fan_fan2_input_show, NULL); 7896 7897 /* sysfs fan fan_watchdog (hwmon driver) ------------------------------- */ 7898 static ssize_t fan_fan_watchdog_show(struct device_driver *drv, 7899 char *buf) 7900 { 7901 return snprintf(buf, PAGE_SIZE, "%u\n", fan_watchdog_maxinterval); 7902 } 7903 7904 static ssize_t fan_fan_watchdog_store(struct device_driver *drv, 7905 const char *buf, size_t count) 7906 { 7907 unsigned long t; 7908 7909 if (parse_strtoul(buf, 120, &t)) 7910 return -EINVAL; 7911 7912 if (!fan_control_allowed) 7913 return -EPERM; 7914 7915 fan_watchdog_maxinterval = t; 7916 fan_watchdog_reset(); 7917 7918 tpacpi_disclose_usertask("fan_watchdog", "set to %lu\n", t); 7919 7920 return count; 7921 } 7922 7923 static DRIVER_ATTR(fan_watchdog, S_IWUSR | S_IRUGO, 7924 fan_fan_watchdog_show, fan_fan_watchdog_store); 7925 7926 /* --------------------------------------------------------------------- */ 7927 static struct attribute *fan_attributes[] = { 7928 &dev_attr_fan_pwm1_enable.attr, &dev_attr_fan_pwm1.attr, 7929 &dev_attr_fan_fan1_input.attr, 7930 NULL, /* for fan2_input */ 7931 NULL 7932 }; 7933 7934 static const struct attribute_group fan_attr_group = { 7935 .attrs = fan_attributes, 7936 }; 7937 7938 #define TPACPI_FAN_Q1 0x0001 /* Unitialized HFSP */ 7939 #define TPACPI_FAN_2FAN 0x0002 /* EC 0x31 bit 0 selects fan2 */ 7940 7941 #define TPACPI_FAN_QI(__id1, __id2, __quirks) \ 7942 { .vendor = PCI_VENDOR_ID_IBM, \ 7943 .bios = TPACPI_MATCH_ANY, \ 7944 .ec = TPID(__id1, __id2), \ 7945 .quirks = __quirks } 7946 7947 #define TPACPI_FAN_QL(__id1, __id2, __quirks) \ 7948 { .vendor = PCI_VENDOR_ID_LENOVO, \ 7949 .bios = TPACPI_MATCH_ANY, \ 7950 .ec = TPID(__id1, __id2), \ 7951 .quirks = __quirks } 7952 7953 static const struct tpacpi_quirk fan_quirk_table[] __initconst = { 7954 TPACPI_FAN_QI('1', 'Y', TPACPI_FAN_Q1), 7955 TPACPI_FAN_QI('7', '8', TPACPI_FAN_Q1), 7956 TPACPI_FAN_QI('7', '6', TPACPI_FAN_Q1), 7957 TPACPI_FAN_QI('7', '0', TPACPI_FAN_Q1), 7958 TPACPI_FAN_QL('7', 'M', TPACPI_FAN_2FAN), 7959 }; 7960 7961 #undef TPACPI_FAN_QL 7962 #undef TPACPI_FAN_QI 7963 7964 static int __init fan_init(struct ibm_init_struct *iibm) 7965 { 7966 int rc; 7967 unsigned long quirks; 7968 7969 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN, 7970 "initializing fan subdriver\n"); 7971 7972 mutex_init(&fan_mutex); 7973 fan_status_access_mode = TPACPI_FAN_NONE; 7974 fan_control_access_mode = TPACPI_FAN_WR_NONE; 7975 fan_control_commands = 0; 7976 fan_watchdog_maxinterval = 0; 7977 tp_features.fan_ctrl_status_undef = 0; 7978 tp_features.second_fan = 0; 7979 fan_control_desired_level = 7; 7980 7981 if (tpacpi_is_ibm()) { 7982 TPACPI_ACPIHANDLE_INIT(fans); 7983 TPACPI_ACPIHANDLE_INIT(gfan); 7984 TPACPI_ACPIHANDLE_INIT(sfan); 7985 } 7986 7987 quirks = tpacpi_check_quirks(fan_quirk_table, 7988 ARRAY_SIZE(fan_quirk_table)); 7989 7990 if (gfan_handle) { 7991 /* 570, 600e/x, 770e, 770x */ 7992 fan_status_access_mode = TPACPI_FAN_RD_ACPI_GFAN; 7993 } else { 7994 /* all other ThinkPads: note that even old-style 7995 * ThinkPad ECs supports the fan control register */ 7996 if (likely(acpi_ec_read(fan_status_offset, 7997 &fan_control_initial_status))) { 7998 fan_status_access_mode = TPACPI_FAN_RD_TPEC; 7999 if (quirks & TPACPI_FAN_Q1) 8000 fan_quirk1_setup(); 8001 if (quirks & TPACPI_FAN_2FAN) { 8002 tp_features.second_fan = 1; 8003 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN, 8004 "secondary fan support enabled\n"); 8005 } 8006 } else { 8007 pr_err("ThinkPad ACPI EC access misbehaving, " 8008 "fan status and control unavailable\n"); 8009 return 1; 8010 } 8011 } 8012 8013 if (sfan_handle) { 8014 /* 570, 770x-JL */ 8015 fan_control_access_mode = TPACPI_FAN_WR_ACPI_SFAN; 8016 fan_control_commands |= 8017 TPACPI_FAN_CMD_LEVEL | TPACPI_FAN_CMD_ENABLE; 8018 } else { 8019 if (!gfan_handle) { 8020 /* gfan without sfan means no fan control */ 8021 /* all other models implement TP EC 0x2f control */ 8022 8023 if (fans_handle) { 8024 /* X31, X40, X41 */ 8025 fan_control_access_mode = 8026 TPACPI_FAN_WR_ACPI_FANS; 8027 fan_control_commands |= 8028 TPACPI_FAN_CMD_SPEED | 8029 TPACPI_FAN_CMD_LEVEL | 8030 TPACPI_FAN_CMD_ENABLE; 8031 } else { 8032 fan_control_access_mode = TPACPI_FAN_WR_TPEC; 8033 fan_control_commands |= 8034 TPACPI_FAN_CMD_LEVEL | 8035 TPACPI_FAN_CMD_ENABLE; 8036 } 8037 } 8038 } 8039 8040 vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN, 8041 "fan is %s, modes %d, %d\n", 8042 str_supported(fan_status_access_mode != TPACPI_FAN_NONE || 8043 fan_control_access_mode != TPACPI_FAN_WR_NONE), 8044 fan_status_access_mode, fan_control_access_mode); 8045 8046 /* fan control master switch */ 8047 if (!fan_control_allowed) { 8048 fan_control_access_mode = TPACPI_FAN_WR_NONE; 8049 fan_control_commands = 0; 8050 dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN, 8051 "fan control features disabled by parameter\n"); 8052 } 8053 8054 /* update fan_control_desired_level */ 8055 if (fan_status_access_mode != TPACPI_FAN_NONE) 8056 fan_get_status_safe(NULL); 8057 8058 if (fan_status_access_mode != TPACPI_FAN_NONE || 8059 fan_control_access_mode != TPACPI_FAN_WR_NONE) { 8060 if (tp_features.second_fan) { 8061 /* attach second fan tachometer */ 8062 fan_attributes[ARRAY_SIZE(fan_attributes)-2] = 8063 &dev_attr_fan_fan2_input.attr; 8064 } 8065 rc = sysfs_create_group(&tpacpi_sensors_pdev->dev.kobj, 8066 &fan_attr_group); 8067 if (rc < 0) 8068 return rc; 8069 8070 rc = driver_create_file(&tpacpi_hwmon_pdriver.driver, 8071 &driver_attr_fan_watchdog); 8072 if (rc < 0) { 8073 sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj, 8074 &fan_attr_group); 8075 return rc; 8076 } 8077 return 0; 8078 } else 8079 return 1; 8080 } 8081 8082 static void fan_exit(void) 8083 { 8084 vdbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_FAN, 8085 "cancelling any pending fan watchdog tasks\n"); 8086 8087 /* FIXME: can we really do this unconditionally? */ 8088 sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj, &fan_attr_group); 8089 driver_remove_file(&tpacpi_hwmon_pdriver.driver, 8090 &driver_attr_fan_watchdog); 8091 8092 cancel_delayed_work(&fan_watchdog_task); 8093 flush_workqueue(tpacpi_wq); 8094 } 8095 8096 static void fan_suspend(void) 8097 { 8098 int rc; 8099 8100 if (!fan_control_allowed) 8101 return; 8102 8103 /* Store fan status in cache */ 8104 fan_control_resume_level = 0; 8105 rc = fan_get_status_safe(&fan_control_resume_level); 8106 if (rc < 0) 8107 pr_notice("failed to read fan level for later " 8108 "restore during resume: %d\n", rc); 8109 8110 /* if it is undefined, don't attempt to restore it. 8111 * KEEP THIS LAST */ 8112 if (tp_features.fan_ctrl_status_undef) 8113 fan_control_resume_level = 0; 8114 } 8115 8116 static void fan_resume(void) 8117 { 8118 u8 current_level = 7; 8119 bool do_set = false; 8120 int rc; 8121 8122 /* DSDT *always* updates status on resume */ 8123 tp_features.fan_ctrl_status_undef = 0; 8124 8125 if (!fan_control_allowed || 8126 !fan_control_resume_level || 8127 (fan_get_status_safe(¤t_level) < 0)) 8128 return; 8129 8130 switch (fan_control_access_mode) { 8131 case TPACPI_FAN_WR_ACPI_SFAN: 8132 /* never decrease fan level */ 8133 do_set = (fan_control_resume_level > current_level); 8134 break; 8135 case TPACPI_FAN_WR_ACPI_FANS: 8136 case TPACPI_FAN_WR_TPEC: 8137 /* never decrease fan level, scale is: 8138 * TP_EC_FAN_FULLSPEED > 7 >= TP_EC_FAN_AUTO 8139 * 8140 * We expect the firmware to set either 7 or AUTO, but we 8141 * handle FULLSPEED out of paranoia. 8142 * 8143 * So, we can safely only restore FULLSPEED or 7, anything 8144 * else could slow the fan. Restoring AUTO is useless, at 8145 * best that's exactly what the DSDT already set (it is the 8146 * slower it uses). 8147 * 8148 * Always keep in mind that the DSDT *will* have set the 8149 * fans to what the vendor supposes is the best level. We 8150 * muck with it only to speed the fan up. 8151 */ 8152 if (fan_control_resume_level != 7 && 8153 !(fan_control_resume_level & TP_EC_FAN_FULLSPEED)) 8154 return; 8155 else 8156 do_set = !(current_level & TP_EC_FAN_FULLSPEED) && 8157 (current_level != fan_control_resume_level); 8158 break; 8159 default: 8160 return; 8161 } 8162 if (do_set) { 8163 pr_notice("restoring fan level to 0x%02x\n", 8164 fan_control_resume_level); 8165 rc = fan_set_level_safe(fan_control_resume_level); 8166 if (rc < 0) 8167 pr_notice("failed to restore fan level: %d\n", rc); 8168 } 8169 } 8170 8171 static int fan_read(struct seq_file *m) 8172 { 8173 int rc; 8174 u8 status; 8175 unsigned int speed = 0; 8176 8177 switch (fan_status_access_mode) { 8178 case TPACPI_FAN_RD_ACPI_GFAN: 8179 /* 570, 600e/x, 770e, 770x */ 8180 rc = fan_get_status_safe(&status); 8181 if (rc < 0) 8182 return rc; 8183 8184 seq_printf(m, "status:\t\t%s\n" 8185 "level:\t\t%d\n", 8186 (status != 0) ? "enabled" : "disabled", status); 8187 break; 8188 8189 case TPACPI_FAN_RD_TPEC: 8190 /* all except 570, 600e/x, 770e, 770x */ 8191 rc = fan_get_status_safe(&status); 8192 if (rc < 0) 8193 return rc; 8194 8195 seq_printf(m, "status:\t\t%s\n", 8196 (status != 0) ? "enabled" : "disabled"); 8197 8198 rc = fan_get_speed(&speed); 8199 if (rc < 0) 8200 return rc; 8201 8202 seq_printf(m, "speed:\t\t%d\n", speed); 8203 8204 if (status & TP_EC_FAN_FULLSPEED) 8205 /* Disengaged mode takes precedence */ 8206 seq_printf(m, "level:\t\tdisengaged\n"); 8207 else if (status & TP_EC_FAN_AUTO) 8208 seq_printf(m, "level:\t\tauto\n"); 8209 else 8210 seq_printf(m, "level:\t\t%d\n", status); 8211 break; 8212 8213 case TPACPI_FAN_NONE: 8214 default: 8215 seq_printf(m, "status:\t\tnot supported\n"); 8216 } 8217 8218 if (fan_control_commands & TPACPI_FAN_CMD_LEVEL) { 8219 seq_printf(m, "commands:\tlevel <level>"); 8220 8221 switch (fan_control_access_mode) { 8222 case TPACPI_FAN_WR_ACPI_SFAN: 8223 seq_printf(m, " (<level> is 0-7)\n"); 8224 break; 8225 8226 default: 8227 seq_printf(m, " (<level> is 0-7, " 8228 "auto, disengaged, full-speed)\n"); 8229 break; 8230 } 8231 } 8232 8233 if (fan_control_commands & TPACPI_FAN_CMD_ENABLE) 8234 seq_printf(m, "commands:\tenable, disable\n" 8235 "commands:\twatchdog <timeout> (<timeout> " 8236 "is 0 (off), 1-120 (seconds))\n"); 8237 8238 if (fan_control_commands & TPACPI_FAN_CMD_SPEED) 8239 seq_printf(m, "commands:\tspeed <speed>" 8240 " (<speed> is 0-65535)\n"); 8241 8242 return 0; 8243 } 8244 8245 static int fan_write_cmd_level(const char *cmd, int *rc) 8246 { 8247 int level; 8248 8249 if (strlencmp(cmd, "level auto") == 0) 8250 level = TP_EC_FAN_AUTO; 8251 else if ((strlencmp(cmd, "level disengaged") == 0) | 8252 (strlencmp(cmd, "level full-speed") == 0)) 8253 level = TP_EC_FAN_FULLSPEED; 8254 else if (sscanf(cmd, "level %d", &level) != 1) 8255 return 0; 8256 8257 *rc = fan_set_level_safe(level); 8258 if (*rc == -ENXIO) 8259 pr_err("level command accepted for unsupported access mode %d\n", 8260 fan_control_access_mode); 8261 else if (!*rc) 8262 tpacpi_disclose_usertask("procfs fan", 8263 "set level to %d\n", level); 8264 8265 return 1; 8266 } 8267 8268 static int fan_write_cmd_enable(const char *cmd, int *rc) 8269 { 8270 if (strlencmp(cmd, "enable") != 0) 8271 return 0; 8272 8273 *rc = fan_set_enable(); 8274 if (*rc == -ENXIO) 8275 pr_err("enable command accepted for unsupported access mode %d\n", 8276 fan_control_access_mode); 8277 else if (!*rc) 8278 tpacpi_disclose_usertask("procfs fan", "enable\n"); 8279 8280 return 1; 8281 } 8282 8283 static int fan_write_cmd_disable(const char *cmd, int *rc) 8284 { 8285 if (strlencmp(cmd, "disable") != 0) 8286 return 0; 8287 8288 *rc = fan_set_disable(); 8289 if (*rc == -ENXIO) 8290 pr_err("disable command accepted for unsupported access mode %d\n", 8291 fan_control_access_mode); 8292 else if (!*rc) 8293 tpacpi_disclose_usertask("procfs fan", "disable\n"); 8294 8295 return 1; 8296 } 8297 8298 static int fan_write_cmd_speed(const char *cmd, int *rc) 8299 { 8300 int speed; 8301 8302 /* TODO: 8303 * Support speed <low> <medium> <high> ? */ 8304 8305 if (sscanf(cmd, "speed %d", &speed) != 1) 8306 return 0; 8307 8308 *rc = fan_set_speed(speed); 8309 if (*rc == -ENXIO) 8310 pr_err("speed command accepted for unsupported access mode %d\n", 8311 fan_control_access_mode); 8312 else if (!*rc) 8313 tpacpi_disclose_usertask("procfs fan", 8314 "set speed to %d\n", speed); 8315 8316 return 1; 8317 } 8318 8319 static int fan_write_cmd_watchdog(const char *cmd, int *rc) 8320 { 8321 int interval; 8322 8323 if (sscanf(cmd, "watchdog %d", &interval) != 1) 8324 return 0; 8325 8326 if (interval < 0 || interval > 120) 8327 *rc = -EINVAL; 8328 else { 8329 fan_watchdog_maxinterval = interval; 8330 tpacpi_disclose_usertask("procfs fan", 8331 "set watchdog timer to %d\n", 8332 interval); 8333 } 8334 8335 return 1; 8336 } 8337 8338 static int fan_write(char *buf) 8339 { 8340 char *cmd; 8341 int rc = 0; 8342 8343 while (!rc && (cmd = next_cmd(&buf))) { 8344 if (!((fan_control_commands & TPACPI_FAN_CMD_LEVEL) && 8345 fan_write_cmd_level(cmd, &rc)) && 8346 !((fan_control_commands & TPACPI_FAN_CMD_ENABLE) && 8347 (fan_write_cmd_enable(cmd, &rc) || 8348 fan_write_cmd_disable(cmd, &rc) || 8349 fan_write_cmd_watchdog(cmd, &rc))) && 8350 !((fan_control_commands & TPACPI_FAN_CMD_SPEED) && 8351 fan_write_cmd_speed(cmd, &rc)) 8352 ) 8353 rc = -EINVAL; 8354 else if (!rc) 8355 fan_watchdog_reset(); 8356 } 8357 8358 return rc; 8359 } 8360 8361 static struct ibm_struct fan_driver_data = { 8362 .name = "fan", 8363 .read = fan_read, 8364 .write = fan_write, 8365 .exit = fan_exit, 8366 .suspend = fan_suspend, 8367 .resume = fan_resume, 8368 }; 8369 8370 /************************************************************************* 8371 * Mute LED subdriver 8372 */ 8373 8374 8375 struct tp_led_table { 8376 acpi_string name; 8377 int on_value; 8378 int off_value; 8379 int state; 8380 }; 8381 8382 static struct tp_led_table led_tables[] = { 8383 [TPACPI_LED_MUTE] = { 8384 .name = "SSMS", 8385 .on_value = 1, 8386 .off_value = 0, 8387 }, 8388 [TPACPI_LED_MICMUTE] = { 8389 .name = "MMTS", 8390 .on_value = 2, 8391 .off_value = 0, 8392 }, 8393 }; 8394 8395 static int mute_led_on_off(struct tp_led_table *t, bool state) 8396 { 8397 acpi_handle temp; 8398 int output; 8399 8400 if (!ACPI_SUCCESS(acpi_get_handle(hkey_handle, t->name, &temp))) { 8401 pr_warn("Thinkpad ACPI has no %s interface.\n", t->name); 8402 return -EIO; 8403 } 8404 8405 if (!acpi_evalf(hkey_handle, &output, t->name, "dd", 8406 state ? t->on_value : t->off_value)) 8407 return -EIO; 8408 8409 t->state = state; 8410 return state; 8411 } 8412 8413 int tpacpi_led_set(int whichled, bool on) 8414 { 8415 struct tp_led_table *t; 8416 8417 if (whichled < 0 || whichled >= TPACPI_LED_MAX) 8418 return -EINVAL; 8419 8420 t = &led_tables[whichled]; 8421 if (t->state < 0 || t->state == on) 8422 return t->state; 8423 return mute_led_on_off(t, on); 8424 } 8425 EXPORT_SYMBOL_GPL(tpacpi_led_set); 8426 8427 static int mute_led_init(struct ibm_init_struct *iibm) 8428 { 8429 acpi_handle temp; 8430 int i; 8431 8432 for (i = 0; i < TPACPI_LED_MAX; i++) { 8433 struct tp_led_table *t = &led_tables[i]; 8434 if (ACPI_SUCCESS(acpi_get_handle(hkey_handle, t->name, &temp))) 8435 mute_led_on_off(t, false); 8436 else 8437 t->state = -ENODEV; 8438 } 8439 return 0; 8440 } 8441 8442 static void mute_led_exit(void) 8443 { 8444 int i; 8445 8446 for (i = 0; i < TPACPI_LED_MAX; i++) 8447 tpacpi_led_set(i, false); 8448 } 8449 8450 static struct ibm_struct mute_led_driver_data = { 8451 .name = "mute_led", 8452 .exit = mute_led_exit, 8453 }; 8454 8455 /**************************************************************************** 8456 **************************************************************************** 8457 * 8458 * Infrastructure 8459 * 8460 **************************************************************************** 8461 ****************************************************************************/ 8462 8463 /* 8464 * HKEY event callout for other subdrivers go here 8465 * (yes, it is ugly, but it is quick, safe, and gets the job done 8466 */ 8467 static void tpacpi_driver_event(const unsigned int hkey_event) 8468 { 8469 if (ibm_backlight_device) { 8470 switch (hkey_event) { 8471 case TP_HKEY_EV_BRGHT_UP: 8472 case TP_HKEY_EV_BRGHT_DOWN: 8473 tpacpi_brightness_notify_change(); 8474 } 8475 } 8476 if (alsa_card) { 8477 switch (hkey_event) { 8478 case TP_HKEY_EV_VOL_UP: 8479 case TP_HKEY_EV_VOL_DOWN: 8480 case TP_HKEY_EV_VOL_MUTE: 8481 volume_alsa_notify_change(); 8482 } 8483 } 8484 } 8485 8486 static void hotkey_driver_event(const unsigned int scancode) 8487 { 8488 tpacpi_driver_event(TP_HKEY_EV_HOTKEY_BASE + scancode); 8489 } 8490 8491 /* sysfs name ---------------------------------------------------------- */ 8492 static ssize_t thinkpad_acpi_pdev_name_show(struct device *dev, 8493 struct device_attribute *attr, 8494 char *buf) 8495 { 8496 return snprintf(buf, PAGE_SIZE, "%s\n", TPACPI_NAME); 8497 } 8498 8499 static struct device_attribute dev_attr_thinkpad_acpi_pdev_name = 8500 __ATTR(name, S_IRUGO, thinkpad_acpi_pdev_name_show, NULL); 8501 8502 /* --------------------------------------------------------------------- */ 8503 8504 /* /proc support */ 8505 static struct proc_dir_entry *proc_dir; 8506 8507 /* 8508 * Module and infrastructure proble, init and exit handling 8509 */ 8510 8511 static bool force_load; 8512 8513 #ifdef CONFIG_THINKPAD_ACPI_DEBUG 8514 static const char * __init str_supported(int is_supported) 8515 { 8516 static char text_unsupported[] __initdata = "not supported"; 8517 8518 return (is_supported)? &text_unsupported[4] : &text_unsupported[0]; 8519 } 8520 #endif /* CONFIG_THINKPAD_ACPI_DEBUG */ 8521 8522 static void ibm_exit(struct ibm_struct *ibm) 8523 { 8524 dbg_printk(TPACPI_DBG_EXIT, "removing %s\n", ibm->name); 8525 8526 list_del_init(&ibm->all_drivers); 8527 8528 if (ibm->flags.acpi_notify_installed) { 8529 dbg_printk(TPACPI_DBG_EXIT, 8530 "%s: acpi_remove_notify_handler\n", ibm->name); 8531 BUG_ON(!ibm->acpi); 8532 acpi_remove_notify_handler(*ibm->acpi->handle, 8533 ibm->acpi->type, 8534 dispatch_acpi_notify); 8535 ibm->flags.acpi_notify_installed = 0; 8536 } 8537 8538 if (ibm->flags.proc_created) { 8539 dbg_printk(TPACPI_DBG_EXIT, 8540 "%s: remove_proc_entry\n", ibm->name); 8541 remove_proc_entry(ibm->name, proc_dir); 8542 ibm->flags.proc_created = 0; 8543 } 8544 8545 if (ibm->flags.acpi_driver_registered) { 8546 dbg_printk(TPACPI_DBG_EXIT, 8547 "%s: acpi_bus_unregister_driver\n", ibm->name); 8548 BUG_ON(!ibm->acpi); 8549 acpi_bus_unregister_driver(ibm->acpi->driver); 8550 kfree(ibm->acpi->driver); 8551 ibm->acpi->driver = NULL; 8552 ibm->flags.acpi_driver_registered = 0; 8553 } 8554 8555 if (ibm->flags.init_called && ibm->exit) { 8556 ibm->exit(); 8557 ibm->flags.init_called = 0; 8558 } 8559 8560 dbg_printk(TPACPI_DBG_INIT, "finished removing %s\n", ibm->name); 8561 } 8562 8563 static int __init ibm_init(struct ibm_init_struct *iibm) 8564 { 8565 int ret; 8566 struct ibm_struct *ibm = iibm->data; 8567 struct proc_dir_entry *entry; 8568 8569 BUG_ON(ibm == NULL); 8570 8571 INIT_LIST_HEAD(&ibm->all_drivers); 8572 8573 if (ibm->flags.experimental && !experimental) 8574 return 0; 8575 8576 dbg_printk(TPACPI_DBG_INIT, 8577 "probing for %s\n", ibm->name); 8578 8579 if (iibm->init) { 8580 ret = iibm->init(iibm); 8581 if (ret > 0) 8582 return 0; /* probe failed */ 8583 if (ret) 8584 return ret; 8585 8586 ibm->flags.init_called = 1; 8587 } 8588 8589 if (ibm->acpi) { 8590 if (ibm->acpi->hid) { 8591 ret = register_tpacpi_subdriver(ibm); 8592 if (ret) 8593 goto err_out; 8594 } 8595 8596 if (ibm->acpi->notify) { 8597 ret = setup_acpi_notify(ibm); 8598 if (ret == -ENODEV) { 8599 pr_notice("disabling subdriver %s\n", 8600 ibm->name); 8601 ret = 0; 8602 goto err_out; 8603 } 8604 if (ret < 0) 8605 goto err_out; 8606 } 8607 } 8608 8609 dbg_printk(TPACPI_DBG_INIT, 8610 "%s installed\n", ibm->name); 8611 8612 if (ibm->read) { 8613 umode_t mode = iibm->base_procfs_mode; 8614 8615 if (!mode) 8616 mode = S_IRUGO; 8617 if (ibm->write) 8618 mode |= S_IWUSR; 8619 entry = proc_create_data(ibm->name, mode, proc_dir, 8620 &dispatch_proc_fops, ibm); 8621 if (!entry) { 8622 pr_err("unable to create proc entry %s\n", ibm->name); 8623 ret = -ENODEV; 8624 goto err_out; 8625 } 8626 ibm->flags.proc_created = 1; 8627 } 8628 8629 list_add_tail(&ibm->all_drivers, &tpacpi_all_drivers); 8630 8631 return 0; 8632 8633 err_out: 8634 dbg_printk(TPACPI_DBG_INIT, 8635 "%s: at error exit path with result %d\n", 8636 ibm->name, ret); 8637 8638 ibm_exit(ibm); 8639 return (ret < 0)? ret : 0; 8640 } 8641 8642 /* Probing */ 8643 8644 static bool __pure __init tpacpi_is_fw_digit(const char c) 8645 { 8646 return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z'); 8647 } 8648 8649 /* Most models: xxyTkkWW (#.##c); Ancient 570/600 and -SL lacks (#.##c) */ 8650 static bool __pure __init tpacpi_is_valid_fw_id(const char* const s, 8651 const char t) 8652 { 8653 return s && strlen(s) >= 8 && 8654 tpacpi_is_fw_digit(s[0]) && 8655 tpacpi_is_fw_digit(s[1]) && 8656 s[2] == t && 8657 (s[3] == 'T' || s[3] == 'N') && 8658 tpacpi_is_fw_digit(s[4]) && 8659 tpacpi_is_fw_digit(s[5]); 8660 } 8661 8662 /* returns 0 - probe ok, or < 0 - probe error. 8663 * Probe ok doesn't mean thinkpad found. 8664 * On error, kfree() cleanup on tp->* is not performed, caller must do it */ 8665 static int __must_check __init get_thinkpad_model_data( 8666 struct thinkpad_id_data *tp) 8667 { 8668 const struct dmi_device *dev = NULL; 8669 char ec_fw_string[18]; 8670 char const *s; 8671 8672 if (!tp) 8673 return -EINVAL; 8674 8675 memset(tp, 0, sizeof(*tp)); 8676 8677 if (dmi_name_in_vendors("IBM")) 8678 tp->vendor = PCI_VENDOR_ID_IBM; 8679 else if (dmi_name_in_vendors("LENOVO")) 8680 tp->vendor = PCI_VENDOR_ID_LENOVO; 8681 else 8682 return 0; 8683 8684 s = dmi_get_system_info(DMI_BIOS_VERSION); 8685 tp->bios_version_str = kstrdup(s, GFP_KERNEL); 8686 if (s && !tp->bios_version_str) 8687 return -ENOMEM; 8688 8689 /* Really ancient ThinkPad 240X will fail this, which is fine */ 8690 if (!(tpacpi_is_valid_fw_id(tp->bios_version_str, 'E') || 8691 tpacpi_is_valid_fw_id(tp->bios_version_str, 'C'))) 8692 return 0; 8693 8694 tp->bios_model = tp->bios_version_str[0] 8695 | (tp->bios_version_str[1] << 8); 8696 tp->bios_release = (tp->bios_version_str[4] << 8) 8697 | tp->bios_version_str[5]; 8698 8699 /* 8700 * ThinkPad T23 or newer, A31 or newer, R50e or newer, 8701 * X32 or newer, all Z series; Some models must have an 8702 * up-to-date BIOS or they will not be detected. 8703 * 8704 * See http://thinkwiki.org/wiki/List_of_DMI_IDs 8705 */ 8706 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) { 8707 if (sscanf(dev->name, 8708 "IBM ThinkPad Embedded Controller -[%17c", 8709 ec_fw_string) == 1) { 8710 ec_fw_string[sizeof(ec_fw_string) - 1] = 0; 8711 ec_fw_string[strcspn(ec_fw_string, " ]")] = 0; 8712 8713 tp->ec_version_str = kstrdup(ec_fw_string, GFP_KERNEL); 8714 if (!tp->ec_version_str) 8715 return -ENOMEM; 8716 8717 if (tpacpi_is_valid_fw_id(ec_fw_string, 'H')) { 8718 tp->ec_model = ec_fw_string[0] 8719 | (ec_fw_string[1] << 8); 8720 tp->ec_release = (ec_fw_string[4] << 8) 8721 | ec_fw_string[5]; 8722 } else { 8723 pr_notice("ThinkPad firmware release %s " 8724 "doesn't match the known patterns\n", 8725 ec_fw_string); 8726 pr_notice("please report this to %s\n", 8727 TPACPI_MAIL); 8728 } 8729 break; 8730 } 8731 } 8732 8733 s = dmi_get_system_info(DMI_PRODUCT_VERSION); 8734 if (s && !(strnicmp(s, "ThinkPad", 8) && strnicmp(s, "Lenovo", 6))) { 8735 tp->model_str = kstrdup(s, GFP_KERNEL); 8736 if (!tp->model_str) 8737 return -ENOMEM; 8738 } else { 8739 s = dmi_get_system_info(DMI_BIOS_VENDOR); 8740 if (s && !(strnicmp(s, "Lenovo", 6))) { 8741 tp->model_str = kstrdup(s, GFP_KERNEL); 8742 if (!tp->model_str) 8743 return -ENOMEM; 8744 } 8745 } 8746 8747 s = dmi_get_system_info(DMI_PRODUCT_NAME); 8748 tp->nummodel_str = kstrdup(s, GFP_KERNEL); 8749 if (s && !tp->nummodel_str) 8750 return -ENOMEM; 8751 8752 return 0; 8753 } 8754 8755 static int __init probe_for_thinkpad(void) 8756 { 8757 int is_thinkpad; 8758 8759 if (acpi_disabled) 8760 return -ENODEV; 8761 8762 /* It would be dangerous to run the driver in this case */ 8763 if (!tpacpi_is_ibm() && !tpacpi_is_lenovo()) 8764 return -ENODEV; 8765 8766 /* 8767 * Non-ancient models have better DMI tagging, but very old models 8768 * don't. tpacpi_is_fw_known() is a cheat to help in that case. 8769 */ 8770 is_thinkpad = (thinkpad_id.model_str != NULL) || 8771 (thinkpad_id.ec_model != 0) || 8772 tpacpi_is_fw_known(); 8773 8774 /* The EC handler is required */ 8775 tpacpi_acpi_handle_locate("ec", TPACPI_ACPI_EC_HID, &ec_handle); 8776 if (!ec_handle) { 8777 if (is_thinkpad) 8778 pr_err("Not yet supported ThinkPad detected!\n"); 8779 return -ENODEV; 8780 } 8781 8782 if (!is_thinkpad && !force_load) 8783 return -ENODEV; 8784 8785 return 0; 8786 } 8787 8788 static void __init thinkpad_acpi_init_banner(void) 8789 { 8790 pr_info("%s v%s\n", TPACPI_DESC, TPACPI_VERSION); 8791 pr_info("%s\n", TPACPI_URL); 8792 8793 pr_info("ThinkPad BIOS %s, EC %s\n", 8794 (thinkpad_id.bios_version_str) ? 8795 thinkpad_id.bios_version_str : "unknown", 8796 (thinkpad_id.ec_version_str) ? 8797 thinkpad_id.ec_version_str : "unknown"); 8798 8799 BUG_ON(!thinkpad_id.vendor); 8800 8801 if (thinkpad_id.model_str) 8802 pr_info("%s %s, model %s\n", 8803 (thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ? 8804 "IBM" : ((thinkpad_id.vendor == 8805 PCI_VENDOR_ID_LENOVO) ? 8806 "Lenovo" : "Unknown vendor"), 8807 thinkpad_id.model_str, 8808 (thinkpad_id.nummodel_str) ? 8809 thinkpad_id.nummodel_str : "unknown"); 8810 } 8811 8812 /* Module init, exit, parameters */ 8813 8814 static struct ibm_init_struct ibms_init[] __initdata = { 8815 { 8816 .data = &thinkpad_acpi_driver_data, 8817 }, 8818 { 8819 .init = hotkey_init, 8820 .data = &hotkey_driver_data, 8821 }, 8822 { 8823 .init = bluetooth_init, 8824 .data = &bluetooth_driver_data, 8825 }, 8826 { 8827 .init = wan_init, 8828 .data = &wan_driver_data, 8829 }, 8830 { 8831 .init = uwb_init, 8832 .data = &uwb_driver_data, 8833 }, 8834 #ifdef CONFIG_THINKPAD_ACPI_VIDEO 8835 { 8836 .init = video_init, 8837 .base_procfs_mode = S_IRUSR, 8838 .data = &video_driver_data, 8839 }, 8840 #endif 8841 { 8842 .init = light_init, 8843 .data = &light_driver_data, 8844 }, 8845 { 8846 .init = cmos_init, 8847 .data = &cmos_driver_data, 8848 }, 8849 { 8850 .init = led_init, 8851 .data = &led_driver_data, 8852 }, 8853 { 8854 .init = beep_init, 8855 .data = &beep_driver_data, 8856 }, 8857 { 8858 .init = thermal_init, 8859 .data = &thermal_driver_data, 8860 }, 8861 { 8862 .init = brightness_init, 8863 .data = &brightness_driver_data, 8864 }, 8865 { 8866 .init = volume_init, 8867 .data = &volume_driver_data, 8868 }, 8869 { 8870 .init = fan_init, 8871 .data = &fan_driver_data, 8872 }, 8873 { 8874 .init = mute_led_init, 8875 .data = &mute_led_driver_data, 8876 }, 8877 }; 8878 8879 static int __init set_ibm_param(const char *val, struct kernel_param *kp) 8880 { 8881 unsigned int i; 8882 struct ibm_struct *ibm; 8883 8884 if (!kp || !kp->name || !val) 8885 return -EINVAL; 8886 8887 for (i = 0; i < ARRAY_SIZE(ibms_init); i++) { 8888 ibm = ibms_init[i].data; 8889 WARN_ON(ibm == NULL); 8890 8891 if (!ibm || !ibm->name) 8892 continue; 8893 8894 if (strcmp(ibm->name, kp->name) == 0 && ibm->write) { 8895 if (strlen(val) > sizeof(ibms_init[i].param) - 2) 8896 return -ENOSPC; 8897 strcpy(ibms_init[i].param, val); 8898 strcat(ibms_init[i].param, ","); 8899 return 0; 8900 } 8901 } 8902 8903 return -EINVAL; 8904 } 8905 8906 module_param(experimental, int, 0444); 8907 MODULE_PARM_DESC(experimental, 8908 "Enables experimental features when non-zero"); 8909 8910 module_param_named(debug, dbg_level, uint, 0); 8911 MODULE_PARM_DESC(debug, "Sets debug level bit-mask"); 8912 8913 module_param(force_load, bool, 0444); 8914 MODULE_PARM_DESC(force_load, 8915 "Attempts to load the driver even on a " 8916 "mis-identified ThinkPad when true"); 8917 8918 module_param_named(fan_control, fan_control_allowed, bool, 0444); 8919 MODULE_PARM_DESC(fan_control, 8920 "Enables setting fan parameters features when true"); 8921 8922 module_param_named(brightness_mode, brightness_mode, uint, 0444); 8923 MODULE_PARM_DESC(brightness_mode, 8924 "Selects brightness control strategy: " 8925 "0=auto, 1=EC, 2=UCMS, 3=EC+NVRAM"); 8926 8927 module_param(brightness_enable, uint, 0444); 8928 MODULE_PARM_DESC(brightness_enable, 8929 "Enables backlight control when 1, disables when 0"); 8930 8931 #ifdef CONFIG_THINKPAD_ACPI_ALSA_SUPPORT 8932 module_param_named(volume_mode, volume_mode, uint, 0444); 8933 MODULE_PARM_DESC(volume_mode, 8934 "Selects volume control strategy: " 8935 "0=auto, 1=EC, 2=N/A, 3=EC+NVRAM"); 8936 8937 module_param_named(volume_capabilities, volume_capabilities, uint, 0444); 8938 MODULE_PARM_DESC(volume_capabilities, 8939 "Selects the mixer capabilites: " 8940 "0=auto, 1=volume and mute, 2=mute only"); 8941 8942 module_param_named(volume_control, volume_control_allowed, bool, 0444); 8943 MODULE_PARM_DESC(volume_control, 8944 "Enables software override for the console audio " 8945 "control when true"); 8946 8947 /* ALSA module API parameters */ 8948 module_param_named(index, alsa_index, int, 0444); 8949 MODULE_PARM_DESC(index, "ALSA index for the ACPI EC Mixer"); 8950 module_param_named(id, alsa_id, charp, 0444); 8951 MODULE_PARM_DESC(id, "ALSA id for the ACPI EC Mixer"); 8952 module_param_named(enable, alsa_enable, bool, 0444); 8953 MODULE_PARM_DESC(enable, "Enable the ALSA interface for the ACPI EC Mixer"); 8954 #endif /* CONFIG_THINKPAD_ACPI_ALSA_SUPPORT */ 8955 8956 #define TPACPI_PARAM(feature) \ 8957 module_param_call(feature, set_ibm_param, NULL, NULL, 0); \ 8958 MODULE_PARM_DESC(feature, "Simulates thinkpad-acpi procfs command " \ 8959 "at module load, see documentation") 8960 8961 TPACPI_PARAM(hotkey); 8962 TPACPI_PARAM(bluetooth); 8963 TPACPI_PARAM(video); 8964 TPACPI_PARAM(light); 8965 TPACPI_PARAM(cmos); 8966 TPACPI_PARAM(led); 8967 TPACPI_PARAM(beep); 8968 TPACPI_PARAM(brightness); 8969 TPACPI_PARAM(volume); 8970 TPACPI_PARAM(fan); 8971 8972 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES 8973 module_param(dbg_wlswemul, uint, 0444); 8974 MODULE_PARM_DESC(dbg_wlswemul, "Enables WLSW emulation"); 8975 module_param_named(wlsw_state, tpacpi_wlsw_emulstate, bool, 0); 8976 MODULE_PARM_DESC(wlsw_state, 8977 "Initial state of the emulated WLSW switch"); 8978 8979 module_param(dbg_bluetoothemul, uint, 0444); 8980 MODULE_PARM_DESC(dbg_bluetoothemul, "Enables bluetooth switch emulation"); 8981 module_param_named(bluetooth_state, tpacpi_bluetooth_emulstate, bool, 0); 8982 MODULE_PARM_DESC(bluetooth_state, 8983 "Initial state of the emulated bluetooth switch"); 8984 8985 module_param(dbg_wwanemul, uint, 0444); 8986 MODULE_PARM_DESC(dbg_wwanemul, "Enables WWAN switch emulation"); 8987 module_param_named(wwan_state, tpacpi_wwan_emulstate, bool, 0); 8988 MODULE_PARM_DESC(wwan_state, 8989 "Initial state of the emulated WWAN switch"); 8990 8991 module_param(dbg_uwbemul, uint, 0444); 8992 MODULE_PARM_DESC(dbg_uwbemul, "Enables UWB switch emulation"); 8993 module_param_named(uwb_state, tpacpi_uwb_emulstate, bool, 0); 8994 MODULE_PARM_DESC(uwb_state, 8995 "Initial state of the emulated UWB switch"); 8996 #endif 8997 8998 static void thinkpad_acpi_module_exit(void) 8999 { 9000 struct ibm_struct *ibm, *itmp; 9001 9002 tpacpi_lifecycle = TPACPI_LIFE_EXITING; 9003 9004 list_for_each_entry_safe_reverse(ibm, itmp, 9005 &tpacpi_all_drivers, 9006 all_drivers) { 9007 ibm_exit(ibm); 9008 } 9009 9010 dbg_printk(TPACPI_DBG_INIT, "finished subdriver exit path...\n"); 9011 9012 if (tpacpi_inputdev) { 9013 if (tp_features.input_device_registered) 9014 input_unregister_device(tpacpi_inputdev); 9015 else 9016 input_free_device(tpacpi_inputdev); 9017 kfree(hotkey_keycode_map); 9018 } 9019 9020 if (tpacpi_hwmon) 9021 hwmon_device_unregister(tpacpi_hwmon); 9022 9023 if (tp_features.sensors_pdev_attrs_registered) 9024 device_remove_file(&tpacpi_sensors_pdev->dev, 9025 &dev_attr_thinkpad_acpi_pdev_name); 9026 if (tpacpi_sensors_pdev) 9027 platform_device_unregister(tpacpi_sensors_pdev); 9028 if (tpacpi_pdev) 9029 platform_device_unregister(tpacpi_pdev); 9030 9031 if (tp_features.sensors_pdrv_attrs_registered) 9032 tpacpi_remove_driver_attributes(&tpacpi_hwmon_pdriver.driver); 9033 if (tp_features.platform_drv_attrs_registered) 9034 tpacpi_remove_driver_attributes(&tpacpi_pdriver.driver); 9035 9036 if (tp_features.sensors_pdrv_registered) 9037 platform_driver_unregister(&tpacpi_hwmon_pdriver); 9038 9039 if (tp_features.platform_drv_registered) 9040 platform_driver_unregister(&tpacpi_pdriver); 9041 9042 if (proc_dir) 9043 remove_proc_entry(TPACPI_PROC_DIR, acpi_root_dir); 9044 9045 if (tpacpi_wq) 9046 destroy_workqueue(tpacpi_wq); 9047 9048 kfree(thinkpad_id.bios_version_str); 9049 kfree(thinkpad_id.ec_version_str); 9050 kfree(thinkpad_id.model_str); 9051 kfree(thinkpad_id.nummodel_str); 9052 } 9053 9054 9055 static int __init thinkpad_acpi_module_init(void) 9056 { 9057 int ret, i; 9058 9059 tpacpi_lifecycle = TPACPI_LIFE_INIT; 9060 9061 /* Driver-level probe */ 9062 9063 ret = get_thinkpad_model_data(&thinkpad_id); 9064 if (ret) { 9065 pr_err("unable to get DMI data: %d\n", ret); 9066 thinkpad_acpi_module_exit(); 9067 return ret; 9068 } 9069 ret = probe_for_thinkpad(); 9070 if (ret) { 9071 thinkpad_acpi_module_exit(); 9072 return ret; 9073 } 9074 9075 /* Driver initialization */ 9076 9077 thinkpad_acpi_init_banner(); 9078 tpacpi_check_outdated_fw(); 9079 9080 TPACPI_ACPIHANDLE_INIT(ecrd); 9081 TPACPI_ACPIHANDLE_INIT(ecwr); 9082 9083 tpacpi_wq = create_singlethread_workqueue(TPACPI_WORKQUEUE_NAME); 9084 if (!tpacpi_wq) { 9085 thinkpad_acpi_module_exit(); 9086 return -ENOMEM; 9087 } 9088 9089 proc_dir = proc_mkdir(TPACPI_PROC_DIR, acpi_root_dir); 9090 if (!proc_dir) { 9091 pr_err("unable to create proc dir " TPACPI_PROC_DIR "\n"); 9092 thinkpad_acpi_module_exit(); 9093 return -ENODEV; 9094 } 9095 9096 ret = platform_driver_register(&tpacpi_pdriver); 9097 if (ret) { 9098 pr_err("unable to register main platform driver\n"); 9099 thinkpad_acpi_module_exit(); 9100 return ret; 9101 } 9102 tp_features.platform_drv_registered = 1; 9103 9104 ret = platform_driver_register(&tpacpi_hwmon_pdriver); 9105 if (ret) { 9106 pr_err("unable to register hwmon platform driver\n"); 9107 thinkpad_acpi_module_exit(); 9108 return ret; 9109 } 9110 tp_features.sensors_pdrv_registered = 1; 9111 9112 ret = tpacpi_create_driver_attributes(&tpacpi_pdriver.driver); 9113 if (!ret) { 9114 tp_features.platform_drv_attrs_registered = 1; 9115 ret = tpacpi_create_driver_attributes( 9116 &tpacpi_hwmon_pdriver.driver); 9117 } 9118 if (ret) { 9119 pr_err("unable to create sysfs driver attributes\n"); 9120 thinkpad_acpi_module_exit(); 9121 return ret; 9122 } 9123 tp_features.sensors_pdrv_attrs_registered = 1; 9124 9125 9126 /* Device initialization */ 9127 tpacpi_pdev = platform_device_register_simple(TPACPI_DRVR_NAME, -1, 9128 NULL, 0); 9129 if (IS_ERR(tpacpi_pdev)) { 9130 ret = PTR_ERR(tpacpi_pdev); 9131 tpacpi_pdev = NULL; 9132 pr_err("unable to register platform device\n"); 9133 thinkpad_acpi_module_exit(); 9134 return ret; 9135 } 9136 tpacpi_sensors_pdev = platform_device_register_simple( 9137 TPACPI_HWMON_DRVR_NAME, 9138 -1, NULL, 0); 9139 if (IS_ERR(tpacpi_sensors_pdev)) { 9140 ret = PTR_ERR(tpacpi_sensors_pdev); 9141 tpacpi_sensors_pdev = NULL; 9142 pr_err("unable to register hwmon platform device\n"); 9143 thinkpad_acpi_module_exit(); 9144 return ret; 9145 } 9146 ret = device_create_file(&tpacpi_sensors_pdev->dev, 9147 &dev_attr_thinkpad_acpi_pdev_name); 9148 if (ret) { 9149 pr_err("unable to create sysfs hwmon device attributes\n"); 9150 thinkpad_acpi_module_exit(); 9151 return ret; 9152 } 9153 tp_features.sensors_pdev_attrs_registered = 1; 9154 tpacpi_hwmon = hwmon_device_register(&tpacpi_sensors_pdev->dev); 9155 if (IS_ERR(tpacpi_hwmon)) { 9156 ret = PTR_ERR(tpacpi_hwmon); 9157 tpacpi_hwmon = NULL; 9158 pr_err("unable to register hwmon device\n"); 9159 thinkpad_acpi_module_exit(); 9160 return ret; 9161 } 9162 mutex_init(&tpacpi_inputdev_send_mutex); 9163 tpacpi_inputdev = input_allocate_device(); 9164 if (!tpacpi_inputdev) { 9165 thinkpad_acpi_module_exit(); 9166 return -ENOMEM; 9167 } else { 9168 /* Prepare input device, but don't register */ 9169 tpacpi_inputdev->name = "ThinkPad Extra Buttons"; 9170 tpacpi_inputdev->phys = TPACPI_DRVR_NAME "/input0"; 9171 tpacpi_inputdev->id.bustype = BUS_HOST; 9172 tpacpi_inputdev->id.vendor = thinkpad_id.vendor; 9173 tpacpi_inputdev->id.product = TPACPI_HKEY_INPUT_PRODUCT; 9174 tpacpi_inputdev->id.version = TPACPI_HKEY_INPUT_VERSION; 9175 tpacpi_inputdev->dev.parent = &tpacpi_pdev->dev; 9176 } 9177 9178 /* Init subdriver dependencies */ 9179 tpacpi_detect_brightness_capabilities(); 9180 9181 /* Init subdrivers */ 9182 for (i = 0; i < ARRAY_SIZE(ibms_init); i++) { 9183 ret = ibm_init(&ibms_init[i]); 9184 if (ret >= 0 && *ibms_init[i].param) 9185 ret = ibms_init[i].data->write(ibms_init[i].param); 9186 if (ret < 0) { 9187 thinkpad_acpi_module_exit(); 9188 return ret; 9189 } 9190 } 9191 9192 tpacpi_lifecycle = TPACPI_LIFE_RUNNING; 9193 9194 ret = input_register_device(tpacpi_inputdev); 9195 if (ret < 0) { 9196 pr_err("unable to register input device\n"); 9197 thinkpad_acpi_module_exit(); 9198 return ret; 9199 } else { 9200 tp_features.input_device_registered = 1; 9201 } 9202 9203 return 0; 9204 } 9205 9206 MODULE_ALIAS(TPACPI_DRVR_SHORTNAME); 9207 9208 /* 9209 * This will autoload the driver in almost every ThinkPad 9210 * in widespread use. 9211 * 9212 * Only _VERY_ old models, like the 240, 240x and 570 lack 9213 * the HKEY event interface. 9214 */ 9215 MODULE_DEVICE_TABLE(acpi, ibm_htk_device_ids); 9216 9217 /* 9218 * DMI matching for module autoloading 9219 * 9220 * See http://thinkwiki.org/wiki/List_of_DMI_IDs 9221 * See http://thinkwiki.org/wiki/BIOS_Upgrade_Downloads 9222 * 9223 * Only models listed in thinkwiki will be supported, so add yours 9224 * if it is not there yet. 9225 */ 9226 #define IBM_BIOS_MODULE_ALIAS(__type) \ 9227 MODULE_ALIAS("dmi:bvnIBM:bvr" __type "ET??WW*") 9228 9229 /* Ancient thinkpad BIOSes have to be identified by 9230 * BIOS type or model number, and there are far less 9231 * BIOS types than model numbers... */ 9232 IBM_BIOS_MODULE_ALIAS("I[MU]"); /* 570, 570e */ 9233 9234 MODULE_AUTHOR("Borislav Deianov <borislav@users.sf.net>"); 9235 MODULE_AUTHOR("Henrique de Moraes Holschuh <hmh@hmh.eng.br>"); 9236 MODULE_DESCRIPTION(TPACPI_DESC); 9237 MODULE_VERSION(TPACPI_VERSION); 9238 MODULE_LICENSE("GPL"); 9239 9240 module_init(thinkpad_acpi_module_init); 9241 module_exit(thinkpad_acpi_module_exit); 9242