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 <acpi/acpi_drivers.h>
  36 #include <linux/acpi.h>
  37 #include <linux/string.h>
  38 #include <linux/dmi.h>
  39
  40 MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
  41 MODULE_DESCRIPTION("Dell laptop WMI hotkeys driver");
  42 MODULE_LICENSE("GPL");
  43
  44 #define DELL_EVENT_GUID "9DBB5994-A997-11DA-B012-B622A1EF5492"
  45
  46 static int acpi_video;
  47
  48 MODULE_ALIAS("wmi:"DELL_EVENT_GUID);
  49
  50 /*
  51  * Certain keys are flagged as KE_IGNORE. All of these are either
  52  * notifications (rather than requests for change) or are also sent
  53  * via the keyboard controller so should not be sent again.
  54  */
  55
  56 static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
  57         { KE_IGNORE, 0x003a, { KEY_CAPSLOCK } },
  58
  59         { KE_KEY, 0xe045, { KEY_PROG1 } },
  60         { KE_KEY, 0xe009, { KEY_EJECTCD } },
  61
  62         /* These also contain the brightness level at offset 6 */
  63         { KE_KEY, 0xe006, { KEY_BRIGHTNESSUP } },
  64         { KE_KEY, 0xe005, { KEY_BRIGHTNESSDOWN } },
  65
  66         /* Battery health status button */
  67         { KE_KEY, 0xe007, { KEY_BATTERY } },
  68
  69         /* This is actually for all radios. Although physically a
  70          * switch, the notification does not provide an indication of
  71          * state and so it should be reported as a key */
  72         { KE_KEY, 0xe008, { KEY_WLAN } },
  73
  74         /* The next device is at offset 6, the active devices are at
  75            offset 8 and the attached devices at offset 10 */
  76         { KE_KEY, 0xe00b, { KEY_SWITCHVIDEOMODE } },
  77
  78         { KE_IGNORE, 0xe00c, { KEY_KBDILLUMTOGGLE } },
  79
  80         /* BIOS error detected */
  81         { KE_IGNORE, 0xe00d, { KEY_RESERVED } },
  82
  83         /* Wifi Catcher */
  84         { KE_KEY, 0xe011, {KEY_PROG2 } },
  85
  86         /* Ambient light sensor toggle */
  87         { KE_IGNORE, 0xe013, { KEY_RESERVED } },
  88
  89         { KE_IGNORE, 0xe020, { KEY_MUTE } },
  90
  91         /* Shortcut and audio panel keys */
  92         { KE_IGNORE, 0xe025, { KEY_RESERVED } },
  93         { KE_IGNORE, 0xe026, { KEY_RESERVED } },
  94
  95         { KE_IGNORE, 0xe02e, { KEY_VOLUMEDOWN } },
  96         { KE_IGNORE, 0xe030, { KEY_VOLUMEUP } },
  97         { KE_IGNORE, 0xe033, { KEY_KBDILLUMUP } },
  98         { KE_IGNORE, 0xe034, { KEY_KBDILLUMDOWN } },
  99         { KE_IGNORE, 0xe03a, { KEY_CAPSLOCK } },
 100         { KE_IGNORE, 0xe045, { KEY_NUMLOCK } },
 101         { KE_IGNORE, 0xe046, { KEY_SCROLLLOCK } },
 102         { KE_IGNORE, 0xe0f7, { KEY_MUTE } },
 103         { KE_IGNORE, 0xe0f8, { KEY_VOLUMEDOWN } },
 104         { KE_IGNORE, 0xe0f9, { KEY_VOLUMEUP } },
 105         { KE_END, 0 }
 106 };
 107
 108 static bool dell_new_hk_type;
 109
 110 struct dell_bios_keymap_entry {
 111         u16 scancode;
 112         u16 keycode;
 113 };
 114
 115 struct dell_bios_hotkey_table {
 116         struct dmi_header header;
 117         struct dell_bios_keymap_entry keymap[];
 118
 119 };
 120
 121 static const struct dell_bios_hotkey_table *dell_bios_hotkey_table;
 122
 123 static const u16 bios_to_linux_keycode[256] __initconst = {
 124
 125         KEY_MEDIA,      KEY_NEXTSONG,   KEY_PLAYPAUSE, KEY_PREVIOUSSONG,
 126         KEY_STOPCD,     KEY_UNKNOWN,    KEY_UNKNOWN,    KEY_UNKNOWN,
 127         KEY_WWW,        KEY_UNKNOWN,    KEY_VOLUMEDOWN, KEY_MUTE,
 128         KEY_VOLUMEUP,   KEY_UNKNOWN,    KEY_BATTERY,    KEY_EJECTCD,
 129         KEY_UNKNOWN,    KEY_SLEEP,      KEY_PROG1, KEY_BRIGHTNESSDOWN,
 130         KEY_BRIGHTNESSUP,       KEY_UNKNOWN,    KEY_KBDILLUMTOGGLE,
 131         KEY_UNKNOWN,    KEY_SWITCHVIDEOMODE,    KEY_UNKNOWN, KEY_UNKNOWN,
 132         KEY_SWITCHVIDEOMODE,    KEY_UNKNOWN,    KEY_UNKNOWN, KEY_PROG2,
 133         KEY_UNKNOWN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 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,
 143         KEY_PROG3
 144 };
 145
 146 static struct input_dev *dell_wmi_input_dev;
 147
 148 static void dell_wmi_notify(u32 value, void *context)
 149 {
 150         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 151         union acpi_object *obj;
 152         acpi_status status;
 153
 154         status = wmi_get_event_data(value, &response);
 155         if (status != AE_OK) {
 156                 pr_info("bad event status 0x%x\n", status);
 157                 return;
 158         }
 159
 160         obj = (union acpi_object *)response.pointer;
 161
 162         if (obj && obj->type == ACPI_TYPE_BUFFER) {
 163                 const struct key_entry *key;
 164                 int reported_key;
 165                 u16 *buffer_entry = (u16 *)obj->buffer.pointer;
 166                 int buffer_size = obj->buffer.length/2;
 167
 168                 if (buffer_size >= 2 && dell_new_hk_type && buffer_entry[1] != 0x10) {
 169                         pr_info("Received unknown WMI event (0x%x)\n",
 170                                 buffer_entry[1]);
 171                         kfree(obj);
 172                         return;
 173                 }
 174
 175                 if (buffer_size >= 3 && (dell_new_hk_type || buffer_entry[1] == 0x0))
 176                         reported_key = (int)buffer_entry[2];
 177                 else if (buffer_size >= 2)
 178                         reported_key = (int)buffer_entry[1] & 0xffff;
 179                 else {
 180                         pr_info("Received unknown WMI event\n");
 181                         kfree(obj);
 182                         return;
 183                 }
 184
 185                 key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
 186                                                         reported_key);
 187                 if (!key) {
 188                         pr_info("Unknown key %x pressed\n", reported_key);
 189                 } else if ((key->keycode == KEY_BRIGHTNESSUP ||
 190                             key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video) {
 191                         /* Don't report brightness notifications that will also
 192                          * come via ACPI */
 193                         ;
 194                 } else {
 195                         sparse_keymap_report_entry(dell_wmi_input_dev, key,
 196                                                    1, true);
 197                 }
 198         }
 199         kfree(obj);
 200 }
 201
 202 static const struct key_entry * __init dell_wmi_prepare_new_keymap(void)
 203 {
 204         int hotkey_num = (dell_bios_hotkey_table->header.length - 4) /
 205                                 sizeof(struct dell_bios_keymap_entry);
 206         struct key_entry *keymap;
 207         int i;
 208
 209         keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
 210         if (!keymap)
 211                 return NULL;
 212
 213         for (i = 0; i < hotkey_num; i++) {
 214                 const struct dell_bios_keymap_entry *bios_entry =
 215                                         &dell_bios_hotkey_table->keymap[i];
 216                 keymap[i].type = KE_KEY;
 217                 keymap[i].code = bios_entry->scancode;
 218                 keymap[i].keycode = bios_entry->keycode < 256 ?
 219                                     bios_to_linux_keycode[bios_entry->keycode] :
 220                                     KEY_RESERVED;
 221         }
 222
 223         keymap[hotkey_num].type = KE_END;
 224
 225         return keymap;
 226 }
 227
 228 static int __init dell_wmi_input_setup(void)
 229 {
 230         int err;
 231
 232         dell_wmi_input_dev = input_allocate_device();
 233         if (!dell_wmi_input_dev)
 234                 return -ENOMEM;
 235
 236         dell_wmi_input_dev->name = "Dell WMI hotkeys";
 237         dell_wmi_input_dev->phys = "wmi/input0";
 238         dell_wmi_input_dev->id.bustype = BUS_HOST;
 239
 240         if (dell_new_hk_type) {
 241                 const struct key_entry *keymap = dell_wmi_prepare_new_keymap();
 242                 if (!keymap) {
 243                         err = -ENOMEM;
 244                         goto err_free_dev;
 245                 }
 246
 247                 err = sparse_keymap_setup(dell_wmi_input_dev, keymap, NULL);
 248
 249                 /*
 250                  * Sparse keymap library makes a copy of keymap so we
 251                  * don't need the original one that was allocated.
 252                  */
 253                 kfree(keymap);
 254         } else {
 255                 err = sparse_keymap_setup(dell_wmi_input_dev,
 256                                           dell_wmi_legacy_keymap, NULL);
 257         }
 258         if (err)
 259                 goto err_free_dev;
 260
 261         err = input_register_device(dell_wmi_input_dev);
 262         if (err)
 263                 goto err_free_keymap;
 264
 265         return 0;
 266
 267  err_free_keymap:
 268         sparse_keymap_free(dell_wmi_input_dev);
 269  err_free_dev:
 270         input_free_device(dell_wmi_input_dev);
 271         return err;
 272 }
 273
 274 static void dell_wmi_input_destroy(void)
 275 {
 276         sparse_keymap_free(dell_wmi_input_dev);
 277         input_unregister_device(dell_wmi_input_dev);
 278 }
 279
 280 static void __init find_hk_type(const struct dmi_header *dm, void *dummy)
 281 {
 282         if (dm->type == 0xb2 && dm->length > 6) {
 283                 dell_new_hk_type = true;
 284                 dell_bios_hotkey_table =
 285                         container_of(dm, struct dell_bios_hotkey_table, header);
 286         }
 287 }
 288
 289 static int __init dell_wmi_init(void)
 290 {
 291         int err;
 292         acpi_status status;
 293
 294         if (!wmi_has_guid(DELL_EVENT_GUID)) {
 295                 pr_warn("No known WMI GUID found\n");
 296                 return -ENODEV;
 297         }
 298
 299         dmi_walk(find_hk_type, NULL);
 300         acpi_video = acpi_video_backlight_support();
 301
 302         err = dell_wmi_input_setup();
 303         if (err)
 304                 return err;
 305
 306         status = wmi_install_notify_handler(DELL_EVENT_GUID,
 307                                          dell_wmi_notify, NULL);
 308         if (ACPI_FAILURE(status)) {
 309                 dell_wmi_input_destroy();
 310                 pr_err("Unable to register notify handler - %d\n", status);
 311                 return -ENODEV;
 312         }
 313
 314         return 0;
 315 }
 316 module_init(dell_wmi_init);
 317
 318 static void __exit dell_wmi_exit(void)
 319 {
 320         wmi_remove_notify_handler(DELL_EVENT_GUID);
 321         dell_wmi_input_destroy();
 322 }
 323 module_exit(dell_wmi_exit);