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