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