drivers/platform/x86/dell-wmi.c

   1 /*
   2  * Dell WMI hotkeys
   3  *
   4  * Copyright (C) 2008 Red Hat <mjg@redhat.com>
   5  *
   6  * Portions based on wistron_btns.c:
   7  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
   8  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
   9  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  27
  28 #include <linux/kernel.h>
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31 #include <linux/slab.h>
  32 #include <linux/types.h>
  33 #include <linux/input.h>
  34 #include <linux/input/sparse-keymap.h>
  35 #include <linux/acpi.h>
  36 #include <linux/string.h>
  37 #include <linux/dmi.h>
  38
  39 MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
  40 MODULE_DESCRIPTION("Dell laptop WMI hotkeys driver");
  41 MODULE_LICENSE("GPL");
  42
  43 #define DELL_EVENT_GUID "9DBB5994-A997-11DA-B012-B622A1EF5492"
  44
  45 static int acpi_video;
  46
  47 MODULE_ALIAS("wmi:"DELL_EVENT_GUID);
  48
  49 /*
  50  * Certain keys are flagged as KE_IGNORE. All of these are either
  51  * notifications (rather than requests for change) or are also sent
  52  * via the keyboard controller so should not be sent again.
  53  */
  54
  55 static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
  56         { KE_IGNORE, 0x003a, { KEY_CAPSLOCK } },
  57
  58         { KE_KEY, 0xe045, { KEY_PROG1 } },
  59         { KE_KEY, 0xe009, { KEY_EJECTCD } },
  60
  61         /* These also contain the brightness level at offset 6 */
  62         { KE_KEY, 0xe006, { KEY_BRIGHTNESSUP } },
  63         { KE_KEY, 0xe005, { KEY_BRIGHTNESSDOWN } },
  64
  65         /* Battery health status button */
  66         { KE_KEY, 0xe007, { KEY_BATTERY } },
  67
  68         /* This is actually for all radios. Although physically a
  69          * switch, the notification does not provide an indication of
  70          * state and so it should be reported as a key */
  71         { KE_KEY, 0xe008, { KEY_WLAN } },
  72
  73         /* The next device is at offset 6, the active devices are at
  74            offset 8 and the attached devices at offset 10 */
  75         { KE_KEY, 0xe00b, { KEY_SWITCHVIDEOMODE } },
  76
  77         { KE_IGNORE, 0xe00c, { KEY_KBDILLUMTOGGLE } },
  78
  79         /* BIOS error detected */
  80         { KE_IGNORE, 0xe00d, { KEY_RESERVED } },
  81
  82         /* Wifi Catcher */
  83         { KE_KEY, 0xe011, {KEY_PROG2 } },
  84
  85         /* Ambient light sensor toggle */
  86         { KE_IGNORE, 0xe013, { KEY_RESERVED } },
  87
  88         { KE_IGNORE, 0xe020, { KEY_MUTE } },
  89
  90         /* Shortcut and audio panel keys */
  91         { KE_IGNORE, 0xe025, { KEY_RESERVED } },
  92         { KE_IGNORE, 0xe026, { KEY_RESERVED } },
  93
  94         { KE_IGNORE, 0xe02e, { KEY_VOLUMEDOWN } },
  95         { KE_IGNORE, 0xe030, { KEY_VOLUMEUP } },
  96         { KE_IGNORE, 0xe033, { KEY_KBDILLUMUP } },
  97         { KE_IGNORE, 0xe034, { KEY_KBDILLUMDOWN } },
  98         { KE_IGNORE, 0xe03a, { KEY_CAPSLOCK } },
  99         { KE_IGNORE, 0xe045, { KEY_NUMLOCK } },
 100         { KE_IGNORE, 0xe046, { KEY_SCROLLLOCK } },
 101         { KE_IGNORE, 0xe0f7, { KEY_MUTE } },
 102         { KE_IGNORE, 0xe0f8, { KEY_VOLUMEDOWN } },
 103         { KE_IGNORE, 0xe0f9, { KEY_VOLUMEUP } },
 104         { KE_END, 0 }
 105 };
 106
 107 static bool dell_new_hk_type;
 108
 109 struct dell_bios_keymap_entry {
 110         u16 scancode;
 111         u16 keycode;
 112 };
 113
 114 struct dell_bios_hotkey_table {
 115         struct dmi_header header;
 116         struct dell_bios_keymap_entry keymap[];
 117
 118 };
 119
 120 static const struct dell_bios_hotkey_table *dell_bios_hotkey_table;
 121
 122 static const u16 bios_to_linux_keycode[256] __initconst = {
 123
 124         KEY_MEDIA,      KEY_NEXTSONG,   KEY_PLAYPAUSE, KEY_PREVIOUSSONG,
 125         KEY_STOPCD,     KEY_UNKNOWN,    KEY_UNKNOWN,    KEY_UNKNOWN,
 126         KEY_WWW,        KEY_UNKNOWN,    KEY_VOLUMEDOWN, KEY_MUTE,
 127         KEY_VOLUMEUP,   KEY_UNKNOWN,    KEY_BATTERY,    KEY_EJECTCD,
 128         KEY_UNKNOWN,    KEY_SLEEP,      KEY_PROG1, KEY_BRIGHTNESSDOWN,
 129         KEY_BRIGHTNESSUP,       KEY_UNKNOWN,    KEY_KBDILLUMTOGGLE,
 130         KEY_UNKNOWN,    KEY_SWITCHVIDEOMODE,    KEY_UNKNOWN, KEY_UNKNOWN,
 131         KEY_SWITCHVIDEOMODE,    KEY_UNKNOWN,    KEY_UNKNOWN, KEY_PROG2,
 132         KEY_UNKNOWN,    KEY_UNKNOWN,    KEY_UNKNOWN,    KEY_UNKNOWN,
 133         KEY_UNKNOWN,    KEY_UNKNOWN,    KEY_UNKNOWN,    KEY_MICMUTE,
 134         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 135         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 136         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 137         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 138         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 139         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 140         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 141         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 142         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 143         0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_PROG3
 144 };
 145
 146 static struct input_dev *dell_wmi_input_dev;
 147
 148 static void dell_wmi_process_key(int reported_key)
 149 {
 150         const struct key_entry *key;
 151
 152         key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
 153                                                 reported_key);
 154         if (!key) {
 155                 pr_info("Unknown key %x pressed\n", reported_key);
 156                 return;
 157         }
 158
 159         pr_debug("Key %x pressed\n", reported_key);
 160
 161         /* Don't report brightness notifications that will also come via ACPI */
 162         if ((key->keycode == KEY_BRIGHTNESSUP ||
 163              key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video)
 164                 return;
 165
 166         sparse_keymap_report_entry(dell_wmi_input_dev, key, 1, true);
 167 }
 168
 169 static void dell_wmi_notify(u32 value, void *context)
 170 {
 171         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 172         union acpi_object *obj;
 173         acpi_status status;
 174         acpi_size buffer_size;
 175         u16 *buffer_entry, *buffer_end;
 176         int len, i;
 177
 178         status = wmi_get_event_data(value, &response);
 179         if (status != AE_OK) {
 180                 pr_warn("bad event status 0x%x\n", status);
 181                 return;
 182         }
 183
 184         obj = (union acpi_object *)response.pointer;
 185         if (!obj) {
 186                 pr_warn("no response\n");
 187                 return;
 188         }
 189
 190         if (obj->type != ACPI_TYPE_BUFFER) {
 191                 pr_warn("bad response type %x\n", obj->type);
 192                 kfree(obj);
 193                 return;
 194         }
 195
 196         pr_debug("Received WMI event (%*ph)\n",
 197                 obj->buffer.length, obj->buffer.pointer);
 198
 199         buffer_entry = (u16 *)obj->buffer.pointer;
 200         buffer_size = obj->buffer.length/2;
 201
 202         if (!dell_new_hk_type) {
 203                 if (buffer_size >= 3 && buffer_entry[1] == 0x0)
 204                         dell_wmi_process_key(buffer_entry[2]);
 205                 else if (buffer_size >= 2)
 206                         dell_wmi_process_key(buffer_entry[1]);
 207                 else
 208                         pr_info("Received unknown WMI event\n");
 209                 kfree(obj);
 210                 return;
 211         }
 212
 213         buffer_end = buffer_entry + buffer_size;
 214
 215         while (buffer_entry < buffer_end) {
 216
 217                 len = buffer_entry[0];
 218                 if (len == 0)
 219                         break;
 220
 221                 len++;
 222
 223                 if (buffer_entry + len > buffer_end) {
 224                         pr_warn("Invalid length of WMI event\n");
 225                         break;
 226                 }
 227
 228                 pr_debug("Process buffer (%*ph)\n", len*2, buffer_entry);
 229
 230                 switch (buffer_entry[1]) {
 231                 case 0x00:
 232                         for (i = 2; i < len; ++i) {
 233                                 switch (buffer_entry[i]) {
 234                                 case 0xe043:
 235                                         /* NIC Link is Up */
 236                                         pr_debug("NIC Link is Up\n");
 237                                         break;
 238                                 case 0xe044:
 239                                         /* NIC Link is Down */
 240                                         pr_debug("NIC Link is Down\n");
 241                                         break;
 242                                 case 0xe045:
 243                                         /* Unknown event but defined in DSDT */
 244                                 default:
 245                                         /* Unknown event */
 246                                         pr_info("Unknown WMI event type 0x00: "
 247                                                 "0x%x\n", (int)buffer_entry[i]);
 248                                         break;
 249                                 }
 250                         }
 251                         break;
 252                 case 0x10:
 253                         /* Keys pressed */
 254                         for (i = 2; i < len; ++i)
 255                                 dell_wmi_process_key(buffer_entry[i]);
 256                         break;
 257                 case 0x11:
 258                         for (i = 2; i < len; ++i) {
 259                                 switch (buffer_entry[i]) {
 260                                 case 0xfff0:
 261                                         /* Battery unplugged */
 262                                         pr_debug("Battery unplugged\n");
 263                                         break;
 264                                 case 0xfff1:
 265                                         /* Battery inserted */
 266                                         pr_debug("Battery inserted\n");
 267                                         break;
 268                                 case 0x01e1:
 269                                 case 0x02ea:
 270                                 case 0x02eb:
 271                                 case 0x02ec:
 272                                 case 0x02f6:
 273                                         /* Keyboard backlight level changed */
 274                                         pr_debug("Keyboard backlight level "
 275                                                  "changed\n");
 276                                         break;
 277                                 default:
 278                                         /* Unknown event */
 279                                         pr_info("Unknown WMI event type 0x11: "
 280                                                 "0x%x\n", (int)buffer_entry[i]);
 281                                         break;
 282                                 }
 283                         }
 284                         break;
 285                 default:
 286                         /* Unknown event */
 287                         pr_info("Unknown WMI event type 0x%x\n",
 288                                 (int)buffer_entry[1]);
 289                         break;
 290                 }
 291
 292                 buffer_entry += len;
 293
 294         }
 295
 296         kfree(obj);
 297 }
 298
 299 static const struct key_entry * __init dell_wmi_prepare_new_keymap(void)
 300 {
 301         int hotkey_num = (dell_bios_hotkey_table->header.length - 4) /
 302                                 sizeof(struct dell_bios_keymap_entry);
 303         struct key_entry *keymap;
 304         int i;
 305
 306         keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
 307         if (!keymap)
 308                 return NULL;
 309
 310         for (i = 0; i < hotkey_num; i++) {
 311                 const struct dell_bios_keymap_entry *bios_entry =
 312                                         &dell_bios_hotkey_table->keymap[i];
 313                 keymap[i].type = KE_KEY;
 314                 keymap[i].code = bios_entry->scancode;
 315                 keymap[i].keycode = bios_entry->keycode < 256 ?
 316                                     bios_to_linux_keycode[bios_entry->keycode] :
 317                                     KEY_RESERVED;
 318         }
 319
 320         keymap[hotkey_num].type = KE_END;
 321
 322         return keymap;
 323 }
 324
 325 static int __init dell_wmi_input_setup(void)
 326 {
 327         int err;
 328
 329         dell_wmi_input_dev = input_allocate_device();
 330         if (!dell_wmi_input_dev)
 331                 return -ENOMEM;
 332
 333         dell_wmi_input_dev->name = "Dell WMI hotkeys";
 334         dell_wmi_input_dev->phys = "wmi/input0";
 335         dell_wmi_input_dev->id.bustype = BUS_HOST;
 336
 337         if (dell_new_hk_type) {
 338                 const struct key_entry *keymap = dell_wmi_prepare_new_keymap();
 339                 if (!keymap) {
 340                         err = -ENOMEM;
 341                         goto err_free_dev;
 342                 }
 343
 344                 err = sparse_keymap_setup(dell_wmi_input_dev, keymap, NULL);
 345
 346                 /*
 347                  * Sparse keymap library makes a copy of keymap so we
 348                  * don't need the original one that was allocated.
 349                  */
 350                 kfree(keymap);
 351         } else {
 352                 err = sparse_keymap_setup(dell_wmi_input_dev,
 353                                           dell_wmi_legacy_keymap, NULL);
 354         }
 355         if (err)
 356                 goto err_free_dev;
 357
 358         err = input_register_device(dell_wmi_input_dev);
 359         if (err)
 360                 goto err_free_keymap;
 361
 362         return 0;
 363
 364  err_free_keymap:
 365         sparse_keymap_free(dell_wmi_input_dev);
 366  err_free_dev:
 367         input_free_device(dell_wmi_input_dev);
 368         return err;
 369 }
 370
 371 static void dell_wmi_input_destroy(void)
 372 {
 373         sparse_keymap_free(dell_wmi_input_dev);
 374         input_unregister_device(dell_wmi_input_dev);
 375 }
 376
 377 static void __init find_hk_type(const struct dmi_header *dm, void *dummy)
 378 {
 379         if (dm->type == 0xb2 && dm->length > 6) {
 380                 dell_new_hk_type = true;
 381                 dell_bios_hotkey_table =
 382                         container_of(dm, struct dell_bios_hotkey_table, header);
 383         }
 384 }
 385
 386 static int __init dell_wmi_init(void)
 387 {
 388         int err;
 389         acpi_status status;
 390
 391         if (!wmi_has_guid(DELL_EVENT_GUID)) {
 392                 pr_warn("No known WMI GUID found\n");
 393                 return -ENODEV;
 394         }
 395
 396         dmi_walk(find_hk_type, NULL);
 397         acpi_video = acpi_video_backlight_support();
 398
 399         err = dell_wmi_input_setup();
 400         if (err)
 401                 return err;
 402
 403         status = wmi_install_notify_handler(DELL_EVENT_GUID,
 404                                          dell_wmi_notify, NULL);
 405         if (ACPI_FAILURE(status)) {
 406                 dell_wmi_input_destroy();
 407                 pr_err("Unable to register notify handler - %d\n", status);
 408                 return -ENODEV;
 409         }
 410
 411         return 0;
 412 }
 413 module_init(dell_wmi_init);
 414
 415 static void __exit dell_wmi_exit(void)
 416 {
 417         wmi_remove_notify_handler(DELL_EVENT_GUID);
 418         dell_wmi_input_destroy();
 419 }
 420 module_exit(dell_wmi_exit);