drivers/platform/x86/lenovo-ymc.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * lenovo-ymc.c - Lenovo Yoga Mode Control driver
   4  *
   5  * Copyright © 2022 Gergo Koteles <soyer@irl.hu>
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/acpi.h>
  11 #include <linux/dmi.h>
  12 #include <linux/input.h>
  13 #include <linux/input/sparse-keymap.h>
  14 #include <linux/wmi.h>
  15 #include "ideapad-laptop.h"
  16
  17 #define LENOVO_YMC_EVENT_GUID   "06129D99-6083-4164-81AD-F092F9D773A6"
  18 #define LENOVO_YMC_QUERY_GUID   "09B0EE6E-C3FD-4243-8DA1-7911FF80BB8C"
  19
  20 #define LENOVO_YMC_QUERY_INSTANCE 0
  21 #define LENOVO_YMC_QUERY_METHOD 0x01
  22
  23 static bool ec_trigger __read_mostly;
  24 module_param(ec_trigger, bool, 0444);
  25 MODULE_PARM_DESC(ec_trigger, "Enable EC triggering work-around to force emitting tablet mode events");
  26
  27 static const struct dmi_system_id ec_trigger_quirk_dmi_table[] = {
  28         {
  29                 /* Lenovo Yoga 7 14ARB7 */
  30                 .matches = {
  31                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
  32                         DMI_MATCH(DMI_PRODUCT_NAME, "82QF"),
  33                 },
  34         },
  35         { }
  36 };
  37
  38 struct lenovo_ymc_private {
  39         struct input_dev *input_dev;
  40         struct acpi_device *ec_acpi_dev;
  41 };
  42
  43 static void lenovo_ymc_trigger_ec(struct wmi_device *wdev, struct lenovo_ymc_private *priv)
  44 {
  45         int err;
  46
  47         if (!priv->ec_acpi_dev)
  48                 return;
  49
  50         err = write_ec_cmd(priv->ec_acpi_dev->handle, VPCCMD_W_YMC, 1);
  51         if (err)
  52                 dev_warn(&wdev->dev, "Could not write YMC: %d\n", err);
  53 }
  54
  55 static const struct key_entry lenovo_ymc_keymap[] = {
  56         /* Laptop */
  57         { KE_SW, 0x01, { .sw = { SW_TABLET_MODE, 0 } } },
  58         /* Tablet */
  59         { KE_SW, 0x02, { .sw = { SW_TABLET_MODE, 1 } } },
  60         /* Drawing Board */
  61         { KE_SW, 0x03, { .sw = { SW_TABLET_MODE, 1 } } },
  62         /* Tent */
  63         { KE_SW, 0x04, { .sw = { SW_TABLET_MODE, 1 } } },
  64         { KE_END },
  65 };
  66
  67 static void lenovo_ymc_notify(struct wmi_device *wdev, union acpi_object *data)
  68 {
  69         struct lenovo_ymc_private *priv = dev_get_drvdata(&wdev->dev);
  70         u32 input_val = 0;
  71         struct acpi_buffer input = { sizeof(input_val), &input_val };
  72         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
  73         union acpi_object *obj;
  74         acpi_status status;
  75         int code;
  76
  77         status = wmi_evaluate_method(LENOVO_YMC_QUERY_GUID,
  78                                 LENOVO_YMC_QUERY_INSTANCE,
  79                                 LENOVO_YMC_QUERY_METHOD,
  80                                 &input, &output);
  81
  82         if (ACPI_FAILURE(status)) {
  83                 dev_warn(&wdev->dev,
  84                         "Failed to evaluate query method: %s\n",
  85                         acpi_format_exception(status));
  86                 return;
  87         }
  88
  89         obj = output.pointer;
  90
  91         if (obj->type != ACPI_TYPE_INTEGER) {
  92                 dev_warn(&wdev->dev,
  93                         "WMI event data is not an integer\n");
  94                 goto free_obj;
  95         }
  96         code = obj->integer.value;
  97
  98         if (!sparse_keymap_report_event(priv->input_dev, code, 1, true))
  99                 dev_warn(&wdev->dev, "Unknown key %d pressed\n", code);
 100
 101 free_obj:
 102         kfree(obj);
 103         lenovo_ymc_trigger_ec(wdev, priv);
 104 }
 105
 106 static void acpi_dev_put_helper(void *p) { acpi_dev_put(p); }
 107
 108 static int lenovo_ymc_probe(struct wmi_device *wdev, const void *ctx)
 109 {
 110         struct lenovo_ymc_private *priv;
 111         struct input_dev *input_dev;
 112         int err;
 113
 114         ec_trigger |= dmi_check_system(ec_trigger_quirk_dmi_table);
 115
 116         priv = devm_kzalloc(&wdev->dev, sizeof(*priv), GFP_KERNEL);
 117         if (!priv)
 118                 return -ENOMEM;
 119
 120         if (ec_trigger) {
 121                 pr_debug("Lenovo YMC enable EC triggering.\n");
 122                 priv->ec_acpi_dev = acpi_dev_get_first_match_dev("VPC2004", NULL, -1);
 123
 124                 if (!priv->ec_acpi_dev) {
 125                         dev_err(&wdev->dev, "Could not find EC ACPI device.\n");
 126                         return -ENODEV;
 127                 }
 128                 err = devm_add_action_or_reset(&wdev->dev,
 129                                 acpi_dev_put_helper, priv->ec_acpi_dev);
 130                 if (err) {
 131                         dev_err(&wdev->dev,
 132                                 "Could not clean up EC ACPI device: %d\n", err);
 133                         return err;
 134                 }
 135         }
 136
 137         input_dev = devm_input_allocate_device(&wdev->dev);
 138         if (!input_dev)
 139                 return -ENOMEM;
 140
 141         input_dev->name = "Lenovo Yoga Tablet Mode Control switch";
 142         input_dev->phys = LENOVO_YMC_EVENT_GUID "/input0";
 143         input_dev->id.bustype = BUS_HOST;
 144         input_dev->dev.parent = &wdev->dev;
 145         err = sparse_keymap_setup(input_dev, lenovo_ymc_keymap, NULL);
 146         if (err) {
 147                 dev_err(&wdev->dev,
 148                         "Could not set up input device keymap: %d\n", err);
 149                 return err;
 150         }
 151
 152         err = input_register_device(input_dev);
 153         if (err) {
 154                 dev_err(&wdev->dev,
 155                         "Could not register input device: %d\n", err);
 156                 return err;
 157         }
 158
 159         priv->input_dev = input_dev;
 160         dev_set_drvdata(&wdev->dev, priv);
 161
 162         /* Report the state for the first time on probe */
 163         lenovo_ymc_trigger_ec(wdev, priv);
 164         lenovo_ymc_notify(wdev, NULL);
 165         return 0;
 166 }
 167
 168 static const struct wmi_device_id lenovo_ymc_wmi_id_table[] = {
 169         { .guid_string = LENOVO_YMC_EVENT_GUID },
 170         { }
 171 };
 172 MODULE_DEVICE_TABLE(wmi, lenovo_ymc_wmi_id_table);
 173
 174 static struct wmi_driver lenovo_ymc_driver = {
 175         .driver = {
 176                 .name = "lenovo-ymc",
 177         },
 178         .id_table = lenovo_ymc_wmi_id_table,
 179         .probe = lenovo_ymc_probe,
 180         .notify = lenovo_ymc_notify,
 181 };
 182
 183 module_wmi_driver(lenovo_ymc_driver);
 184
 185 MODULE_AUTHOR("Gergo Koteles <soyer@irl.hu>");
 186 MODULE_DESCRIPTION("Lenovo Yoga Mode Control driver");
 187 MODULE_LICENSE("GPL");