drivers/platform/x86/intel-hid.c

   1 /*
   2  *  Intel HID event & 5 button array driver
   3  *
   4  *  Copyright (C) 2015 Alex Hung <alex.hung@canonical.com>
   5  *  Copyright (C) 2015 Andrew Lutomirski <luto@kernel.org>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/init.h>
  22 #include <linux/input.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/input/sparse-keymap.h>
  25 #include <linux/acpi.h>
  26 #include <linux/suspend.h>
  27 #include <acpi/acpi_bus.h>
  28
  29 MODULE_LICENSE("GPL");
  30 MODULE_AUTHOR("Alex Hung");
  31
  32 static const struct acpi_device_id intel_hid_ids[] = {
  33         {"INT33D5", 0},
  34         {"", 0},
  35 };
  36
  37 /* In theory, these are HID usages. */
  38 static const struct key_entry intel_hid_keymap[] = {
  39         /* 1: LSuper (Page 0x07, usage 0xE3) -- unclear what to do */
  40         /* 2: Toggle SW_ROTATE_LOCK -- easy to implement if seen in wild */
  41         { KE_KEY, 3, { KEY_NUMLOCK } },
  42         { KE_KEY, 4, { KEY_HOME } },
  43         { KE_KEY, 5, { KEY_END } },
  44         { KE_KEY, 6, { KEY_PAGEUP } },
  45         { KE_KEY, 7, { KEY_PAGEDOWN } },
  46         { KE_KEY, 8, { KEY_RFKILL } },
  47         { KE_KEY, 9, { KEY_POWER } },
  48         { KE_KEY, 11, { KEY_SLEEP } },
  49         /* 13 has two different meanings in the spec -- ignore it. */
  50         { KE_KEY, 14, { KEY_STOPCD } },
  51         { KE_KEY, 15, { KEY_PLAYPAUSE } },
  52         { KE_KEY, 16, { KEY_MUTE } },
  53         { KE_KEY, 17, { KEY_VOLUMEUP } },
  54         { KE_KEY, 18, { KEY_VOLUMEDOWN } },
  55         { KE_KEY, 19, { KEY_BRIGHTNESSUP } },
  56         { KE_KEY, 20, { KEY_BRIGHTNESSDOWN } },
  57         /* 27: wake -- needs special handling */
  58         { KE_END },
  59 };
  60
  61 /* 5 button array notification value. */
  62 static const struct key_entry intel_array_keymap[] = {
  63         { KE_KEY,    0xC2, { KEY_LEFTMETA } },                /* Press */
  64         { KE_IGNORE, 0xC3, { KEY_LEFTMETA } },                /* Release */
  65         { KE_KEY,    0xC4, { KEY_VOLUMEUP } },                /* Press */
  66         { KE_IGNORE, 0xC5, { KEY_VOLUMEUP } },                /* Release */
  67         { KE_KEY,    0xC6, { KEY_VOLUMEDOWN } },              /* Press */
  68         { KE_IGNORE, 0xC7, { KEY_VOLUMEDOWN } },              /* Release */
  69         { KE_SW,     0xC8, { .sw = { SW_ROTATE_LOCK, 1 } } }, /* Press */
  70         { KE_SW,     0xC9, { .sw = { SW_ROTATE_LOCK, 0 } } }, /* Release */
  71         { KE_KEY,    0xCE, { KEY_POWER } },                   /* Press */
  72         { KE_IGNORE, 0xCF, { KEY_POWER } },                   /* Release */
  73         { KE_END },
  74 };
  75
  76 struct intel_hid_priv {
  77         struct input_dev *input_dev;
  78         struct input_dev *array;
  79         bool wakeup_mode;
  80 };
  81
  82 static int intel_hid_set_enable(struct device *device, bool enable)
  83 {
  84         acpi_status status;
  85
  86         status = acpi_execute_simple_method(ACPI_HANDLE(device), "HDSM",
  87                                             enable);
  88         if (ACPI_FAILURE(status)) {
  89                 dev_warn(device, "failed to %sable hotkeys\n",
  90                          enable ? "en" : "dis");
  91                 return -EIO;
  92         }
  93
  94         return 0;
  95 }
  96
  97 static void intel_button_array_enable(struct device *device, bool enable)
  98 {
  99         struct intel_hid_priv *priv = dev_get_drvdata(device);
 100         acpi_handle handle = ACPI_HANDLE(device);
 101         unsigned long long button_cap;
 102         acpi_status status;
 103
 104         if (!priv->array)
 105                 return;
 106
 107         /* Query supported platform features */
 108         status = acpi_evaluate_integer(handle, "BTNC", NULL, &button_cap);
 109         if (ACPI_FAILURE(status)) {
 110                 dev_warn(device, "failed to get button capability\n");
 111                 return;
 112         }
 113
 114         /* Enable|disable features - power button is always enabled */
 115         status = acpi_execute_simple_method(handle, "BTNE",
 116                                             enable ? button_cap : 1);
 117         if (ACPI_FAILURE(status))
 118                 dev_warn(device, "failed to set button capability\n");
 119 }
 120
 121 static int intel_hid_pm_prepare(struct device *device)
 122 {
 123         struct intel_hid_priv *priv = dev_get_drvdata(device);
 124
 125         priv->wakeup_mode = true;
 126         return 0;
 127 }
 128
 129 static int intel_hid_pl_suspend_handler(struct device *device)
 130 {
 131         if (pm_suspend_via_firmware()) {
 132                 intel_hid_set_enable(device, false);
 133                 intel_button_array_enable(device, false);
 134         }
 135         return 0;
 136 }
 137
 138 static int intel_hid_pl_resume_handler(struct device *device)
 139 {
 140         struct intel_hid_priv *priv = dev_get_drvdata(device);
 141
 142         priv->wakeup_mode = false;
 143         if (pm_resume_via_firmware()) {
 144                 intel_hid_set_enable(device, true);
 145                 intel_button_array_enable(device, true);
 146         }
 147         return 0;
 148 }
 149
 150 static const struct dev_pm_ops intel_hid_pl_pm_ops = {
 151         .prepare = intel_hid_pm_prepare,
 152         .freeze  = intel_hid_pl_suspend_handler,
 153         .thaw  = intel_hid_pl_resume_handler,
 154         .restore  = intel_hid_pl_resume_handler,
 155         .suspend  = intel_hid_pl_suspend_handler,
 156         .resume  = intel_hid_pl_resume_handler,
 157 };
 158
 159 static int intel_hid_input_setup(struct platform_device *device)
 160 {
 161         struct intel_hid_priv *priv = dev_get_drvdata(&device->dev);
 162         int ret;
 163
 164         priv->input_dev = devm_input_allocate_device(&device->dev);
 165         if (!priv->input_dev)
 166                 return -ENOMEM;
 167
 168         ret = sparse_keymap_setup(priv->input_dev, intel_hid_keymap, NULL);
 169         if (ret)
 170                 return ret;
 171
 172         priv->input_dev->name = "Intel HID events";
 173         priv->input_dev->id.bustype = BUS_HOST;
 174
 175         return input_register_device(priv->input_dev);
 176 }
 177
 178 static int intel_button_array_input_setup(struct platform_device *device)
 179 {
 180         struct intel_hid_priv *priv = dev_get_drvdata(&device->dev);
 181         int ret;
 182
 183         /* Setup input device for 5 button array */
 184         priv->array = devm_input_allocate_device(&device->dev);
 185         if (!priv->array)
 186                 return -ENOMEM;
 187
 188         ret = sparse_keymap_setup(priv->array, intel_array_keymap, NULL);
 189         if (ret)
 190                 return ret;
 191
 192         priv->array->name = "Intel HID 5 button array";
 193         priv->array->id.bustype = BUS_HOST;
 194
 195         return input_register_device(priv->array);
 196 }
 197
 198 static void notify_handler(acpi_handle handle, u32 event, void *context)
 199 {
 200         struct platform_device *device = context;
 201         struct intel_hid_priv *priv = dev_get_drvdata(&device->dev);
 202         unsigned long long ev_index;
 203         acpi_status status;
 204
 205         if (priv->wakeup_mode) {
 206                 /*
 207                  * Needed for wakeup from suspend-to-idle to work on some
 208                  * platforms that don't expose the 5-button array, but still
 209                  * send notifies with the power button event code to this
 210                  * device object on power button actions while suspended.
 211                  */
 212                 if (event == 0xce)
 213                         goto wakeup;
 214
 215                 /* Wake up on 5-button array events only. */
 216                 if (event == 0xc0 || !priv->array)
 217                         return;
 218
 219                 if (!sparse_keymap_entry_from_scancode(priv->array, event)) {
 220                         dev_info(&device->dev, "unknown event 0x%x\n", event);
 221                         return;
 222                 }
 223
 224 wakeup:
 225                 pm_wakeup_hard_event(&device->dev);
 226                 return;
 227         }
 228
 229         /*
 230          * Needed for suspend to work on some platforms that don't expose
 231          * the 5-button array, but still send notifies with power button
 232          * event code to this device object on power button actions.
 233          *
 234          * Report the power button press and release.
 235          */
 236         if (!priv->array) {
 237                 if (event == 0xce) {
 238                         input_report_key(priv->input_dev, KEY_POWER, 1);
 239                         input_sync(priv->input_dev);
 240                         return;
 241                 }
 242
 243                 if (event == 0xcf) {
 244                         input_report_key(priv->input_dev, KEY_POWER, 0);
 245                         input_sync(priv->input_dev);
 246                         return;
 247                 }
 248         }
 249
 250         /* 0xC0 is for HID events, other values are for 5 button array */
 251         if (event != 0xc0) {
 252                 if (!priv->array ||
 253                     !sparse_keymap_report_event(priv->array, event, 1, true))
 254                         dev_dbg(&device->dev, "unknown event 0x%x\n", event);
 255                 return;
 256         }
 257
 258         status = acpi_evaluate_integer(handle, "HDEM", NULL, &ev_index);
 259         if (ACPI_FAILURE(status)) {
 260                 dev_warn(&device->dev, "failed to get event index\n");
 261                 return;
 262         }
 263
 264         if (!sparse_keymap_report_event(priv->input_dev, ev_index, 1, true))
 265                 dev_dbg(&device->dev, "unknown event index 0x%llx\n",
 266                          ev_index);
 267 }
 268
 269 static int intel_hid_probe(struct platform_device *device)
 270 {
 271         acpi_handle handle = ACPI_HANDLE(&device->dev);
 272         unsigned long long event_cap, mode;
 273         struct intel_hid_priv *priv;
 274         acpi_status status;
 275         int err;
 276
 277         status = acpi_evaluate_integer(handle, "HDMM", NULL, &mode);
 278         if (ACPI_FAILURE(status)) {
 279                 dev_warn(&device->dev, "failed to read mode\n");
 280                 return -ENODEV;
 281         }
 282
 283         if (mode != 0) {
 284                 /*
 285                  * This driver only implements "simple" mode.  There appear
 286                  * to be no other modes, but we should be paranoid and check
 287                  * for compatibility.
 288                  */
 289                 dev_info(&device->dev, "platform is not in simple mode\n");
 290                 return -ENODEV;
 291         }
 292
 293         priv = devm_kzalloc(&device->dev, sizeof(*priv), GFP_KERNEL);
 294         if (!priv)
 295                 return -ENOMEM;
 296         dev_set_drvdata(&device->dev, priv);
 297
 298         err = intel_hid_input_setup(device);
 299         if (err) {
 300                 pr_err("Failed to setup Intel HID hotkeys\n");
 301                 return err;
 302         }
 303
 304         /* Setup 5 button array */
 305         status = acpi_evaluate_integer(handle, "HEBC", NULL, &event_cap);
 306         if (ACPI_SUCCESS(status) && (event_cap & 0x20000)) {
 307                 dev_info(&device->dev, "platform supports 5 button array\n");
 308                 err = intel_button_array_input_setup(device);
 309                 if (err)
 310                         pr_err("Failed to setup Intel 5 button array hotkeys\n");
 311         }
 312
 313         status = acpi_install_notify_handler(handle,
 314                                              ACPI_DEVICE_NOTIFY,
 315                                              notify_handler,
 316                                              device);
 317         if (ACPI_FAILURE(status))
 318                 return -EBUSY;
 319
 320         err = intel_hid_set_enable(&device->dev, true);
 321         if (err)
 322                 goto err_remove_notify;
 323
 324         if (priv->array) {
 325                 intel_button_array_enable(&device->dev, true);
 326
 327                 /* Call button load method to enable HID power button */
 328                 status = acpi_evaluate_object(handle, "BTNL", NULL, NULL);
 329                 if (ACPI_FAILURE(status))
 330                         dev_warn(&device->dev,
 331                                  "failed to enable HID power button\n");
 332         }
 333
 334         device_init_wakeup(&device->dev, true);
 335         return 0;
 336
 337 err_remove_notify:
 338         acpi_remove_notify_handler(handle, ACPI_DEVICE_NOTIFY, notify_handler);
 339
 340         return err;
 341 }
 342
 343 static int intel_hid_remove(struct platform_device *device)
 344 {
 345         acpi_handle handle = ACPI_HANDLE(&device->dev);
 346
 347         acpi_remove_notify_handler(handle, ACPI_DEVICE_NOTIFY, notify_handler);
 348         intel_hid_set_enable(&device->dev, false);
 349         intel_button_array_enable(&device->dev, false);
 350
 351         /*
 352          * Even if we failed to shut off the event stream, we can still
 353          * safely detach from the device.
 354          */
 355         return 0;
 356 }
 357
 358 static struct platform_driver intel_hid_pl_driver = {
 359         .driver = {
 360                 .name = "intel-hid",
 361                 .acpi_match_table = intel_hid_ids,
 362                 .pm = &intel_hid_pl_pm_ops,
 363         },
 364         .probe = intel_hid_probe,
 365         .remove = intel_hid_remove,
 366 };
 367 MODULE_DEVICE_TABLE(acpi, intel_hid_ids);
 368
 369 /*
 370  * Unfortunately, some laptops provide a _HID="INT33D5" device with
 371  * _CID="PNP0C02".  This causes the pnpacpi scan driver to claim the
 372  * ACPI node, so no platform device will be created.  The pnpacpi
 373  * driver rejects this device in subsequent processing, so no physical
 374  * node is created at all.
 375  *
 376  * As a workaround until the ACPI core figures out how to handle
 377  * this corner case, manually ask the ACPI platform device code to
 378  * claim the ACPI node.
 379  */
 380 static acpi_status __init
 381 check_acpi_dev(acpi_handle handle, u32 lvl, void *context, void **rv)
 382 {
 383         const struct acpi_device_id *ids = context;
 384         struct acpi_device *dev;
 385
 386         if (acpi_bus_get_device(handle, &dev) != 0)
 387                 return AE_OK;
 388
 389         if (acpi_match_device_ids(dev, ids) == 0)
 390                 if (acpi_create_platform_device(dev, NULL))
 391                         dev_info(&dev->dev,
 392                                  "intel-hid: created platform device\n");
 393
 394         return AE_OK;
 395 }
 396
 397 static int __init intel_hid_init(void)
 398 {
 399         acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
 400                             ACPI_UINT32_MAX, check_acpi_dev, NULL,
 401                             (void *)intel_hid_ids, NULL);
 402
 403         return platform_driver_register(&intel_hid_pl_driver);
 404 }
 405 module_init(intel_hid_init);
 406
 407 static void __exit intel_hid_exit(void)
 408 {
 409         platform_driver_unregister(&intel_hid_pl_driver);
 410 }
 411 module_exit(intel_hid_exit);