drivers/platform/x86/dell-wmi.c

   1 /*
   2  * Dell WMI hotkeys
   3  *
   4  * Copyright (C) 2008 Red Hat <mjg@redhat.com>
   5  * Copyright (C) 2014-2015 Pali Rohár <pali.rohar@gmail.com>
   6  *
   7  * Portions based on wistron_btns.c:
   8  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
   9  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
  10  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  28
  29 #include <linux/kernel.h>
  30 #include <linux/module.h>
  31 #include <linux/init.h>
  32 #include <linux/slab.h>
  33 #include <linux/types.h>
  34 #include <linux/input.h>
  35 #include <linux/input/sparse-keymap.h>
  36 #include <linux/acpi.h>
  37 #include <linux/string.h>
  38 #include <linux/dmi.h>
  39 #include <acpi/video.h>
  40
  41 MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
  42 MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
  43 MODULE_DESCRIPTION("Dell laptop WMI hotkeys driver");
  44 MODULE_LICENSE("GPL");
  45
  46 #define DELL_EVENT_GUID "9DBB5994-A997-11DA-B012-B622A1EF5492"
  47 #define DELL_DESCRIPTOR_GUID "8D9DDCBC-A997-11DA-B012-B622A1EF5492"
  48
  49 static u32 dell_wmi_interface_version;
  50
  51 MODULE_ALIAS("wmi:"DELL_EVENT_GUID);
  52 MODULE_ALIAS("wmi:"DELL_DESCRIPTOR_GUID);
  53
  54 /*
  55  * Certain keys are flagged as KE_IGNORE. All of these are either
  56  * notifications (rather than requests for change) or are also sent
  57  * via the keyboard controller so should not be sent again.
  58  */
  59
  60 static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
  61         { KE_IGNORE, 0x003a, { KEY_CAPSLOCK } },
  62
  63         { KE_KEY, 0xe045, { KEY_PROG1 } },
  64         { KE_KEY, 0xe009, { KEY_EJECTCD } },
  65
  66         /* These also contain the brightness level at offset 6 */
  67         { KE_KEY, 0xe006, { KEY_BRIGHTNESSUP } },
  68         { KE_KEY, 0xe005, { KEY_BRIGHTNESSDOWN } },
  69
  70         /* Battery health status button */
  71         { KE_KEY, 0xe007, { KEY_BATTERY } },
  72
  73         /* Radio devices state change */
  74         { KE_IGNORE, 0xe008, { KEY_RFKILL } },
  75
  76         /* The next device is at offset 6, the active devices are at
  77            offset 8 and the attached devices at offset 10 */
  78         { KE_KEY, 0xe00b, { KEY_SWITCHVIDEOMODE } },
  79
  80         { KE_IGNORE, 0xe00c, { KEY_KBDILLUMTOGGLE } },
  81
  82         /* BIOS error detected */
  83         { KE_IGNORE, 0xe00d, { KEY_RESERVED } },
  84
  85         /* Wifi Catcher */
  86         { KE_KEY, 0xe011, {KEY_PROG2 } },
  87
  88         /* Ambient light sensor toggle */
  89         { KE_IGNORE, 0xe013, { KEY_RESERVED } },
  90
  91         { KE_IGNORE, 0xe020, { KEY_MUTE } },
  92
  93         /* Shortcut and audio panel keys */
  94         { KE_IGNORE, 0xe025, { KEY_RESERVED } },
  95         { KE_IGNORE, 0xe026, { KEY_RESERVED } },
  96
  97         { KE_IGNORE, 0xe02e, { KEY_VOLUMEDOWN } },
  98         { KE_IGNORE, 0xe030, { KEY_VOLUMEUP } },
  99         { KE_IGNORE, 0xe033, { KEY_KBDILLUMUP } },
 100         { KE_IGNORE, 0xe034, { KEY_KBDILLUMDOWN } },
 101         { KE_IGNORE, 0xe03a, { KEY_CAPSLOCK } },
 102         { KE_IGNORE, 0xe045, { KEY_NUMLOCK } },
 103         { KE_IGNORE, 0xe046, { KEY_SCROLLLOCK } },
 104         { KE_IGNORE, 0xe0f7, { KEY_MUTE } },
 105         { KE_IGNORE, 0xe0f8, { KEY_VOLUMEDOWN } },
 106         { KE_IGNORE, 0xe0f9, { KEY_VOLUMEUP } },
 107         { KE_END, 0 }
 108 };
 109
 110 static bool dell_new_hk_type;
 111
 112 struct dell_bios_keymap_entry {
 113         u16 scancode;
 114         u16 keycode;
 115 };
 116
 117 struct dell_bios_hotkey_table {
 118         struct dmi_header header;
 119         struct dell_bios_keymap_entry keymap[];
 120
 121 };
 122
 123 static const struct dell_bios_hotkey_table *dell_bios_hotkey_table;
 124
 125 /* Uninitialized entries here are KEY_RESERVED == 0. */
 126 static const u16 bios_to_linux_keycode[256] __initconst = {
 127         [0]     = KEY_MEDIA,
 128         [1]     = KEY_NEXTSONG,
 129         [2]     = KEY_PLAYPAUSE,
 130         [3]     = KEY_PREVIOUSSONG,
 131         [4]     = KEY_STOPCD,
 132         [5]     = KEY_UNKNOWN,
 133         [6]     = KEY_UNKNOWN,
 134         [7]     = KEY_UNKNOWN,
 135         [8]     = KEY_WWW,
 136         [9]     = KEY_UNKNOWN,
 137         [10]    = KEY_VOLUMEDOWN,
 138         [11]    = KEY_MUTE,
 139         [12]    = KEY_VOLUMEUP,
 140         [13]    = KEY_UNKNOWN,
 141         [14]    = KEY_BATTERY,
 142         [15]    = KEY_EJECTCD,
 143         [16]    = KEY_UNKNOWN,
 144         [17]    = KEY_SLEEP,
 145         [18]    = KEY_PROG1,
 146         [19]    = KEY_BRIGHTNESSDOWN,
 147         [20]    = KEY_BRIGHTNESSUP,
 148         [21]    = KEY_UNKNOWN,
 149         [22]    = KEY_KBDILLUMTOGGLE,
 150         [23]    = KEY_UNKNOWN,
 151         [24]    = KEY_SWITCHVIDEOMODE,
 152         [25]    = KEY_UNKNOWN,
 153         [26]    = KEY_UNKNOWN,
 154         [27]    = KEY_SWITCHVIDEOMODE,
 155         [28]    = KEY_UNKNOWN,
 156         [29]    = KEY_UNKNOWN,
 157         [30]    = KEY_PROG2,
 158         [31]    = KEY_UNKNOWN,
 159         [32]    = KEY_UNKNOWN,
 160         [33]    = KEY_UNKNOWN,
 161         [34]    = KEY_UNKNOWN,
 162         [35]    = KEY_UNKNOWN,
 163         [36]    = KEY_UNKNOWN,
 164         [37]    = KEY_UNKNOWN,
 165         [38]    = KEY_MICMUTE,
 166         [255]   = KEY_PROG3,
 167 };
 168
 169 static struct input_dev *dell_wmi_input_dev;
 170
 171 static void dell_wmi_process_key(int reported_key)
 172 {
 173         const struct key_entry *key;
 174
 175         key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
 176                                                 reported_key);
 177         if (!key) {
 178                 pr_info("Unknown key with scancode 0x%x pressed\n",
 179                         reported_key);
 180                 return;
 181         }
 182
 183         pr_debug("Key %x pressed\n", reported_key);
 184
 185         /* Don't report brightness notifications that will also come via ACPI */
 186         if ((key->keycode == KEY_BRIGHTNESSUP ||
 187              key->keycode == KEY_BRIGHTNESSDOWN) &&
 188             acpi_video_handles_brightness_key_presses())
 189                 return;
 190
 191         sparse_keymap_report_entry(dell_wmi_input_dev, key, 1, true);
 192 }
 193
 194 static void dell_wmi_notify(u32 value, void *context)
 195 {
 196         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 197         union acpi_object *obj;
 198         acpi_status status;
 199         acpi_size buffer_size;
 200         u16 *buffer_entry, *buffer_end;
 201         int len, i;
 202
 203         status = wmi_get_event_data(value, &response);
 204         if (status != AE_OK) {
 205                 pr_warn("bad event status 0x%x\n", status);
 206                 return;
 207         }
 208
 209         obj = (union acpi_object *)response.pointer;
 210         if (!obj) {
 211                 pr_warn("no response\n");
 212                 return;
 213         }
 214
 215         if (obj->type != ACPI_TYPE_BUFFER) {
 216                 pr_warn("bad response type %x\n", obj->type);
 217                 kfree(obj);
 218                 return;
 219         }
 220
 221         pr_debug("Received WMI event (%*ph)\n",
 222                 obj->buffer.length, obj->buffer.pointer);
 223
 224         buffer_entry = (u16 *)obj->buffer.pointer;
 225         buffer_size = obj->buffer.length/2;
 226
 227         if (!dell_new_hk_type) {
 228                 if (buffer_size >= 3 && buffer_entry[1] == 0x0)
 229                         dell_wmi_process_key(buffer_entry[2]);
 230                 else if (buffer_size >= 2)
 231                         dell_wmi_process_key(buffer_entry[1]);
 232                 else
 233                         pr_info("Received unknown WMI event\n");
 234                 kfree(obj);
 235                 return;
 236         }
 237
 238         buffer_end = buffer_entry + buffer_size;
 239
 240         /*
 241          * BIOS/ACPI on devices with WMI interface version 0 does not clear
 242          * buffer before filling it. So next time when BIOS/ACPI send WMI event
 243          * which is smaller as previous then it contains garbage in buffer from
 244          * previous event.
 245          *
 246          * BIOS/ACPI on devices with WMI interface version 1 clears buffer and
 247          * sometimes send more events in buffer at one call.
 248          *
 249          * So to prevent reading garbage from buffer we will process only first
 250          * one event on devices with WMI interface version 0.
 251          */
 252         if (dell_wmi_interface_version == 0 && buffer_entry < buffer_end)
 253                 if (buffer_end > buffer_entry + buffer_entry[0] + 1)
 254                         buffer_end = buffer_entry + buffer_entry[0] + 1;
 255
 256         while (buffer_entry < buffer_end) {
 257
 258                 len = buffer_entry[0];
 259                 if (len == 0)
 260                         break;
 261
 262                 len++;
 263
 264                 if (buffer_entry + len > buffer_end) {
 265                         pr_warn("Invalid length of WMI event\n");
 266                         break;
 267                 }
 268
 269                 pr_debug("Process buffer (%*ph)\n", len*2, buffer_entry);
 270
 271                 switch (buffer_entry[1]) {
 272                 case 0x00:
 273                         for (i = 2; i < len; ++i) {
 274                                 switch (buffer_entry[i]) {
 275                                 case 0xe043:
 276                                         /* NIC Link is Up */
 277                                         pr_debug("NIC Link is Up\n");
 278                                         break;
 279                                 case 0xe044:
 280                                         /* NIC Link is Down */
 281                                         pr_debug("NIC Link is Down\n");
 282                                         break;
 283                                 case 0xe045:
 284                                         /* Unknown event but defined in DSDT */
 285                                 default:
 286                                         /* Unknown event */
 287                                         pr_info("Unknown WMI event type 0x00: "
 288                                                 "0x%x\n", (int)buffer_entry[i]);
 289                                         break;
 290                                 }
 291                         }
 292                         break;
 293                 case 0x10:
 294                         /* Keys pressed */
 295                         for (i = 2; i < len; ++i)
 296                                 dell_wmi_process_key(buffer_entry[i]);
 297                         break;
 298                 case 0x11:
 299                         for (i = 2; i < len; ++i) {
 300                                 switch (buffer_entry[i]) {
 301                                 case 0xfff0:
 302                                         /* Battery unplugged */
 303                                         pr_debug("Battery unplugged\n");
 304                                         break;
 305                                 case 0xfff1:
 306                                         /* Battery inserted */
 307                                         pr_debug("Battery inserted\n");
 308                                         break;
 309                                 case 0x01e1:
 310                                 case 0x02ea:
 311                                 case 0x02eb:
 312                                 case 0x02ec:
 313                                 case 0x02f6:
 314                                         /* Keyboard backlight level changed */
 315                                         pr_debug("Keyboard backlight level "
 316                                                  "changed\n");
 317                                         break;
 318                                 default:
 319                                         /* Unknown event */
 320                                         pr_info("Unknown WMI event type 0x11: "
 321                                                 "0x%x\n", (int)buffer_entry[i]);
 322                                         break;
 323                                 }
 324                         }
 325                         break;
 326                 default:
 327                         /* Unknown event */
 328                         pr_info("Unknown WMI event type 0x%x\n",
 329                                 (int)buffer_entry[1]);
 330                         break;
 331                 }
 332
 333                 buffer_entry += len;
 334
 335         }
 336
 337         kfree(obj);
 338 }
 339
 340 static const struct key_entry * __init dell_wmi_prepare_new_keymap(void)
 341 {
 342         int hotkey_num = (dell_bios_hotkey_table->header.length - 4) /
 343                                 sizeof(struct dell_bios_keymap_entry);
 344         struct key_entry *keymap;
 345         int i;
 346
 347         keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
 348         if (!keymap)
 349                 return NULL;
 350
 351         for (i = 0; i < hotkey_num; i++) {
 352                 const struct dell_bios_keymap_entry *bios_entry =
 353                                         &dell_bios_hotkey_table->keymap[i];
 354
 355                 /* Uninitialized entries are 0 aka KEY_RESERVED. */
 356                 u16 keycode = (bios_entry->keycode <
 357                                ARRAY_SIZE(bios_to_linux_keycode)) ?
 358                         bios_to_linux_keycode[bios_entry->keycode] :
 359                         KEY_RESERVED;
 360
 361                 /*
 362                  * Log if we find an entry in the DMI table that we don't
 363                  * understand.  If this happens, we should figure out what
 364                  * the entry means and add it to bios_to_linux_keycode.
 365                  */
 366                 if (keycode == KEY_RESERVED) {
 367                         pr_info("firmware scancode 0x%x maps to unrecognized keycode 0x%x\n",
 368                                 bios_entry->scancode, bios_entry->keycode);
 369                         continue;
 370                 }
 371
 372                 if (keycode == KEY_KBDILLUMTOGGLE)
 373                         keymap[i].type = KE_IGNORE;
 374                 else
 375                         keymap[i].type = KE_KEY;
 376                 keymap[i].code = bios_entry->scancode;
 377                 keymap[i].keycode = keycode;
 378         }
 379
 380         keymap[hotkey_num].type = KE_END;
 381
 382         return keymap;
 383 }
 384
 385 static int __init dell_wmi_input_setup(void)
 386 {
 387         int err;
 388
 389         dell_wmi_input_dev = input_allocate_device();
 390         if (!dell_wmi_input_dev)
 391                 return -ENOMEM;
 392
 393         dell_wmi_input_dev->name = "Dell WMI hotkeys";
 394         dell_wmi_input_dev->phys = "wmi/input0";
 395         dell_wmi_input_dev->id.bustype = BUS_HOST;
 396
 397         if (dell_new_hk_type) {
 398                 const struct key_entry *keymap = dell_wmi_prepare_new_keymap();
 399                 if (!keymap) {
 400                         err = -ENOMEM;
 401                         goto err_free_dev;
 402                 }
 403
 404                 err = sparse_keymap_setup(dell_wmi_input_dev, keymap, NULL);
 405
 406                 /*
 407                  * Sparse keymap library makes a copy of keymap so we
 408                  * don't need the original one that was allocated.
 409                  */
 410                 kfree(keymap);
 411         } else {
 412                 err = sparse_keymap_setup(dell_wmi_input_dev,
 413                                           dell_wmi_legacy_keymap, NULL);
 414         }
 415         if (err)
 416                 goto err_free_dev;
 417
 418         err = input_register_device(dell_wmi_input_dev);
 419         if (err)
 420                 goto err_free_keymap;
 421
 422         return 0;
 423
 424  err_free_keymap:
 425         sparse_keymap_free(dell_wmi_input_dev);
 426  err_free_dev:
 427         input_free_device(dell_wmi_input_dev);
 428         return err;
 429 }
 430
 431 static void dell_wmi_input_destroy(void)
 432 {
 433         sparse_keymap_free(dell_wmi_input_dev);
 434         input_unregister_device(dell_wmi_input_dev);
 435 }
 436
 437 static void __init find_hk_type(const struct dmi_header *dm, void *dummy)
 438 {
 439         if (dm->type == 0xb2 && dm->length > 6) {
 440                 dell_new_hk_type = true;
 441                 dell_bios_hotkey_table =
 442                         container_of(dm, struct dell_bios_hotkey_table, header);
 443         }
 444 }
 445
 446 /*
 447  * Descriptor buffer is 128 byte long and contains:
 448  *
 449  *       Name             Offset  Length  Value
 450  * Vendor Signature          0       4    "DELL"
 451  * Object Signature          4       4    " WMI"
 452  * WMI Interface Version     8       4    <version>
 453  * WMI buffer length        12       4    4096
 454  */
 455 static int __init dell_wmi_check_descriptor_buffer(void)
 456 {
 457         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
 458         union acpi_object *obj;
 459         acpi_status status;
 460         u32 *buffer;
 461
 462         status = wmi_query_block(DELL_DESCRIPTOR_GUID, 0, &out);
 463         if (ACPI_FAILURE(status)) {
 464                 pr_err("Cannot read Dell descriptor buffer - %d\n", status);
 465                 return status;
 466         }
 467
 468         obj = (union acpi_object *)out.pointer;
 469         if (!obj) {
 470                 pr_err("Dell descriptor buffer is empty\n");
 471                 return -EINVAL;
 472         }
 473
 474         if (obj->type != ACPI_TYPE_BUFFER) {
 475                 pr_err("Cannot read Dell descriptor buffer\n");
 476                 kfree(obj);
 477                 return -EINVAL;
 478         }
 479
 480         if (obj->buffer.length != 128) {
 481                 pr_err("Dell descriptor buffer has invalid length (%d)\n",
 482                         obj->buffer.length);
 483                 if (obj->buffer.length < 16) {
 484                         kfree(obj);
 485                         return -EINVAL;
 486                 }
 487         }
 488
 489         buffer = (u32 *)obj->buffer.pointer;
 490
 491         if (buffer[0] != 0x4C4C4544 && buffer[1] != 0x494D5720)
 492                 pr_warn("Dell descriptor buffer has invalid signature (%*ph)\n",
 493                         8, buffer);
 494
 495         if (buffer[2] != 0 && buffer[2] != 1)
 496                 pr_warn("Dell descriptor buffer has unknown version (%d)\n",
 497                         buffer[2]);
 498
 499         if (buffer[3] != 4096)
 500                 pr_warn("Dell descriptor buffer has invalid buffer length (%d)\n",
 501                         buffer[3]);
 502
 503         dell_wmi_interface_version = buffer[2];
 504
 505         pr_info("Detected Dell WMI interface version %u\n",
 506                 dell_wmi_interface_version);
 507
 508         kfree(obj);
 509         return 0;
 510 }
 511
 512 static int __init dell_wmi_init(void)
 513 {
 514         int err;
 515         acpi_status status;
 516
 517         if (!wmi_has_guid(DELL_EVENT_GUID) ||
 518             !wmi_has_guid(DELL_DESCRIPTOR_GUID)) {
 519                 pr_warn("Dell WMI GUID were not found\n");
 520                 return -ENODEV;
 521         }
 522
 523         err = dell_wmi_check_descriptor_buffer();
 524         if (err)
 525                 return err;
 526
 527         dmi_walk(find_hk_type, NULL);
 528
 529         err = dell_wmi_input_setup();
 530         if (err)
 531                 return err;
 532
 533         status = wmi_install_notify_handler(DELL_EVENT_GUID,
 534                                          dell_wmi_notify, NULL);
 535         if (ACPI_FAILURE(status)) {
 536                 dell_wmi_input_destroy();
 537                 pr_err("Unable to register notify handler - %d\n", status);
 538                 return -ENODEV;
 539         }
 540
 541         return 0;
 542 }
 543 module_init(dell_wmi_init);
 544
 545 static void __exit dell_wmi_exit(void)
 546 {
 547         wmi_remove_notify_handler(DELL_EVENT_GUID);
 548         dell_wmi_input_destroy();
 549 }
 550 module_exit(dell_wmi_exit);