linux/drivers/platform/x86/thinkpad_acpi.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  thinkpad_acpi.c - ThinkPad ACPI Extras
   4 *
   5 *  Copyright (C) 2004-2005 Borislav Deianov <borislav@users.sf.net>
   6 *  Copyright (C) 2006-2009 Henrique de Moraes Holschuh <hmh@hmh.eng.br>
   7 */
   8
   9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11#define TPACPI_VERSION "0.26"
  12#define TPACPI_SYSFS_VERSION 0x030000
  13
  14/*
  15 *  Changelog:
  16 *  2007-10-20          changelog trimmed down
  17 *
  18 *  2007-03-27  0.14    renamed to thinkpad_acpi and moved to
  19 *                      drivers/misc.
  20 *
  21 *  2006-11-22  0.13    new maintainer
  22 *                      changelog now lives in git commit history, and will
  23 *                      not be updated further in-file.
  24 *
  25 *  2005-03-17  0.11    support for 600e, 770x
  26 *                          thanks to Jamie Lentin <lentinj@dial.pipex.com>
  27 *
  28 *  2005-01-16  0.9     use MODULE_VERSION
  29 *                          thanks to Henrik Brix Andersen <brix@gentoo.org>
  30 *                      fix parameter passing on module loading
  31 *                          thanks to Rusty Russell <rusty@rustcorp.com.au>
  32 *                          thanks to Jim Radford <radford@blackbean.org>
  33 *  2004-11-08  0.8     fix init error case, don't return from a macro
  34 *                          thanks to Chris Wright <chrisw@osdl.org>
  35 */
  36
  37#include <linux/kernel.h>
  38#include <linux/module.h>
  39#include <linux/init.h>
  40#include <linux/types.h>
  41#include <linux/string.h>
  42#include <linux/list.h>
  43#include <linux/mutex.h>
  44#include <linux/sched.h>
  45#include <linux/sched/signal.h>
  46#include <linux/kthread.h>
  47#include <linux/freezer.h>
  48#include <linux/delay.h>
  49#include <linux/slab.h>
  50#include <linux/nvram.h>
  51#include <linux/proc_fs.h>
  52#include <linux/seq_file.h>
  53#include <linux/sysfs.h>
  54#include <linux/backlight.h>
  55#include <linux/bitops.h>
  56#include <linux/fb.h>
  57#include <linux/platform_device.h>
  58#include <linux/hwmon.h>
  59#include <linux/hwmon-sysfs.h>
  60#include <linux/input.h>
  61#include <linux/leds.h>
  62#include <linux/rfkill.h>
  63#include <linux/dmi.h>
  64#include <linux/jiffies.h>
  65#include <linux/workqueue.h>
  66#include <linux/acpi.h>
  67#include <linux/pci.h>
  68#include <linux/power_supply.h>
  69#include <linux/platform_profile.h>
  70#include <sound/core.h>
  71#include <sound/control.h>
  72#include <sound/initval.h>
  73#include <linux/uaccess.h>
  74#include <acpi/battery.h>
  75#include <acpi/video.h>
  76#include "dual_accel_detect.h"
  77
  78/* ThinkPad CMOS commands */
  79#define TP_CMOS_VOLUME_DOWN     0
  80#define TP_CMOS_VOLUME_UP       1
  81#define TP_CMOS_VOLUME_MUTE     2
  82#define TP_CMOS_BRIGHTNESS_UP   4
  83#define TP_CMOS_BRIGHTNESS_DOWN 5
  84#define TP_CMOS_THINKLIGHT_ON   12
  85#define TP_CMOS_THINKLIGHT_OFF  13
  86
  87/* NVRAM Addresses */
  88enum tp_nvram_addr {
  89        TP_NVRAM_ADDR_HK2               = 0x57,
  90        TP_NVRAM_ADDR_THINKLIGHT        = 0x58,
  91        TP_NVRAM_ADDR_VIDEO             = 0x59,
  92        TP_NVRAM_ADDR_BRIGHTNESS        = 0x5e,
  93        TP_NVRAM_ADDR_MIXER             = 0x60,
  94};
  95
  96/* NVRAM bit masks */
  97enum {
  98        TP_NVRAM_MASK_HKT_THINKPAD      = 0x08,
  99        TP_NVRAM_MASK_HKT_ZOOM          = 0x20,
 100        TP_NVRAM_MASK_HKT_DISPLAY       = 0x40,
 101        TP_NVRAM_MASK_HKT_HIBERNATE     = 0x80,
 102        TP_NVRAM_MASK_THINKLIGHT        = 0x10,
 103        TP_NVRAM_MASK_HKT_DISPEXPND     = 0x30,
 104        TP_NVRAM_MASK_HKT_BRIGHTNESS    = 0x20,
 105        TP_NVRAM_MASK_LEVEL_BRIGHTNESS  = 0x0f,
 106        TP_NVRAM_POS_LEVEL_BRIGHTNESS   = 0,
 107        TP_NVRAM_MASK_MUTE              = 0x40,
 108        TP_NVRAM_MASK_HKT_VOLUME        = 0x80,
 109        TP_NVRAM_MASK_LEVEL_VOLUME      = 0x0f,
 110        TP_NVRAM_POS_LEVEL_VOLUME       = 0,
 111};
 112
 113/* Misc NVRAM-related */
 114enum {
 115        TP_NVRAM_LEVEL_VOLUME_MAX = 14,
 116};
 117
 118/* ACPI HIDs */
 119#define TPACPI_ACPI_IBM_HKEY_HID        "IBM0068"
 120#define TPACPI_ACPI_LENOVO_HKEY_HID     "LEN0068"
 121#define TPACPI_ACPI_LENOVO_HKEY_V2_HID  "LEN0268"
 122#define TPACPI_ACPI_EC_HID              "PNP0C09"
 123
 124/* Input IDs */
 125#define TPACPI_HKEY_INPUT_PRODUCT       0x5054 /* "TP" */
 126#define TPACPI_HKEY_INPUT_VERSION       0x4101
 127
 128/* ACPI \WGSV commands */
 129enum {
 130        TP_ACPI_WGSV_GET_STATE          = 0x01, /* Get state information */
 131        TP_ACPI_WGSV_PWR_ON_ON_RESUME   = 0x02, /* Resume WWAN powered on */
 132        TP_ACPI_WGSV_PWR_OFF_ON_RESUME  = 0x03, /* Resume WWAN powered off */
 133        TP_ACPI_WGSV_SAVE_STATE         = 0x04, /* Save state for S4/S5 */
 134};
 135
 136/* TP_ACPI_WGSV_GET_STATE bits */
 137enum {
 138        TP_ACPI_WGSV_STATE_WWANEXIST    = 0x0001, /* WWAN hw available */
 139        TP_ACPI_WGSV_STATE_WWANPWR      = 0x0002, /* WWAN radio enabled */
 140        TP_ACPI_WGSV_STATE_WWANPWRRES   = 0x0004, /* WWAN state at resume */
 141        TP_ACPI_WGSV_STATE_WWANBIOSOFF  = 0x0008, /* WWAN disabled in BIOS */
 142        TP_ACPI_WGSV_STATE_BLTHEXIST    = 0x0001, /* BLTH hw available */
 143        TP_ACPI_WGSV_STATE_BLTHPWR      = 0x0002, /* BLTH radio enabled */
 144        TP_ACPI_WGSV_STATE_BLTHPWRRES   = 0x0004, /* BLTH state at resume */
 145        TP_ACPI_WGSV_STATE_BLTHBIOSOFF  = 0x0008, /* BLTH disabled in BIOS */
 146        TP_ACPI_WGSV_STATE_UWBEXIST     = 0x0010, /* UWB hw available */
 147        TP_ACPI_WGSV_STATE_UWBPWR       = 0x0020, /* UWB radio enabled */
 148};
 149
 150/* HKEY events */
 151enum tpacpi_hkey_event_t {
 152        /* Hotkey-related */
 153        TP_HKEY_EV_HOTKEY_BASE          = 0x1001, /* first hotkey (FN+F1) */
 154        TP_HKEY_EV_BRGHT_UP             = 0x1010, /* Brightness up */
 155        TP_HKEY_EV_BRGHT_DOWN           = 0x1011, /* Brightness down */
 156        TP_HKEY_EV_KBD_LIGHT            = 0x1012, /* Thinklight/kbd backlight */
 157        TP_HKEY_EV_VOL_UP               = 0x1015, /* Volume up or unmute */
 158        TP_HKEY_EV_VOL_DOWN             = 0x1016, /* Volume down or unmute */
 159        TP_HKEY_EV_VOL_MUTE             = 0x1017, /* Mixer output mute */
 160
 161        /* Reasons for waking up from S3/S4 */
 162        TP_HKEY_EV_WKUP_S3_UNDOCK       = 0x2304, /* undock requested, S3 */
 163        TP_HKEY_EV_WKUP_S4_UNDOCK       = 0x2404, /* undock requested, S4 */
 164        TP_HKEY_EV_WKUP_S3_BAYEJ        = 0x2305, /* bay ejection req, S3 */
 165        TP_HKEY_EV_WKUP_S4_BAYEJ        = 0x2405, /* bay ejection req, S4 */
 166        TP_HKEY_EV_WKUP_S3_BATLOW       = 0x2313, /* battery empty, S3 */
 167        TP_HKEY_EV_WKUP_S4_BATLOW       = 0x2413, /* battery empty, S4 */
 168
 169        /* Auto-sleep after eject request */
 170        TP_HKEY_EV_BAYEJ_ACK            = 0x3003, /* bay ejection complete */
 171        TP_HKEY_EV_UNDOCK_ACK           = 0x4003, /* undock complete */
 172
 173        /* Misc bay events */
 174        TP_HKEY_EV_OPTDRV_EJ            = 0x3006, /* opt. drive tray ejected */
 175        TP_HKEY_EV_HOTPLUG_DOCK         = 0x4010, /* docked into hotplug dock
 176                                                     or port replicator */
 177        TP_HKEY_EV_HOTPLUG_UNDOCK       = 0x4011, /* undocked from hotplug
 178                                                     dock or port replicator */
 179        /*
 180         * Thinkpad X1 Tablet series devices emit 0x4012 and 0x4013
 181         * when keyboard cover is attached, detached or folded onto the back
 182         */
 183        TP_HKEY_EV_KBD_COVER_ATTACH     = 0x4012, /* keyboard cover attached */
 184        TP_HKEY_EV_KBD_COVER_DETACH     = 0x4013, /* keyboard cover detached or folded back */
 185
 186        /* User-interface events */
 187        TP_HKEY_EV_LID_CLOSE            = 0x5001, /* laptop lid closed */
 188        TP_HKEY_EV_LID_OPEN             = 0x5002, /* laptop lid opened */
 189        TP_HKEY_EV_TABLET_TABLET        = 0x5009, /* tablet swivel up */
 190        TP_HKEY_EV_TABLET_NOTEBOOK      = 0x500a, /* tablet swivel down */
 191        TP_HKEY_EV_TABLET_CHANGED       = 0x60c0, /* X1 Yoga (2016):
 192                                                   * enter/leave tablet mode
 193                                                   */
 194        TP_HKEY_EV_PEN_INSERTED         = 0x500b, /* tablet pen inserted */
 195        TP_HKEY_EV_PEN_REMOVED          = 0x500c, /* tablet pen removed */
 196        TP_HKEY_EV_BRGHT_CHANGED        = 0x5010, /* backlight control event */
 197
 198        /* Key-related user-interface events */
 199        TP_HKEY_EV_KEY_NUMLOCK          = 0x6000, /* NumLock key pressed */
 200        TP_HKEY_EV_KEY_FN               = 0x6005, /* Fn key pressed? E420 */
 201        TP_HKEY_EV_KEY_FN_ESC           = 0x6060, /* Fn+Esc key pressed X240 */
 202
 203        /* Thermal events */
 204        TP_HKEY_EV_ALARM_BAT_HOT        = 0x6011, /* battery too hot */
 205        TP_HKEY_EV_ALARM_BAT_XHOT       = 0x6012, /* battery critically hot */
 206        TP_HKEY_EV_ALARM_SENSOR_HOT     = 0x6021, /* sensor too hot */
 207        TP_HKEY_EV_ALARM_SENSOR_XHOT    = 0x6022, /* sensor critically hot */
 208        TP_HKEY_EV_THM_TABLE_CHANGED    = 0x6030, /* windows; thermal table changed */
 209        TP_HKEY_EV_THM_CSM_COMPLETED    = 0x6032, /* windows; thermal control set
 210                                                   * command completed. Related to
 211                                                   * AML DYTC */
 212        TP_HKEY_EV_THM_TRANSFM_CHANGED  = 0x60F0, /* windows; thermal transformation
 213                                                   * changed. Related to AML GMTS */
 214
 215        /* AC-related events */
 216        TP_HKEY_EV_AC_CHANGED           = 0x6040, /* AC status changed */
 217
 218        /* Further user-interface events */
 219        TP_HKEY_EV_PALM_DETECTED        = 0x60b0, /* palm hoveres keyboard */
 220        TP_HKEY_EV_PALM_UNDETECTED      = 0x60b1, /* palm removed */
 221
 222        /* Misc */
 223        TP_HKEY_EV_RFKILL_CHANGED       = 0x7000, /* rfkill switch changed */
 224};
 225
 226/****************************************************************************
 227 * Main driver
 228 */
 229
 230#define TPACPI_NAME "thinkpad"
 231#define TPACPI_DESC "ThinkPad ACPI Extras"
 232#define TPACPI_FILE TPACPI_NAME "_acpi"
 233#define TPACPI_URL "http://ibm-acpi.sf.net/"
 234#define TPACPI_MAIL "ibm-acpi-devel@lists.sourceforge.net"
 235
 236#define TPACPI_PROC_DIR "ibm"
 237#define TPACPI_ACPI_EVENT_PREFIX "ibm"
 238#define TPACPI_DRVR_NAME TPACPI_FILE
 239#define TPACPI_DRVR_SHORTNAME "tpacpi"
 240#define TPACPI_HWMON_DRVR_NAME TPACPI_NAME "_hwmon"
 241
 242#define TPACPI_NVRAM_KTHREAD_NAME "ktpacpi_nvramd"
 243#define TPACPI_WORKQUEUE_NAME "ktpacpid"
 244
 245#define TPACPI_MAX_ACPI_ARGS 3
 246
 247/* Debugging printk groups */
 248#define TPACPI_DBG_ALL          0xffff
 249#define TPACPI_DBG_DISCLOSETASK 0x8000
 250#define TPACPI_DBG_INIT         0x0001
 251#define TPACPI_DBG_EXIT         0x0002
 252#define TPACPI_DBG_RFKILL       0x0004
 253#define TPACPI_DBG_HKEY         0x0008
 254#define TPACPI_DBG_FAN          0x0010
 255#define TPACPI_DBG_BRGHT        0x0020
 256#define TPACPI_DBG_MIXER        0x0040
 257
 258#define onoff(status, bit) ((status) & (1 << (bit)) ? "on" : "off")
 259#define enabled(status, bit) ((status) & (1 << (bit)) ? "enabled" : "disabled")
 260#define strlencmp(a, b) (strncmp((a), (b), strlen(b)))
 261
 262
 263/****************************************************************************
 264 * Driver-wide structs and misc. variables
 265 */
 266
 267struct ibm_struct;
 268
 269struct tp_acpi_drv_struct {
 270        const struct acpi_device_id *hid;
 271        struct acpi_driver *driver;
 272
 273        void (*notify) (struct ibm_struct *, u32);
 274        acpi_handle *handle;
 275        u32 type;
 276        struct acpi_device *device;
 277};
 278
 279struct ibm_struct {
 280        char *name;
 281
 282        int (*read) (struct seq_file *);
 283        int (*write) (char *);
 284        void (*exit) (void);
 285        void (*resume) (void);
 286        void (*suspend) (void);
 287        void (*shutdown) (void);
 288
 289        struct list_head all_drivers;
 290
 291        struct tp_acpi_drv_struct *acpi;
 292
 293        struct {
 294                u8 acpi_driver_registered:1;
 295                u8 acpi_notify_installed:1;
 296                u8 proc_created:1;
 297                u8 init_called:1;
 298                u8 experimental:1;
 299        } flags;
 300};
 301
 302struct ibm_init_struct {
 303        char param[32];
 304
 305        int (*init) (struct ibm_init_struct *);
 306        umode_t base_procfs_mode;
 307        struct ibm_struct *data;
 308};
 309
 310static struct {
 311        u32 bluetooth:1;
 312        u32 hotkey:1;
 313        u32 hotkey_mask:1;
 314        u32 hotkey_wlsw:1;
 315        enum {
 316                TP_HOTKEY_TABLET_NONE = 0,
 317                TP_HOTKEY_TABLET_USES_MHKG,
 318                TP_HOTKEY_TABLET_USES_GMMS,
 319        } hotkey_tablet;
 320        u32 kbdlight:1;
 321        u32 light:1;
 322        u32 light_status:1;
 323        u32 bright_acpimode:1;
 324        u32 bright_unkfw:1;
 325        u32 wan:1;
 326        u32 uwb:1;
 327        u32 fan_ctrl_status_undef:1;
 328        u32 second_fan:1;
 329        u32 second_fan_ctl:1;
 330        u32 beep_needs_two_args:1;
 331        u32 mixer_no_level_control:1;
 332        u32 battery_force_primary:1;
 333        u32 input_device_registered:1;
 334        u32 platform_drv_registered:1;
 335        u32 platform_drv_attrs_registered:1;
 336        u32 sensors_pdrv_registered:1;
 337        u32 sensors_pdrv_attrs_registered:1;
 338        u32 sensors_pdev_attrs_registered:1;
 339        u32 hotkey_poll_active:1;
 340        u32 has_adaptive_kbd:1;
 341} tp_features;
 342
 343static struct {
 344        u16 hotkey_mask_ff:1;
 345        u16 volume_ctrl_forbidden:1;
 346} tp_warned;
 347
 348struct thinkpad_id_data {
 349        unsigned int vendor;    /* ThinkPad vendor:
 350                                 * PCI_VENDOR_ID_IBM/PCI_VENDOR_ID_LENOVO */
 351
 352        char *bios_version_str; /* Something like 1ZET51WW (1.03z) */
 353        char *ec_version_str;   /* Something like 1ZHT51WW-1.04a */
 354
 355        u32 bios_model;         /* 1Y = 0x3159, 0 = unknown */
 356        u32 ec_model;
 357        u16 bios_release;       /* 1ZETK1WW = 0x4b31, 0 = unknown */
 358        u16 ec_release;
 359
 360        char *model_str;        /* ThinkPad T43 */
 361        char *nummodel_str;     /* 9384A9C for a 9384-A9C model */
 362};
 363static struct thinkpad_id_data thinkpad_id;
 364
 365static enum {
 366        TPACPI_LIFE_INIT = 0,
 367        TPACPI_LIFE_RUNNING,
 368        TPACPI_LIFE_EXITING,
 369} tpacpi_lifecycle;
 370
 371static int experimental;
 372static u32 dbg_level;
 373
 374static struct workqueue_struct *tpacpi_wq;
 375
 376enum led_status_t {
 377        TPACPI_LED_OFF = 0,
 378        TPACPI_LED_ON,
 379        TPACPI_LED_BLINK,
 380};
 381
 382/* tpacpi LED class */
 383struct tpacpi_led_classdev {
 384        struct led_classdev led_classdev;
 385        int led;
 386};
 387
 388/* brightness level capabilities */
 389static unsigned int bright_maxlvl;      /* 0 = unknown */
 390
 391#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
 392static int dbg_wlswemul;
 393static bool tpacpi_wlsw_emulstate;
 394static int dbg_bluetoothemul;
 395static bool tpacpi_bluetooth_emulstate;
 396static int dbg_wwanemul;
 397static bool tpacpi_wwan_emulstate;
 398static int dbg_uwbemul;
 399static bool tpacpi_uwb_emulstate;
 400#endif
 401
 402
 403/*************************************************************************
 404 *  Debugging helpers
 405 */
 406
 407#define dbg_printk(a_dbg_level, format, arg...)                         \
 408do {                                                                    \
 409        if (dbg_level & (a_dbg_level))                                  \
 410                printk(KERN_DEBUG pr_fmt("%s: " format),                \
 411                       __func__, ##arg);                                \
 412} while (0)
 413
 414#ifdef CONFIG_THINKPAD_ACPI_DEBUG
 415#define vdbg_printk dbg_printk
 416static const char *str_supported(int is_supported);
 417#else
 418static inline const char *str_supported(int is_supported) { return ""; }
 419#define vdbg_printk(a_dbg_level, format, arg...)        \
 420        do { if (0) no_printk(format, ##arg); } while (0)
 421#endif
 422
 423static void tpacpi_log_usertask(const char * const what)
 424{
 425        printk(KERN_DEBUG pr_fmt("%s: access by process with PID %d\n"),
 426               what, task_tgid_vnr(current));
 427}
 428
 429#define tpacpi_disclose_usertask(what, format, arg...)                  \
 430do {                                                                    \
 431        if (unlikely((dbg_level & TPACPI_DBG_DISCLOSETASK) &&           \
 432                     (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) {      \
 433                printk(KERN_DEBUG pr_fmt("%s: PID %d: " format),        \
 434                       what, task_tgid_vnr(current), ## arg);           \
 435        }                                                               \
 436} while (0)
 437
 438/*
 439 * Quirk handling helpers
 440 *
 441 * ThinkPad IDs and versions seen in the field so far are
 442 * two or three characters from the set [0-9A-Z], i.e. base 36.
 443 *
 444 * We use values well outside that range as specials.
 445 */
 446
 447#define TPACPI_MATCH_ANY                0xffffffffU
 448#define TPACPI_MATCH_ANY_VERSION        0xffffU
 449#define TPACPI_MATCH_UNKNOWN            0U
 450
 451/* TPID('1', 'Y') == 0x3159 */
 452#define TPID(__c1, __c2)        (((__c1) << 8) | (__c2))
 453#define TPID3(__c1, __c2, __c3) (((__c1) << 16) | ((__c2) << 8) | (__c3))
 454#define TPVER TPID
 455
 456#define TPACPI_Q_IBM(__id1, __id2, __quirk)     \
 457        { .vendor = PCI_VENDOR_ID_IBM,          \
 458          .bios = TPID(__id1, __id2),           \
 459          .ec = TPACPI_MATCH_ANY,               \
 460          .quirks = (__quirk) }
 461
 462#define TPACPI_Q_LNV(__id1, __id2, __quirk)     \
 463        { .vendor = PCI_VENDOR_ID_LENOVO,       \
 464          .bios = TPID(__id1, __id2),           \
 465          .ec = TPACPI_MATCH_ANY,               \
 466          .quirks = (__quirk) }
 467
 468#define TPACPI_Q_LNV3(__id1, __id2, __id3, __quirk) \
 469        { .vendor = PCI_VENDOR_ID_LENOVO,       \
 470          .bios = TPID3(__id1, __id2, __id3),   \
 471          .ec = TPACPI_MATCH_ANY,               \
 472          .quirks = (__quirk) }
 473
 474#define TPACPI_QEC_IBM(__id1, __id2, __quirk)   \
 475        { .vendor = PCI_VENDOR_ID_IBM,          \
 476          .bios = TPACPI_MATCH_ANY,             \
 477          .ec = TPID(__id1, __id2),             \
 478          .quirks = (__quirk) }
 479
 480#define TPACPI_QEC_LNV(__id1, __id2, __quirk)   \
 481        { .vendor = PCI_VENDOR_ID_LENOVO,       \
 482          .bios = TPACPI_MATCH_ANY,             \
 483          .ec = TPID(__id1, __id2),             \
 484          .quirks = (__quirk) }
 485
 486struct tpacpi_quirk {
 487        unsigned int vendor;
 488        u32 bios;
 489        u32 ec;
 490        unsigned long quirks;
 491};
 492
 493/**
 494 * tpacpi_check_quirks() - search BIOS/EC version on a list
 495 * @qlist:              array of &struct tpacpi_quirk
 496 * @qlist_size:         number of elements in @qlist
 497 *
 498 * Iterates over a quirks list until one is found that matches the
 499 * ThinkPad's vendor, BIOS and EC model.
 500 *
 501 * Returns 0 if nothing matches, otherwise returns the quirks field of
 502 * the matching &struct tpacpi_quirk entry.
 503 *
 504 * The match criteria is: vendor, ec and bios much match.
 505 */
 506static unsigned long __init tpacpi_check_quirks(
 507                        const struct tpacpi_quirk *qlist,
 508                        unsigned int qlist_size)
 509{
 510        while (qlist_size) {
 511                if ((qlist->vendor == thinkpad_id.vendor ||
 512                                qlist->vendor == TPACPI_MATCH_ANY) &&
 513                    (qlist->bios == thinkpad_id.bios_model ||
 514                                qlist->bios == TPACPI_MATCH_ANY) &&
 515                    (qlist->ec == thinkpad_id.ec_model ||
 516                                qlist->ec == TPACPI_MATCH_ANY))
 517                        return qlist->quirks;
 518
 519                qlist_size--;
 520                qlist++;
 521        }
 522        return 0;
 523}
 524
 525static inline bool __pure __init tpacpi_is_lenovo(void)
 526{
 527        return thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO;
 528}
 529
 530static inline bool __pure __init tpacpi_is_ibm(void)
 531{
 532        return thinkpad_id.vendor == PCI_VENDOR_ID_IBM;
 533}
 534
 535/****************************************************************************
 536 ****************************************************************************
 537 *
 538 * ACPI Helpers and device model
 539 *
 540 ****************************************************************************
 541 ****************************************************************************/
 542
 543/*************************************************************************
 544 * ACPI basic handles
 545 */
 546
 547static acpi_handle root_handle;
 548static acpi_handle ec_handle;
 549
 550#define TPACPI_HANDLE(object, parent, paths...)                 \
 551        static acpi_handle  object##_handle;                    \
 552        static const acpi_handle * const object##_parent __initconst =  \
 553                                                &parent##_handle; \
 554        static char *object##_paths[] __initdata = { paths }
 555
 556TPACPI_HANDLE(ecrd, ec, "ECRD");        /* 570 */
 557TPACPI_HANDLE(ecwr, ec, "ECWR");        /* 570 */
 558
 559TPACPI_HANDLE(cmos, root, "\\UCMS",     /* R50, R50e, R50p, R51, */
 560                                        /* T4x, X31, X40 */
 561           "\\CMOS",            /* A3x, G4x, R32, T23, T30, X22-24, X30 */
 562           "\\CMS",             /* R40, R40e */
 563           );                   /* all others */
 564
 565TPACPI_HANDLE(hkey, ec, "\\_SB.HKEY",   /* 600e/x, 770e, 770x */
 566           "^HKEY",             /* R30, R31 */
 567           "HKEY",              /* all others */
 568           );                   /* 570 */
 569
 570/*************************************************************************
 571 * ACPI helpers
 572 */
 573
 574static int acpi_evalf(acpi_handle handle,
 575                      int *res, char *method, char *fmt, ...)
 576{
 577        char *fmt0 = fmt;
 578        struct acpi_object_list params;
 579        union acpi_object in_objs[TPACPI_MAX_ACPI_ARGS];
 580        struct acpi_buffer result, *resultp;
 581        union acpi_object out_obj;
 582        acpi_status status;
 583        va_list ap;
 584        char res_type;
 585        int success;
 586        int quiet;
 587
 588        if (!*fmt) {
 589                pr_err("acpi_evalf() called with empty format\n");
 590                return 0;
 591        }
 592
 593        if (*fmt == 'q') {
 594                quiet = 1;
 595                fmt++;
 596        } else
 597                quiet = 0;
 598
 599        res_type = *(fmt++);
 600
 601        params.count = 0;
 602        params.pointer = &in_objs[0];
 603
 604        va_start(ap, fmt);
 605        while (*fmt) {
 606                char c = *(fmt++);
 607                switch (c) {
 608                case 'd':       /* int */
 609                        in_objs[params.count].integer.value = va_arg(ap, int);
 610                        in_objs[params.count++].type = ACPI_TYPE_INTEGER;
 611                        break;
 612                        /* add more types as needed */
 613                default:
 614                        pr_err("acpi_evalf() called with invalid format character '%c'\n",
 615                               c);
 616                        va_end(ap);
 617                        return 0;
 618                }
 619        }
 620        va_end(ap);
 621
 622        if (res_type != 'v') {
 623                result.length = sizeof(out_obj);
 624                result.pointer = &out_obj;
 625                resultp = &result;
 626        } else
 627                resultp = NULL;
 628
 629        status = acpi_evaluate_object(handle, method, &params, resultp);
 630
 631        switch (res_type) {
 632        case 'd':               /* int */
 633                success = (status == AE_OK &&
 634                           out_obj.type == ACPI_TYPE_INTEGER);
 635                if (success && res)
 636                        *res = out_obj.integer.value;
 637                break;
 638        case 'v':               /* void */
 639                success = status == AE_OK;
 640                break;
 641                /* add more types as needed */
 642        default:
 643                pr_err("acpi_evalf() called with invalid format character '%c'\n",
 644                       res_type);
 645                return 0;
 646        }
 647
 648        if (!success && !quiet)
 649                pr_err("acpi_evalf(%s, %s, ...) failed: %s\n",
 650                       method, fmt0, acpi_format_exception(status));
 651
 652        return success;
 653}
 654
 655static int acpi_ec_read(int i, u8 *p)
 656{
 657        int v;
 658
 659        if (ecrd_handle) {
 660                if (!acpi_evalf(ecrd_handle, &v, NULL, "dd", i))
 661                        return 0;
 662                *p = v;
 663        } else {
 664                if (ec_read(i, p) < 0)
 665                        return 0;
 666        }
 667
 668        return 1;
 669}
 670
 671static int acpi_ec_write(int i, u8 v)
 672{
 673        if (ecwr_handle) {
 674                if (!acpi_evalf(ecwr_handle, NULL, NULL, "vdd", i, v))
 675                        return 0;
 676        } else {
 677                if (ec_write(i, v) < 0)
 678                        return 0;
 679        }
 680
 681        return 1;
 682}
 683
 684static int issue_thinkpad_cmos_command(int cmos_cmd)
 685{
 686        if (!cmos_handle)
 687                return -ENXIO;
 688
 689        if (!acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd))
 690                return -EIO;
 691
 692        return 0;
 693}
 694
 695/*************************************************************************
 696 * ACPI device model
 697 */
 698
 699#define TPACPI_ACPIHANDLE_INIT(object) \
 700        drv_acpi_handle_init(#object, &object##_handle, *object##_parent, \
 701                object##_paths, ARRAY_SIZE(object##_paths))
 702
 703static void __init drv_acpi_handle_init(const char *name,
 704                           acpi_handle *handle, const acpi_handle parent,
 705                           char **paths, const int num_paths)
 706{
 707        int i;
 708        acpi_status status;
 709
 710        vdbg_printk(TPACPI_DBG_INIT, "trying to locate ACPI handle for %s\n",
 711                name);
 712
 713        for (i = 0; i < num_paths; i++) {
 714                status = acpi_get_handle(parent, paths[i], handle);
 715                if (ACPI_SUCCESS(status)) {
 716                        dbg_printk(TPACPI_DBG_INIT,
 717                                   "Found ACPI handle %s for %s\n",
 718                                   paths[i], name);
 719                        return;
 720                }
 721        }
 722
 723        vdbg_printk(TPACPI_DBG_INIT, "ACPI handle for %s not found\n",
 724                    name);
 725        *handle = NULL;
 726}
 727
 728static acpi_status __init tpacpi_acpi_handle_locate_callback(acpi_handle handle,
 729                        u32 level, void *context, void **return_value)
 730{
 731        struct acpi_device *dev;
 732        if (!strcmp(context, "video")) {
 733                if (acpi_bus_get_device(handle, &dev))
 734                        return AE_OK;
 735                if (strcmp(ACPI_VIDEO_HID, acpi_device_hid(dev)))
 736                        return AE_OK;
 737        }
 738
 739        *(acpi_handle *)return_value = handle;
 740
 741        return AE_CTRL_TERMINATE;
 742}
 743
 744static void __init tpacpi_acpi_handle_locate(const char *name,
 745                const char *hid,
 746                acpi_handle *handle)
 747{
 748        acpi_status status;
 749        acpi_handle device_found;
 750
 751        BUG_ON(!name || !handle);
 752        vdbg_printk(TPACPI_DBG_INIT,
 753                        "trying to locate ACPI handle for %s, using HID %s\n",
 754                        name, hid ? hid : "NULL");
 755
 756        memset(&device_found, 0, sizeof(device_found));
 757        status = acpi_get_devices(hid, tpacpi_acpi_handle_locate_callback,
 758                                  (void *)name, &device_found);
 759
 760        *handle = NULL;
 761
 762        if (ACPI_SUCCESS(status)) {
 763                *handle = device_found;
 764                dbg_printk(TPACPI_DBG_INIT,
 765                           "Found ACPI handle for %s\n", name);
 766        } else {
 767                vdbg_printk(TPACPI_DBG_INIT,
 768                            "Could not locate an ACPI handle for %s: %s\n",
 769                            name, acpi_format_exception(status));
 770        }
 771}
 772
 773static void dispatch_acpi_notify(acpi_handle handle, u32 event, void *data)
 774{
 775        struct ibm_struct *ibm = data;
 776
 777        if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
 778                return;
 779
 780        if (!ibm || !ibm->acpi || !ibm->acpi->notify)
 781                return;
 782
 783        ibm->acpi->notify(ibm, event);
 784}
 785
 786static int __init setup_acpi_notify(struct ibm_struct *ibm)
 787{
 788        acpi_status status;
 789        int rc;
 790
 791        BUG_ON(!ibm->acpi);
 792
 793        if (!*ibm->acpi->handle)
 794                return 0;
 795
 796        vdbg_printk(TPACPI_DBG_INIT,
 797                "setting up ACPI notify for %s\n", ibm->name);
 798
 799        rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
 800        if (rc < 0) {
 801                pr_err("acpi_bus_get_device(%s) failed: %d\n", ibm->name, rc);
 802                return -ENODEV;
 803        }
 804
 805        ibm->acpi->device->driver_data = ibm;
 806        sprintf(acpi_device_class(ibm->acpi->device), "%s/%s",
 807                TPACPI_ACPI_EVENT_PREFIX,
 808                ibm->name);
 809
 810        status = acpi_install_notify_handler(*ibm->acpi->handle,
 811                        ibm->acpi->type, dispatch_acpi_notify, ibm);
 812        if (ACPI_FAILURE(status)) {
 813                if (status == AE_ALREADY_EXISTS) {
 814                        pr_notice("another device driver is already handling %s events\n",
 815                                  ibm->name);
 816                } else {
 817                        pr_err("acpi_install_notify_handler(%s) failed: %s\n",
 818                               ibm->name, acpi_format_exception(status));
 819                }
 820                return -ENODEV;
 821        }
 822        ibm->flags.acpi_notify_installed = 1;
 823        return 0;
 824}
 825
 826static int __init tpacpi_device_add(struct acpi_device *device)
 827{
 828        return 0;
 829}
 830
 831static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
 832{
 833        int rc;
 834
 835        dbg_printk(TPACPI_DBG_INIT,
 836                "registering %s as an ACPI driver\n", ibm->name);
 837
 838        BUG_ON(!ibm->acpi);
 839
 840        ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
 841        if (!ibm->acpi->driver) {
 842                pr_err("failed to allocate memory for ibm->acpi->driver\n");
 843                return -ENOMEM;
 844        }
 845
 846        sprintf(ibm->acpi->driver->name, "%s_%s", TPACPI_NAME, ibm->name);
 847        ibm->acpi->driver->ids = ibm->acpi->hid;
 848
 849        ibm->acpi->driver->ops.add = &tpacpi_device_add;
 850
 851        rc = acpi_bus_register_driver(ibm->acpi->driver);
 852        if (rc < 0) {
 853                pr_err("acpi_bus_register_driver(%s) failed: %d\n",
 854                       ibm->name, rc);
 855                kfree(ibm->acpi->driver);
 856                ibm->acpi->driver = NULL;
 857        } else if (!rc)
 858                ibm->flags.acpi_driver_registered = 1;
 859
 860        return rc;
 861}
 862
 863
 864/****************************************************************************
 865 ****************************************************************************
 866 *
 867 * Procfs Helpers
 868 *
 869 ****************************************************************************
 870 ****************************************************************************/
 871
 872static int dispatch_proc_show(struct seq_file *m, void *v)
 873{
 874        struct ibm_struct *ibm = m->private;
 875
 876        if (!ibm || !ibm->read)
 877                return -EINVAL;
 878        return ibm->read(m);
 879}
 880
 881static int dispatch_proc_open(struct inode *inode, struct file *file)
 882{
 883        return single_open(file, dispatch_proc_show, PDE_DATA(inode));
 884}
 885
 886static ssize_t dispatch_proc_write(struct file *file,
 887                        const char __user *userbuf,
 888                        size_t count, loff_t *pos)
 889{
 890        struct ibm_struct *ibm = PDE_DATA(file_inode(file));
 891        char *kernbuf;
 892        int ret;
 893
 894        if (!ibm || !ibm->write)
 895                return -EINVAL;
 896        if (count > PAGE_SIZE - 1)
 897                return -EINVAL;
 898
 899        kernbuf = kmalloc(count + 1, GFP_KERNEL);
 900        if (!kernbuf)
 901                return -ENOMEM;
 902
 903        if (copy_from_user(kernbuf, userbuf, count)) {
 904                kfree(kernbuf);
 905                return -EFAULT;
 906        }
 907
 908        kernbuf[count] = 0;
 909        ret = ibm->write(kernbuf);
 910        if (ret == 0)
 911                ret = count;
 912
 913        kfree(kernbuf);
 914
 915        return ret;
 916}
 917
 918static const struct proc_ops dispatch_proc_ops = {
 919        .proc_open      = dispatch_proc_open,
 920        .proc_read      = seq_read,
 921        .proc_lseek     = seq_lseek,
 922        .proc_release   = single_release,
 923        .proc_write     = dispatch_proc_write,
 924};
 925
 926/****************************************************************************
 927 ****************************************************************************
 928 *
 929 * Device model: input, hwmon and platform
 930 *
 931 ****************************************************************************
 932 ****************************************************************************/
 933
 934static struct platform_device *tpacpi_pdev;
 935static struct platform_device *tpacpi_sensors_pdev;
 936static struct device *tpacpi_hwmon;
 937static struct input_dev *tpacpi_inputdev;
 938static struct mutex tpacpi_inputdev_send_mutex;
 939static LIST_HEAD(tpacpi_all_drivers);
 940
 941#ifdef CONFIG_PM_SLEEP
 942static int tpacpi_suspend_handler(struct device *dev)
 943{
 944        struct ibm_struct *ibm, *itmp;
 945
 946        list_for_each_entry_safe(ibm, itmp,
 947                                 &tpacpi_all_drivers,
 948                                 all_drivers) {
 949                if (ibm->suspend)
 950                        (ibm->suspend)();
 951        }
 952
 953        return 0;
 954}
 955
 956static int tpacpi_resume_handler(struct device *dev)
 957{
 958        struct ibm_struct *ibm, *itmp;
 959
 960        list_for_each_entry_safe(ibm, itmp,
 961                                 &tpacpi_all_drivers,
 962                                 all_drivers) {
 963                if (ibm->resume)
 964                        (ibm->resume)();
 965        }
 966
 967        return 0;
 968}
 969#endif
 970
 971static SIMPLE_DEV_PM_OPS(tpacpi_pm,
 972                         tpacpi_suspend_handler, tpacpi_resume_handler);
 973
 974static void tpacpi_shutdown_handler(struct platform_device *pdev)
 975{
 976        struct ibm_struct *ibm, *itmp;
 977
 978        list_for_each_entry_safe(ibm, itmp,
 979                                 &tpacpi_all_drivers,
 980                                 all_drivers) {
 981                if (ibm->shutdown)
 982                        (ibm->shutdown)();
 983        }
 984}
 985
 986static struct platform_driver tpacpi_pdriver = {
 987        .driver = {
 988                .name = TPACPI_DRVR_NAME,
 989                .pm = &tpacpi_pm,
 990        },
 991        .shutdown = tpacpi_shutdown_handler,
 992};
 993
 994static struct platform_driver tpacpi_hwmon_pdriver = {
 995        .driver = {
 996                .name = TPACPI_HWMON_DRVR_NAME,
 997        },
 998};
 999
1000/*************************************************************************
1001 * sysfs support helpers
1002 */
1003
1004struct attribute_set {
1005        unsigned int members, max_members;
1006        struct attribute_group group;
1007};
1008
1009struct attribute_set_obj {
1010        struct attribute_set s;
1011        struct attribute *a;
1012} __attribute__((packed));
1013
1014static struct attribute_set *create_attr_set(unsigned int max_members,
1015                                                const char *name)
1016{
1017        struct attribute_set_obj *sobj;
1018
1019        if (max_members == 0)
1020                return NULL;
1021
1022        /* Allocates space for implicit NULL at the end too */
1023        sobj = kzalloc(sizeof(struct attribute_set_obj) +
1024                    max_members * sizeof(struct attribute *),
1025                    GFP_KERNEL);
1026        if (!sobj)
1027                return NULL;
1028        sobj->s.max_members = max_members;
1029        sobj->s.group.attrs = &sobj->a;
1030        sobj->s.group.name = name;
1031
1032        return &sobj->s;
1033}
1034
1035#define destroy_attr_set(_set) \
1036        kfree(_set)
1037
1038/* not multi-threaded safe, use it in a single thread per set */
1039static int add_to_attr_set(struct attribute_set *s, struct attribute *attr)
1040{
1041        if (!s || !attr)
1042                return -EINVAL;
1043
1044        if (s->members >= s->max_members)
1045                return -ENOMEM;
1046
1047        s->group.attrs[s->members] = attr;
1048        s->members++;
1049
1050        return 0;
1051}
1052
1053static int add_many_to_attr_set(struct attribute_set *s,
1054                        struct attribute **attr,
1055                        unsigned int count)
1056{
1057        int i, res;
1058
1059        for (i = 0; i < count; i++) {
1060                res = add_to_attr_set(s, attr[i]);
1061                if (res)
1062                        return res;
1063        }
1064
1065        return 0;
1066}
1067
1068static void delete_attr_set(struct attribute_set *s, struct kobject *kobj)
1069{
1070        sysfs_remove_group(kobj, &s->group);
1071        destroy_attr_set(s);
1072}
1073
1074#define register_attr_set_with_sysfs(_attr_set, _kobj) \
1075        sysfs_create_group(_kobj, &_attr_set->group)
1076
1077static int parse_strtoul(const char *buf,
1078                unsigned long max, unsigned long *value)
1079{
1080        char *endp;
1081
1082        *value = simple_strtoul(skip_spaces(buf), &endp, 0);
1083        endp = skip_spaces(endp);
1084        if (*endp || *value > max)
1085                return -EINVAL;
1086
1087        return 0;
1088}
1089
1090static void tpacpi_disable_brightness_delay(void)
1091{
1092        if (acpi_evalf(hkey_handle, NULL, "PWMS", "qvd", 0))
1093                pr_notice("ACPI backlight control delay disabled\n");
1094}
1095
1096static void printk_deprecated_attribute(const char * const what,
1097                                        const char * const details)
1098{
1099        tpacpi_log_usertask("deprecated sysfs attribute");
1100        pr_warn("WARNING: sysfs attribute %s is deprecated and will be removed. %s\n",
1101                what, details);
1102}
1103
1104/*************************************************************************
1105 * rfkill and radio control support helpers
1106 */
1107
1108/*
1109 * ThinkPad-ACPI firmware handling model:
1110 *
1111 * WLSW (master wireless switch) is event-driven, and is common to all
1112 * firmware-controlled radios.  It cannot be controlled, just monitored,
1113 * as expected.  It overrides all radio state in firmware
1114 *
1115 * The kernel, a masked-off hotkey, and WLSW can change the radio state
1116 * (TODO: verify how WLSW interacts with the returned radio state).
1117 *
1118 * The only time there are shadow radio state changes, is when
1119 * masked-off hotkeys are used.
1120 */
1121
1122/*
1123 * Internal driver API for radio state:
1124 *
1125 * int: < 0 = error, otherwise enum tpacpi_rfkill_state
1126 * bool: true means radio blocked (off)
1127 */
1128enum tpacpi_rfkill_state {
1129        TPACPI_RFK_RADIO_OFF = 0,
1130        TPACPI_RFK_RADIO_ON
1131};
1132
1133/* rfkill switches */
1134enum tpacpi_rfk_id {
1135        TPACPI_RFK_BLUETOOTH_SW_ID = 0,
1136        TPACPI_RFK_WWAN_SW_ID,
1137        TPACPI_RFK_UWB_SW_ID,
1138        TPACPI_RFK_SW_MAX
1139};
1140
1141static const char *tpacpi_rfkill_names[] = {
1142        [TPACPI_RFK_BLUETOOTH_SW_ID] = "bluetooth",
1143        [TPACPI_RFK_WWAN_SW_ID] = "wwan",
1144        [TPACPI_RFK_UWB_SW_ID] = "uwb",
1145        [TPACPI_RFK_SW_MAX] = NULL
1146};
1147
1148/* ThinkPad-ACPI rfkill subdriver */
1149struct tpacpi_rfk {
1150        struct rfkill *rfkill;
1151        enum tpacpi_rfk_id id;
1152        const struct tpacpi_rfk_ops *ops;
1153};
1154
1155struct tpacpi_rfk_ops {
1156        /* firmware interface */
1157        int (*get_status)(void);
1158        int (*set_status)(const enum tpacpi_rfkill_state);
1159};
1160
1161static struct tpacpi_rfk *tpacpi_rfkill_switches[TPACPI_RFK_SW_MAX];
1162
1163/* Query FW and update rfkill sw state for a given rfkill switch */
1164static int tpacpi_rfk_update_swstate(const struct tpacpi_rfk *tp_rfk)
1165{
1166        int status;
1167
1168        if (!tp_rfk)
1169                return -ENODEV;
1170
1171        status = (tp_rfk->ops->get_status)();
1172        if (status < 0)
1173                return status;
1174
1175        rfkill_set_sw_state(tp_rfk->rfkill,
1176                            (status == TPACPI_RFK_RADIO_OFF));
1177
1178        return status;
1179}
1180
1181/* Query FW and update rfkill sw state for all rfkill switches */
1182static void tpacpi_rfk_update_swstate_all(void)
1183{
1184        unsigned int i;
1185
1186        for (i = 0; i < TPACPI_RFK_SW_MAX; i++)
1187                tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[i]);
1188}
1189
1190/*
1191 * Sync the HW-blocking state of all rfkill switches,
1192 * do notice it causes the rfkill core to schedule uevents
1193 */
1194static void tpacpi_rfk_update_hwblock_state(bool blocked)
1195{
1196        unsigned int i;
1197        struct tpacpi_rfk *tp_rfk;
1198
1199        for (i = 0; i < TPACPI_RFK_SW_MAX; i++) {
1200                tp_rfk = tpacpi_rfkill_switches[i];
1201                if (tp_rfk) {
1202                        if (rfkill_set_hw_state(tp_rfk->rfkill,
1203                                                blocked)) {
1204                                /* ignore -- we track sw block */
1205                        }
1206                }
1207        }
1208}
1209
1210/* Call to get the WLSW state from the firmware */
1211static int hotkey_get_wlsw(void);
1212
1213/* Call to query WLSW state and update all rfkill switches */
1214static bool tpacpi_rfk_check_hwblock_state(void)
1215{
1216        int res = hotkey_get_wlsw();
1217        int hw_blocked;
1218
1219        /* When unknown or unsupported, we have to assume it is unblocked */
1220        if (res < 0)
1221                return false;
1222
1223        hw_blocked = (res == TPACPI_RFK_RADIO_OFF);
1224        tpacpi_rfk_update_hwblock_state(hw_blocked);
1225
1226        return hw_blocked;
1227}
1228
1229static int tpacpi_rfk_hook_set_block(void *data, bool blocked)
1230{
1231        struct tpacpi_rfk *tp_rfk = data;
1232        int res;
1233
1234        dbg_printk(TPACPI_DBG_RFKILL,
1235                   "request to change radio state to %s\n",
1236                   blocked ? "blocked" : "unblocked");
1237
1238        /* try to set radio state */
1239        res = (tp_rfk->ops->set_status)(blocked ?
1240                                TPACPI_RFK_RADIO_OFF : TPACPI_RFK_RADIO_ON);
1241
1242        /* and update the rfkill core with whatever the FW really did */
1243        tpacpi_rfk_update_swstate(tp_rfk);
1244
1245        return (res < 0) ? res : 0;
1246}
1247
1248static const struct rfkill_ops tpacpi_rfk_rfkill_ops = {
1249        .set_block = tpacpi_rfk_hook_set_block,
1250};
1251
1252static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
1253                        const struct tpacpi_rfk_ops *tp_rfkops,
1254                        const enum rfkill_type rfktype,
1255                        const char *name,
1256                        const bool set_default)
1257{
1258        struct tpacpi_rfk *atp_rfk;
1259        int res;
1260        bool sw_state = false;
1261        bool hw_state;
1262        int sw_status;
1263
1264        BUG_ON(id >= TPACPI_RFK_SW_MAX || tpacpi_rfkill_switches[id]);
1265
1266        atp_rfk = kzalloc(sizeof(struct tpacpi_rfk), GFP_KERNEL);
1267        if (atp_rfk)
1268                atp_rfk->rfkill = rfkill_alloc(name,
1269                                                &tpacpi_pdev->dev,
1270                                                rfktype,
1271                                                &tpacpi_rfk_rfkill_ops,
1272                                                atp_rfk);
1273        if (!atp_rfk || !atp_rfk->rfkill) {
1274                pr_err("failed to allocate memory for rfkill class\n");
1275                kfree(atp_rfk);
1276                return -ENOMEM;
1277        }
1278
1279        atp_rfk->id = id;
1280        atp_rfk->ops = tp_rfkops;
1281
1282        sw_status = (tp_rfkops->get_status)();
1283        if (sw_status < 0) {
1284                pr_err("failed to read initial state for %s, error %d\n",
1285                       name, sw_status);
1286        } else {
1287                sw_state = (sw_status == TPACPI_RFK_RADIO_OFF);
1288                if (set_default) {
1289                        /* try to keep the initial state, since we ask the
1290                         * firmware to preserve it across S5 in NVRAM */
1291                        rfkill_init_sw_state(atp_rfk->rfkill, sw_state);
1292                }
1293        }
1294        hw_state = tpacpi_rfk_check_hwblock_state();
1295        rfkill_set_hw_state(atp_rfk->rfkill, hw_state);
1296
1297        res = rfkill_register(atp_rfk->rfkill);
1298        if (res < 0) {
1299                pr_err("failed to register %s rfkill switch: %d\n", name, res);
1300                rfkill_destroy(atp_rfk->rfkill);
1301                kfree(atp_rfk);
1302                return res;
1303        }
1304
1305        tpacpi_rfkill_switches[id] = atp_rfk;
1306
1307        pr_info("rfkill switch %s: radio is %sblocked\n",
1308                name, (sw_state || hw_state) ? "" : "un");
1309        return 0;
1310}
1311
1312static void tpacpi_destroy_rfkill(const enum tpacpi_rfk_id id)
1313{
1314        struct tpacpi_rfk *tp_rfk;
1315
1316        BUG_ON(id >= TPACPI_RFK_SW_MAX);
1317
1318        tp_rfk = tpacpi_rfkill_switches[id];
1319        if (tp_rfk) {
1320                rfkill_unregister(tp_rfk->rfkill);
1321                rfkill_destroy(tp_rfk->rfkill);
1322                tpacpi_rfkill_switches[id] = NULL;
1323                kfree(tp_rfk);
1324        }
1325}
1326
1327static void printk_deprecated_rfkill_attribute(const char * const what)
1328{
1329        printk_deprecated_attribute(what,
1330                        "Please switch to generic rfkill before year 2010");
1331}
1332
1333/* sysfs <radio> enable ------------------------------------------------ */
1334static ssize_t tpacpi_rfk_sysfs_enable_show(const enum tpacpi_rfk_id id,
1335                                            struct device_attribute *attr,
1336                                            char *buf)
1337{
1338        int status;
1339
1340        printk_deprecated_rfkill_attribute(attr->attr.name);
1341
1342        /* This is in the ABI... */
1343        if (tpacpi_rfk_check_hwblock_state()) {
1344                status = TPACPI_RFK_RADIO_OFF;
1345        } else {
1346                status = tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
1347                if (status < 0)
1348                        return status;
1349        }
1350
1351        return snprintf(buf, PAGE_SIZE, "%d\n",
1352                        (status == TPACPI_RFK_RADIO_ON) ? 1 : 0);
1353}
1354
1355static ssize_t tpacpi_rfk_sysfs_enable_store(const enum tpacpi_rfk_id id,
1356                            struct device_attribute *attr,
1357                            const char *buf, size_t count)
1358{
1359        unsigned long t;
1360        int res;
1361
1362        printk_deprecated_rfkill_attribute(attr->attr.name);
1363
1364        if (parse_strtoul(buf, 1, &t))
1365                return -EINVAL;
1366
1367        tpacpi_disclose_usertask(attr->attr.name, "set to %ld\n", t);
1368
1369        /* This is in the ABI... */
1370        if (tpacpi_rfk_check_hwblock_state() && !!t)
1371                return -EPERM;
1372
1373        res = tpacpi_rfkill_switches[id]->ops->set_status((!!t) ?
1374                                TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF);
1375        tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
1376
1377        return (res < 0) ? res : count;
1378}
1379
1380/* procfs -------------------------------------------------------------- */
1381static int tpacpi_rfk_procfs_read(const enum tpacpi_rfk_id id, struct seq_file *m)
1382{
1383        if (id >= TPACPI_RFK_SW_MAX)
1384                seq_printf(m, "status:\t\tnot supported\n");
1385        else {
1386                int status;
1387
1388                /* This is in the ABI... */
1389                if (tpacpi_rfk_check_hwblock_state()) {
1390                        status = TPACPI_RFK_RADIO_OFF;
1391                } else {
1392                        status = tpacpi_rfk_update_swstate(
1393                                                tpacpi_rfkill_switches[id]);
1394                        if (status < 0)
1395                                return status;
1396                }
1397
1398                seq_printf(m, "status:\t\t%s\n",
1399                                (status == TPACPI_RFK_RADIO_ON) ?
1400                                        "enabled" : "disabled");
1401                seq_printf(m, "commands:\tenable, disable\n");
1402        }
1403
1404        return 0;
1405}
1406
1407static int tpacpi_rfk_procfs_write(const enum tpacpi_rfk_id id, char *buf)
1408{
1409        char *cmd;
1410        int status = -1;
1411        int res = 0;
1412
1413        if (id >= TPACPI_RFK_SW_MAX)
1414                return -ENODEV;
1415
1416        while ((cmd = strsep(&buf, ","))) {
1417                if (strlencmp(cmd, "enable") == 0)
1418                        status = TPACPI_RFK_RADIO_ON;
1419                else if (strlencmp(cmd, "disable") == 0)
1420                        status = TPACPI_RFK_RADIO_OFF;
1421                else
1422                        return -EINVAL;
1423        }
1424
1425        if (status != -1) {
1426                tpacpi_disclose_usertask("procfs", "attempt to %s %s\n",
1427                                (status == TPACPI_RFK_RADIO_ON) ?
1428                                                "enable" : "disable",
1429                                tpacpi_rfkill_names[id]);
1430                res = (tpacpi_rfkill_switches[id]->ops->set_status)(status);
1431                tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
1432        }
1433
1434        return res;
1435}
1436
1437/*************************************************************************
1438 * thinkpad-acpi driver attributes
1439 */
1440
1441/* interface_version --------------------------------------------------- */
1442static ssize_t interface_version_show(struct device_driver *drv, char *buf)
1443{
1444        return snprintf(buf, PAGE_SIZE, "0x%08x\n", TPACPI_SYSFS_VERSION);
1445}
1446static DRIVER_ATTR_RO(interface_version);
1447
1448/* debug_level --------------------------------------------------------- */
1449static ssize_t debug_level_show(struct device_driver *drv, char *buf)
1450{
1451        return snprintf(buf, PAGE_SIZE, "0x%04x\n", dbg_level);
1452}
1453
1454static ssize_t debug_level_store(struct device_driver *drv, const char *buf,
1455                                 size_t count)
1456{
1457        unsigned long t;
1458
1459        if (parse_strtoul(buf, 0xffff, &t))
1460                return -EINVAL;
1461
1462        dbg_level = t;
1463
1464        return count;
1465}
1466static DRIVER_ATTR_RW(debug_level);
1467
1468/* version ------------------------------------------------------------- */
1469static ssize_t version_show(struct device_driver *drv, char *buf)
1470{
1471        return snprintf(buf, PAGE_SIZE, "%s v%s\n",
1472                        TPACPI_DESC, TPACPI_VERSION);
1473}
1474static DRIVER_ATTR_RO(version);
1475
1476/* --------------------------------------------------------------------- */
1477
1478#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
1479
1480/* wlsw_emulstate ------------------------------------------------------ */
1481static ssize_t wlsw_emulstate_show(struct device_driver *drv, char *buf)
1482{
1483        return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wlsw_emulstate);
1484}
1485
1486static ssize_t wlsw_emulstate_store(struct device_driver *drv, const char *buf,
1487                                    size_t count)
1488{
1489        unsigned long t;
1490
1491        if (parse_strtoul(buf, 1, &t))
1492                return -EINVAL;
1493
1494        if (tpacpi_wlsw_emulstate != !!t) {
1495                tpacpi_wlsw_emulstate = !!t;
1496                tpacpi_rfk_update_hwblock_state(!t);    /* negative logic */
1497        }
1498
1499        return count;
1500}
1501static DRIVER_ATTR_RW(wlsw_emulstate);
1502
1503/* bluetooth_emulstate ------------------------------------------------- */
1504static ssize_t bluetooth_emulstate_show(struct device_driver *drv, char *buf)
1505{
1506        return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_bluetooth_emulstate);
1507}
1508
1509static ssize_t bluetooth_emulstate_store(struct device_driver *drv,
1510                                         const char *buf, size_t count)
1511{
1512        unsigned long t;
1513
1514        if (parse_strtoul(buf, 1, &t))
1515                return -EINVAL;
1516
1517        tpacpi_bluetooth_emulstate = !!t;
1518
1519        return count;
1520}
1521static DRIVER_ATTR_RW(bluetooth_emulstate);
1522
1523/* wwan_emulstate ------------------------------------------------- */
1524static ssize_t wwan_emulstate_show(struct device_driver *drv, char *buf)
1525{
1526        return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wwan_emulstate);
1527}
1528
1529static ssize_t wwan_emulstate_store(struct device_driver *drv, const char *buf,
1530                                    size_t count)
1531{
1532        unsigned long t;
1533
1534        if (parse_strtoul(buf, 1, &t))
1535                return -EINVAL;
1536
1537        tpacpi_wwan_emulstate = !!t;
1538
1539        return count;
1540}
1541static DRIVER_ATTR_RW(wwan_emulstate);
1542
1543/* uwb_emulstate ------------------------------------------------- */
1544static ssize_t uwb_emulstate_show(struct device_driver *drv, char *buf)
1545{
1546        return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_uwb_emulstate);
1547}
1548
1549static ssize_t uwb_emulstate_store(struct device_driver *drv, const char *buf,
1550                                   size_t count)
1551{
1552        unsigned long t;
1553
1554        if (parse_strtoul(buf, 1, &t))
1555                return -EINVAL;
1556
1557        tpacpi_uwb_emulstate = !!t;
1558
1559        return count;
1560}
1561static DRIVER_ATTR_RW(uwb_emulstate);
1562#endif
1563
1564/* --------------------------------------------------------------------- */
1565
1566static struct driver_attribute *tpacpi_driver_attributes[] = {
1567        &driver_attr_debug_level, &driver_attr_version,
1568        &driver_attr_interface_version,
1569};
1570
1571static int __init tpacpi_create_driver_attributes(struct device_driver *drv)
1572{
1573        int i, res;
1574
1575        i = 0;
1576        res = 0;
1577        while (!res && i < ARRAY_SIZE(tpacpi_driver_attributes)) {
1578                res = driver_create_file(drv, tpacpi_driver_attributes[i]);
1579                i++;
1580        }
1581
1582#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
1583        if (!res && dbg_wlswemul)
1584                res = driver_create_file(drv, &driver_attr_wlsw_emulstate);
1585        if (!res && dbg_bluetoothemul)
1586                res = driver_create_file(drv, &driver_attr_bluetooth_emulstate);
1587        if (!res && dbg_wwanemul)
1588                res = driver_create_file(drv, &driver_attr_wwan_emulstate);
1589        if (!res && dbg_uwbemul)
1590                res = driver_create_file(drv, &driver_attr_uwb_emulstate);
1591#endif
1592
1593        return res;
1594}
1595
1596static void tpacpi_remove_driver_attributes(struct device_driver *drv)
1597{
1598        int i;
1599
1600        for (i = 0; i < ARRAY_SIZE(tpacpi_driver_attributes); i++)
1601                driver_remove_file(drv, tpacpi_driver_attributes[i]);
1602
1603#ifdef THINKPAD_ACPI_DEBUGFACILITIES
1604        driver_remove_file(drv, &driver_attr_wlsw_emulstate);
1605        driver_remove_file(drv, &driver_attr_bluetooth_emulstate);
1606        driver_remove_file(drv, &driver_attr_wwan_emulstate);
1607        driver_remove_file(drv, &driver_attr_uwb_emulstate);
1608#endif
1609}
1610
1611/*************************************************************************
1612 * Firmware Data
1613 */
1614
1615/*
1616 * Table of recommended minimum BIOS versions
1617 *
1618 * Reasons for listing:
1619 *    1. Stable BIOS, listed because the unknown amount of
1620 *       bugs and bad ACPI behaviour on older versions
1621 *
1622 *    2. BIOS or EC fw with known bugs that trigger on Linux
1623 *
1624 *    3. BIOS with known reduced functionality in older versions
1625 *
1626 *  We recommend the latest BIOS and EC version.
1627 *  We only support the latest BIOS and EC fw version as a rule.
1628 *
1629 *  Sources: IBM ThinkPad Public Web Documents (update changelogs),
1630 *  Information from users in ThinkWiki
1631 *
1632 *  WARNING: we use this table also to detect that the machine is
1633 *  a ThinkPad in some cases, so don't remove entries lightly.
1634 */
1635
1636#define TPV_Q(__v, __id1, __id2, __bv1, __bv2)          \
1637        { .vendor       = (__v),                        \
1638          .bios         = TPID(__id1, __id2),           \
1639          .ec           = TPACPI_MATCH_ANY,             \
1640          .quirks       = TPACPI_MATCH_ANY_VERSION << 16 \
1641                          | TPVER(__bv1, __bv2) }
1642
1643#define TPV_Q_X(__v, __bid1, __bid2, __bv1, __bv2,      \
1644                __eid, __ev1, __ev2)                    \
1645        { .vendor       = (__v),                        \
1646          .bios         = TPID(__bid1, __bid2),         \
1647          .ec           = __eid,                        \
1648          .quirks       = TPVER(__ev1, __ev2) << 16     \
1649                          | TPVER(__bv1, __bv2) }
1650
1651#define TPV_QI0(__id1, __id2, __bv1, __bv2) \
1652        TPV_Q(PCI_VENDOR_ID_IBM, __id1, __id2, __bv1, __bv2)
1653
1654/* Outdated IBM BIOSes often lack the EC id string */
1655#define TPV_QI1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
1656        TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2,        \
1657                __bv1, __bv2, TPID(__id1, __id2),       \
1658                __ev1, __ev2),                          \
1659        TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2,        \
1660                __bv1, __bv2, TPACPI_MATCH_UNKNOWN,     \
1661                __ev1, __ev2)
1662
1663/* Outdated IBM BIOSes often lack the EC id string */
1664#define TPV_QI2(__bid1, __bid2, __bv1, __bv2,           \
1665                __eid1, __eid2, __ev1, __ev2)           \
1666        TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2,      \
1667                __bv1, __bv2, TPID(__eid1, __eid2),     \
1668                __ev1, __ev2),                          \
1669        TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2,      \
1670                __bv1, __bv2, TPACPI_MATCH_UNKNOWN,     \
1671                __ev1, __ev2)
1672
1673#define TPV_QL0(__id1, __id2, __bv1, __bv2) \
1674        TPV_Q(PCI_VENDOR_ID_LENOVO, __id1, __id2, __bv1, __bv2)
1675
1676#define TPV_QL1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
1677        TPV_Q_X(PCI_VENDOR_ID_LENOVO, __id1, __id2,     \
1678                __bv1, __bv2, TPID(__id1, __id2),       \
1679                __ev1, __ev2)
1680
1681#define TPV_QL2(__bid1, __bid2, __bv1, __bv2,           \
1682                __eid1, __eid2, __ev1, __ev2)           \
1683        TPV_Q_X(PCI_VENDOR_ID_LENOVO, __bid1, __bid2,   \
1684                __bv1, __bv2, TPID(__eid1, __eid2),     \
1685                __ev1, __ev2)
1686
1687static const struct tpacpi_quirk tpacpi_bios_version_qtable[] __initconst = {
1688        /*  Numeric models ------------------ */
1689        /*      FW MODEL   BIOS VERS          */
1690        TPV_QI0('I', 'M',  '6', '5'),            /* 570 */
1691        TPV_QI0('I', 'U',  '2', '6'),            /* 570E */
1692        TPV_QI0('I', 'B',  '5', '4'),            /* 600 */
1693        TPV_QI0('I', 'H',  '4', '7'),            /* 600E */
1694        TPV_QI0('I', 'N',  '3', '6'),            /* 600E */
1695        TPV_QI0('I', 'T',  '5', '5'),            /* 600X */
1696        TPV_QI0('I', 'D',  '4', '8'),            /* 770, 770E, 770ED */
1697        TPV_QI0('I', 'I',  '4', '2'),            /* 770X */
1698        TPV_QI0('I', 'O',  '2', '3'),            /* 770Z */
1699
1700        /* A-series ------------------------- */
1701        /*      FW MODEL   BIOS VERS  EC VERS */
1702        TPV_QI0('I', 'W',  '5', '9'),            /* A20m */
1703        TPV_QI0('I', 'V',  '6', '9'),            /* A20p */
1704        TPV_QI0('1', '0',  '2', '6'),            /* A21e, A22e */
1705        TPV_QI0('K', 'U',  '3', '6'),            /* A21e */
1706        TPV_QI0('K', 'X',  '3', '6'),            /* A21m, A22m */
1707        TPV_QI0('K', 'Y',  '3', '8'),            /* A21p, A22p */
1708        TPV_QI0('1', 'B',  '1', '7'),            /* A22e */
1709        TPV_QI0('1', '3',  '2', '0'),            /* A22m */
1710        TPV_QI0('1', 'E',  '7', '3'),            /* A30/p (0) */
1711        TPV_QI1('1', 'G',  '4', '1',  '1', '7'), /* A31/p (0) */
1712        TPV_QI1('1', 'N',  '1', '6',  '0', '7'), /* A31/p (0) */
1713
1714        /* G-series ------------------------- */
1715        /*      FW MODEL   BIOS VERS          */
1716        TPV_QI0('1', 'T',  'A', '6'),            /* G40 */
1717        TPV_QI0('1', 'X',  '5', '7'),            /* G41 */
1718
1719        /* R-series, T-series --------------- */
1720        /*      FW MODEL   BIOS VERS  EC VERS */
1721        TPV_QI0('1', 'C',  'F', '0'),            /* R30 */
1722        TPV_QI0('1', 'F',  'F', '1'),            /* R31 */
1723        TPV_QI0('1', 'M',  '9', '7'),            /* R32 */
1724        TPV_QI0('1', 'O',  '6', '1'),            /* R40 */
1725        TPV_QI0('1', 'P',  '6', '5'),            /* R40 */
1726        TPV_QI0('1', 'S',  '7', '0'),            /* R40e */
1727        TPV_QI1('1', 'R',  'D', 'R',  '7', '1'), /* R50/p, R51,
1728                                                    T40/p, T41/p, T42/p (1) */
1729        TPV_QI1('1', 'V',  '7', '1',  '2', '8'), /* R50e, R51 (1) */
1730        TPV_QI1('7', '8',  '7', '1',  '0', '6'), /* R51e (1) */
1731        TPV_QI1('7', '6',  '6', '9',  '1', '6'), /* R52 (1) */
1732        TPV_QI1('7', '0',  '6', '9',  '2', '8'), /* R52, T43 (1) */
1733
1734        TPV_QI0('I', 'Y',  '6', '1'),            /* T20 */
1735        TPV_QI0('K', 'Z',  '3', '4'),            /* T21 */
1736        TPV_QI0('1', '6',  '3', '2'),            /* T22 */
1737        TPV_QI1('1', 'A',  '6', '4',  '2', '3'), /* T23 (0) */
1738        TPV_QI1('1', 'I',  '7', '1',  '2', '0'), /* T30 (0) */
1739        TPV_QI1('1', 'Y',  '6', '5',  '2', '9'), /* T43/p (1) */
1740
1741        TPV_QL1('7', '9',  'E', '3',  '5', '0'), /* T60/p */
1742        TPV_QL1('7', 'C',  'D', '2',  '2', '2'), /* R60, R60i */
1743        TPV_QL1('7', 'E',  'D', '0',  '1', '5'), /* R60e, R60i */
1744
1745        /*      BIOS FW    BIOS VERS  EC FW     EC VERS */
1746        TPV_QI2('1', 'W',  '9', '0',  '1', 'V', '2', '8'), /* R50e (1) */
1747        TPV_QL2('7', 'I',  '3', '4',  '7', '9', '5', '0'), /* T60/p wide */
1748
1749        /* X-series ------------------------- */
1750        /*      FW MODEL   BIOS VERS  EC VERS */
1751        TPV_QI0('I', 'Z',  '9', 'D'),            /* X20, X21 */
1752        TPV_QI0('1', 'D',  '7', '0'),            /* X22, X23, X24 */
1753        TPV_QI1('1', 'K',  '4', '8',  '1', '8'), /* X30 (0) */
1754        TPV_QI1('1', 'Q',  '9', '7',  '2', '3'), /* X31, X32 (0) */
1755        TPV_QI1('1', 'U',  'D', '3',  'B', '2'), /* X40 (0) */
1756        TPV_QI1('7', '4',  '6', '4',  '2', '7'), /* X41 (0) */
1757        TPV_QI1('7', '5',  '6', '0',  '2', '0'), /* X41t (0) */
1758
1759        TPV_QL1('7', 'B',  'D', '7',  '4', '0'), /* X60/s */
1760        TPV_QL1('7', 'J',  '3', '0',  '1', '3'), /* X60t */
1761
1762        /* (0) - older versions lack DMI EC fw string and functionality */
1763        /* (1) - older versions known to lack functionality */
1764};
1765
1766#undef TPV_QL1
1767#undef TPV_QL0
1768#undef TPV_QI2
1769#undef TPV_QI1
1770#undef TPV_QI0
1771#undef TPV_Q_X
1772#undef TPV_Q
1773
1774static void __init tpacpi_check_outdated_fw(void)
1775{
1776        unsigned long fwvers;
1777        u16 ec_version, bios_version;
1778
1779        fwvers = tpacpi_check_quirks(tpacpi_bios_version_qtable,
1780                                ARRAY_SIZE(tpacpi_bios_version_qtable));
1781
1782        if (!fwvers)
1783                return;
1784
1785        bios_version = fwvers & 0xffffU;
1786        ec_version = (fwvers >> 16) & 0xffffU;
1787
1788        /* note that unknown versions are set to 0x0000 and we use that */
1789        if ((bios_version > thinkpad_id.bios_release) ||
1790            (ec_version > thinkpad_id.ec_release &&
1791                                ec_version != TPACPI_MATCH_ANY_VERSION)) {
1792                /*
1793                 * The changelogs would let us track down the exact
1794                 * reason, but it is just too much of a pain to track
1795                 * it.  We only list BIOSes that are either really
1796                 * broken, or really stable to begin with, so it is
1797                 * best if the user upgrades the firmware anyway.
1798                 */
1799                pr_warn("WARNING: Outdated ThinkPad BIOS/EC firmware\n");
1800                pr_warn("WARNING: This firmware may be missing critical bug fixes and/or important features\n");
1801        }
1802}
1803
1804static bool __init tpacpi_is_fw_known(void)
1805{
1806        return tpacpi_check_quirks(tpacpi_bios_version_qtable,
1807                        ARRAY_SIZE(tpacpi_bios_version_qtable)) != 0;
1808}
1809
1810/****************************************************************************
1811 ****************************************************************************
1812 *
1813 * Subdrivers
1814 *
1815 ****************************************************************************
1816 ****************************************************************************/
1817
1818/*************************************************************************
1819 * thinkpad-acpi metadata subdriver
1820 */
1821
1822static int thinkpad_acpi_driver_read(struct seq_file *m)
1823{
1824        seq_printf(m, "driver:\t\t%s\n", TPACPI_DESC);
1825        seq_printf(m, "version:\t%s\n", TPACPI_VERSION);
1826        return 0;
1827}
1828
1829static struct ibm_struct thinkpad_acpi_driver_data = {
1830        .name = "driver",
1831        .read = thinkpad_acpi_driver_read,
1832};
1833
1834/*************************************************************************
1835 * Hotkey subdriver
1836 */
1837
1838/*
1839 * ThinkPad firmware event model
1840 *
1841 * The ThinkPad firmware has two main event interfaces: normal ACPI
1842 * notifications (which follow the ACPI standard), and a private event
1843 * interface.
1844 *
1845 * The private event interface also issues events for the hotkeys.  As
1846 * the driver gained features, the event handling code ended up being
1847 * built around the hotkey subdriver.  This will need to be refactored
1848 * to a more formal event API eventually.
1849 *
1850 * Some "hotkeys" are actually supposed to be used as event reports,
1851 * such as "brightness has changed", "volume has changed", depending on
1852 * the ThinkPad model and how the firmware is operating.
1853 *
1854 * Unlike other classes, hotkey-class events have mask/unmask control on
1855 * non-ancient firmware.  However, how it behaves changes a lot with the
1856 * firmware model and version.
1857 */
1858
1859enum {  /* hot key scan codes (derived from ACPI DSDT) */
1860        TP_ACPI_HOTKEYSCAN_FNF1         = 0,
1861        TP_ACPI_HOTKEYSCAN_FNF2,
1862        TP_ACPI_HOTKEYSCAN_FNF3,
1863        TP_ACPI_HOTKEYSCAN_FNF4,
1864        TP_ACPI_HOTKEYSCAN_FNF5,
1865        TP_ACPI_HOTKEYSCAN_FNF6,
1866        TP_ACPI_HOTKEYSCAN_FNF7,
1867        TP_ACPI_HOTKEYSCAN_FNF8,
1868        TP_ACPI_HOTKEYSCAN_FNF9,
1869        TP_ACPI_HOTKEYSCAN_FNF10,
1870        TP_ACPI_HOTKEYSCAN_FNF11,
1871        TP_ACPI_HOTKEYSCAN_FNF12,
1872        TP_ACPI_HOTKEYSCAN_FNBACKSPACE,
1873        TP_ACPI_HOTKEYSCAN_FNINSERT,
1874        TP_ACPI_HOTKEYSCAN_FNDELETE,
1875        TP_ACPI_HOTKEYSCAN_FNHOME,
1876        TP_ACPI_HOTKEYSCAN_FNEND,
1877        TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1878        TP_ACPI_HOTKEYSCAN_FNPAGEDOWN,
1879        TP_ACPI_HOTKEYSCAN_FNSPACE,
1880        TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1881        TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1882        TP_ACPI_HOTKEYSCAN_MUTE,
1883        TP_ACPI_HOTKEYSCAN_THINKPAD,
1884        TP_ACPI_HOTKEYSCAN_UNK1,
1885        TP_ACPI_HOTKEYSCAN_UNK2,
1886        TP_ACPI_HOTKEYSCAN_UNK3,
1887        TP_ACPI_HOTKEYSCAN_UNK4,
1888        TP_ACPI_HOTKEYSCAN_UNK5,
1889        TP_ACPI_HOTKEYSCAN_UNK6,
1890        TP_ACPI_HOTKEYSCAN_UNK7,
1891        TP_ACPI_HOTKEYSCAN_UNK8,
1892
1893        /* Adaptive keyboard keycodes */
1894        TP_ACPI_HOTKEYSCAN_ADAPTIVE_START,
1895        TP_ACPI_HOTKEYSCAN_MUTE2        = TP_ACPI_HOTKEYSCAN_ADAPTIVE_START,
1896        TP_ACPI_HOTKEYSCAN_BRIGHTNESS_ZERO,
1897        TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL,
1898        TP_ACPI_HOTKEYSCAN_CLOUD,
1899        TP_ACPI_HOTKEYSCAN_UNK9,
1900        TP_ACPI_HOTKEYSCAN_VOICE,
1901        TP_ACPI_HOTKEYSCAN_UNK10,
1902        TP_ACPI_HOTKEYSCAN_GESTURES,
1903        TP_ACPI_HOTKEYSCAN_UNK11,
1904        TP_ACPI_HOTKEYSCAN_UNK12,
1905        TP_ACPI_HOTKEYSCAN_UNK13,
1906        TP_ACPI_HOTKEYSCAN_CONFIG,
1907        TP_ACPI_HOTKEYSCAN_NEW_TAB,
1908        TP_ACPI_HOTKEYSCAN_RELOAD,
1909        TP_ACPI_HOTKEYSCAN_BACK,
1910        TP_ACPI_HOTKEYSCAN_MIC_DOWN,
1911        TP_ACPI_HOTKEYSCAN_MIC_UP,
1912        TP_ACPI_HOTKEYSCAN_MIC_CANCELLATION,
1913        TP_ACPI_HOTKEYSCAN_CAMERA_MODE,
1914        TP_ACPI_HOTKEYSCAN_ROTATE_DISPLAY,
1915
1916        /* Lenovo extended keymap, starting at 0x1300 */
1917        TP_ACPI_HOTKEYSCAN_EXTENDED_START,
1918        /* first new observed key (star, favorites) is 0x1311 */
1919        TP_ACPI_HOTKEYSCAN_STAR = 69,
1920        TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL2,
1921        TP_ACPI_HOTKEYSCAN_CALCULATOR,
1922        TP_ACPI_HOTKEYSCAN_BLUETOOTH,
1923        TP_ACPI_HOTKEYSCAN_KEYBOARD,
1924        TP_ACPI_HOTKEYSCAN_FN_RIGHT_SHIFT, /* Used by "Lenovo Quick Clean" */
1925        TP_ACPI_HOTKEYSCAN_NOTIFICATION_CENTER,
1926        TP_ACPI_HOTKEYSCAN_PICKUP_PHONE,
1927        TP_ACPI_HOTKEYSCAN_HANGUP_PHONE,
1928
1929        /* Hotkey keymap size */
1930        TPACPI_HOTKEY_MAP_LEN
1931};
1932
1933enum {  /* Keys/events available through NVRAM polling */
1934        TPACPI_HKEY_NVRAM_KNOWN_MASK = 0x00fb88c0U,
1935        TPACPI_HKEY_NVRAM_GOOD_MASK  = 0x00fb8000U,
1936};
1937
1938enum {  /* Positions of some of the keys in hotkey masks */
1939        TP_ACPI_HKEY_DISPSWTCH_MASK     = 1 << TP_ACPI_HOTKEYSCAN_FNF7,
1940        TP_ACPI_HKEY_DISPXPAND_MASK     = 1 << TP_ACPI_HOTKEYSCAN_FNF8,
1941        TP_ACPI_HKEY_HIBERNATE_MASK     = 1 << TP_ACPI_HOTKEYSCAN_FNF12,
1942        TP_ACPI_HKEY_BRGHTUP_MASK       = 1 << TP_ACPI_HOTKEYSCAN_FNHOME,
1943        TP_ACPI_HKEY_BRGHTDWN_MASK      = 1 << TP_ACPI_HOTKEYSCAN_FNEND,
1944        TP_ACPI_HKEY_KBD_LIGHT_MASK     = 1 << TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1945        TP_ACPI_HKEY_ZOOM_MASK          = 1 << TP_ACPI_HOTKEYSCAN_FNSPACE,
1946        TP_ACPI_HKEY_VOLUP_MASK         = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1947        TP_ACPI_HKEY_VOLDWN_MASK        = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1948        TP_ACPI_HKEY_MUTE_MASK          = 1 << TP_ACPI_HOTKEYSCAN_MUTE,
1949        TP_ACPI_HKEY_THINKPAD_MASK      = 1 << TP_ACPI_HOTKEYSCAN_THINKPAD,
1950};
1951
1952enum {  /* NVRAM to ACPI HKEY group map */
1953        TP_NVRAM_HKEY_GROUP_HK2         = TP_ACPI_HKEY_THINKPAD_MASK |
1954                                          TP_ACPI_HKEY_ZOOM_MASK |
1955                                          TP_ACPI_HKEY_DISPSWTCH_MASK |
1956                                          TP_ACPI_HKEY_HIBERNATE_MASK,
1957        TP_NVRAM_HKEY_GROUP_BRIGHTNESS  = TP_ACPI_HKEY_BRGHTUP_MASK |
1958                                          TP_ACPI_HKEY_BRGHTDWN_MASK,
1959        TP_NVRAM_HKEY_GROUP_VOLUME      = TP_ACPI_HKEY_VOLUP_MASK |
1960                                          TP_ACPI_HKEY_VOLDWN_MASK |
1961                                          TP_ACPI_HKEY_MUTE_MASK,
1962};
1963
1964#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1965struct tp_nvram_state {
1966       u16 thinkpad_toggle:1;
1967       u16 zoom_toggle:1;
1968       u16 display_toggle:1;
1969       u16 thinklight_toggle:1;
1970       u16 hibernate_toggle:1;
1971       u16 displayexp_toggle:1;
1972       u16 display_state:1;
1973       u16 brightness_toggle:1;
1974       u16 volume_toggle:1;
1975       u16 mute:1;
1976
1977       u8 brightness_level;
1978       u8 volume_level;
1979};
1980
1981/* kthread for the hotkey poller */
1982static struct task_struct *tpacpi_hotkey_task;
1983
1984/*
1985 * Acquire mutex to write poller control variables as an
1986 * atomic block.
1987 *
1988 * Increment hotkey_config_change when changing them if you
1989 * want the kthread to forget old state.
1990 *
1991 * See HOTKEY_CONFIG_CRITICAL_START/HOTKEY_CONFIG_CRITICAL_END
1992 */
1993static struct mutex hotkey_thread_data_mutex;
1994static unsigned int hotkey_config_change;
1995
1996/*
1997 * hotkey poller control variables
1998 *
1999 * Must be atomic or readers will also need to acquire mutex
2000 *
2001 * HOTKEY_CONFIG_CRITICAL_START/HOTKEY_CONFIG_CRITICAL_END
2002 * should be used only when the changes need to be taken as
2003 * a block, OR when one needs to force the kthread to forget
2004 * old state.
2005 */
2006static u32 hotkey_source_mask;          /* bit mask 0=ACPI,1=NVRAM */
2007static unsigned int hotkey_poll_freq = 10; /* Hz */
2008
2009#define HOTKEY_CONFIG_CRITICAL_START \
2010        do { \
2011                mutex_lock(&hotkey_thread_data_mutex); \
2012                hotkey_config_change++; \
2013        } while (0);
2014#define HOTKEY_CONFIG_CRITICAL_END \
2015        mutex_unlock(&hotkey_thread_data_mutex);
2016
2017#else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
2018
2019#define hotkey_source_mask 0U
2020#define HOTKEY_CONFIG_CRITICAL_START
2021#define HOTKEY_CONFIG_CRITICAL_END
2022
2023#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
2024
2025static struct mutex hotkey_mutex;
2026
2027static enum {   /* Reasons for waking up */
2028        TP_ACPI_WAKEUP_NONE = 0,        /* None or unknown */
2029        TP_ACPI_WAKEUP_BAYEJ,           /* Bay ejection request */
2030        TP_ACPI_WAKEUP_UNDOCK,          /* Undock request */
2031} hotkey_wakeup_reason;
2032
2033static int hotkey_autosleep_ack;
2034
2035static u32 hotkey_orig_mask;            /* events the BIOS had enabled */
2036static u32 hotkey_all_mask;             /* all events supported in fw */
2037static u32 hotkey_adaptive_all_mask;    /* all adaptive events supported in fw */
2038static u32 hotkey_reserved_mask;        /* events better left disabled */
2039static u32 hotkey_driver_mask;          /* events needed by the driver */
2040static u32 hotkey_user_mask;            /* events visible to userspace */
2041static u32 hotkey_acpi_mask;            /* events enabled in firmware */
2042
2043static u16 *hotkey_keycode_map;
2044
2045static struct attribute_set *hotkey_dev_attributes;
2046
2047static void tpacpi_driver_event(const unsigned int hkey_event);
2048static void hotkey_driver_event(const unsigned int scancode);
2049static void hotkey_poll_setup(const bool may_warn);
2050
2051/* HKEY.MHKG() return bits */
2052#define TP_HOTKEY_TABLET_MASK (1 << 3)
2053enum {
2054        TP_ACPI_MULTI_MODE_INVALID      = 0,
2055        TP_ACPI_MULTI_MODE_UNKNOWN      = 1 << 0,
2056        TP_ACPI_MULTI_MODE_LAPTOP       = 1 << 1,
2057        TP_ACPI_MULTI_MODE_TABLET       = 1 << 2,
2058        TP_ACPI_MULTI_MODE_FLAT         = 1 << 3,
2059        TP_ACPI_MULTI_MODE_STAND        = 1 << 4,
2060        TP_ACPI_MULTI_MODE_TENT         = 1 << 5,
2061        TP_ACPI_MULTI_MODE_STAND_TENT   = 1 << 6,
2062};
2063
2064enum {
2065        /* The following modes are considered tablet mode for the purpose of
2066         * reporting the status to userspace. i.e. in all these modes it makes
2067         * sense to disable the laptop input devices such as touchpad and
2068         * keyboard.
2069         */
2070        TP_ACPI_MULTI_MODE_TABLET_LIKE  = TP_ACPI_MULTI_MODE_TABLET |
2071                                          TP_ACPI_MULTI_MODE_STAND |
2072                                          TP_ACPI_MULTI_MODE_TENT |
2073                                          TP_ACPI_MULTI_MODE_STAND_TENT,
2074};
2075
2076static int hotkey_get_wlsw(void)
2077{
2078        int status;
2079
2080        if (!tp_features.hotkey_wlsw)
2081                return -ENODEV;
2082
2083#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
2084        if (dbg_wlswemul)
2085                return (tpacpi_wlsw_emulstate) ?
2086                                TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
2087#endif
2088
2089        if (!acpi_evalf(hkey_handle, &status, "WLSW", "d"))
2090                return -EIO;
2091
2092        return (status) ? TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
2093}
2094
2095static int hotkey_gmms_get_tablet_mode(int s, int *has_tablet_mode)
2096{
2097        int type = (s >> 16) & 0xffff;
2098        int value = s & 0xffff;
2099        int mode = TP_ACPI_MULTI_MODE_INVALID;
2100        int valid_modes = 0;
2101
2102        if (has_tablet_mode)
2103                *has_tablet_mode = 0;
2104
2105        switch (type) {
2106        case 1:
2107                valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2108                              TP_ACPI_MULTI_MODE_TABLET |
2109                              TP_ACPI_MULTI_MODE_STAND_TENT;
2110                break;
2111        case 2:
2112                valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2113                              TP_ACPI_MULTI_MODE_FLAT |
2114                              TP_ACPI_MULTI_MODE_TABLET |
2115                              TP_ACPI_MULTI_MODE_STAND |
2116                              TP_ACPI_MULTI_MODE_TENT;
2117                break;
2118        case 3:
2119                valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2120                              TP_ACPI_MULTI_MODE_FLAT;
2121                break;
2122        case 4:
2123        case 5:
2124                /* In mode 4, FLAT is not specified as a valid mode. However,
2125                 * it can be seen at least on the X1 Yoga 2nd Generation.
2126                 */
2127                valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
2128                              TP_ACPI_MULTI_MODE_FLAT |
2129                              TP_ACPI_MULTI_MODE_TABLET |
2130                              TP_ACPI_MULTI_MODE_STAND |
2131                              TP_ACPI_MULTI_MODE_TENT;
2132                break;
2133        default:
2134                pr_err("Unknown multi mode status type %d with value 0x%04X, please report this to %s\n",
2135                       type, value, TPACPI_MAIL);
2136                return 0;
2137        }
2138
2139        if (has_tablet_mode && (valid_modes & TP_ACPI_MULTI_MODE_TABLET_LIKE))
2140                *has_tablet_mode = 1;
2141
2142        switch (value) {
2143        case 1:
2144                mode = TP_ACPI_MULTI_MODE_LAPTOP;
2145                break;
2146        case 2:
2147                mode = TP_ACPI_MULTI_MODE_FLAT;
2148                break;
2149        case 3:
2150                mode = TP_ACPI_MULTI_MODE_TABLET;
2151                break;
2152        case 4:
2153                if (type == 1)
2154                        mode = TP_ACPI_MULTI_MODE_STAND_TENT;
2155                else
2156                        mode = TP_ACPI_MULTI_MODE_STAND;
2157                break;
2158        case 5:
2159                mode = TP_ACPI_MULTI_MODE_TENT;
2160                break;
2161        default:
2162                if (type == 5 && value == 0xffff) {
2163                        pr_warn("Multi mode status is undetected, assuming laptop\n");
2164                        return 0;
2165                }
2166        }
2167
2168        if (!(mode & valid_modes)) {
2169                pr_err("Unknown/reserved multi mode value 0x%04X for type %d, please report this to %s\n",
2170                       value, type, TPACPI_MAIL);
2171                return 0;
2172        }
2173
2174        return !!(mode & TP_ACPI_MULTI_MODE_TABLET_LIKE);
2175}
2176
2177static int hotkey_get_tablet_mode(int *status)
2178{
2179        int s;
2180
2181        switch (tp_features.hotkey_tablet) {
2182        case TP_HOTKEY_TABLET_USES_MHKG:
2183                if (!acpi_evalf(hkey_handle, &s, "MHKG", "d"))
2184                        return -EIO;
2185
2186                *status = ((s & TP_HOTKEY_TABLET_MASK) != 0);
2187                break;
2188        case TP_HOTKEY_TABLET_USES_GMMS:
2189                if (!acpi_evalf(hkey_handle, &s, "GMMS", "dd", 0))
2190                        return -EIO;
2191
2192                *status = hotkey_gmms_get_tablet_mode(s, NULL);
2193                break;
2194        default:
2195                break;
2196        }
2197
2198        return 0;
2199}
2200
2201/*
2202 * Reads current event mask from firmware, and updates
2203 * hotkey_acpi_mask accordingly.  Also resets any bits
2204 * from hotkey_user_mask that are unavailable to be
2205 * delivered (shadow requirement of the userspace ABI).
2206 *
2207 * Call with hotkey_mutex held
2208 */
2209static int hotkey_mask_get(void)
2210{
2211        if (tp_features.hotkey_mask) {
2212                u32 m = 0;
2213
2214                if (!acpi_evalf(hkey_handle, &m, "DHKN", "d"))
2215                        return -EIO;
2216
2217                hotkey_acpi_mask = m;
2218        } else {
2219                /* no mask support doesn't mean no event support... */
2220                hotkey_acpi_mask = hotkey_all_mask;
2221        }
2222
2223        /* sync userspace-visible mask */
2224        hotkey_user_mask &= (hotkey_acpi_mask | hotkey_source_mask);
2225
2226        return 0;
2227}
2228
2229static void hotkey_mask_warn_incomplete_mask(void)
2230{
2231        /* log only what the user can fix... */
2232        const u32 wantedmask = hotkey_driver_mask &
2233                ~(hotkey_acpi_mask | hotkey_source_mask) &
2234                (hotkey_all_mask | TPACPI_HKEY_NVRAM_KNOWN_MASK);
2235
2236        if (wantedmask)
2237                pr_notice("required events 0x%08x not enabled!\n", wantedmask);
2238}
2239
2240/*
2241 * Set the firmware mask when supported
2242 *
2243 * Also calls hotkey_mask_get to update hotkey_acpi_mask.
2244 *
2245 * NOTE: does not set bits in hotkey_user_mask, but may reset them.
2246 *
2247 * Call with hotkey_mutex held
2248 */
2249static int hotkey_mask_set(u32 mask)
2250{
2251        int i;
2252        int rc = 0;
2253
2254        const u32 fwmask = mask & ~hotkey_source_mask;
2255
2256        if (tp_features.hotkey_mask) {
2257                for (i = 0; i < 32; i++) {
2258                        if (!acpi_evalf(hkey_handle,
2259                                        NULL, "MHKM", "vdd", i + 1,
2260                                        !!(mask & (1 << i)))) {
2261                                rc = -EIO;
2262                                break;
2263                        }
2264                }
2265        }
2266
2267        /*
2268         * We *must* make an inconditional call to hotkey_mask_get to
2269         * refresh hotkey_acpi_mask and update hotkey_user_mask
2270         *
2271         * Take the opportunity to also log when we cannot _enable_
2272         * a given event.
2273         */
2274        if (!hotkey_mask_get() && !rc && (fwmask & ~hotkey_acpi_mask)) {
2275                pr_notice("asked for hotkey mask 0x%08x, but firmware forced it to 0x%08x\n",
2276                          fwmask, hotkey_acpi_mask);
2277        }
2278
2279        if (tpacpi_lifecycle != TPACPI_LIFE_EXITING)
2280                hotkey_mask_warn_incomplete_mask();
2281
2282        return rc;
2283}
2284
2285/*
2286 * Sets hotkey_user_mask and tries to set the firmware mask
2287 *
2288 * Call with hotkey_mutex held
2289 */
2290static int hotkey_user_mask_set(const u32 mask)
2291{
2292        int rc;
2293
2294        /* Give people a chance to notice they are doing something that
2295         * is bound to go boom on their users sooner or later */
2296        if (!tp_warned.hotkey_mask_ff &&
2297            (mask == 0xffff || mask == 0xffffff ||
2298             mask == 0xffffffff)) {
2299                tp_warned.hotkey_mask_ff = 1;
2300                pr_notice("setting the hotkey mask to 0x%08x is likely not the best way to go about it\n",
2301                          mask);
2302                pr_notice("please consider using the driver defaults, and refer to up-to-date thinkpad-acpi documentation\n");
2303        }
2304
2305        /* Try to enable what the user asked for, plus whatever we need.
2306         * this syncs everything but won't enable bits in hotkey_user_mask */
2307        rc = hotkey_mask_set((mask | hotkey_driver_mask) & ~hotkey_source_mask);
2308
2309        /* Enable the available bits in hotkey_user_mask */
2310        hotkey_user_mask = mask & (hotkey_acpi_mask | hotkey_source_mask);
2311
2312        return rc;
2313}
2314
2315/*
2316 * Sets the driver hotkey mask.
2317 *
2318 * Can be called even if the hotkey subdriver is inactive
2319 */
2320static int tpacpi_hotkey_driver_mask_set(const u32 mask)
2321{
2322        int rc;
2323
2324        /* Do the right thing if hotkey_init has not been called yet */
2325        if (!tp_features.hotkey) {
2326                hotkey_driver_mask = mask;
2327                return 0;
2328        }
2329
2330        mutex_lock(&hotkey_mutex);
2331
2332        HOTKEY_CONFIG_CRITICAL_START
2333        hotkey_driver_mask = mask;
2334#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2335        hotkey_source_mask |= (mask & ~hotkey_all_mask);
2336#endif
2337        HOTKEY_CONFIG_CRITICAL_END
2338
2339        rc = hotkey_mask_set((hotkey_acpi_mask | hotkey_driver_mask) &
2340                                                        ~hotkey_source_mask);
2341        hotkey_poll_setup(true);
2342
2343        mutex_unlock(&hotkey_mutex);
2344
2345        return rc;
2346}
2347
2348static int hotkey_status_get(int *status)
2349{
2350        if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
2351                return -EIO;
2352
2353        return 0;
2354}
2355
2356static int hotkey_status_set(bool enable)
2357{
2358        if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", enable ? 1 : 0))
2359                return -EIO;
2360
2361        return 0;
2362}
2363
2364static void tpacpi_input_send_tabletsw(void)
2365{
2366        int state;
2367
2368        if (tp_features.hotkey_tablet &&
2369            !hotkey_get_tablet_mode(&state)) {
2370                mutex_lock(&tpacpi_inputdev_send_mutex);
2371
2372                input_report_switch(tpacpi_inputdev,
2373                                    SW_TABLET_MODE, !!state);
2374                input_sync(tpacpi_inputdev);
2375
2376                mutex_unlock(&tpacpi_inputdev_send_mutex);
2377        }
2378}
2379
2380/* Do NOT call without validating scancode first */
2381static void tpacpi_input_send_key(const unsigned int scancode)
2382{
2383        const unsigned int keycode = hotkey_keycode_map[scancode];
2384
2385        if (keycode != KEY_RESERVED) {
2386                mutex_lock(&tpacpi_inputdev_send_mutex);
2387
2388                input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
2389                input_report_key(tpacpi_inputdev, keycode, 1);
2390                input_sync(tpacpi_inputdev);
2391
2392                input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
2393                input_report_key(tpacpi_inputdev, keycode, 0);
2394                input_sync(tpacpi_inputdev);
2395
2396                mutex_unlock(&tpacpi_inputdev_send_mutex);
2397        }
2398}
2399
2400/* Do NOT call without validating scancode first */
2401static void tpacpi_input_send_key_masked(const unsigned int scancode)
2402{
2403        hotkey_driver_event(scancode);
2404        if (hotkey_user_mask & (1 << scancode))
2405                tpacpi_input_send_key(scancode);
2406}
2407
2408#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2409static struct tp_acpi_drv_struct ibm_hotkey_acpidriver;
2410
2411/* Do NOT call without validating scancode first */
2412static void tpacpi_hotkey_send_key(unsigned int scancode)
2413{
2414        tpacpi_input_send_key_masked(scancode);
2415}
2416
2417static void hotkey_read_nvram(struct tp_nvram_state *n, const u32 m)
2418{
2419        u8 d;
2420
2421        if (m & TP_NVRAM_HKEY_GROUP_HK2) {
2422                d = nvram_read_byte(TP_NVRAM_ADDR_HK2);
2423                n->thinkpad_toggle = !!(d & TP_NVRAM_MASK_HKT_THINKPAD);
2424                n->zoom_toggle = !!(d & TP_NVRAM_MASK_HKT_ZOOM);
2425                n->display_toggle = !!(d & TP_NVRAM_MASK_HKT_DISPLAY);
2426                n->hibernate_toggle = !!(d & TP_NVRAM_MASK_HKT_HIBERNATE);
2427        }
2428        if (m & TP_ACPI_HKEY_KBD_LIGHT_MASK) {
2429                d = nvram_read_byte(TP_NVRAM_ADDR_THINKLIGHT);
2430                n->thinklight_toggle = !!(d & TP_NVRAM_MASK_THINKLIGHT);
2431        }
2432        if (m & TP_ACPI_HKEY_DISPXPAND_MASK) {
2433                d = nvram_read_byte(TP_NVRAM_ADDR_VIDEO);
2434                n->displayexp_toggle =
2435                                !!(d & TP_NVRAM_MASK_HKT_DISPEXPND);
2436        }
2437        if (m & TP_NVRAM_HKEY_GROUP_BRIGHTNESS) {
2438                d = nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS);
2439                n->brightness_level = (d & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
2440                                >> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
2441                n->brightness_toggle =
2442                                !!(d & TP_NVRAM_MASK_HKT_BRIGHTNESS);
2443        }
2444        if (m & TP_NVRAM_HKEY_GROUP_VOLUME) {
2445                d = nvram_read_byte(TP_NVRAM_ADDR_MIXER);
2446                n->volume_level = (d & TP_NVRAM_MASK_LEVEL_VOLUME)
2447                                >> TP_NVRAM_POS_LEVEL_VOLUME;
2448                n->mute = !!(d & TP_NVRAM_MASK_MUTE);
2449                n->volume_toggle = !!(d & TP_NVRAM_MASK_HKT_VOLUME);
2450        }
2451}
2452
2453#define TPACPI_COMPARE_KEY(__scancode, __member) \
2454do { \
2455        if ((event_mask & (1 << __scancode)) && \
2456            oldn->__member != newn->__member) \
2457                tpacpi_hotkey_send_key(__scancode); \
2458} while (0)
2459
2460#define TPACPI_MAY_SEND_KEY(__scancode) \
2461do { \
2462        if (event_mask & (1 << __scancode)) \
2463                tpacpi_hotkey_send_key(__scancode); \
2464} while (0)
2465
2466static void issue_volchange(const unsigned int oldvol,
2467                            const unsigned int newvol,
2468                            const u32 event_mask)
2469{
2470        unsigned int i = oldvol;
2471
2472        while (i > newvol) {
2473                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
2474                i--;
2475        }
2476        while (i < newvol) {
2477                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2478                i++;
2479        }
2480}
2481
2482static void issue_brightnesschange(const unsigned int oldbrt,
2483                                   const unsigned int newbrt,
2484                                   const u32 event_mask)
2485{
2486        unsigned int i = oldbrt;
2487
2488        while (i > newbrt) {
2489                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
2490                i--;
2491        }
2492        while (i < newbrt) {
2493                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
2494                i++;
2495        }
2496}
2497
2498static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn,
2499                                           struct tp_nvram_state *newn,
2500                                           const u32 event_mask)
2501{
2502
2503        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_THINKPAD, thinkpad_toggle);
2504        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNSPACE, zoom_toggle);
2505        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF7, display_toggle);
2506        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF12, hibernate_toggle);
2507
2508        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNPAGEUP, thinklight_toggle);
2509
2510        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF8, displayexp_toggle);
2511
2512        /*
2513         * Handle volume
2514         *
2515         * This code is supposed to duplicate the IBM firmware behaviour:
2516         * - Pressing MUTE issues mute hotkey message, even when already mute
2517         * - Pressing Volume up/down issues volume up/down hotkey messages,
2518         *   even when already at maximum or minimum volume
2519         * - The act of unmuting issues volume up/down notification,
2520         *   depending which key was used to unmute
2521         *
2522         * We are constrained to what the NVRAM can tell us, which is not much
2523         * and certainly not enough if more than one volume hotkey was pressed
2524         * since the last poll cycle.
2525         *
2526         * Just to make our life interesting, some newer Lenovo ThinkPads have
2527         * bugs in the BIOS and may fail to update volume_toggle properly.
2528         */
2529        if (newn->mute) {
2530                /* muted */
2531                if (!oldn->mute ||
2532                    oldn->volume_toggle != newn->volume_toggle ||
2533                    oldn->volume_level != newn->volume_level) {
2534                        /* recently muted, or repeated mute keypress, or
2535                         * multiple presses ending in mute */
2536                        issue_volchange(oldn->volume_level, newn->volume_level,
2537                                event_mask);
2538                        TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE);
2539                }
2540        } else {
2541                /* unmute */
2542                if (oldn->mute) {
2543                        /* recently unmuted, issue 'unmute' keypress */
2544                        TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2545                }
2546                if (oldn->volume_level != newn->volume_level) {
2547                        issue_volchange(oldn->volume_level, newn->volume_level,
2548                                event_mask);
2549                } else if (oldn->volume_toggle != newn->volume_toggle) {
2550                        /* repeated vol up/down keypress at end of scale ? */
2551                        if (newn->volume_level == 0)
2552                                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
2553                        else if (newn->volume_level >= TP_NVRAM_LEVEL_VOLUME_MAX)
2554                                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2555                }
2556        }
2557
2558        /* handle brightness */
2559        if (oldn->brightness_level != newn->brightness_level) {
2560                issue_brightnesschange(oldn->brightness_level,
2561                                       newn->brightness_level, event_mask);
2562        } else if (oldn->brightness_toggle != newn->brightness_toggle) {
2563                /* repeated key presses that didn't change state */
2564                if (newn->brightness_level == 0)
2565                        TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
2566                else if (newn->brightness_level >= bright_maxlvl
2567                                && !tp_features.bright_unkfw)
2568                        TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
2569        }
2570
2571#undef TPACPI_COMPARE_KEY
2572#undef TPACPI_MAY_SEND_KEY
2573}
2574
2575/*
2576 * Polling driver
2577 *
2578 * We track all events in hotkey_source_mask all the time, since
2579 * most of them are edge-based.  We only issue those requested by
2580 * hotkey_user_mask or hotkey_driver_mask, though.
2581 */
2582static int hotkey_kthread(void *data)
2583{
2584        struct tp_nvram_state s[2] = { 0 };
2585        u32 poll_mask, event_mask;
2586        unsigned int si, so;
2587        unsigned long t;
2588        unsigned int change_detector;
2589        unsigned int poll_freq;
2590        bool was_frozen;
2591
2592        if (tpacpi_lifecycle == TPACPI_LIFE_EXITING)
2593                goto exit;
2594
2595        set_freezable();
2596
2597        so = 0;
2598        si = 1;
2599        t = 0;
2600
2601        /* Initial state for compares */
2602        mutex_lock(&hotkey_thread_data_mutex);
2603        change_detector = hotkey_config_change;
2604        poll_mask = hotkey_source_mask;
2605        event_mask = hotkey_source_mask &
2606                        (hotkey_driver_mask | hotkey_user_mask);
2607        poll_freq = hotkey_poll_freq;
2608        mutex_unlock(&hotkey_thread_data_mutex);
2609        hotkey_read_nvram(&s[so], poll_mask);
2610
2611        while (!kthread_should_stop()) {
2612                if (t == 0) {
2613                        if (likely(poll_freq))
2614                                t = 1000/poll_freq;
2615                        else
2616                                t = 100;        /* should never happen... */
2617                }
2618                t = msleep_interruptible(t);
2619                if (unlikely(kthread_freezable_should_stop(&was_frozen)))
2620                        break;
2621
2622                if (t > 0 && !was_frozen)
2623                        continue;
2624
2625                mutex_lock(&hotkey_thread_data_mutex);
2626                if (was_frozen || hotkey_config_change != change_detector) {
2627                        /* forget old state on thaw or config change */
2628                        si = so;
2629                        t = 0;
2630                        change_detector = hotkey_config_change;
2631                }
2632                poll_mask = hotkey_source_mask;
2633                event_mask = hotkey_source_mask &
2634                                (hotkey_driver_mask | hotkey_user_mask);
2635                poll_freq = hotkey_poll_freq;
2636                mutex_unlock(&hotkey_thread_data_mutex);
2637
2638                if (likely(poll_mask)) {
2639                        hotkey_read_nvram(&s[si], poll_mask);
2640                        if (likely(si != so)) {
2641                                hotkey_compare_and_issue_event(&s[so], &s[si],
2642                                                                event_mask);
2643                        }
2644                }
2645
2646                so = si;
2647                si ^= 1;
2648        }
2649
2650exit:
2651        return 0;
2652}
2653
2654/* call with hotkey_mutex held */
2655static void hotkey_poll_stop_sync(void)
2656{
2657        if (tpacpi_hotkey_task) {
2658                kthread_stop(tpacpi_hotkey_task);
2659                tpacpi_hotkey_task = NULL;
2660        }
2661}
2662
2663/* call with hotkey_mutex held */
2664static void hotkey_poll_setup(const bool may_warn)
2665{
2666        const u32 poll_driver_mask = hotkey_driver_mask & hotkey_source_mask;
2667        const u32 poll_user_mask = hotkey_user_mask & hotkey_source_mask;
2668
2669        if (hotkey_poll_freq > 0 &&
2670            (poll_driver_mask ||
2671             (poll_user_mask && tpacpi_inputdev->users > 0))) {
2672                if (!tpacpi_hotkey_task) {
2673                        tpacpi_hotkey_task = kthread_run(hotkey_kthread,
2674                                        NULL, TPACPI_NVRAM_KTHREAD_NAME);
2675                        if (IS_ERR(tpacpi_hotkey_task)) {
2676                                tpacpi_hotkey_task = NULL;
2677                                pr_err("could not create kernel thread for hotkey polling\n");
2678                        }
2679                }
2680        } else {
2681                hotkey_poll_stop_sync();
2682                if (may_warn && (poll_driver_mask || poll_user_mask) &&
2683                    hotkey_poll_freq == 0) {
2684                        pr_notice("hot keys 0x%08x and/or events 0x%08x require polling, which is currently disabled\n",
2685                                  poll_user_mask, poll_driver_mask);
2686                }
2687        }
2688}
2689
2690static void hotkey_poll_setup_safe(const bool may_warn)
2691{
2692        mutex_lock(&hotkey_mutex);
2693        hotkey_poll_setup(may_warn);
2694        mutex_unlock(&hotkey_mutex);
2695}
2696
2697/* call with hotkey_mutex held */
2698static void hotkey_poll_set_freq(unsigned int freq)
2699{
2700        if (!freq)
2701                hotkey_poll_stop_sync();
2702
2703        hotkey_poll_freq = freq;
2704}
2705
2706#else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
2707
2708static void hotkey_poll_setup(const bool __unused)
2709{
2710}
2711
2712static void hotkey_poll_setup_safe(const bool __unused)
2713{
2714}
2715
2716#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
2717
2718static int hotkey_inputdev_open(struct input_dev *dev)
2719{
2720        switch (tpacpi_lifecycle) {
2721        case TPACPI_LIFE_INIT:
2722        case TPACPI_LIFE_RUNNING:
2723                hotkey_poll_setup_safe(false);
2724                return 0;
2725        case TPACPI_LIFE_EXITING:
2726                return -EBUSY;
2727        }
2728
2729        /* Should only happen if tpacpi_lifecycle is corrupt */
2730        BUG();
2731        return -EBUSY;
2732}
2733
2734static void hotkey_inputdev_close(struct input_dev *dev)
2735{
2736        /* disable hotkey polling when possible */
2737        if (tpacpi_lifecycle != TPACPI_LIFE_EXITING &&
2738            !(hotkey_source_mask & hotkey_driver_mask))
2739                hotkey_poll_setup_safe(false);
2740}
2741
2742/* sysfs hotkey enable ------------------------------------------------- */
2743static ssize_t hotkey_enable_show(struct device *dev,
2744                           struct device_attribute *attr,
2745                           char *buf)
2746{
2747        int res, status;
2748
2749        printk_deprecated_attribute("hotkey_enable",
2750                        "Hotkey reporting is always enabled");
2751
2752        res = hotkey_status_get(&status);
2753        if (res)
2754                return res;
2755
2756        return snprintf(buf, PAGE_SIZE, "%d\n", status);
2757}
2758
2759static ssize_t hotkey_enable_store(struct device *dev,
2760                            struct device_attribute *attr,
2761                            const char *buf, size_t count)
2762{
2763        unsigned long t;
2764
2765        printk_deprecated_attribute("hotkey_enable",
2766                        "Hotkeys can be disabled through hotkey_mask");
2767
2768        if (parse_strtoul(buf, 1, &t))
2769                return -EINVAL;
2770
2771        if (t == 0)
2772                return -EPERM;
2773
2774        return count;
2775}
2776
2777static DEVICE_ATTR_RW(hotkey_enable);
2778
2779/* sysfs hotkey mask --------------------------------------------------- */
2780static ssize_t hotkey_mask_show(struct device *dev,
2781                           struct device_attribute *attr,
2782                           char *buf)
2783{
2784        return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_user_mask);
2785}
2786
2787static ssize_t hotkey_mask_store(struct device *dev,
2788                            struct device_attribute *attr,
2789                            const char *buf, size_t count)
2790{
2791        unsigned long t;
2792        int res;
2793
2794        if (parse_strtoul(buf, 0xffffffffUL, &t))
2795                return -EINVAL;
2796
2797        if (mutex_lock_killable(&hotkey_mutex))
2798                return -ERESTARTSYS;
2799
2800        res = hotkey_user_mask_set(t);
2801
2802#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2803        hotkey_poll_setup(true);
2804#endif
2805
2806        mutex_unlock(&hotkey_mutex);
2807
2808        tpacpi_disclose_usertask("hotkey_mask", "set to 0x%08lx\n", t);
2809
2810        return (res) ? res : count;
2811}
2812
2813static DEVICE_ATTR_RW(hotkey_mask);
2814
2815/* sysfs hotkey bios_enabled ------------------------------------------- */
2816static ssize_t hotkey_bios_enabled_show(struct device *dev,
2817                           struct device_attribute *attr,
2818                           char *buf)
2819{
2820        return sprintf(buf, "0\n");
2821}
2822
2823static DEVICE_ATTR_RO(hotkey_bios_enabled);
2824
2825/* sysfs hotkey bios_mask ---------------------------------------------- */
2826static ssize_t hotkey_bios_mask_show(struct device *dev,
2827                           struct device_attribute *attr,
2828                           char *buf)
2829{
2830        printk_deprecated_attribute("hotkey_bios_mask",
2831                        "This attribute is useless.");
2832        return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask);
2833}
2834
2835static DEVICE_ATTR_RO(hotkey_bios_mask);
2836
2837/* sysfs hotkey all_mask ----------------------------------------------- */
2838static ssize_t hotkey_all_mask_show(struct device *dev,
2839                           struct device_attribute *attr,
2840                           char *buf)
2841{
2842        return snprintf(buf, PAGE_SIZE, "0x%08x\n",
2843                                hotkey_all_mask | hotkey_source_mask);
2844}
2845
2846static DEVICE_ATTR_RO(hotkey_all_mask);
2847
2848/* sysfs hotkey all_mask ----------------------------------------------- */
2849static ssize_t hotkey_adaptive_all_mask_show(struct device *dev,
2850                           struct device_attribute *attr,
2851                           char *buf)
2852{
2853        return snprintf(buf, PAGE_SIZE, "0x%08x\n",
2854                        hotkey_adaptive_all_mask | hotkey_source_mask);
2855}
2856
2857static DEVICE_ATTR_RO(hotkey_adaptive_all_mask);
2858
2859/* sysfs hotkey recommended_mask --------------------------------------- */
2860static ssize_t hotkey_recommended_mask_show(struct device *dev,
2861                                            struct device_attribute *attr,
2862                                            char *buf)
2863{
2864        return snprintf(buf, PAGE_SIZE, "0x%08x\n",
2865                        (hotkey_all_mask | hotkey_source_mask)
2866                        & ~hotkey_reserved_mask);
2867}
2868
2869static DEVICE_ATTR_RO(hotkey_recommended_mask);
2870
2871#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2872
2873/* sysfs hotkey hotkey_source_mask ------------------------------------- */
2874static ssize_t hotkey_source_mask_show(struct device *dev,
2875                           struct device_attribute *attr,
2876                           char *buf)
2877{
2878        return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_source_mask);
2879}
2880
2881static ssize_t hotkey_source_mask_store(struct device *dev,
2882                            struct device_attribute *attr,
2883                            const char *buf, size_t count)
2884{
2885        unsigned long t;
2886        u32 r_ev;
2887        int rc;
2888
2889        if (parse_strtoul(buf, 0xffffffffUL, &t) ||
2890                ((t & ~TPACPI_HKEY_NVRAM_KNOWN_MASK) != 0))
2891                return -EINVAL;
2892
2893        if (mutex_lock_killable(&hotkey_mutex))
2894                return -ERESTARTSYS;
2895
2896        HOTKEY_CONFIG_CRITICAL_START
2897        hotkey_source_mask = t;
2898        HOTKEY_CONFIG_CRITICAL_END
2899
2900        rc = hotkey_mask_set((hotkey_user_mask | hotkey_driver_mask) &
2901                        ~hotkey_source_mask);
2902        hotkey_poll_setup(true);
2903
2904        /* check if events needed by the driver got disabled */
2905        r_ev = hotkey_driver_mask & ~(hotkey_acpi_mask & hotkey_all_mask)
2906                & ~hotkey_source_mask & TPACPI_HKEY_NVRAM_KNOWN_MASK;
2907
2908        mutex_unlock(&hotkey_mutex);
2909
2910        if (rc < 0)
2911                pr_err("hotkey_source_mask: failed to update the firmware event mask!\n");
2912
2913        if (r_ev)
2914                pr_notice("hotkey_source_mask: some important events were disabled: 0x%04x\n",
2915                          r_ev);
2916
2917        tpacpi_disclose_usertask("hotkey_source_mask", "set to 0x%08lx\n", t);
2918
2919        return (rc < 0) ? rc : count;
2920}
2921
2922static DEVICE_ATTR_RW(hotkey_source_mask);
2923
2924/* sysfs hotkey hotkey_poll_freq --------------------------------------- */
2925static ssize_t hotkey_poll_freq_show(struct device *dev,
2926                           struct device_attribute *attr,
2927                           char *buf)
2928{
2929        return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_poll_freq);
2930}
2931
2932static ssize_t hotkey_poll_freq_store(struct device *dev,
2933                            struct device_attribute *attr,
2934                            const char *buf, size_t count)
2935{
2936        unsigned long t;
2937
2938        if (parse_strtoul(buf, 25, &t))
2939                return -EINVAL;
2940
2941        if (mutex_lock_killable(&hotkey_mutex))
2942                return -ERESTARTSYS;
2943
2944        hotkey_poll_set_freq(t);
2945        hotkey_poll_setup(true);
2946
2947        mutex_unlock(&hotkey_mutex);
2948
2949        tpacpi_disclose_usertask("hotkey_poll_freq", "set to %lu\n", t);
2950
2951        return count;
2952}
2953
2954static DEVICE_ATTR_RW(hotkey_poll_freq);
2955
2956#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
2957
2958/* sysfs hotkey radio_sw (pollable) ------------------------------------ */
2959static ssize_t hotkey_radio_sw_show(struct device *dev,
2960                           struct device_attribute *attr,
2961                           char *buf)
2962{
2963        int res;
2964        res = hotkey_get_wlsw();
2965        if (res < 0)
2966                return res;
2967
2968        /* Opportunistic update */
2969        tpacpi_rfk_update_hwblock_state((res == TPACPI_RFK_RADIO_OFF));
2970
2971        return snprintf(buf, PAGE_SIZE, "%d\n",
2972                        (res == TPACPI_RFK_RADIO_OFF) ? 0 : 1);
2973}
2974
2975static DEVICE_ATTR_RO(hotkey_radio_sw);
2976
2977static void hotkey_radio_sw_notify_change(void)
2978{
2979        if (tp_features.hotkey_wlsw)
2980                sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
2981                             "hotkey_radio_sw");
2982}
2983
2984/* sysfs hotkey tablet mode (pollable) --------------------------------- */
2985static ssize_t hotkey_tablet_mode_show(struct device *dev,
2986                           struct device_attribute *attr,
2987                           char *buf)
2988{
2989        int res, s;
2990        res = hotkey_get_tablet_mode(&s);
2991        if (res < 0)
2992                return res;
2993
2994        return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
2995}
2996
2997static DEVICE_ATTR_RO(hotkey_tablet_mode);
2998
2999static void hotkey_tablet_mode_notify_change(void)
3000{
3001        if (tp_features.hotkey_tablet)
3002                sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
3003                             "hotkey_tablet_mode");
3004}
3005
3006/* sysfs wakeup reason (pollable) -------------------------------------- */
3007static ssize_t hotkey_wakeup_reason_show(struct device *dev,
3008                           struct device_attribute *attr,
3009                           char *buf)
3010{
3011        return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_wakeup_reason);
3012}
3013
3014static DEVICE_ATTR(wakeup_reason, S_IRUGO, hotkey_wakeup_reason_show, NULL);
3015
3016static void hotkey_wakeup_reason_notify_change(void)
3017{
3018        sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
3019                     "wakeup_reason");
3020}
3021
3022/* sysfs wakeup hotunplug_complete (pollable) -------------------------- */
3023static ssize_t hotkey_wakeup_hotunplug_complete_show(struct device *dev,
3024                           struct device_attribute *attr,
3025                           char *buf)
3026{
3027        return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_autosleep_ack);
3028}
3029
3030static DEVICE_ATTR(wakeup_hotunplug_complete, S_IRUGO,
3031                   hotkey_wakeup_hotunplug_complete_show, NULL);
3032
3033static void hotkey_wakeup_hotunplug_complete_notify_change(void)
3034{
3035        sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
3036                     "wakeup_hotunplug_complete");
3037}
3038
3039/* sysfs adaptive kbd mode --------------------------------------------- */
3040
3041static int adaptive_keyboard_get_mode(void);
3042static int adaptive_keyboard_set_mode(int new_mode);
3043
3044enum ADAPTIVE_KEY_MODE {
3045        HOME_MODE,
3046        WEB_BROWSER_MODE,
3047        WEB_CONFERENCE_MODE,
3048        FUNCTION_MODE,
3049        LAYFLAT_MODE
3050};
3051
3052static ssize_t adaptive_kbd_mode_show(struct device *dev,
3053                           struct device_attribute *attr,
3054                           char *buf)
3055{
3056        int current_mode;
3057
3058        current_mode = adaptive_keyboard_get_mode();
3059        if (current_mode < 0)
3060                return current_mode;
3061
3062        return snprintf(buf, PAGE_SIZE, "%d\n", current_mode);
3063}
3064
3065static ssize_t adaptive_kbd_mode_store(struct device *dev,
3066                            struct device_attribute *attr,
3067                            const char *buf, size_t count)
3068{
3069        unsigned long t;
3070        int res;
3071
3072        if (parse_strtoul(buf, LAYFLAT_MODE, &t))
3073                return -EINVAL;
3074
3075        res = adaptive_keyboard_set_mode(t);
3076        return (res < 0) ? res : count;
3077}
3078
3079static DEVICE_ATTR_RW(adaptive_kbd_mode);
3080
3081static struct attribute *adaptive_kbd_attributes[] = {
3082        &dev_attr_adaptive_kbd_mode.attr,
3083        NULL
3084};
3085
3086static const struct attribute_group adaptive_kbd_attr_group = {
3087        .attrs = adaptive_kbd_attributes,
3088};
3089
3090/* --------------------------------------------------------------------- */
3091
3092static struct attribute *hotkey_attributes[] __initdata = {
3093        &dev_attr_hotkey_enable.attr,
3094        &dev_attr_hotkey_bios_enabled.attr,
3095        &dev_attr_hotkey_bios_mask.attr,
3096        &dev_attr_wakeup_reason.attr,
3097        &dev_attr_wakeup_hotunplug_complete.attr,
3098        &dev_attr_hotkey_mask.attr,
3099        &dev_attr_hotkey_all_mask.attr,
3100        &dev_attr_hotkey_adaptive_all_mask.attr,
3101        &dev_attr_hotkey_recommended_mask.attr,
3102#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3103        &dev_attr_hotkey_source_mask.attr,
3104        &dev_attr_hotkey_poll_freq.attr,
3105#endif
3106};
3107
3108/*
3109 * Sync both the hw and sw blocking state of all switches
3110 */
3111static void tpacpi_send_radiosw_update(void)
3112{
3113        int wlsw;
3114
3115        /*
3116         * We must sync all rfkill controllers *before* issuing any
3117         * rfkill input events, or we will race the rfkill core input
3118         * handler.
3119         *
3120         * tpacpi_inputdev_send_mutex works as a synchronization point
3121         * for the above.
3122         *
3123         * We optimize to avoid numerous calls to hotkey_get_wlsw.
3124         */
3125
3126        wlsw = hotkey_get_wlsw();
3127
3128        /* Sync hw blocking state first if it is hw-blocked */
3129        if (wlsw == TPACPI_RFK_RADIO_OFF)
3130                tpacpi_rfk_update_hwblock_state(true);
3131
3132        /* Sync sw blocking state */
3133        tpacpi_rfk_update_swstate_all();
3134
3135        /* Sync hw blocking state last if it is hw-unblocked */
3136        if (wlsw == TPACPI_RFK_RADIO_ON)
3137                tpacpi_rfk_update_hwblock_state(false);
3138
3139        /* Issue rfkill input event for WLSW switch */
3140        if (!(wlsw < 0)) {
3141                mutex_lock(&tpacpi_inputdev_send_mutex);
3142
3143                input_report_switch(tpacpi_inputdev,
3144                                    SW_RFKILL_ALL, (wlsw > 0));
3145                input_sync(tpacpi_inputdev);
3146
3147                mutex_unlock(&tpacpi_inputdev_send_mutex);
3148        }
3149
3150        /*
3151         * this can be unconditional, as we will poll state again
3152         * if userspace uses the notify to read data
3153         */
3154        hotkey_radio_sw_notify_change();
3155}
3156
3157static void hotkey_exit(void)
3158{
3159#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3160        mutex_lock(&hotkey_mutex);
3161        hotkey_poll_stop_sync();
3162        mutex_unlock(&hotkey_mutex);
3163#endif
3164
3165        if (hotkey_dev_attributes)
3166                delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
3167
3168        dbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_HKEY,
3169                   "restoring original HKEY status and mask\n");
3170        /* yes, there is a bitwise or below, we want the
3171         * functions to be called even if one of them fail */
3172        if (((tp_features.hotkey_mask &&
3173              hotkey_mask_set(hotkey_orig_mask)) |
3174             hotkey_status_set(false)) != 0)
3175                pr_err("failed to restore hot key mask to BIOS defaults\n");
3176}
3177
3178static void __init hotkey_unmap(const unsigned int scancode)
3179{
3180        if (hotkey_keycode_map[scancode] != KEY_RESERVED) {
3181                clear_bit(hotkey_keycode_map[scancode],
3182                          tpacpi_inputdev->keybit);
3183                hotkey_keycode_map[scancode] = KEY_RESERVED;
3184        }
3185}
3186
3187/*
3188 * HKEY quirks:
3189 *   TPACPI_HK_Q_INIMASK:       Supports FN+F3,FN+F4,FN+F12
3190 */
3191
3192#define TPACPI_HK_Q_INIMASK     0x0001
3193
3194static const struct tpacpi_quirk tpacpi_hotkey_qtable[] __initconst = {
3195        TPACPI_Q_IBM('I', 'H', TPACPI_HK_Q_INIMASK), /* 600E */
3196        TPACPI_Q_IBM('I', 'N', TPACPI_HK_Q_INIMASK), /* 600E */
3197        TPACPI_Q_IBM('I', 'D', TPACPI_HK_Q_INIMASK), /* 770, 770E, 770ED */
3198        TPACPI_Q_IBM('I', 'W', TPACPI_HK_Q_INIMASK), /* A20m */
3199        TPACPI_Q_IBM('I', 'V', TPACPI_HK_Q_INIMASK), /* A20p */
3200        TPACPI_Q_IBM('1', '0', TPACPI_HK_Q_INIMASK), /* A21e, A22e */
3201        TPACPI_Q_IBM('K', 'U', TPACPI_HK_Q_INIMASK), /* A21e */
3202        TPACPI_Q_IBM('K', 'X', TPACPI_HK_Q_INIMASK), /* A21m, A22m */
3203        TPACPI_Q_IBM('K', 'Y', TPACPI_HK_Q_INIMASK), /* A21p, A22p */
3204        TPACPI_Q_IBM('1', 'B', TPACPI_HK_Q_INIMASK), /* A22e */
3205        TPACPI_Q_IBM('1', '3', TPACPI_HK_Q_INIMASK), /* A22m */
3206        TPACPI_Q_IBM('1', 'E', TPACPI_HK_Q_INIMASK), /* A30/p (0) */
3207        TPACPI_Q_IBM('1', 'C', TPACPI_HK_Q_INIMASK), /* R30 */
3208        TPACPI_Q_IBM('1', 'F', TPACPI_HK_Q_INIMASK), /* R31 */
3209        TPACPI_Q_IBM('I', 'Y', TPACPI_HK_Q_INIMASK), /* T20 */
3210        TPACPI_Q_IBM('K', 'Z', TPACPI_HK_Q_INIMASK), /* T21 */
3211        TPACPI_Q_IBM('1', '6', TPACPI_HK_Q_INIMASK), /* T22 */
3212        TPACPI_Q_IBM('I', 'Z', TPACPI_HK_Q_INIMASK), /* X20, X21 */
3213        TPACPI_Q_IBM('1', 'D', TPACPI_HK_Q_INIMASK), /* X22, X23, X24 */
3214};
3215
3216typedef u16 tpacpi_keymap_entry_t;
3217typedef tpacpi_keymap_entry_t tpacpi_keymap_t[TPACPI_HOTKEY_MAP_LEN];
3218
3219static int hotkey_init_tablet_mode(void)
3220{
3221        int in_tablet_mode = 0, res;
3222        char *type = NULL;
3223
3224        if (acpi_evalf(hkey_handle, &res, "GMMS", "qdd", 0)) {
3225                int has_tablet_mode;
3226
3227                in_tablet_mode = hotkey_gmms_get_tablet_mode(res,
3228                                                             &has_tablet_mode);
3229                /*
3230                 * The Yoga 11e series has 2 accelerometers described by a
3231                 * BOSC0200 ACPI node. This setup relies on a Windows service
3232                 * which calls special ACPI methods on this node to report
3233                 * the laptop/tent/tablet mode to the EC. The bmc150 iio driver
3234                 * does not support this, so skip the hotkey on these models.
3235                 */
3236                if (has_tablet_mode && !dual_accel_detect())
3237                        tp_features.hotkey_tablet = TP_HOTKEY_TABLET_USES_GMMS;
3238                type = "GMMS";
3239        } else if (acpi_evalf(hkey_handle, &res, "MHKG", "qd")) {
3240                /* For X41t, X60t, X61t Tablets... */
3241                tp_features.hotkey_tablet = TP_HOTKEY_TABLET_USES_MHKG;
3242                in_tablet_mode = !!(res & TP_HOTKEY_TABLET_MASK);
3243                type = "MHKG";
3244        }
3245
3246        if (!tp_features.hotkey_tablet)
3247                return 0;
3248
3249        pr_info("Tablet mode switch found (type: %s), currently in %s mode\n",
3250                type, in_tablet_mode ? "tablet" : "laptop");
3251
3252        res = add_to_attr_set(hotkey_dev_attributes,
3253                              &dev_attr_hotkey_tablet_mode.attr);
3254        if (res)
3255                return -1;
3256
3257        return in_tablet_mode;
3258}
3259
3260static int __init hotkey_init(struct ibm_init_struct *iibm)
3261{
3262        /* Requirements for changing the default keymaps:
3263         *
3264         * 1. Many of the keys are mapped to KEY_RESERVED for very
3265         *    good reasons.  Do not change them unless you have deep
3266         *    knowledge on the IBM and Lenovo ThinkPad firmware for
3267         *    the various ThinkPad models.  The driver behaves
3268         *    differently for KEY_RESERVED: such keys have their
3269         *    hot key mask *unset* in mask_recommended, and also
3270         *    in the initial hot key mask programmed into the
3271         *    firmware at driver load time, which means the firm-
3272         *    ware may react very differently if you change them to
3273         *    something else;
3274         *
3275         * 2. You must be subscribed to the linux-thinkpad and
3276         *    ibm-acpi-devel mailing lists, and you should read the
3277         *    list archives since 2007 if you want to change the
3278         *    keymaps.  This requirement exists so that you will
3279         *    know the past history of problems with the thinkpad-
3280         *    acpi driver keymaps, and also that you will be
3281         *    listening to any bug reports;
3282         *
3283         * 3. Do not send thinkpad-acpi specific patches directly to
3284         *    for merging, *ever*.  Send them to the linux-acpi
3285         *    mailinglist for comments.  Merging is to be done only
3286         *    through acpi-test and the ACPI maintainer.
3287         *
3288         * If the above is too much to ask, don't change the keymap.
3289         * Ask the thinkpad-acpi maintainer to do it, instead.
3290         */
3291
3292        enum keymap_index {
3293                TPACPI_KEYMAP_IBM_GENERIC = 0,
3294                TPACPI_KEYMAP_LENOVO_GENERIC,
3295        };
3296
3297        static const tpacpi_keymap_t tpacpi_keymaps[] __initconst = {
3298        /* Generic keymap for IBM ThinkPads */
3299        [TPACPI_KEYMAP_IBM_GENERIC] = {
3300                /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
3301                KEY_FN_F1,      KEY_BATTERY,    KEY_COFFEE,     KEY_SLEEP,
3302                KEY_WLAN,       KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
3303                KEY_FN_F9,      KEY_FN_F10,     KEY_FN_F11,     KEY_SUSPEND,
3304
3305                /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
3306                KEY_UNKNOWN,    /* 0x0C: FN+BACKSPACE */
3307                KEY_UNKNOWN,    /* 0x0D: FN+INSERT */
3308                KEY_UNKNOWN,    /* 0x0E: FN+DELETE */
3309
3310                /* brightness: firmware always reacts to them */
3311                KEY_RESERVED,   /* 0x0F: FN+HOME (brightness up) */
3312                KEY_RESERVED,   /* 0x10: FN+END (brightness down) */
3313
3314                /* Thinklight: firmware always react to it */
3315                KEY_RESERVED,   /* 0x11: FN+PGUP (thinklight toggle) */
3316
3317                KEY_UNKNOWN,    /* 0x12: FN+PGDOWN */
3318                KEY_ZOOM,       /* 0x13: FN+SPACE (zoom) */
3319
3320                /* Volume: firmware always react to it and reprograms
3321                 * the built-in *extra* mixer.  Never map it to control
3322                 * another mixer by default. */
3323                KEY_RESERVED,   /* 0x14: VOLUME UP */
3324                KEY_RESERVED,   /* 0x15: VOLUME DOWN */
3325                KEY_RESERVED,   /* 0x16: MUTE */
3326
3327                KEY_VENDOR,     /* 0x17: Thinkpad/AccessIBM/Lenovo */
3328
3329                /* (assignments unknown, please report if found) */
3330                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3331                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3332
3333                /* No assignments, only used for Adaptive keyboards. */
3334                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3335                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3336                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3337                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3338                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3339
3340                /* No assignment, used for newer Lenovo models */
3341                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3342                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3343                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3344                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3345                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3346                KEY_UNKNOWN, KEY_UNKNOWN
3347
3348                },
3349
3350        /* Generic keymap for Lenovo ThinkPads */
3351        [TPACPI_KEYMAP_LENOVO_GENERIC] = {
3352                /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
3353                KEY_FN_F1,      KEY_COFFEE,     KEY_BATTERY,    KEY_SLEEP,
3354                KEY_WLAN,       KEY_CAMERA, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
3355                KEY_FN_F9,      KEY_FN_F10,     KEY_FN_F11,     KEY_SUSPEND,
3356
3357                /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
3358                KEY_UNKNOWN,    /* 0x0C: FN+BACKSPACE */
3359                KEY_UNKNOWN,    /* 0x0D: FN+INSERT */
3360                KEY_UNKNOWN,    /* 0x0E: FN+DELETE */
3361
3362                /* These should be enabled --only-- when ACPI video
3363                 * is disabled (i.e. in "vendor" mode), and are handled
3364                 * in a special way by the init code */
3365                KEY_BRIGHTNESSUP,       /* 0x0F: FN+HOME (brightness up) */
3366                KEY_BRIGHTNESSDOWN,     /* 0x10: FN+END (brightness down) */
3367
3368                KEY_RESERVED,   /* 0x11: FN+PGUP (thinklight toggle) */
3369
3370                KEY_UNKNOWN,    /* 0x12: FN+PGDOWN */
3371                KEY_ZOOM,       /* 0x13: FN+SPACE (zoom) */
3372
3373                /* Volume: z60/z61, T60 (BIOS version?): firmware always
3374                 * react to it and reprograms the built-in *extra* mixer.
3375                 * Never map it to control another mixer by default.
3376                 *
3377                 * T60?, T61, R60?, R61: firmware and EC tries to send
3378                 * these over the regular keyboard, so these are no-ops,
3379                 * but there are still weird bugs re. MUTE, so do not
3380                 * change unless you get test reports from all Lenovo
3381                 * models.  May cause the BIOS to interfere with the
3382                 * HDA mixer.
3383                 */
3384                KEY_RESERVED,   /* 0x14: VOLUME UP */
3385                KEY_RESERVED,   /* 0x15: VOLUME DOWN */
3386                KEY_RESERVED,   /* 0x16: MUTE */
3387
3388                KEY_VENDOR,     /* 0x17: Thinkpad/AccessIBM/Lenovo */
3389
3390                /* (assignments unknown, please report if found) */
3391                KEY_UNKNOWN, KEY_UNKNOWN,
3392
3393                /*
3394                 * The mic mute button only sends 0x1a.  It does not
3395                 * automatically mute the mic or change the mute light.
3396                 */
3397                KEY_MICMUTE,    /* 0x1a: Mic mute (since ?400 or so) */
3398
3399                /* (assignments unknown, please report if found) */
3400                KEY_UNKNOWN,
3401
3402                /* Extra keys in use since the X240 / T440 / T540 */
3403                KEY_CONFIG, KEY_SEARCH, KEY_SCALE, KEY_FILE,
3404
3405                /*
3406                 * These are the adaptive keyboard keycodes for Carbon X1 2014.
3407                 * The first item in this list is the Mute button which is
3408                 * emitted with 0x103 through
3409                 * adaptive_keyboard_hotkey_notify_hotkey() when the sound
3410                 * symbol is held.
3411                 * We'll need to offset those by 0x20.
3412                 */
3413                KEY_RESERVED,        /* Mute held, 0x103 */
3414                KEY_BRIGHTNESS_MIN,  /* Backlight off */
3415                KEY_RESERVED,        /* Clipping tool */
3416                KEY_RESERVED,        /* Cloud */
3417                KEY_RESERVED,
3418                KEY_VOICECOMMAND,    /* Voice */
3419                KEY_RESERVED,
3420                KEY_RESERVED,        /* Gestures */
3421                KEY_RESERVED,
3422                KEY_RESERVED,
3423                KEY_RESERVED,
3424                KEY_CONFIG,          /* Settings */
3425                KEY_RESERVED,        /* New tab */
3426                KEY_REFRESH,         /* Reload */
3427                KEY_BACK,            /* Back */
3428                KEY_RESERVED,        /* Microphone down */
3429                KEY_RESERVED,        /* Microphone up */
3430                KEY_RESERVED,        /* Microphone cancellation */
3431                KEY_RESERVED,        /* Camera mode */
3432                KEY_RESERVED,        /* Rotate display, 0x116 */
3433
3434                /*
3435                 * These are found in 2017 models (e.g. T470s, X270).
3436                 * The lowest known value is 0x311, which according to
3437                 * the manual should launch a user defined favorite
3438                 * application.
3439                 *
3440                 * The offset for these is TP_ACPI_HOTKEYSCAN_EXTENDED_START,
3441                 * corresponding to 0x34.
3442                 */
3443
3444                /* (assignments unknown, please report if found) */
3445                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3446                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3447                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3448                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3449                KEY_UNKNOWN,
3450
3451                KEY_BOOKMARKS,                  /* Favorite app, 0x311 */
3452                KEY_SELECTIVE_SCREENSHOT,       /* Clipping tool */
3453                KEY_CALC,                       /* Calculator (above numpad, P52) */
3454                KEY_BLUETOOTH,                  /* Bluetooth */
3455                KEY_KEYBOARD,                   /* Keyboard, 0x315 */
3456                KEY_FN_RIGHT_SHIFT,             /* Fn + right Shift */
3457                KEY_NOTIFICATION_CENTER,        /* Notification Center */
3458                KEY_PICKUP_PHONE,               /* Answer incoming call */
3459                KEY_HANGUP_PHONE,               /* Decline incoming call */
3460                },
3461        };
3462
3463        static const struct tpacpi_quirk tpacpi_keymap_qtable[] __initconst = {
3464                /* Generic maps (fallback) */
3465                {
3466                  .vendor = PCI_VENDOR_ID_IBM,
3467                  .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
3468                  .quirks = TPACPI_KEYMAP_IBM_GENERIC,
3469                },
3470                {
3471                  .vendor = PCI_VENDOR_ID_LENOVO,
3472                  .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
3473                  .quirks = TPACPI_KEYMAP_LENOVO_GENERIC,
3474                },
3475        };
3476
3477#define TPACPI_HOTKEY_MAP_SIZE          sizeof(tpacpi_keymap_t)
3478#define TPACPI_HOTKEY_MAP_TYPESIZE      sizeof(tpacpi_keymap_entry_t)
3479
3480        int res, i;
3481        int status;
3482        int hkeyv;
3483        bool radiosw_state  = false;
3484        bool tabletsw_state = false;
3485
3486        unsigned long quirks;
3487        unsigned long keymap_id;
3488
3489        vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3490                        "initializing hotkey subdriver\n");
3491
3492        BUG_ON(!tpacpi_inputdev);
3493        BUG_ON(tpacpi_inputdev->open != NULL ||
3494               tpacpi_inputdev->close != NULL);
3495
3496        TPACPI_ACPIHANDLE_INIT(hkey);
3497        mutex_init(&hotkey_mutex);
3498
3499#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3500        mutex_init(&hotkey_thread_data_mutex);
3501#endif
3502
3503        /* hotkey not supported on 570 */
3504        tp_features.hotkey = hkey_handle != NULL;
3505
3506        vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3507                "hotkeys are %s\n",
3508                str_supported(tp_features.hotkey));
3509
3510        if (!tp_features.hotkey)
3511                return 1;
3512
3513        quirks = tpacpi_check_quirks(tpacpi_hotkey_qtable,
3514                                     ARRAY_SIZE(tpacpi_hotkey_qtable));
3515
3516        tpacpi_disable_brightness_delay();
3517
3518        /* MUST have enough space for all attributes to be added to
3519         * hotkey_dev_attributes */
3520        hotkey_dev_attributes = create_attr_set(
3521                                        ARRAY_SIZE(hotkey_attributes) + 2,
3522                                        NULL);
3523        if (!hotkey_dev_attributes)
3524                return -ENOMEM;
3525        res = add_many_to_attr_set(hotkey_dev_attributes,
3526                        hotkey_attributes,
3527                        ARRAY_SIZE(hotkey_attributes));
3528        if (res)
3529                goto err_exit;
3530
3531        /* mask not supported on 600e/x, 770e, 770x, A21e, A2xm/p,
3532           A30, R30, R31, T20-22, X20-21, X22-24.  Detected by checking
3533           for HKEY interface version 0x100 */
3534        if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) {
3535                vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3536                            "firmware HKEY interface version: 0x%x\n",
3537                            hkeyv);
3538
3539                switch (hkeyv >> 8) {
3540                case 1:
3541                        /*
3542                         * MHKV 0x100 in A31, R40, R40e,
3543                         * T4x, X31, and later
3544                         */
3545
3546                        /* Paranoia check AND init hotkey_all_mask */
3547                        if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
3548                                        "MHKA", "qd")) {
3549                                pr_err("missing MHKA handler, please report this to %s\n",
3550                                       TPACPI_MAIL);
3551                                /* Fallback: pre-init for FN+F3,F4,F12 */
3552                                hotkey_all_mask = 0x080cU;
3553                        } else {
3554                                tp_features.hotkey_mask = 1;
3555                        }
3556                        break;
3557
3558                case 2:
3559                        /*
3560                         * MHKV 0x200 in X1, T460s, X260, T560, X1 Tablet (2016)
3561                         */
3562
3563                        /* Paranoia check AND init hotkey_all_mask */
3564                        if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
3565                                        "MHKA", "dd", 1)) {
3566                                pr_err("missing MHKA handler, please report this to %s\n",
3567                                       TPACPI_MAIL);
3568                                /* Fallback: pre-init for FN+F3,F4,F12 */
3569                                hotkey_all_mask = 0x080cU;
3570                        } else {
3571                                tp_features.hotkey_mask = 1;
3572                        }
3573
3574                        /*
3575                         * Check if we have an adaptive keyboard, like on the
3576                         * Lenovo Carbon X1 2014 (2nd Gen).
3577                         */
3578                        if (acpi_evalf(hkey_handle, &hotkey_adaptive_all_mask,
3579                                       "MHKA", "dd", 2)) {
3580                                if (hotkey_adaptive_all_mask != 0) {
3581                                        tp_features.has_adaptive_kbd = true;
3582                                        res = sysfs_create_group(
3583                                                &tpacpi_pdev->dev.kobj,
3584                                                &adaptive_kbd_attr_group);
3585                                        if (res)
3586                                                goto err_exit;
3587                                }
3588                        } else {
3589                                tp_features.has_adaptive_kbd = false;
3590                                hotkey_adaptive_all_mask = 0x0U;
3591                        }
3592                        break;
3593
3594                default:
3595                        pr_err("unknown version of the HKEY interface: 0x%x\n",
3596                               hkeyv);
3597                        pr_err("please report this to %s\n", TPACPI_MAIL);
3598                        break;
3599                }
3600        }
3601
3602        vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3603                "hotkey masks are %s\n",
3604                str_supported(tp_features.hotkey_mask));
3605
3606        /* Init hotkey_all_mask if not initialized yet */
3607        if (!tp_features.hotkey_mask && !hotkey_all_mask &&
3608            (quirks & TPACPI_HK_Q_INIMASK))
3609                hotkey_all_mask = 0x080cU;  /* FN+F12, FN+F4, FN+F3 */
3610
3611        /* Init hotkey_acpi_mask and hotkey_orig_mask */
3612        if (tp_features.hotkey_mask) {
3613                /* hotkey_source_mask *must* be zero for
3614                 * the first hotkey_mask_get to return hotkey_orig_mask */
3615                res = hotkey_mask_get();
3616                if (res)
3617                        goto err_exit;
3618
3619                hotkey_orig_mask = hotkey_acpi_mask;
3620        } else {
3621                hotkey_orig_mask = hotkey_all_mask;
3622                hotkey_acpi_mask = hotkey_all_mask;
3623        }
3624
3625#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
3626        if (dbg_wlswemul) {
3627                tp_features.hotkey_wlsw = 1;
3628                radiosw_state = !!tpacpi_wlsw_emulstate;
3629                pr_info("radio switch emulation enabled\n");
3630        } else
3631#endif
3632        /* Not all thinkpads have a hardware radio switch */
3633        if (acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
3634                tp_features.hotkey_wlsw = 1;
3635                radiosw_state = !!status;
3636                pr_info("radio switch found; radios are %s\n",
3637                        enabled(status, 0));
3638        }
3639        if (tp_features.hotkey_wlsw)
3640                res = add_to_attr_set(hotkey_dev_attributes,
3641                                &dev_attr_hotkey_radio_sw.attr);
3642
3643        res = hotkey_init_tablet_mode();
3644        if (res < 0)
3645                goto err_exit;
3646
3647        tabletsw_state = res;
3648
3649        res = register_attr_set_with_sysfs(hotkey_dev_attributes,
3650                                           &tpacpi_pdev->dev.kobj);
3651        if (res)
3652                goto err_exit;
3653
3654        /* Set up key map */
3655        keymap_id = tpacpi_check_quirks(tpacpi_keymap_qtable,
3656                                        ARRAY_SIZE(tpacpi_keymap_qtable));
3657        BUG_ON(keymap_id >= ARRAY_SIZE(tpacpi_keymaps));
3658        dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3659                   "using keymap number %lu\n", keymap_id);
3660
3661        hotkey_keycode_map = kmemdup(&tpacpi_keymaps[keymap_id],
3662                        TPACPI_HOTKEY_MAP_SIZE, GFP_KERNEL);
3663        if (!hotkey_keycode_map) {
3664                pr_err("failed to allocate memory for key map\n");
3665                res = -ENOMEM;
3666                goto err_exit;
3667        }
3668
3669        input_set_capability(tpacpi_inputdev, EV_MSC, MSC_SCAN);
3670        tpacpi_inputdev->keycodesize = TPACPI_HOTKEY_MAP_TYPESIZE;
3671        tpacpi_inputdev->keycodemax = TPACPI_HOTKEY_MAP_LEN;
3672        tpacpi_inputdev->keycode = hotkey_keycode_map;
3673        for (i = 0; i < TPACPI_HOTKEY_MAP_LEN; i++) {
3674                if (hotkey_keycode_map[i] != KEY_RESERVED) {
3675                        input_set_capability(tpacpi_inputdev, EV_KEY,
3676                                                hotkey_keycode_map[i]);
3677                } else {
3678                        if (i < sizeof(hotkey_reserved_mask)*8)
3679                                hotkey_reserved_mask |= 1 << i;
3680                }
3681        }
3682
3683        if (tp_features.hotkey_wlsw) {
3684                input_set_capability(tpacpi_inputdev, EV_SW, SW_RFKILL_ALL);
3685                input_report_switch(tpacpi_inputdev,
3686                                    SW_RFKILL_ALL, radiosw_state);
3687        }
3688        if (tp_features.hotkey_tablet) {
3689                input_set_capability(tpacpi_inputdev, EV_SW, SW_TABLET_MODE);
3690                input_report_switch(tpacpi_inputdev,
3691                                    SW_TABLET_MODE, tabletsw_state);
3692        }
3693
3694        /* Do not issue duplicate brightness change events to
3695         * userspace. tpacpi_detect_brightness_capabilities() must have
3696         * been called before this point  */
3697        if (acpi_video_get_backlight_type() != acpi_backlight_vendor) {
3698                pr_info("This ThinkPad has standard ACPI backlight brightness control, supported by the ACPI video driver\n");
3699                pr_notice("Disabling thinkpad-acpi brightness events by default...\n");
3700
3701                /* Disable brightness up/down on Lenovo thinkpads when
3702                 * ACPI is handling them, otherwise it is plain impossible
3703                 * for userspace to do something even remotely sane */
3704                hotkey_reserved_mask |=
3705                        (1 << TP_ACPI_HOTKEYSCAN_FNHOME)
3706                        | (1 << TP_ACPI_HOTKEYSCAN_FNEND);
3707                hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNHOME);
3708                hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNEND);
3709        }
3710
3711#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3712        hotkey_source_mask = TPACPI_HKEY_NVRAM_GOOD_MASK
3713                                & ~hotkey_all_mask
3714                                & ~hotkey_reserved_mask;
3715
3716        vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3717                    "hotkey source mask 0x%08x, polling freq %u\n",
3718                    hotkey_source_mask, hotkey_poll_freq);
3719#endif
3720
3721        dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3722                        "enabling firmware HKEY event interface...\n");
3723        res = hotkey_status_set(true);
3724        if (res) {
3725                hotkey_exit();
3726                return res;
3727        }
3728        res = hotkey_mask_set(((hotkey_all_mask & ~hotkey_reserved_mask)
3729                               | hotkey_driver_mask)
3730                              & ~hotkey_source_mask);
3731        if (res < 0 && res != -ENXIO) {
3732                hotkey_exit();
3733                return res;
3734        }
3735        hotkey_user_mask = (hotkey_acpi_mask | hotkey_source_mask)
3736                                & ~hotkey_reserved_mask;
3737        vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
3738                "initial masks: user=0x%08x, fw=0x%08x, poll=0x%08x\n",
3739                hotkey_user_mask, hotkey_acpi_mask, hotkey_source_mask);
3740
3741        tpacpi_inputdev->open = &hotkey_inputdev_open;
3742        tpacpi_inputdev->close = &hotkey_inputdev_close;
3743
3744        hotkey_poll_setup_safe(true);
3745
3746        return 0;
3747
3748err_exit:
3749        delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
3750        sysfs_remove_group(&tpacpi_pdev->dev.kobj,
3751                        &adaptive_kbd_attr_group);
3752
3753        hotkey_dev_attributes = NULL;
3754
3755        return (res < 0) ? res : 1;
3756}
3757
3758/* Thinkpad X1 Carbon support 5 modes including Home mode, Web browser
3759 * mode, Web conference mode, Function mode and Lay-flat mode.
3760 * We support Home mode and Function mode currently.
3761 *
3762 * Will consider support rest of modes in future.
3763 *
3764 */
3765static const int adaptive_keyboard_modes[] = {
3766        HOME_MODE,
3767/*      WEB_BROWSER_MODE = 2,
3768        WEB_CONFERENCE_MODE = 3, */
3769        FUNCTION_MODE
3770};
3771
3772#define DFR_CHANGE_ROW                  0x101
3773#define DFR_SHOW_QUICKVIEW_ROW          0x102
3774#define FIRST_ADAPTIVE_KEY              0x103
3775
3776/* press Fn key a while second, it will switch to Function Mode. Then
3777 * release Fn key, previous mode be restored.
3778 */
3779static bool adaptive_keyboard_mode_is_saved;
3780static int adaptive_keyboard_prev_mode;
3781
3782static int adaptive_keyboard_get_mode(void)
3783{
3784        int mode = 0;
3785
3786        if (!acpi_evalf(hkey_handle, &mode, "GTRW", "dd", 0)) {
3787                pr_err("Cannot read adaptive keyboard mode\n");
3788                return -EIO;
3789        }
3790
3791        return mode;
3792}
3793
3794static int adaptive_keyboard_set_mode(int new_mode)
3795{
3796        if (new_mode < 0 ||
3797                new_mode > LAYFLAT_MODE)
3798                return -EINVAL;
3799
3800        if (!acpi_evalf(hkey_handle, NULL, "STRW", "vd", new_mode)) {
3801                pr_err("Cannot set adaptive keyboard mode\n");
3802                return -EIO;
3803        }
3804
3805        return 0;
3806}
3807
3808static int adaptive_keyboard_get_next_mode(int mode)
3809{
3810        size_t i;
3811        size_t max_mode = ARRAY_SIZE(adaptive_keyboard_modes) - 1;
3812
3813        for (i = 0; i <= max_mode; i++) {
3814                if (adaptive_keyboard_modes[i] == mode)
3815                        break;
3816        }
3817
3818        if (i >= max_mode)
3819                i = 0;
3820        else
3821                i++;
3822
3823        return adaptive_keyboard_modes[i];
3824}
3825
3826static bool adaptive_keyboard_hotkey_notify_hotkey(unsigned int scancode)
3827{
3828        int current_mode = 0;
3829        int new_mode = 0;
3830        int keycode;
3831
3832        switch (scancode) {
3833        case DFR_CHANGE_ROW:
3834                if (adaptive_keyboard_mode_is_saved) {
3835                        new_mode = adaptive_keyboard_prev_mode;
3836                        adaptive_keyboard_mode_is_saved = false;
3837                } else {
3838                        current_mode = adaptive_keyboard_get_mode();
3839                        if (current_mode < 0)
3840                                return false;
3841                        new_mode = adaptive_keyboard_get_next_mode(
3842                                        current_mode);
3843                }
3844
3845                if (adaptive_keyboard_set_mode(new_mode) < 0)
3846                        return false;
3847
3848                return true;
3849
3850        case DFR_SHOW_QUICKVIEW_ROW:
3851                current_mode = adaptive_keyboard_get_mode();
3852                if (current_mode < 0)
3853                        return false;
3854
3855                adaptive_keyboard_prev_mode = current_mode;
3856                adaptive_keyboard_mode_is_saved = true;
3857
3858                if (adaptive_keyboard_set_mode (FUNCTION_MODE) < 0)
3859                        return false;
3860                return true;
3861
3862        default:
3863                if (scancode < FIRST_ADAPTIVE_KEY ||
3864                    scancode >= FIRST_ADAPTIVE_KEY +
3865                    TP_ACPI_HOTKEYSCAN_EXTENDED_START -
3866                    TP_ACPI_HOTKEYSCAN_ADAPTIVE_START) {
3867                        pr_info("Unhandled adaptive keyboard key: 0x%x\n",
3868                                scancode);
3869                        return false;
3870                }
3871                keycode = hotkey_keycode_map[scancode - FIRST_ADAPTIVE_KEY +
3872                                             TP_ACPI_HOTKEYSCAN_ADAPTIVE_START];
3873                if (keycode != KEY_RESERVED) {
3874                        mutex_lock(&tpacpi_inputdev_send_mutex);
3875
3876                        input_report_key(tpacpi_inputdev, keycode, 1);
3877                        input_sync(tpacpi_inputdev);
3878
3879                        input_report_key(tpacpi_inputdev, keycode, 0);
3880                        input_sync(tpacpi_inputdev);
3881
3882                        mutex_unlock(&tpacpi_inputdev_send_mutex);
3883                }
3884                return true;
3885        }
3886}
3887
3888static bool hotkey_notify_hotkey(const u32 hkey,
3889                                 bool *send_acpi_ev,
3890                                 bool *ignore_acpi_ev)
3891{
3892        /* 0x1000-0x1FFF: key presses */
3893        unsigned int scancode = hkey & 0xfff;
3894        *send_acpi_ev = true;
3895        *ignore_acpi_ev = false;
3896
3897        /*
3898         * Original events are in the 0x10XX range, the adaptive keyboard
3899         * found in 2014 X1 Carbon emits events are of 0x11XX. In 2017
3900         * models, additional keys are emitted through 0x13XX.
3901         */
3902        switch ((hkey >> 8) & 0xf) {
3903        case 0:
3904                if (scancode > 0 &&
3905                    scancode <= TP_ACPI_HOTKEYSCAN_ADAPTIVE_START) {
3906                        /* HKEY event 0x1001 is scancode 0x00 */
3907                        scancode--;
3908                        if (!(hotkey_source_mask & (1 << scancode))) {
3909                                tpacpi_input_send_key_masked(scancode);
3910                                *send_acpi_ev = false;
3911                        } else {
3912                                *ignore_acpi_ev = true;
3913                        }
3914                        return true;
3915                }
3916                break;
3917
3918        case 1:
3919                return adaptive_keyboard_hotkey_notify_hotkey(scancode);
3920
3921        case 3:
3922                /* Extended keycodes start at 0x300 and our offset into the map
3923                 * TP_ACPI_HOTKEYSCAN_EXTENDED_START. The calculated scancode
3924                 * will be positive, but might not be in the correct range.
3925                 */
3926                scancode -= (0x300 - TP_ACPI_HOTKEYSCAN_EXTENDED_START);
3927                if (scancode >= TP_ACPI_HOTKEYSCAN_EXTENDED_START &&
3928                    scancode < TPACPI_HOTKEY_MAP_LEN) {
3929                        tpacpi_input_send_key(scancode);
3930                        return true;
3931                }
3932                break;
3933        }
3934
3935        return false;
3936}
3937
3938static bool hotkey_notify_wakeup(const u32 hkey,
3939                                 bool *send_acpi_ev,
3940                                 bool *ignore_acpi_ev)
3941{
3942        /* 0x2000-0x2FFF: Wakeup reason */
3943        *send_acpi_ev = true;
3944        *ignore_acpi_ev = false;
3945
3946        switch (hkey) {
3947        case TP_HKEY_EV_WKUP_S3_UNDOCK: /* suspend, undock */
3948        case TP_HKEY_EV_WKUP_S4_UNDOCK: /* hibernation, undock */
3949                hotkey_wakeup_reason = TP_ACPI_WAKEUP_UNDOCK;
3950                *ignore_acpi_ev = true;
3951                break;
3952
3953        case TP_HKEY_EV_WKUP_S3_BAYEJ: /* suspend, bay eject */
3954        case TP_HKEY_EV_WKUP_S4_BAYEJ: /* hibernation, bay eject */
3955                hotkey_wakeup_reason = TP_ACPI_WAKEUP_BAYEJ;
3956                *ignore_acpi_ev = true;
3957                break;
3958
3959        case TP_HKEY_EV_WKUP_S3_BATLOW: /* Battery on critical low level/S3 */
3960        case TP_HKEY_EV_WKUP_S4_BATLOW: /* Battery on critical low level/S4 */
3961                pr_alert("EMERGENCY WAKEUP: battery almost empty\n");
3962                /* how to auto-heal: */
3963                /* 2313: woke up from S3, go to S4/S5 */
3964                /* 2413: woke up from S4, go to S5 */
3965                break;
3966
3967        default:
3968                return false;
3969        }
3970
3971        if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
3972                pr_info("woke up due to a hot-unplug request...\n");
3973                hotkey_wakeup_reason_notify_change();
3974        }
3975        return true;
3976}
3977
3978static bool hotkey_notify_dockevent(const u32 hkey,
3979                                 bool *send_acpi_ev,
3980                                 bool *ignore_acpi_ev)
3981{
3982        /* 0x4000-0x4FFF: dock-related events */
3983        *send_acpi_ev = true;
3984        *ignore_acpi_ev = false;
3985
3986        switch (hkey) {
3987        case TP_HKEY_EV_UNDOCK_ACK:
3988                /* ACPI undock operation completed after wakeup */
3989                hotkey_autosleep_ack = 1;
3990                pr_info("undocked\n");
3991                hotkey_wakeup_hotunplug_complete_notify_change();
3992                return true;
3993
3994        case TP_HKEY_EV_HOTPLUG_DOCK: /* docked to port replicator */
3995                pr_info("docked into hotplug port replicator\n");
3996                return true;
3997        case TP_HKEY_EV_HOTPLUG_UNDOCK: /* undocked from port replicator */
3998                pr_info("undocked from hotplug port replicator\n");
3999                return true;
4000
4001        /*
4002         * Deliberately ignore attaching and detaching the keybord cover to avoid
4003         * duplicates from intel-vbtn, which already emits SW_TABLET_MODE events
4004         * to userspace.
4005         *
4006         * Please refer to the following thread for more information and a preliminary
4007         * implementation using the GTOP ("Get Tablet OPtions") interface that could be
4008         * extended to other attachment options of the ThinkPad X1 Tablet series, such as
4009         * the Pico cartridge dock module:
4010         * https://lore.kernel.org/platform-driver-x86/38cb8265-1e30-d547-9e12-b4ae290be737@a-kobel.de/
4011         */
4012        case TP_HKEY_EV_KBD_COVER_ATTACH:
4013        case TP_HKEY_EV_KBD_COVER_DETACH:
4014                *send_acpi_ev = false;
4015                *ignore_acpi_ev = true;
4016                return true;
4017
4018        default:
4019                return false;
4020        }
4021}
4022
4023static bool hotkey_notify_usrevent(const u32 hkey,
4024                                 bool *send_acpi_ev,
4025                                 bool *ignore_acpi_ev)
4026{
4027        /* 0x5000-0x5FFF: human interface helpers */
4028        *send_acpi_ev = true;
4029        *ignore_acpi_ev = false;
4030
4031        switch (hkey) {
4032        case TP_HKEY_EV_PEN_INSERTED:  /* X61t: tablet pen inserted into bay */
4033        case TP_HKEY_EV_PEN_REMOVED:   /* X61t: tablet pen removed from bay */
4034                return true;
4035
4036        case TP_HKEY_EV_TABLET_TABLET:   /* X41t-X61t: tablet mode */
4037        case TP_HKEY_EV_TABLET_NOTEBOOK: /* X41t-X61t: normal mode */
4038                tpacpi_input_send_tabletsw();
4039                hotkey_tablet_mode_notify_change();
4040                *send_acpi_ev = false;
4041                return true;
4042
4043        case TP_HKEY_EV_LID_CLOSE:      /* Lid closed */
4044        case TP_HKEY_EV_LID_OPEN:       /* Lid opened */
4045        case TP_HKEY_EV_BRGHT_CHANGED:  /* brightness changed */
4046                /* do not propagate these events */
4047                *ignore_acpi_ev = true;
4048                return true;
4049
4050        default:
4051                return false;
4052        }
4053}
4054
4055static void thermal_dump_all_sensors(void);
4056static void palmsensor_refresh(void);
4057
4058static bool hotkey_notify_6xxx(const u32 hkey,
4059                                 bool *send_acpi_ev,
4060                                 bool *ignore_acpi_ev)
4061{
4062        /* 0x6000-0x6FFF: thermal alarms/notices and keyboard events */
4063        *send_acpi_ev = true;
4064        *ignore_acpi_ev = false;
4065
4066        switch (hkey) {
4067        case TP_HKEY_EV_THM_TABLE_CHANGED:
4068                pr_debug("EC reports: Thermal Table has changed\n");
4069                /* recommended action: do nothing, we don't have
4070                 * Lenovo ATM information */
4071                return true;
4072        case TP_HKEY_EV_THM_CSM_COMPLETED:
4073                pr_debug("EC reports: Thermal Control Command set completed (DYTC)\n");
4074                /* Thermal event - pass on to event handler */
4075                tpacpi_driver_event(hkey);
4076                return true;
4077        case TP_HKEY_EV_THM_TRANSFM_CHANGED:
4078                pr_debug("EC reports: Thermal Transformation changed (GMTS)\n");
4079                /* recommended action: do nothing, we don't have
4080                 * Lenovo ATM information */
4081                return true;
4082        case TP_HKEY_EV_ALARM_BAT_HOT:
4083                pr_crit("THERMAL ALARM: battery is too hot!\n");
4084                /* recommended action: warn user through gui */
4085                break;
4086        case TP_HKEY_EV_ALARM_BAT_XHOT:
4087                pr_alert("THERMAL EMERGENCY: battery is extremely hot!\n");
4088                /* recommended action: immediate sleep/hibernate */
4089                break;
4090        case TP_HKEY_EV_ALARM_SENSOR_HOT:
4091                pr_crit("THERMAL ALARM: a sensor reports something is too hot!\n");
4092                /* recommended action: warn user through gui, that */
4093                /* some internal component is too hot */
4094                break;
4095        case TP_HKEY_EV_ALARM_SENSOR_XHOT:
4096                pr_alert("THERMAL EMERGENCY: a sensor reports something is extremely hot!\n");
4097                /* recommended action: immediate sleep/hibernate */
4098                break;
4099        case TP_HKEY_EV_AC_CHANGED:
4100                /* X120e, X121e, X220, X220i, X220t, X230, T420, T420s, W520:
4101                 * AC status changed; can be triggered by plugging or
4102                 * unplugging AC adapter, docking or undocking. */
4103
4104                fallthrough;
4105
4106        case TP_HKEY_EV_KEY_NUMLOCK:
4107        case TP_HKEY_EV_KEY_FN:
4108                /* key press events, we just ignore them as long as the EC
4109                 * is still reporting them in the normal keyboard stream */
4110                *send_acpi_ev = false;
4111                *ignore_acpi_ev = true;
4112                return true;
4113
4114        case TP_HKEY_EV_KEY_FN_ESC:
4115                /* Get the media key status to force the status LED to update */
4116                acpi_evalf(hkey_handle, NULL, "GMKS", "v");
4117                *send_acpi_ev = false;
4118                *ignore_acpi_ev = true;
4119                return true;
4120
4121        case TP_HKEY_EV_TABLET_CHANGED:
4122                tpacpi_input_send_tabletsw();
4123                hotkey_tablet_mode_notify_change();
4124                *send_acpi_ev = false;
4125                return true;
4126
4127        case TP_HKEY_EV_PALM_DETECTED:
4128        case TP_HKEY_EV_PALM_UNDETECTED:
4129                /* palm detected  - pass on to event handler */
4130                palmsensor_refresh();
4131                return true;
4132
4133        default:
4134                /* report simply as unknown, no sensor dump */
4135                return false;
4136        }
4137
4138        thermal_dump_all_sensors();
4139        return true;
4140}
4141
4142static void hotkey_notify(struct ibm_struct *ibm, u32 event)
4143{
4144        u32 hkey;
4145        bool send_acpi_ev;
4146        bool ignore_acpi_ev;
4147        bool known_ev;
4148
4149        if (event != 0x80) {
4150                pr_err("unknown HKEY notification event %d\n", event);
4151                /* forward it to userspace, maybe it knows how to handle it */
4152                acpi_bus_generate_netlink_event(
4153                                        ibm->acpi->device->pnp.device_class,
4154                                        dev_name(&ibm->acpi->device->dev),
4155                                        event, 0);
4156                return;
4157        }
4158
4159        while (1) {
4160                if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
4161                        pr_err("failed to retrieve HKEY event\n");
4162                        return;
4163                }
4164
4165                if (hkey == 0) {
4166                        /* queue empty */
4167                        return;
4168                }
4169
4170                send_acpi_ev = true;
4171                ignore_acpi_ev = false;
4172
4173                switch (hkey >> 12) {
4174                case 1:
4175                        /* 0x1000-0x1FFF: key presses */
4176                        known_ev = hotkey_notify_hotkey(hkey, &send_acpi_ev,
4177                                                 &ignore_acpi_ev);
4178                        break;
4179                case 2:
4180                        /* 0x2000-0x2FFF: Wakeup reason */
4181                        known_ev = hotkey_notify_wakeup(hkey, &send_acpi_ev,
4182                                                 &ignore_acpi_ev);
4183                        break;
4184                case 3:
4185                        /* 0x3000-0x3FFF: bay-related wakeups */
4186                        switch (hkey) {
4187                        case TP_HKEY_EV_BAYEJ_ACK:
4188                                hotkey_autosleep_ack = 1;
4189                                pr_info("bay ejected\n");
4190                                hotkey_wakeup_hotunplug_complete_notify_change();
4191                                known_ev = true;
4192                                break;
4193                        case TP_HKEY_EV_OPTDRV_EJ:
4194                                /* FIXME: kick libata if SATA link offline */
4195                                known_ev = true;
4196                                break;
4197                        default:
4198                                known_ev = false;
4199                        }
4200                        break;
4201                case 4:
4202                        /* 0x4000-0x4FFF: dock-related events */
4203                        known_ev = hotkey_notify_dockevent(hkey, &send_acpi_ev,
4204                                                &ignore_acpi_ev);
4205                        break;
4206                case 5:
4207                        /* 0x5000-0x5FFF: human interface helpers */
4208                        known_ev = hotkey_notify_usrevent(hkey, &send_acpi_ev,
4209                                                 &ignore_acpi_ev);
4210                        break;
4211                case 6:
4212                        /* 0x6000-0x6FFF: thermal alarms/notices and
4213                         *                keyboard events */
4214                        known_ev = hotkey_notify_6xxx(hkey, &send_acpi_ev,
4215                                                 &ignore_acpi_ev);
4216                        break;
4217                case 7:
4218                        /* 0x7000-0x7FFF: misc */
4219                        if (tp_features.hotkey_wlsw &&
4220                                        hkey == TP_HKEY_EV_RFKILL_CHANGED) {
4221                                tpacpi_send_radiosw_update();
4222                                send_acpi_ev = 0;
4223                                known_ev = true;
4224                                break;
4225                        }
4226                        fallthrough;    /* to default */
4227                default:
4228                        known_ev = false;
4229                }
4230                if (!known_ev) {
4231                        pr_notice("unhandled HKEY event 0x%04x\n", hkey);
4232                        pr_notice("please report the conditions when this event happened to %s\n",
4233                                  TPACPI_MAIL);
4234                }
4235
4236                /* netlink events */
4237                if (!ignore_acpi_ev && send_acpi_ev) {
4238                        acpi_bus_generate_netlink_event(
4239                                        ibm->acpi->device->pnp.device_class,
4240                                        dev_name(&ibm->acpi->device->dev),
4241                                        event, hkey);
4242                }
4243        }
4244}
4245
4246static void hotkey_suspend(void)
4247{
4248        /* Do these on suspend, we get the events on early resume! */
4249        hotkey_wakeup_reason = TP_ACPI_WAKEUP_NONE;
4250        hotkey_autosleep_ack = 0;
4251
4252        /* save previous mode of adaptive keyboard of X1 Carbon */
4253        if (tp_features.has_adaptive_kbd) {
4254                if (!acpi_evalf(hkey_handle, &adaptive_keyboard_prev_mode,
4255                                        "GTRW", "dd", 0)) {
4256                        pr_err("Cannot read adaptive keyboard mode.\n");
4257                }
4258        }
4259}
4260
4261static void hotkey_resume(void)
4262{
4263        tpacpi_disable_brightness_delay();
4264
4265        if (hotkey_status_set(true) < 0 ||
4266            hotkey_mask_set(hotkey_acpi_mask) < 0)
4267                pr_err("error while attempting to reset the event firmware interface\n");
4268
4269        tpacpi_send_radiosw_update();
4270        tpacpi_input_send_tabletsw();
4271        hotkey_tablet_mode_notify_change();
4272        hotkey_wakeup_reason_notify_change();
4273        hotkey_wakeup_hotunplug_complete_notify_change();
4274        hotkey_poll_setup_safe(false);
4275
4276        /* restore previous mode of adapive keyboard of X1 Carbon */
4277        if (tp_features.has_adaptive_kbd) {
4278                if (!acpi_evalf(hkey_handle, NULL, "STRW", "vd",
4279                                        adaptive_keyboard_prev_mode)) {
4280                        pr_err("Cannot set adaptive keyboard mode.\n");
4281                }
4282        }
4283}
4284
4285/* procfs -------------------------------------------------------------- */
4286static int hotkey_read(struct seq_file *m)
4287{
4288        int res, status;
4289
4290        if (!tp_features.hotkey) {
4291                seq_printf(m, "status:\t\tnot supported\n");
4292                return 0;
4293        }
4294
4295        if (mutex_lock_killable(&hotkey_mutex))
4296                return -ERESTARTSYS;
4297        res = hotkey_status_get(&status);
4298        if (!res)
4299                res = hotkey_mask_get();
4300        mutex_unlock(&hotkey_mutex);
4301        if (res)
4302                return res;
4303
4304        seq_printf(m, "status:\t\t%s\n", enabled(status, 0));
4305        if (hotkey_all_mask) {
4306                seq_printf(m, "mask:\t\t0x%08x\n", hotkey_user_mask);
4307                seq_printf(m, "commands:\tenable, disable, reset, <mask>\n");
4308        } else {
4309                seq_printf(m, "mask:\t\tnot supported\n");
4310                seq_printf(m, "commands:\tenable, disable, reset\n");
4311        }
4312
4313        return 0;
4314}
4315
4316static void hotkey_enabledisable_warn(bool enable)
4317{
4318        tpacpi_log_usertask("procfs hotkey enable/disable");
4319        if (!WARN((tpacpi_lifecycle == TPACPI_LIFE_RUNNING || !enable),
4320                  pr_fmt("hotkey enable/disable functionality has been removed from the driver.  Hotkeys are always enabled.\n")))
4321                pr_err("Please remove the hotkey=enable module parameter, it is deprecated.  Hotkeys are always enabled.\n");
4322}
4323
4324static int hotkey_write(char *buf)
4325{
4326        int res;
4327        u32 mask;
4328        char *cmd;
4329
4330        if (!tp_features.hotkey)
4331                return -ENODEV;
4332
4333        if (mutex_lock_killable(&hotkey_mutex))
4334                return -ERESTARTSYS;
4335
4336        mask = hotkey_user_mask;
4337
4338        res = 0;
4339        while ((cmd = strsep(&buf, ","))) {
4340                if (strlencmp(cmd, "enable") == 0) {
4341                        hotkey_enabledisable_warn(1);
4342                } else if (strlencmp(cmd, "disable") == 0) {
4343                        hotkey_enabledisable_warn(0);
4344                        res = -EPERM;
4345                } else if (strlencmp(cmd, "reset") == 0) {
4346                        mask = (hotkey_all_mask | hotkey_source_mask)
4347                                & ~hotkey_reserved_mask;
4348                } else if (sscanf(cmd, "0x%x", &mask) == 1) {
4349                        /* mask set */
4350                } else if (sscanf(cmd, "%x", &mask) == 1) {
4351                        /* mask set */
4352                } else {
4353                        res = -EINVAL;
4354                        goto errexit;
4355                }
4356        }
4357
4358        if (!res) {
4359                tpacpi_disclose_usertask("procfs hotkey",
4360                        "set mask to 0x%08x\n", mask);
4361                res = hotkey_user_mask_set(mask);
4362        }
4363
4364errexit:
4365        mutex_unlock(&hotkey_mutex);
4366        return res;
4367}
4368
4369static const struct acpi_device_id ibm_htk_device_ids[] = {
4370        {TPACPI_ACPI_IBM_HKEY_HID, 0},
4371        {TPACPI_ACPI_LENOVO_HKEY_HID, 0},
4372        {TPACPI_ACPI_LENOVO_HKEY_V2_HID, 0},
4373        {"", 0},
4374};
4375
4376static struct tp_acpi_drv_struct ibm_hotkey_acpidriver = {
4377        .hid = ibm_htk_device_ids,
4378        .notify = hotkey_notify,
4379        .handle = &hkey_handle,
4380        .type = ACPI_DEVICE_NOTIFY,
4381};
4382
4383static struct ibm_struct hotkey_driver_data = {
4384        .name = "hotkey",
4385        .read = hotkey_read,
4386        .write = hotkey_write,
4387        .exit = hotkey_exit,
4388        .resume = hotkey_resume,
4389        .suspend = hotkey_suspend,
4390        .acpi = &ibm_hotkey_acpidriver,
4391};
4392
4393/*************************************************************************
4394 * Bluetooth subdriver
4395 */
4396
4397enum {
4398        /* ACPI GBDC/SBDC bits */
4399        TP_ACPI_BLUETOOTH_HWPRESENT     = 0x01, /* Bluetooth hw available */
4400        TP_ACPI_BLUETOOTH_RADIOSSW      = 0x02, /* Bluetooth radio enabled */
4401        TP_ACPI_BLUETOOTH_RESUMECTRL    = 0x04, /* Bluetooth state at resume:
4402                                                   0 = disable, 1 = enable */
4403};
4404
4405enum {
4406        /* ACPI \BLTH commands */
4407        TP_ACPI_BLTH_GET_ULTRAPORT_ID   = 0x00, /* Get Ultraport BT ID */
4408        TP_ACPI_BLTH_GET_PWR_ON_RESUME  = 0x01, /* Get power-on-resume state */
4409        TP_ACPI_BLTH_PWR_ON_ON_RESUME   = 0x02, /* Resume powered on */
4410        TP_ACPI_BLTH_PWR_OFF_ON_RESUME  = 0x03, /* Resume powered off */
4411        TP_ACPI_BLTH_SAVE_STATE         = 0x05, /* Save state for S4/S5 */
4412};
4413
4414#define TPACPI_RFK_BLUETOOTH_SW_NAME    "tpacpi_bluetooth_sw"
4415
4416static int bluetooth_get_status(void)
4417{
4418        int status;
4419
4420#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
4421        if (dbg_bluetoothemul)
4422                return (tpacpi_bluetooth_emulstate) ?
4423                       TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4424#endif
4425
4426        if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
4427                return -EIO;
4428
4429        return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0) ?