platform/x86/lenovo-yogabook-wmi.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* WMI driver for Lenovo Yoga Book YB1-X90* / -X91* tablets */
0003
0004 #include <linux/acpi.h>
0005 #include <linux/devm-helpers.h>
0006 #include <linux/gpio/consumer.h>
0007 #include <linux/gpio/machine.h>
0008 #include <linux/interrupt.h>
0009 #include <linux/module.h>
0010 #include <linux/leds.h>
0011 #include <linux/wmi.h>
0012 #include <linux/workqueue.h>
0013
0014 #define YB_MBTN_EVENT_GUID  "243FEC1D-1963-41C1-8100-06A9D82A94B4"
0015 #define YB_MBTN_METHOD_GUID "742B0CA1-0B20-404B-9CAA-AEFCABF30CE0"
0016
0017 #define YB_PAD_ENABLE   1
0018 #define YB_PAD_DISABLE  2
0019 #define YB_LIGHTUP_BTN  3
0020
0021 #define YB_KBD_BL_DEFAULT 128
0022
0023 /* flags */
0024 enum {
0025     YB_KBD_IS_ON,
0026     YB_DIGITIZER_IS_ON,
0027     YB_DIGITIZER_MODE,
0028     YB_TABLET_MODE,
0029     YB_SUSPENDED,
0030 };
0031
0032 struct yogabook_wmi {
0033     struct wmi_device *wdev;
0034     struct acpi_device *kbd_adev;
0035     struct acpi_device *dig_adev;
0036     struct device *kbd_dev;
0037     struct device *dig_dev;
0038     struct gpio_desc *backside_hall_gpio;
0039     int backside_hall_irq;
0040     struct work_struct work;
0041     struct led_classdev kbd_bl_led;
0042     unsigned long flags;
0043     uint8_t brightness;
0044 };
0045
0046 static int yogabook_wmi_do_action(struct wmi_device *wdev, int action)
0047 {
0048     struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
0049     struct acpi_buffer input;
0050     acpi_status status;
0051     u32 dummy_arg = 0;
0052
0053     dev_dbg(&wdev->dev, "Do action: %d\n", action);
0054
0055     input.pointer = &dummy_arg;
0056     input.length = sizeof(dummy_arg);
0057
0058     status = wmi_evaluate_method(YB_MBTN_METHOD_GUID, 0, action, &input,
0059                      &output);
0060     if (ACPI_FAILURE(status)) {
0061         dev_err(&wdev->dev, "Calling WMI method failure: 0x%x\n",
0062             status);
0063         return status;
0064     }
0065
0066     kfree(output.pointer);
0067
0068     return 0;
0069 }
0070
0071 /*
0072  * To control keyboard backlight, call the method KBLC() of the TCS1 ACPI
0073  * device (Goodix touchpad acts as virtual sensor keyboard).
0074  */
0075 static int yogabook_wmi_set_kbd_backlight(struct wmi_device *wdev,
0076                       uint8_t level)
0077 {
0078     struct yogabook_wmi *data = dev_get_drvdata(&wdev->dev);
0079     struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
0080     struct acpi_object_list input;
0081     union acpi_object param;
0082     acpi_status status;
0083
0084     if (data->kbd_adev->power.state != ACPI_STATE_D0) {
0085         dev_warn(&wdev->dev, "keyboard touchscreen not in D0, cannot set brightness\n");
0086         return -ENXIO;
0087     }
0088
0089     dev_dbg(&wdev->dev, "Set KBLC level to %u\n", level);
0090
0091     input.count = 1;
0092     input.pointer = &param;
0093
0094     param.type = ACPI_TYPE_INTEGER;
0095     param.integer.value = 255 - level;
0096
0097     status = acpi_evaluate_object(acpi_device_handle(data->kbd_adev), "KBLC",
0098                       &input, &output);
0099     if (ACPI_FAILURE(status)) {
0100         dev_err(&wdev->dev, "Failed to call KBLC method: 0x%x\n", status);
0101         return status;
0102     }
0103
0104     kfree(output.pointer);
0105     return 0;
0106 }
0107
0108 static void yogabook_wmi_work(struct work_struct *work)
0109 {
0110     struct yogabook_wmi *data = container_of(work, struct yogabook_wmi, work);
0111     struct device *dev = &data->wdev->dev;
0112     bool kbd_on, digitizer_on;
0113     int r;
0114
0115     if (test_bit(YB_SUSPENDED, &data->flags))
0116         return;
0117
0118     if (test_bit(YB_TABLET_MODE, &data->flags)) {
0119         kbd_on = false;
0120         digitizer_on = false;
0121     } else if (test_bit(YB_DIGITIZER_MODE, &data->flags)) {
0122         digitizer_on = true;
0123         kbd_on = false;
0124     } else {
0125         kbd_on = true;
0126         digitizer_on = false;
0127     }
0128
0129     if (!kbd_on && test_bit(YB_KBD_IS_ON, &data->flags)) {
0130         /*
0131          * Must be done before releasing the keyboard touchscreen driver,
0132          * so that the keyboard touchscreen dev is still in D0.
0133          */
0134         yogabook_wmi_set_kbd_backlight(data->wdev, 0);
0135         device_release_driver(data->kbd_dev);
0136         clear_bit(YB_KBD_IS_ON, &data->flags);
0137     }
0138
0139     if (!digitizer_on && test_bit(YB_DIGITIZER_IS_ON, &data->flags)) {
0140         yogabook_wmi_do_action(data->wdev, YB_PAD_DISABLE);
0141         device_release_driver(data->dig_dev);
0142         clear_bit(YB_DIGITIZER_IS_ON, &data->flags);
0143     }
0144
0145     if (kbd_on && !test_bit(YB_KBD_IS_ON, &data->flags)) {
0146         r = device_reprobe(data->kbd_dev);
0147         if (r)
0148             dev_warn(dev, "Reprobe of keyboard touchscreen failed: %d\n", r);
0149
0150         yogabook_wmi_set_kbd_backlight(data->wdev, data->brightness);
0151         set_bit(YB_KBD_IS_ON, &data->flags);
0152     }
0153
0154     if (digitizer_on && !test_bit(YB_DIGITIZER_IS_ON, &data->flags)) {
0155         r = device_reprobe(data->dig_dev);
0156         if (r)
0157             dev_warn(dev, "Reprobe of digitizer failed: %d\n", r);
0158
0159         yogabook_wmi_do_action(data->wdev, YB_PAD_ENABLE);
0160         set_bit(YB_DIGITIZER_IS_ON, &data->flags);
0161     }
0162 }
0163
0164 static void yogabook_wmi_notify(struct wmi_device *wdev, union acpi_object *dummy)
0165 {
0166     struct yogabook_wmi *data = dev_get_drvdata(&wdev->dev);
0167
0168     if (test_bit(YB_SUSPENDED, &data->flags))
0169         return;
0170
0171     if (test_bit(YB_DIGITIZER_MODE, &data->flags))
0172         clear_bit(YB_DIGITIZER_MODE, &data->flags);
0173     else
0174         set_bit(YB_DIGITIZER_MODE, &data->flags);
0175
0176     /*
0177      * We are called from the ACPI core and the driver [un]binding which is
0178      * done also needs ACPI functions, use a workqueue to avoid deadlocking.
0179      */
0180     schedule_work(&data->work);
0181 }
0182
0183 static irqreturn_t yogabook_backside_hall_irq(int irq, void *_data)
0184 {
0185     struct yogabook_wmi *data = _data;
0186
0187     if (gpiod_get_value(data->backside_hall_gpio))
0188         set_bit(YB_TABLET_MODE, &data->flags);
0189     else
0190         clear_bit(YB_TABLET_MODE, &data->flags);
0191
0192     schedule_work(&data->work);
0193
0194     return IRQ_HANDLED;
0195 }
0196
0197 static enum led_brightness kbd_brightness_get(struct led_classdev *cdev)
0198 {
0199     struct yogabook_wmi *data =
0200         container_of(cdev, struct yogabook_wmi, kbd_bl_led);
0201
0202     return data->brightness;
0203 }
0204
0205 static int kbd_brightness_set(struct led_classdev *cdev,
0206                   enum led_brightness value)
0207 {
0208     struct yogabook_wmi *data =
0209         container_of(cdev, struct yogabook_wmi, kbd_bl_led);
0210     struct wmi_device *wdev = data->wdev;
0211
0212     if ((value < 0) || (value > 255))
0213         return -EINVAL;
0214
0215     data->brightness = value;
0216
0217     if (data->kbd_adev->power.state != ACPI_STATE_D0)
0218         return 0;
0219
0220     return yogabook_wmi_set_kbd_backlight(wdev, data->brightness);
0221 }
0222
0223 static struct gpiod_lookup_table yogabook_wmi_gpios = {
0224     .dev_id     = "243FEC1D-1963-41C1-8100-06A9D82A94B4",
0225     .table      = {
0226         GPIO_LOOKUP("INT33FF:02", 18, "backside_hall_sw", GPIO_ACTIVE_LOW),
0227         {}
0228     },
0229 };
0230
0231 static void yogabook_wmi_rm_gpio_lookup(void *unused)
0232 {
0233     gpiod_remove_lookup_table(&yogabook_wmi_gpios);
0234 }
0235
0236 static int yogabook_wmi_probe(struct wmi_device *wdev, const void *context)
0237 {
0238     struct yogabook_wmi *data;
0239     int r;
0240
0241     data = devm_kzalloc(&wdev->dev, sizeof(struct yogabook_wmi), GFP_KERNEL);
0242     if (data == NULL)
0243         return -ENOMEM;
0244
0245     dev_set_drvdata(&wdev->dev, data);
0246
0247     data->wdev = wdev;
0248     data->brightness = YB_KBD_BL_DEFAULT;
0249     set_bit(YB_KBD_IS_ON, &data->flags);
0250     set_bit(YB_DIGITIZER_IS_ON, &data->flags);
0251
0252     r = devm_work_autocancel(&wdev->dev, &data->work, yogabook_wmi_work);
0253     if (r)
0254         return r;
0255
0256     data->kbd_adev = acpi_dev_get_first_match_dev("GDIX1001", NULL, -1);
0257     if (!data->kbd_adev) {
0258         dev_err(&wdev->dev, "Cannot find the touchpad device in ACPI tables\n");
0259         return -ENODEV;
0260     }
0261
0262     data->dig_adev = acpi_dev_get_first_match_dev("WCOM0019", NULL, -1);
0263     if (!data->dig_adev) {
0264         dev_err(&wdev->dev, "Cannot find the digitizer device in ACPI tables\n");
0265         r = -ENODEV;
0266         goto error_put_devs;
0267     }
0268
0269     data->kbd_dev = get_device(acpi_get_first_physical_node(data->kbd_adev));
0270     if (!data->kbd_dev || !data->kbd_dev->driver) {
0271         r = -EPROBE_DEFER;
0272         goto error_put_devs;
0273     }
0274
0275     data->dig_dev = get_device(acpi_get_first_physical_node(data->dig_adev));
0276     if (!data->dig_dev || !data->dig_dev->driver) {
0277         r = -EPROBE_DEFER;
0278         goto error_put_devs;
0279     }
0280
0281     gpiod_add_lookup_table(&yogabook_wmi_gpios);
0282
0283     r = devm_add_action_or_reset(&wdev->dev, yogabook_wmi_rm_gpio_lookup, NULL);
0284     if (r)
0285         goto error_put_devs;
0286
0287     data->backside_hall_gpio =
0288         devm_gpiod_get(&wdev->dev, "backside_hall_sw", GPIOD_IN);
0289     if (IS_ERR(data->backside_hall_gpio)) {
0290         r = PTR_ERR(data->backside_hall_gpio);
0291         dev_err_probe(&wdev->dev, r, "Getting backside_hall_sw GPIO\n");
0292         goto error_put_devs;
0293     }
0294
0295     r = gpiod_to_irq(data->backside_hall_gpio);
0296     if (r < 0) {
0297         dev_err_probe(&wdev->dev, r, "Getting backside_hall_sw IRQ\n");
0298         goto error_put_devs;
0299     }
0300     data->backside_hall_irq = r;
0301
0302     r = devm_request_irq(&wdev->dev, data->backside_hall_irq,
0303                  yogabook_backside_hall_irq,
0304                  IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
0305                  "backside_hall_sw", data);
0306     if (r) {
0307         dev_err_probe(&wdev->dev, r, "Requesting backside_hall_sw IRQ\n");
0308         goto error_put_devs;
0309     }
0310
0311     schedule_work(&data->work);
0312
0313     data->kbd_bl_led.name = "ybwmi::kbd_backlight";
0314     data->kbd_bl_led.brightness_set_blocking = kbd_brightness_set;
0315     data->kbd_bl_led.brightness_get = kbd_brightness_get;
0316     data->kbd_bl_led.max_brightness = 255;
0317
0318     r = devm_led_classdev_register(&wdev->dev, &data->kbd_bl_led);
0319     if (r < 0) {
0320         dev_err_probe(&wdev->dev, r, "Registering backlight LED device\n");
0321         goto error_put_devs;
0322     }
0323
0324     return 0;
0325
0326 error_put_devs:
0327     put_device(data->dig_dev);
0328     put_device(data->kbd_dev);
0329     acpi_dev_put(data->dig_adev);
0330     acpi_dev_put(data->kbd_adev);
0331     return r;
0332 }
0333
0334 static void yogabook_wmi_remove(struct wmi_device *wdev)
0335 {
0336     struct yogabook_wmi *data = dev_get_drvdata(&wdev->dev);
0337
0338     put_device(data->dig_dev);
0339     put_device(data->kbd_dev);
0340     acpi_dev_put(data->dig_adev);
0341     acpi_dev_put(data->kbd_adev);
0342 }
0343
0344 static int __maybe_unused yogabook_wmi_suspend(struct device *dev)
0345 {
0346     struct wmi_device *wdev = container_of(dev, struct wmi_device, dev);
0347     struct yogabook_wmi *data = dev_get_drvdata(dev);
0348
0349     set_bit(YB_SUSPENDED, &data->flags);
0350
0351     flush_work(&data->work);
0352
0353     /* Turn off the pen button at sleep */
0354     if (test_bit(YB_DIGITIZER_IS_ON, &data->flags))
0355         yogabook_wmi_do_action(wdev, YB_PAD_DISABLE);
0356
0357     return 0;
0358 }
0359
0360 static int __maybe_unused yogabook_wmi_resume(struct device *dev)
0361 {
0362     struct wmi_device *wdev = container_of(dev, struct wmi_device, dev);
0363     struct yogabook_wmi *data = dev_get_drvdata(dev);
0364
0365     if (test_bit(YB_KBD_IS_ON, &data->flags)) {
0366         /* Ensure keyboard touchpad is on before we call KBLC() */
0367         acpi_device_set_power(data->kbd_adev, ACPI_STATE_D0);
0368         yogabook_wmi_set_kbd_backlight(wdev, data->brightness);
0369     }
0370
0371     if (test_bit(YB_DIGITIZER_IS_ON, &data->flags))
0372         yogabook_wmi_do_action(wdev, YB_PAD_ENABLE);
0373
0374     clear_bit(YB_SUSPENDED, &data->flags);
0375
0376     /* Check for YB_TABLET_MODE changes made during suspend */
0377     schedule_work(&data->work);
0378
0379     return 0;
0380 }
0381
0382 static const struct wmi_device_id yogabook_wmi_id_table[] = {
0383     {
0384         .guid_string = YB_MBTN_EVENT_GUID,
0385     },
0386     { } /* Terminating entry */
0387 };
0388
0389 static SIMPLE_DEV_PM_OPS(yogabook_wmi_pm_ops,
0390              yogabook_wmi_suspend, yogabook_wmi_resume);
0391
0392 static struct wmi_driver yogabook_wmi_driver = {
0393     .driver = {
0394         .name = "yogabook-wmi",
0395         .pm = &yogabook_wmi_pm_ops,
0396     },
0397     .no_notify_data = true,
0398     .id_table = yogabook_wmi_id_table,
0399     .probe = yogabook_wmi_probe,
0400     .remove = yogabook_wmi_remove,
0401     .notify = yogabook_wmi_notify,
0402 };
0403 module_wmi_driver(yogabook_wmi_driver);
0404
0405 MODULE_DEVICE_TABLE(wmi, yogabook_wmi_id_table);
0406 MODULE_AUTHOR("Yauhen Kharuzhy");
0407 MODULE_DESCRIPTION("Lenovo Yoga Book WMI driver");
0408 MODULE_LICENSE("GPL v2");