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 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28 #include <linux/init.h>
  29 #include <linux/types.h>
  30 #include <linux/input.h>
  31 #include <acpi/acpi_drivers.h>
  32 #include <linux/acpi.h>
  33 #include <linux/string.h>
  34 #include <linux/dmi.h>
  35
  36 MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
  37 MODULE_DESCRIPTION("Dell laptop WMI hotkeys driver");
  38 MODULE_LICENSE("GPL");
  39
  40 #define DELL_EVENT_GUID "9DBB5994-A997-11DA-B012-B622A1EF5492"
  41
  42 static int acpi_video;
  43
  44 MODULE_ALIAS("wmi:"DELL_EVENT_GUID);
  45
  46 struct key_entry {
  47         char type;              /* See KE_* below */
  48         u16 code;
  49         u16 keycode;
  50 };
  51
  52 enum { KE_KEY, KE_SW, KE_IGNORE, KE_END };
  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 struct key_entry dell_legacy_wmi_keymap[] = {
  61         {KE_KEY, 0xe045, KEY_PROG1},
  62         {KE_KEY, 0xe009, KEY_EJECTCD},
  63
  64         /* These also contain the brightness level at offset 6 */
  65         {KE_KEY, 0xe006, KEY_BRIGHTNESSUP},
  66         {KE_KEY, 0xe005, KEY_BRIGHTNESSDOWN},
  67
  68         /* Battery health status button */
  69         {KE_KEY, 0xe007, KEY_BATTERY},
  70
  71         /* This is actually for all radios. Although physically a
  72          * switch, the notification does not provide an indication of
  73          * state and so it should be reported as a key */
  74         {KE_KEY, 0xe008, KEY_WLAN},
  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         {KE_IGNORE, 0xe02e, KEY_VOLUMEDOWN},
  93         {KE_IGNORE, 0xe030, KEY_VOLUMEUP},
  94         {KE_IGNORE, 0xe033, KEY_KBDILLUMUP},
  95         {KE_IGNORE, 0xe034, KEY_KBDILLUMDOWN},
  96         {KE_IGNORE, 0xe03a, KEY_CAPSLOCK},
  97         {KE_IGNORE, 0xe045, KEY_NUMLOCK},
  98         {KE_IGNORE, 0xe046, KEY_SCROLLLOCK},
  99         {KE_END, 0}
 100 };
 101
 102 static bool dell_new_hk_type;
 103
 104 struct dell_new_keymap_entry {
 105         u16 scancode;
 106         u16 keycode;
 107 };
 108
 109 struct dell_hotkey_table {
 110         struct dmi_header header;
 111         struct dell_new_keymap_entry keymap[];
 112
 113 };
 114
 115 static struct key_entry *dell_new_wmi_keymap;
 116
 117 static u16 bios_to_linux_keycode[256] = {
 118
 119         KEY_MEDIA,      KEY_NEXTSONG,   KEY_PLAYPAUSE, KEY_PREVIOUSSONG,
 120         KEY_STOPCD,     KEY_UNKNOWN,    KEY_UNKNOWN,    KEY_UNKNOWN,
 121         KEY_WWW,        KEY_UNKNOWN,    KEY_VOLUMEDOWN, KEY_MUTE,
 122         KEY_VOLUMEUP,   KEY_UNKNOWN,    KEY_BATTERY,    KEY_EJECTCD,
 123         KEY_UNKNOWN,    KEY_SLEEP,      KEY_PROG1, KEY_BRIGHTNESSDOWN,
 124         KEY_BRIGHTNESSUP,       KEY_UNKNOWN,    KEY_KBDILLUMTOGGLE,
 125         KEY_UNKNOWN,    KEY_SWITCHVIDEOMODE,    KEY_UNKNOWN, KEY_UNKNOWN,
 126         KEY_SWITCHVIDEOMODE,    KEY_UNKNOWN,    KEY_UNKNOWN, KEY_PROG2,
 127         KEY_UNKNOWN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 128         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 129         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 130         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 131         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 132         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 133         0, 0, 0, 0, 0, 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,
 137         KEY_PROG3
 138 };
 139
 140
 141 static struct key_entry *dell_wmi_keymap = dell_legacy_wmi_keymap;
 142
 143 static struct input_dev *dell_wmi_input_dev;
 144
 145 static struct key_entry *dell_wmi_get_entry_by_scancode(int code)
 146 {
 147         struct key_entry *key;
 148
 149         for (key = dell_wmi_keymap; key->type != KE_END; key++)
 150                 if (code == key->code)
 151                         return key;
 152
 153         return NULL;
 154 }
 155
 156 static struct key_entry *dell_wmi_get_entry_by_keycode(int keycode)
 157 {
 158         struct key_entry *key;
 159
 160         for (key = dell_wmi_keymap; key->type != KE_END; key++)
 161                 if (key->type == KE_KEY && keycode == key->keycode)
 162                         return key;
 163
 164         return NULL;
 165 }
 166
 167 static int dell_wmi_getkeycode(struct input_dev *dev, int scancode,
 168                                int *keycode)
 169 {
 170         struct key_entry *key = dell_wmi_get_entry_by_scancode(scancode);
 171
 172         if (key && key->type == KE_KEY) {
 173                 *keycode = key->keycode;
 174                 return 0;
 175         }
 176
 177         return -EINVAL;
 178 }
 179
 180 static int dell_wmi_setkeycode(struct input_dev *dev, int scancode, int keycode)
 181 {
 182         struct key_entry *key;
 183         int old_keycode;
 184
 185         if (keycode < 0 || keycode > KEY_MAX)
 186                 return -EINVAL;
 187
 188         key = dell_wmi_get_entry_by_scancode(scancode);
 189         if (key && key->type == KE_KEY) {
 190                 old_keycode = key->keycode;
 191                 key->keycode = keycode;
 192                 set_bit(keycode, dev->keybit);
 193                 if (!dell_wmi_get_entry_by_keycode(old_keycode))
 194                         clear_bit(old_keycode, dev->keybit);
 195                 return 0;
 196         }
 197         return -EINVAL;
 198 }
 199
 200 static void dell_wmi_notify(u32 value, void *context)
 201 {
 202         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 203         static struct key_entry *key;
 204         union acpi_object *obj;
 205
 206         wmi_get_event_data(value, &response);
 207
 208         obj = (union acpi_object *)response.pointer;
 209
 210         if (obj && obj->type == ACPI_TYPE_BUFFER) {
 211                 int reported_key;
 212                 u16 *buffer_entry = (u16 *)obj->buffer.pointer;
 213                 if (dell_new_hk_type && (buffer_entry[1] != 0x10)) {
 214                         printk(KERN_INFO "dell-wmi: Received unknown WMI event"
 215                                          " (0x%x)\n", buffer_entry[1]);
 216                         return;
 217                 }
 218
 219                 if (dell_new_hk_type)
 220                         reported_key = (int)buffer_entry[2];
 221                 else
 222                         reported_key = (int)buffer_entry[1] & 0xffff;
 223
 224                 key = dell_wmi_get_entry_by_scancode(reported_key);
 225
 226                 if (!key) {
 227                         printk(KERN_INFO "dell-wmi: Unknown key %x pressed\n",
 228                                 reported_key);
 229                 } else if ((key->keycode == KEY_BRIGHTNESSUP ||
 230                             key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video) {
 231                         /* Don't report brightness notifications that will also
 232                          * come via ACPI */
 233                         return;
 234                 } else {
 235                         input_report_key(dell_wmi_input_dev, key->keycode, 1);
 236                         input_sync(dell_wmi_input_dev);
 237                         input_report_key(dell_wmi_input_dev, key->keycode, 0);
 238                         input_sync(dell_wmi_input_dev);
 239                 }
 240         }
 241         kfree(obj);
 242 }
 243
 244
 245 static void setup_new_hk_map(const struct dmi_header *dm)
 246 {
 247
 248         int i;
 249         int hotkey_num = (dm->length-4)/sizeof(struct dell_new_keymap_entry);
 250         struct dell_hotkey_table *table =
 251                 container_of(dm, struct dell_hotkey_table, header);
 252
 253         dell_new_wmi_keymap = kzalloc((hotkey_num+1) *
 254                                       sizeof(struct key_entry), GFP_KERNEL);
 255
 256         for (i = 0; i < hotkey_num; i++) {
 257                 dell_new_wmi_keymap[i].type = KE_KEY;
 258                 dell_new_wmi_keymap[i].code = table->keymap[i].scancode;
 259                 dell_new_wmi_keymap[i].keycode =
 260                         (table->keymap[i].keycode > 255) ? 0 :
 261                         bios_to_linux_keycode[table->keymap[i].keycode];
 262         }
 263
 264         dell_new_wmi_keymap[i].type = KE_END;
 265         dell_new_wmi_keymap[i].code = 0;
 266         dell_new_wmi_keymap[i].keycode = 0;
 267
 268         dell_wmi_keymap = dell_new_wmi_keymap;
 269
 270 }
 271
 272
 273 static void find_hk_type(const struct dmi_header *dm, void *dummy)
 274 {
 275
 276         if ((dm->type == 0xb2) && (dm->length > 6)) {
 277                 dell_new_hk_type = true;
 278                 setup_new_hk_map(dm);
 279         }
 280
 281 }
 282
 283
 284 static int __init dell_wmi_input_setup(void)
 285 {
 286         struct key_entry *key;
 287         int err;
 288
 289         dell_wmi_input_dev = input_allocate_device();
 290
 291         if (!dell_wmi_input_dev)
 292                 return -ENOMEM;
 293
 294         dell_wmi_input_dev->name = "Dell WMI hotkeys";
 295         dell_wmi_input_dev->phys = "wmi/input0";
 296         dell_wmi_input_dev->id.bustype = BUS_HOST;
 297         dell_wmi_input_dev->getkeycode = dell_wmi_getkeycode;
 298         dell_wmi_input_dev->setkeycode = dell_wmi_setkeycode;
 299
 300         for (key = dell_wmi_keymap; key->type != KE_END; key++) {
 301                 switch (key->type) {
 302                 case KE_KEY:
 303                         set_bit(EV_KEY, dell_wmi_input_dev->evbit);
 304                         set_bit(key->keycode, dell_wmi_input_dev->keybit);
 305                         break;
 306                 case KE_SW:
 307                         set_bit(EV_SW, dell_wmi_input_dev->evbit);
 308                         set_bit(key->keycode, dell_wmi_input_dev->swbit);
 309                         break;
 310                 }
 311         }
 312
 313         err = input_register_device(dell_wmi_input_dev);
 314
 315         if (err) {
 316                 input_free_device(dell_wmi_input_dev);
 317                 return err;
 318         }
 319
 320         return 0;
 321 }
 322
 323 static int __init dell_wmi_init(void)
 324 {
 325         int err;
 326
 327         if (wmi_has_guid(DELL_EVENT_GUID)) {
 328                 printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
 329                 return -ENODEV;
 330         }
 331
 332         dmi_walk(find_hk_type, NULL);
 333         acpi_video = acpi_video_backlight_support();
 334
 335         err = dell_wmi_input_setup();
 336         if (err)
 337                 return err;
 338
 339         err = wmi_install_notify_handler(DELL_EVENT_GUID,
 340                                          dell_wmi_notify, NULL);
 341         if (err) {
 342                 input_unregister_device(dell_wmi_input_dev);
 343                 printk(KERN_ERR
 344                         "dell-wmi: Unable to register notify handler - %d\n",
 345                         err);
 346                 return err;
 347         }
 348
 349         return 0;
 350 }
 351
 352 static void __exit dell_wmi_exit(void)
 353 {
 354         wmi_remove_notify_handler(DELL_EVENT_GUID);
 355         input_unregister_device(dell_wmi_input_dev);
 356 }
 357
 358 module_init(dell_wmi_init);
 359 module_exit(dell_wmi_exit);