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                 /* Wake up on 5-button array events only. */
 207                 if (event == 0xc0 || !priv->array)
 208                         return;
 209
 210                 if (sparse_keymap_entry_from_scancode(priv->array, event))
 211                         pm_wakeup_hard_event(&device->dev);
 212                 else
 213                         dev_info(&device->dev, "unknown event 0x%x\n", event);
 214
 215                 return;
 216         }
 217
 218         /* 0xC0 is for HID events, other values are for 5 button array */
 219         if (event != 0xc0) {
 220                 if (!priv->array ||
 221                     !sparse_keymap_report_event(priv->array, event, 1, true))
 222                         dev_info(&device->dev, "unknown event 0x%x\n", event);
 223                 return;
 224         }
 225
 226         status = acpi_evaluate_integer(handle, "HDEM", NULL, &ev_index);
 227         if (ACPI_FAILURE(status)) {
 228                 dev_warn(&device->dev, "failed to get event index\n");
 229                 return;
 230         }
 231
 232         if (!sparse_keymap_report_event(priv->input_dev, ev_index, 1, true))
 233                 dev_info(&device->dev, "unknown event index 0x%llx\n",
 234                          ev_index);
 235 }
 236
 237 static int intel_hid_probe(struct platform_device *device)
 238 {
 239         acpi_handle handle = ACPI_HANDLE(&device->dev);
 240         unsigned long long event_cap, mode;
 241         struct intel_hid_priv *priv;
 242         acpi_status status;
 243         int err;
 244
 245         status = acpi_evaluate_integer(handle, "HDMM", NULL, &mode);
 246         if (ACPI_FAILURE(status)) {
 247                 dev_warn(&device->dev, "failed to read mode\n");
 248                 return -ENODEV;
 249         }
 250
 251         if (mode != 0) {
 252                 /*
 253                  * This driver only implements "simple" mode.  There appear
 254                  * to be no other modes, but we should be paranoid and check
 255                  * for compatibility.
 256                  */
 257                 dev_info(&device->dev, "platform is not in simple mode\n");
 258                 return -ENODEV;
 259         }
 260
 261         priv = devm_kzalloc(&device->dev, sizeof(*priv), GFP_KERNEL);
 262         if (!priv)
 263                 return -ENOMEM;
 264         dev_set_drvdata(&device->dev, priv);
 265
 266         err = intel_hid_input_setup(device);
 267         if (err) {
 268                 pr_err("Failed to setup Intel HID hotkeys\n");
 269                 return err;
 270         }
 271
 272         /* Setup 5 button array */
 273         status = acpi_evaluate_integer(handle, "HEBC", NULL, &event_cap);
 274         if (ACPI_SUCCESS(status) && (event_cap & 0x20000)) {
 275                 dev_info(&device->dev, "platform supports 5 button array\n");
 276                 err = intel_button_array_input_setup(device);
 277                 if (err)
 278                         pr_err("Failed to setup Intel 5 button array hotkeys\n");
 279         }
 280
 281         status = acpi_install_notify_handler(handle,
 282                                              ACPI_DEVICE_NOTIFY,
 283                                              notify_handler,
 284                                              device);
 285         if (ACPI_FAILURE(status))
 286                 return -EBUSY;
 287
 288         err = intel_hid_set_enable(&device->dev, true);
 289         if (err)
 290                 goto err_remove_notify;
 291
 292         if (priv->array) {
 293                 intel_button_array_enable(&device->dev, true);
 294
 295                 /* Call button load method to enable HID power button */
 296                 status = acpi_evaluate_object(handle, "BTNL", NULL, NULL);
 297                 if (ACPI_FAILURE(status))
 298                         dev_warn(&device->dev,
 299                                  "failed to enable HID power button\n");
 300         }
 301
 302         device_init_wakeup(&device->dev, true);
 303         return 0;
 304
 305 err_remove_notify:
 306         acpi_remove_notify_handler(handle, ACPI_DEVICE_NOTIFY, notify_handler);
 307
 308         return err;
 309 }
 310
 311 static int intel_hid_remove(struct platform_device *device)
 312 {
 313         acpi_handle handle = ACPI_HANDLE(&device->dev);
 314
 315         acpi_remove_notify_handler(handle, ACPI_DEVICE_NOTIFY, notify_handler);
 316         intel_hid_set_enable(&device->dev, false);
 317         intel_button_array_enable(&device->dev, false);
 318
 319         /*
 320          * Even if we failed to shut off the event stream, we can still
 321          * safely detach from the device.
 322          */
 323         return 0;
 324 }
 325
 326 static struct platform_driver intel_hid_pl_driver = {
 327         .driver = {
 328                 .name = "intel-hid",
 329                 .acpi_match_table = intel_hid_ids,
 330                 .pm = &intel_hid_pl_pm_ops,
 331         },
 332         .probe = intel_hid_probe,
 333         .remove = intel_hid_remove,
 334 };
 335 MODULE_DEVICE_TABLE(acpi, intel_hid_ids);
 336
 337 /*
 338  * Unfortunately, some laptops provide a _HID="INT33D5" device with
 339  * _CID="PNP0C02".  This causes the pnpacpi scan driver to claim the
 340  * ACPI node, so no platform device will be created.  The pnpacpi
 341  * driver rejects this device in subsequent processing, so no physical
 342  * node is created at all.
 343  *
 344  * As a workaround until the ACPI core figures out how to handle
 345  * this corner case, manually ask the ACPI platform device code to
 346  * claim the ACPI node.
 347  */
 348 static acpi_status __init
 349 check_acpi_dev(acpi_handle handle, u32 lvl, void *context, void **rv)
 350 {
 351         const struct acpi_device_id *ids = context;
 352         struct acpi_device *dev;
 353
 354         if (acpi_bus_get_device(handle, &dev) != 0)
 355                 return AE_OK;
 356
 357         if (acpi_match_device_ids(dev, ids) == 0)
 358                 if (acpi_create_platform_device(dev, NULL))
 359                         dev_info(&dev->dev,
 360                                  "intel-hid: created platform device\n");
 361
 362         return AE_OK;
 363 }
 364
 365 static int __init intel_hid_init(void)
 366 {
 367         acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
 368                             ACPI_UINT32_MAX, check_acpi_dev, NULL,
 369                             (void *)intel_hid_ids, NULL);
 370
 371         return platform_driver_register(&intel_hid_pl_driver);
 372 }
 373 module_init(intel_hid_init);
 374
 375 static void __exit intel_hid_exit(void)
 376 {
 377         platform_driver_unregister(&intel_hid_pl_driver);
 378 }
 379 module_exit(intel_hid_exit);