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(unsigned 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(unsigned 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,
 168                                 unsigned int scancode, unsigned 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,
 181                                 unsigned int scancode, unsigned int keycode)
 182 {
 183         struct key_entry *key;
 184         unsigned int old_keycode;
 185
 186         key = dell_wmi_get_entry_by_scancode(scancode);
 187         if (key && key->type == KE_KEY) {
 188                 old_keycode = key->keycode;
 189                 key->keycode = keycode;
 190                 set_bit(keycode, dev->keybit);
 191                 if (!dell_wmi_get_entry_by_keycode(old_keycode))
 192                         clear_bit(old_keycode, dev->keybit);
 193                 return 0;
 194         }
 195         return -EINVAL;
 196 }
 197
 198 static void dell_wmi_notify(u32 value, void *context)
 199 {
 200         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 201         static struct key_entry *key;
 202         union acpi_object *obj;
 203         acpi_status status;
 204
 205         status = wmi_get_event_data(value, &response);
 206         if (status != AE_OK) {
 207                 printk(KERN_INFO "dell-wmi: bad event status 0x%x\n", status);
 208                 return;
 209         }
 210
 211         obj = (union acpi_object *)response.pointer;
 212
 213         if (obj && obj->type == ACPI_TYPE_BUFFER) {
 214                 int reported_key;
 215                 u16 *buffer_entry = (u16 *)obj->buffer.pointer;
 216                 if (dell_new_hk_type && (buffer_entry[1] != 0x10)) {
 217                         printk(KERN_INFO "dell-wmi: Received unknown WMI event"
 218                                          " (0x%x)\n", buffer_entry[1]);
 219                         return;
 220                 }
 221
 222                 if (dell_new_hk_type)
 223                         reported_key = (int)buffer_entry[2];
 224                 else
 225                         reported_key = (int)buffer_entry[1] & 0xffff;
 226
 227                 key = dell_wmi_get_entry_by_scancode(reported_key);
 228
 229                 if (!key) {
 230                         printk(KERN_INFO "dell-wmi: Unknown key %x pressed\n",
 231                                 reported_key);
 232                 } else if ((key->keycode == KEY_BRIGHTNESSUP ||
 233                             key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video) {
 234                         /* Don't report brightness notifications that will also
 235                          * come via ACPI */
 236                         return;
 237                 } else {
 238                         input_report_key(dell_wmi_input_dev, key->keycode, 1);
 239                         input_sync(dell_wmi_input_dev);
 240                         input_report_key(dell_wmi_input_dev, key->keycode, 0);
 241                         input_sync(dell_wmi_input_dev);
 242                 }
 243         }
 244         kfree(obj);
 245 }
 246
 247
 248 static void setup_new_hk_map(const struct dmi_header *dm)
 249 {
 250
 251         int i;
 252         int hotkey_num = (dm->length-4)/sizeof(struct dell_new_keymap_entry);
 253         struct dell_hotkey_table *table =
 254                 container_of(dm, struct dell_hotkey_table, header);
 255
 256         dell_new_wmi_keymap = kzalloc((hotkey_num+1) *
 257                                       sizeof(struct key_entry), GFP_KERNEL);
 258
 259         for (i = 0; i < hotkey_num; i++) {
 260                 dell_new_wmi_keymap[i].type = KE_KEY;
 261                 dell_new_wmi_keymap[i].code = table->keymap[i].scancode;
 262                 dell_new_wmi_keymap[i].keycode =
 263                         (table->keymap[i].keycode > 255) ? 0 :
 264                         bios_to_linux_keycode[table->keymap[i].keycode];
 265         }
 266
 267         dell_new_wmi_keymap[i].type = KE_END;
 268         dell_new_wmi_keymap[i].code = 0;
 269         dell_new_wmi_keymap[i].keycode = 0;
 270
 271         dell_wmi_keymap = dell_new_wmi_keymap;
 272
 273 }
 274
 275
 276 static void find_hk_type(const struct dmi_header *dm, void *dummy)
 277 {
 278
 279         if ((dm->type == 0xb2) && (dm->length > 6)) {
 280                 dell_new_hk_type = true;
 281                 setup_new_hk_map(dm);
 282         }
 283
 284 }
 285
 286
 287 static int __init dell_wmi_input_setup(void)
 288 {
 289         struct key_entry *key;
 290         int err;
 291
 292         dell_wmi_input_dev = input_allocate_device();
 293
 294         if (!dell_wmi_input_dev)
 295                 return -ENOMEM;
 296
 297         dell_wmi_input_dev->name = "Dell WMI hotkeys";
 298         dell_wmi_input_dev->phys = "wmi/input0";
 299         dell_wmi_input_dev->id.bustype = BUS_HOST;
 300         dell_wmi_input_dev->getkeycode = dell_wmi_getkeycode;
 301         dell_wmi_input_dev->setkeycode = dell_wmi_setkeycode;
 302
 303         for (key = dell_wmi_keymap; key->type != KE_END; key++) {
 304                 switch (key->type) {
 305                 case KE_KEY:
 306                         set_bit(EV_KEY, dell_wmi_input_dev->evbit);
 307                         set_bit(key->keycode, dell_wmi_input_dev->keybit);
 308                         break;
 309                 case KE_SW:
 310                         set_bit(EV_SW, dell_wmi_input_dev->evbit);
 311                         set_bit(key->keycode, dell_wmi_input_dev->swbit);
 312                         break;
 313                 }
 314         }
 315
 316         err = input_register_device(dell_wmi_input_dev);
 317
 318         if (err) {
 319                 input_free_device(dell_wmi_input_dev);
 320                 return err;
 321         }
 322
 323         return 0;
 324 }
 325
 326 static int __init dell_wmi_init(void)
 327 {
 328         int err;
 329         acpi_status status;
 330
 331         if (!wmi_has_guid(DELL_EVENT_GUID)) {
 332                 printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
 333                 return -ENODEV;
 334         }
 335
 336         dmi_walk(find_hk_type, NULL);
 337         acpi_video = acpi_video_backlight_support();
 338
 339         err = dell_wmi_input_setup();
 340         if (err)
 341                 return err;
 342
 343         status = wmi_install_notify_handler(DELL_EVENT_GUID,
 344                                          dell_wmi_notify, NULL);
 345         if (ACPI_FAILURE(status)) {
 346                 input_unregister_device(dell_wmi_input_dev);
 347                 printk(KERN_ERR
 348                         "dell-wmi: Unable to register notify handler - %d\n",
 349                         status);
 350                 return -ENODEV;
 351         }
 352
 353         return 0;
 354 }
 355
 356 static void __exit dell_wmi_exit(void)
 357 {
 358         wmi_remove_notify_handler(DELL_EVENT_GUID);
 359         input_unregister_device(dell_wmi_input_dev);
 360 }
 361
 362 module_init(dell_wmi_init);
 363 module_exit(dell_wmi_exit);