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 struct dell_dmi_results {
 124         int err;
 125         struct key_entry *keymap;
 126 };
 127
 128 /* Uninitialized entries here are KEY_RESERVED == 0. */
 129 static const u16 bios_to_linux_keycode[256] __initconst = {
 130         [0]     = KEY_MEDIA,
 131         [1]     = KEY_NEXTSONG,
 132         [2]     = KEY_PLAYPAUSE,
 133         [3]     = KEY_PREVIOUSSONG,
 134         [4]     = KEY_STOPCD,
 135         [5]     = KEY_UNKNOWN,
 136         [6]     = KEY_UNKNOWN,
 137         [7]     = KEY_UNKNOWN,
 138         [8]     = KEY_WWW,
 139         [9]     = KEY_UNKNOWN,
 140         [10]    = KEY_VOLUMEDOWN,
 141         [11]    = KEY_MUTE,
 142         [12]    = KEY_VOLUMEUP,
 143         [13]    = KEY_UNKNOWN,
 144         [14]    = KEY_BATTERY,
 145         [15]    = KEY_EJECTCD,
 146         [16]    = KEY_UNKNOWN,
 147         [17]    = KEY_SLEEP,
 148         [18]    = KEY_PROG1,
 149         [19]    = KEY_BRIGHTNESSDOWN,
 150         [20]    = KEY_BRIGHTNESSUP,
 151         [21]    = KEY_UNKNOWN,
 152         [22]    = KEY_KBDILLUMTOGGLE,
 153         [23]    = KEY_UNKNOWN,
 154         [24]    = KEY_SWITCHVIDEOMODE,
 155         [25]    = KEY_UNKNOWN,
 156         [26]    = KEY_UNKNOWN,
 157         [27]    = KEY_SWITCHVIDEOMODE,
 158         [28]    = KEY_UNKNOWN,
 159         [29]    = KEY_UNKNOWN,
 160         [30]    = KEY_PROG2,
 161         [31]    = KEY_UNKNOWN,
 162         [32]    = KEY_UNKNOWN,
 163         [33]    = KEY_UNKNOWN,
 164         [34]    = KEY_UNKNOWN,
 165         [35]    = KEY_UNKNOWN,
 166         [36]    = KEY_UNKNOWN,
 167         [37]    = KEY_UNKNOWN,
 168         [38]    = KEY_MICMUTE,
 169         [255]   = KEY_PROG3,
 170 };
 171
 172 static struct input_dev *dell_wmi_input_dev;
 173
 174 static void dell_wmi_process_key(int reported_key)
 175 {
 176         const struct key_entry *key;
 177
 178         key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
 179                                                 reported_key);
 180         if (!key) {
 181                 pr_info("Unknown key with scancode 0x%x pressed\n",
 182                         reported_key);
 183                 return;
 184         }
 185
 186         pr_debug("Key %x pressed\n", reported_key);
 187
 188         /* Don't report brightness notifications that will also come via ACPI */
 189         if ((key->keycode == KEY_BRIGHTNESSUP ||
 190              key->keycode == KEY_BRIGHTNESSDOWN) &&
 191             acpi_video_handles_brightness_key_presses())
 192                 return;
 193
 194         sparse_keymap_report_entry(dell_wmi_input_dev, key, 1, true);
 195 }
 196
 197 static void dell_wmi_notify(u32 value, void *context)
 198 {
 199         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 200         union acpi_object *obj;
 201         acpi_status status;
 202         acpi_size buffer_size;
 203         u16 *buffer_entry, *buffer_end;
 204         int len, i;
 205
 206         status = wmi_get_event_data(value, &response);
 207         if (status != AE_OK) {
 208                 pr_warn("bad event status 0x%x\n", status);
 209                 return;
 210         }
 211
 212         obj = (union acpi_object *)response.pointer;
 213         if (!obj) {
 214                 pr_warn("no response\n");
 215                 return;
 216         }
 217
 218         if (obj->type != ACPI_TYPE_BUFFER) {
 219                 pr_warn("bad response type %x\n", obj->type);
 220                 kfree(obj);
 221                 return;
 222         }
 223
 224         pr_debug("Received WMI event (%*ph)\n",
 225                 obj->buffer.length, obj->buffer.pointer);
 226
 227         buffer_entry = (u16 *)obj->buffer.pointer;
 228         buffer_size = obj->buffer.length/2;
 229
 230         if (!dell_new_hk_type) {
 231                 if (buffer_size >= 3 && buffer_entry[1] == 0x0)
 232                         dell_wmi_process_key(buffer_entry[2]);
 233                 else if (buffer_size >= 2)
 234                         dell_wmi_process_key(buffer_entry[1]);
 235                 else
 236                         pr_info("Received unknown WMI event\n");
 237                 kfree(obj);
 238                 return;
 239         }
 240
 241         buffer_end = buffer_entry + buffer_size;
 242
 243         /*
 244          * BIOS/ACPI on devices with WMI interface version 0 does not clear
 245          * buffer before filling it. So next time when BIOS/ACPI send WMI event
 246          * which is smaller as previous then it contains garbage in buffer from
 247          * previous event.
 248          *
 249          * BIOS/ACPI on devices with WMI interface version 1 clears buffer and
 250          * sometimes send more events in buffer at one call.
 251          *
 252          * So to prevent reading garbage from buffer we will process only first
 253          * one event on devices with WMI interface version 0.
 254          */
 255         if (dell_wmi_interface_version == 0 && buffer_entry < buffer_end)
 256                 if (buffer_end > buffer_entry + buffer_entry[0] + 1)
 257                         buffer_end = buffer_entry + buffer_entry[0] + 1;
 258
 259         while (buffer_entry < buffer_end) {
 260
 261                 len = buffer_entry[0];
 262                 if (len == 0)
 263                         break;
 264
 265                 len++;
 266
 267                 if (buffer_entry + len > buffer_end) {
 268                         pr_warn("Invalid length of WMI event\n");
 269                         break;
 270                 }
 271
 272                 pr_debug("Process buffer (%*ph)\n", len*2, buffer_entry);
 273
 274                 switch (buffer_entry[1]) {
 275                 case 0x00:
 276                         for (i = 2; i < len; ++i) {
 277                                 switch (buffer_entry[i]) {
 278                                 case 0xe043:
 279                                         /* NIC Link is Up */
 280                                         pr_debug("NIC Link is Up\n");
 281                                         break;
 282                                 case 0xe044:
 283                                         /* NIC Link is Down */
 284                                         pr_debug("NIC Link is Down\n");
 285                                         break;
 286                                 case 0xe045:
 287                                         /* Unknown event but defined in DSDT */
 288                                 default:
 289                                         /* Unknown event */
 290                                         pr_info("Unknown WMI event type 0x00: "
 291                                                 "0x%x\n", (int)buffer_entry[i]);
 292                                         break;
 293                                 }
 294                         }
 295                         break;
 296                 case 0x10:
 297                         /* Keys pressed */
 298                         for (i = 2; i < len; ++i)
 299                                 dell_wmi_process_key(buffer_entry[i]);
 300                         break;
 301                 case 0x11:
 302                         for (i = 2; i < len; ++i) {
 303                                 switch (buffer_entry[i]) {
 304                                 case 0xfff0:
 305                                         /* Battery unplugged */
 306                                         pr_debug("Battery unplugged\n");
 307                                         break;
 308                                 case 0xfff1:
 309                                         /* Battery inserted */
 310                                         pr_debug("Battery inserted\n");
 311                                         break;
 312                                 case 0x01e1:
 313                                 case 0x02ea:
 314                                 case 0x02eb:
 315                                 case 0x02ec:
 316                                 case 0x02f6:
 317                                         /* Keyboard backlight level changed */
 318                                         pr_debug("Keyboard backlight level "
 319                                                  "changed\n");
 320                                         break;
 321                                 default:
 322                                         /* Unknown event */
 323                                         pr_info("Unknown WMI event type 0x11: "
 324                                                 "0x%x\n", (int)buffer_entry[i]);
 325                                         break;
 326                                 }
 327                         }
 328                         break;
 329                 default:
 330                         /* Unknown event */
 331                         pr_info("Unknown WMI event type 0x%x\n",
 332                                 (int)buffer_entry[1]);
 333                         break;
 334                 }
 335
 336                 buffer_entry += len;
 337
 338         }
 339
 340         kfree(obj);
 341 }
 342
 343 static void __init handle_dmi_entry(const struct dmi_header *dm,
 344                                     void *opaque)
 345 {
 346         struct dell_dmi_results *results = opaque;
 347         struct dell_bios_hotkey_table *table;
 348         struct key_entry *keymap;
 349         int hotkey_num, i;
 350
 351         if (results->err || results->keymap)
 352                 return;         /* We already found the hotkey table. */
 353
 354         if (dm->type != 0xb2)
 355                 return;
 356
 357         table = container_of(dm, struct dell_bios_hotkey_table, header);
 358
 359         hotkey_num = (table->header.length -
 360                       sizeof(struct dell_bios_hotkey_table)) /
 361                                 sizeof(struct dell_bios_keymap_entry);
 362         if (hotkey_num < 1) {
 363                 /*
 364                  * Historically, dell-wmi would ignore a DMI entry of
 365                  * fewer than 7 bytes.  Sizes between 4 and 8 bytes are
 366                  * nonsensical (both the header and all entries are 4
 367                  * bytes), so we approximate the old behavior by
 368                  * ignoring tables with fewer than one entry.
 369                  */
 370                 return;
 371         }
 372
 373         keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
 374         if (!keymap) {
 375                 results->err = -ENOMEM;
 376                 return;
 377         }
 378
 379         for (i = 0; i < hotkey_num; i++) {
 380                 const struct dell_bios_keymap_entry *bios_entry =
 381                                         &table->keymap[i];
 382
 383                 /* Uninitialized entries are 0 aka KEY_RESERVED. */
 384                 u16 keycode = (bios_entry->keycode <
 385                                ARRAY_SIZE(bios_to_linux_keycode)) ?
 386                         bios_to_linux_keycode[bios_entry->keycode] :
 387                         KEY_RESERVED;
 388
 389                 /*
 390                  * Log if we find an entry in the DMI table that we don't
 391                  * understand.  If this happens, we should figure out what
 392                  * the entry means and add it to bios_to_linux_keycode.
 393                  */
 394                 if (keycode == KEY_RESERVED) {
 395                         pr_info("firmware scancode 0x%x maps to unrecognized keycode 0x%x\n",
 396                                 bios_entry->scancode, bios_entry->keycode);
 397                         continue;
 398                 }
 399
 400                 if (keycode == KEY_KBDILLUMTOGGLE)
 401                         keymap[i].type = KE_IGNORE;
 402                 else
 403                         keymap[i].type = KE_KEY;
 404                 keymap[i].code = bios_entry->scancode;
 405                 keymap[i].keycode = keycode;
 406         }
 407
 408         keymap[hotkey_num].type = KE_END;
 409
 410         results->keymap = keymap;
 411 }
 412
 413 static int __init dell_wmi_input_setup(void)
 414 {
 415         struct dell_dmi_results dmi_results = {};
 416         int err;
 417
 418         dell_wmi_input_dev = input_allocate_device();
 419         if (!dell_wmi_input_dev)
 420                 return -ENOMEM;
 421
 422         dell_wmi_input_dev->name = "Dell WMI hotkeys";
 423         dell_wmi_input_dev->phys = "wmi/input0";
 424         dell_wmi_input_dev->id.bustype = BUS_HOST;
 425
 426         if (dmi_walk(handle_dmi_entry, &dmi_results)) {
 427                 /*
 428                  * Historically, dell-wmi ignored dmi_walk errors.  A failure
 429                  * is certainly surprising, but it probably just indicates
 430                  * a very old laptop.
 431                  */
 432                 pr_warn("no DMI; using the old-style hotkey interface\n");
 433         }
 434
 435         if (dmi_results.err) {
 436                 err = dmi_results.err;
 437                 goto err_free_dev;
 438         }
 439
 440         if (dmi_results.keymap) {
 441                 dell_new_hk_type = true;
 442
 443                 err = sparse_keymap_setup(dell_wmi_input_dev,
 444                                           dmi_results.keymap, NULL);
 445
 446                 /*
 447                  * Sparse keymap library makes a copy of keymap so we
 448                  * don't need the original one that was allocated.
 449                  */
 450                 kfree(dmi_results.keymap);
 451         } else {
 452                 err = sparse_keymap_setup(dell_wmi_input_dev,
 453                                           dell_wmi_legacy_keymap, NULL);
 454         }
 455         if (err)
 456                 goto err_free_dev;
 457
 458         err = input_register_device(dell_wmi_input_dev);
 459         if (err)
 460                 goto err_free_keymap;
 461
 462         return 0;
 463
 464  err_free_keymap:
 465         sparse_keymap_free(dell_wmi_input_dev);
 466  err_free_dev:
 467         input_free_device(dell_wmi_input_dev);
 468         return err;
 469 }
 470
 471 static void dell_wmi_input_destroy(void)
 472 {
 473         sparse_keymap_free(dell_wmi_input_dev);
 474         input_unregister_device(dell_wmi_input_dev);
 475 }
 476
 477 /*
 478  * Descriptor buffer is 128 byte long and contains:
 479  *
 480  *       Name             Offset  Length  Value
 481  * Vendor Signature          0       4    "DELL"
 482  * Object Signature          4       4    " WMI"
 483  * WMI Interface Version     8       4    <version>
 484  * WMI buffer length        12       4    4096
 485  */
 486 static int __init dell_wmi_check_descriptor_buffer(void)
 487 {
 488         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
 489         union acpi_object *obj;
 490         acpi_status status;
 491         u32 *buffer;
 492
 493         status = wmi_query_block(DELL_DESCRIPTOR_GUID, 0, &out);
 494         if (ACPI_FAILURE(status)) {
 495                 pr_err("Cannot read Dell descriptor buffer - %d\n", status);
 496                 return status;
 497         }
 498
 499         obj = (union acpi_object *)out.pointer;
 500         if (!obj) {
 501                 pr_err("Dell descriptor buffer is empty\n");
 502                 return -EINVAL;
 503         }
 504
 505         if (obj->type != ACPI_TYPE_BUFFER) {
 506                 pr_err("Cannot read Dell descriptor buffer\n");
 507                 kfree(obj);
 508                 return -EINVAL;
 509         }
 510
 511         if (obj->buffer.length != 128) {
 512                 pr_err("Dell descriptor buffer has invalid length (%d)\n",
 513                         obj->buffer.length);
 514                 if (obj->buffer.length < 16) {
 515                         kfree(obj);
 516                         return -EINVAL;
 517                 }
 518         }
 519
 520         buffer = (u32 *)obj->buffer.pointer;
 521
 522         if (buffer[0] != 0x4C4C4544 && buffer[1] != 0x494D5720)
 523                 pr_warn("Dell descriptor buffer has invalid signature (%*ph)\n",
 524                         8, buffer);
 525
 526         if (buffer[2] != 0 && buffer[2] != 1)
 527                 pr_warn("Dell descriptor buffer has unknown version (%d)\n",
 528                         buffer[2]);
 529
 530         if (buffer[3] != 4096)
 531                 pr_warn("Dell descriptor buffer has invalid buffer length (%d)\n",
 532                         buffer[3]);
 533
 534         dell_wmi_interface_version = buffer[2];
 535
 536         pr_info("Detected Dell WMI interface version %u\n",
 537                 dell_wmi_interface_version);
 538
 539         kfree(obj);
 540         return 0;
 541 }
 542
 543 static int __init dell_wmi_init(void)
 544 {
 545         int err;
 546         acpi_status status;
 547
 548         if (!wmi_has_guid(DELL_EVENT_GUID) ||
 549             !wmi_has_guid(DELL_DESCRIPTOR_GUID)) {
 550                 pr_warn("Dell WMI GUID were not found\n");
 551                 return -ENODEV;
 552         }
 553
 554         err = dell_wmi_check_descriptor_buffer();
 555         if (err)
 556                 return err;
 557
 558         err = dell_wmi_input_setup();
 559         if (err)
 560                 return err;
 561
 562         status = wmi_install_notify_handler(DELL_EVENT_GUID,
 563                                          dell_wmi_notify, NULL);
 564         if (ACPI_FAILURE(status)) {
 565                 dell_wmi_input_destroy();
 566                 pr_err("Unable to register notify handler - %d\n", status);
 567                 return -ENODEV;
 568         }
 569
 570         return 0;
 571 }
 572 module_init(dell_wmi_init);
 573
 574 static void __exit dell_wmi_exit(void)
 575 {
 576         wmi_remove_notify_handler(DELL_EVENT_GUID);
 577         dell_wmi_input_destroy();
 578 }
 579 module_exit(dell_wmi_exit);