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 || dm->length <= 6)
 355                 return;
 356
 357         table = container_of(dm, struct dell_bios_hotkey_table, header);
 358
 359         hotkey_num = (table->header.length - 4) /
 360                                 sizeof(struct dell_bios_keymap_entry);
 361
 362         keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
 363         if (!keymap) {
 364                 results->err = -ENOMEM;
 365                 return;
 366         }
 367
 368         for (i = 0; i < hotkey_num; i++) {
 369                 const struct dell_bios_keymap_entry *bios_entry =
 370                                         &table->keymap[i];
 371
 372                 /* Uninitialized entries are 0 aka KEY_RESERVED. */
 373                 u16 keycode = (bios_entry->keycode <
 374                                ARRAY_SIZE(bios_to_linux_keycode)) ?
 375                         bios_to_linux_keycode[bios_entry->keycode] :
 376                         KEY_RESERVED;
 377
 378                 /*
 379                  * Log if we find an entry in the DMI table that we don't
 380                  * understand.  If this happens, we should figure out what
 381                  * the entry means and add it to bios_to_linux_keycode.
 382                  */
 383                 if (keycode == KEY_RESERVED) {
 384                         pr_info("firmware scancode 0x%x maps to unrecognized keycode 0x%x\n",
 385                                 bios_entry->scancode, bios_entry->keycode);
 386                         continue;
 387                 }
 388
 389                 if (keycode == KEY_KBDILLUMTOGGLE)
 390                         keymap[i].type = KE_IGNORE;
 391                 else
 392                         keymap[i].type = KE_KEY;
 393                 keymap[i].code = bios_entry->scancode;
 394                 keymap[i].keycode = keycode;
 395         }
 396
 397         keymap[hotkey_num].type = KE_END;
 398
 399         results->keymap = keymap;
 400 }
 401
 402 static int __init dell_wmi_input_setup(void)
 403 {
 404         struct dell_dmi_results dmi_results = {};
 405         int err;
 406
 407         dell_wmi_input_dev = input_allocate_device();
 408         if (!dell_wmi_input_dev)
 409                 return -ENOMEM;
 410
 411         dell_wmi_input_dev->name = "Dell WMI hotkeys";
 412         dell_wmi_input_dev->phys = "wmi/input0";
 413         dell_wmi_input_dev->id.bustype = BUS_HOST;
 414
 415         if (dmi_walk(handle_dmi_entry, &dmi_results)) {
 416                 /*
 417                  * Historically, dell-wmi ignored dmi_walk errors.  A failure
 418                  * is certainly surprising, but it probably just indicates
 419                  * a very old laptop.
 420                  */
 421                 pr_warn("no DMI; using the old-style hotkey interface\n");
 422         }
 423
 424         if (dmi_results.err) {
 425                 err = dmi_results.err;
 426                 goto err_free_dev;
 427         }
 428
 429         if (dmi_results.keymap) {
 430                 dell_new_hk_type = true;
 431
 432                 err = sparse_keymap_setup(dell_wmi_input_dev,
 433                                           dmi_results.keymap, NULL);
 434
 435                 /*
 436                  * Sparse keymap library makes a copy of keymap so we
 437                  * don't need the original one that was allocated.
 438                  */
 439                 kfree(dmi_results.keymap);
 440         } else {
 441                 err = sparse_keymap_setup(dell_wmi_input_dev,
 442                                           dell_wmi_legacy_keymap, NULL);
 443         }
 444         if (err)
 445                 goto err_free_dev;
 446
 447         err = input_register_device(dell_wmi_input_dev);
 448         if (err)
 449                 goto err_free_keymap;
 450
 451         return 0;
 452
 453  err_free_keymap:
 454         sparse_keymap_free(dell_wmi_input_dev);
 455  err_free_dev:
 456         input_free_device(dell_wmi_input_dev);
 457         return err;
 458 }
 459
 460 static void dell_wmi_input_destroy(void)
 461 {
 462         sparse_keymap_free(dell_wmi_input_dev);
 463         input_unregister_device(dell_wmi_input_dev);
 464 }
 465
 466 /*
 467  * Descriptor buffer is 128 byte long and contains:
 468  *
 469  *       Name             Offset  Length  Value
 470  * Vendor Signature          0       4    "DELL"
 471  * Object Signature          4       4    " WMI"
 472  * WMI Interface Version     8       4    <version>
 473  * WMI buffer length        12       4    4096
 474  */
 475 static int __init dell_wmi_check_descriptor_buffer(void)
 476 {
 477         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
 478         union acpi_object *obj;
 479         acpi_status status;
 480         u32 *buffer;
 481
 482         status = wmi_query_block(DELL_DESCRIPTOR_GUID, 0, &out);
 483         if (ACPI_FAILURE(status)) {
 484                 pr_err("Cannot read Dell descriptor buffer - %d\n", status);
 485                 return status;
 486         }
 487
 488         obj = (union acpi_object *)out.pointer;
 489         if (!obj) {
 490                 pr_err("Dell descriptor buffer is empty\n");
 491                 return -EINVAL;
 492         }
 493
 494         if (obj->type != ACPI_TYPE_BUFFER) {
 495                 pr_err("Cannot read Dell descriptor buffer\n");
 496                 kfree(obj);
 497                 return -EINVAL;
 498         }
 499
 500         if (obj->buffer.length != 128) {
 501                 pr_err("Dell descriptor buffer has invalid length (%d)\n",
 502                         obj->buffer.length);
 503                 if (obj->buffer.length < 16) {
 504                         kfree(obj);
 505                         return -EINVAL;
 506                 }
 507         }
 508
 509         buffer = (u32 *)obj->buffer.pointer;
 510
 511         if (buffer[0] != 0x4C4C4544 && buffer[1] != 0x494D5720)
 512                 pr_warn("Dell descriptor buffer has invalid signature (%*ph)\n",
 513                         8, buffer);
 514
 515         if (buffer[2] != 0 && buffer[2] != 1)
 516                 pr_warn("Dell descriptor buffer has unknown version (%d)\n",
 517                         buffer[2]);
 518
 519         if (buffer[3] != 4096)
 520                 pr_warn("Dell descriptor buffer has invalid buffer length (%d)\n",
 521                         buffer[3]);
 522
 523         dell_wmi_interface_version = buffer[2];
 524
 525         pr_info("Detected Dell WMI interface version %u\n",
 526                 dell_wmi_interface_version);
 527
 528         kfree(obj);
 529         return 0;
 530 }
 531
 532 static int __init dell_wmi_init(void)
 533 {
 534         int err;
 535         acpi_status status;
 536
 537         if (!wmi_has_guid(DELL_EVENT_GUID) ||
 538             !wmi_has_guid(DELL_DESCRIPTOR_GUID)) {
 539                 pr_warn("Dell WMI GUID were not found\n");
 540                 return -ENODEV;
 541         }
 542
 543         err = dell_wmi_check_descriptor_buffer();
 544         if (err)
 545                 return err;
 546
 547         err = dell_wmi_input_setup();
 548         if (err)
 549                 return err;
 550
 551         status = wmi_install_notify_handler(DELL_EVENT_GUID,
 552                                          dell_wmi_notify, NULL);
 553         if (ACPI_FAILURE(status)) {
 554                 dell_wmi_input_destroy();
 555                 pr_err("Unable to register notify handler - %d\n", status);
 556                 return -ENODEV;
 557         }
 558
 559         return 0;
 560 }
 561 module_init(dell_wmi_init);
 562
 563 static void __exit dell_wmi_exit(void)
 564 {
 565         wmi_remove_notify_handler(DELL_EVENT_GUID);
 566         dell_wmi_input_destroy();
 567 }
 568 module_exit(dell_wmi_exit);