1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Platform driver for Lenovo Yoga Book YB1-X90F/L tablets (Android model)
4 * WMI driver for Lenovo Yoga Book YB1-X91F/L tablets (Windows model)
5 *
6 * The keyboard half of the YB1 models can function as both a capacitive
7 * touch keyboard or as a Wacom digitizer, but not at the same time.
8 *
9 * This driver takes care of switching between the 2 functions.
10 *
11 * Copyright 2023 Hans de Goede <hansg@kernel.org>
12 */
13
14 #include <linux/acpi.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/gpio/machine.h>
17 #include <linux/i2c.h>
18 #include <linux/interrupt.h>
19 #include <linux/leds.h>
20 #include <linux/module.h>
21 #include <linux/platform_device.h>
22 #include <linux/pwm.h>
23 #include <linux/wmi.h>
24 #include <linux/workqueue.h>
25
26 #define YB_MBTN_EVENT_GUID "243FEC1D-1963-41C1-8100-06A9D82A94B4"
27
28 #define YB_KBD_BL_DEFAULT 128
29 #define YB_KBD_BL_MAX 255
30 #define YB_KBD_BL_PWM_PERIOD 13333
31
32 #define YB_PDEV_NAME "yogabook-touch-kbd-digitizer-switch"
33
34 /* flags */
35 enum {
36 YB_KBD_IS_ON,
37 YB_DIGITIZER_IS_ON,
38 YB_DIGITIZER_MODE,
39 YB_TABLET_MODE,
40 YB_SUSPENDED,
41 };
42
43 struct yogabook_data {
44 struct device *dev;
45 struct acpi_device *kbd_adev;
46 struct acpi_device *dig_adev;
47 struct device *kbd_dev;
48 struct device *dig_dev;
49 struct led_classdev *pen_led;
50 struct gpio_desc *pen_touch_event;
51 struct gpio_desc *kbd_bl_led_enable;
52 struct gpio_desc *backside_hall_gpio;
53 struct pwm_device *kbd_bl_pwm;
54 int (*set_kbd_backlight)(struct yogabook_data *data, uint8_t level);
55 int pen_touch_irq;
56 int backside_hall_irq;
57 struct work_struct work;
58 struct led_classdev kbd_bl_led;
59 unsigned long flags;
60 uint8_t brightness;
61 };
62
yogabook_work(struct work_struct * work)63 static void yogabook_work(struct work_struct *work)
64 {
65 struct yogabook_data *data = container_of(work, struct yogabook_data, work);
66 bool kbd_on, digitizer_on;
67 int r;
68
69 if (test_bit(YB_SUSPENDED, &data->flags))
70 return;
71
72 if (test_bit(YB_TABLET_MODE, &data->flags)) {
73 kbd_on = false;
74 digitizer_on = false;
75 } else if (test_bit(YB_DIGITIZER_MODE, &data->flags)) {
76 digitizer_on = true;
77 kbd_on = false;
78 } else {
79 kbd_on = true;
80 digitizer_on = false;
81 }
82
83 if (!kbd_on && test_bit(YB_KBD_IS_ON, &data->flags)) {
84 /*
85 * Must be done before releasing the keyboard touchscreen driver,
86 * so that the keyboard touchscreen dev is still in D0.
87 */
88 data->set_kbd_backlight(data, 0);
89 device_release_driver(data->kbd_dev);
90 clear_bit(YB_KBD_IS_ON, &data->flags);
91 }
92
93 if (!digitizer_on && test_bit(YB_DIGITIZER_IS_ON, &data->flags)) {
94 led_set_brightness(data->pen_led, LED_OFF);
95 device_release_driver(data->dig_dev);
96 clear_bit(YB_DIGITIZER_IS_ON, &data->flags);
97 }
98
99 if (kbd_on && !test_bit(YB_KBD_IS_ON, &data->flags)) {
100 r = device_reprobe(data->kbd_dev);
101 if (r)
102 dev_warn(data->dev, "Reprobe of keyboard touchscreen failed: %d\n", r);
103
104 data->set_kbd_backlight(data, data->brightness);
105 set_bit(YB_KBD_IS_ON, &data->flags);
106 }
107
108 if (digitizer_on && !test_bit(YB_DIGITIZER_IS_ON, &data->flags)) {
109 r = device_reprobe(data->dig_dev);
110 if (r)
111 dev_warn(data->dev, "Reprobe of digitizer failed: %d\n", r);
112
113 led_set_brightness(data->pen_led, LED_FULL);
114 set_bit(YB_DIGITIZER_IS_ON, &data->flags);
115 }
116 }
117
yogabook_toggle_digitizer_mode(struct yogabook_data * data)118 static void yogabook_toggle_digitizer_mode(struct yogabook_data *data)
119 {
120 if (test_bit(YB_SUSPENDED, &data->flags))
121 return;
122
123 if (test_bit(YB_DIGITIZER_MODE, &data->flags))
124 clear_bit(YB_DIGITIZER_MODE, &data->flags);
125 else
126 set_bit(YB_DIGITIZER_MODE, &data->flags);
127
128 /*
129 * We are called from the ACPI core and the driver [un]binding which is
130 * done also needs ACPI functions, use a workqueue to avoid deadlocking.
131 */
132 schedule_work(&data->work);
133 }
134
yogabook_backside_hall_irq(int irq,void * _data)135 static irqreturn_t yogabook_backside_hall_irq(int irq, void *_data)
136 {
137 struct yogabook_data *data = _data;
138
139 if (gpiod_get_value(data->backside_hall_gpio))
140 set_bit(YB_TABLET_MODE, &data->flags);
141 else
142 clear_bit(YB_TABLET_MODE, &data->flags);
143
144 schedule_work(&data->work);
145
146 return IRQ_HANDLED;
147 }
148
149 #define kbd_led_to_yogabook(cdev) container_of(cdev, struct yogabook_data, kbd_bl_led)
150
kbd_brightness_get(struct led_classdev * cdev)151 static enum led_brightness kbd_brightness_get(struct led_classdev *cdev)
152 {
153 struct yogabook_data *data = kbd_led_to_yogabook(cdev);
154
155 return data->brightness;
156 }
157
kbd_brightness_set(struct led_classdev * cdev,enum led_brightness value)158 static int kbd_brightness_set(struct led_classdev *cdev,
159 enum led_brightness value)
160 {
161 struct yogabook_data *data = kbd_led_to_yogabook(cdev);
162
163 if ((value < 0) || (value > YB_KBD_BL_MAX))
164 return -EINVAL;
165
166 data->brightness = value;
167
168 if (!test_bit(YB_KBD_IS_ON, &data->flags))
169 return 0;
170
171 return data->set_kbd_backlight(data, data->brightness);
172 }
173
174 static struct gpiod_lookup_table yogabook_gpios = {
175 .table = {
176 GPIO_LOOKUP("INT33FF:02", 18, "backside_hall_sw", GPIO_ACTIVE_LOW),
177 {}
178 },
179 };
180
181 static struct led_lookup_data yogabook_pen_led = {
182 .provider = "platform::indicator",
183 .con_id = "pen-icon-led",
184 };
185
yogabook_probe(struct device * dev,struct yogabook_data * data,const char * kbd_bl_led_name)186 static int yogabook_probe(struct device *dev, struct yogabook_data *data,
187 const char *kbd_bl_led_name)
188 {
189 int r;
190
191 data->dev = dev;
192 data->brightness = YB_KBD_BL_DEFAULT;
193 set_bit(YB_KBD_IS_ON, &data->flags);
194 set_bit(YB_DIGITIZER_IS_ON, &data->flags);
195 INIT_WORK(&data->work, yogabook_work);
196
197 yogabook_pen_led.dev_id = dev_name(dev);
198 led_add_lookup(&yogabook_pen_led);
199 data->pen_led = devm_led_get(dev, "pen-icon-led");
200 led_remove_lookup(&yogabook_pen_led);
201
202 if (IS_ERR(data->pen_led))
203 return dev_err_probe(dev, PTR_ERR(data->pen_led), "Getting pen icon LED\n");
204
205 yogabook_gpios.dev_id = dev_name(dev);
206 gpiod_add_lookup_table(&yogabook_gpios);
207 data->backside_hall_gpio = devm_gpiod_get(dev, "backside_hall_sw", GPIOD_IN);
208 gpiod_remove_lookup_table(&yogabook_gpios);
209
210 if (IS_ERR(data->backside_hall_gpio))
211 return dev_err_probe(dev, PTR_ERR(data->backside_hall_gpio),
212 "Getting backside_hall_sw GPIO\n");
213
214 r = gpiod_to_irq(data->backside_hall_gpio);
215 if (r < 0)
216 return dev_err_probe(dev, r, "Getting backside_hall_sw IRQ\n");
217
218 data->backside_hall_irq = r;
219
220 /* Set default brightness before enabling the IRQ */
221 data->set_kbd_backlight(data, YB_KBD_BL_DEFAULT);
222
223 r = request_irq(data->backside_hall_irq, yogabook_backside_hall_irq,
224 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
225 "backside_hall_sw", data);
226 if (r)
227 return dev_err_probe(dev, r, "Requesting backside_hall_sw IRQ\n");
228
229 schedule_work(&data->work);
230
231 data->kbd_bl_led.name = kbd_bl_led_name;
232 data->kbd_bl_led.brightness_set_blocking = kbd_brightness_set;
233 data->kbd_bl_led.brightness_get = kbd_brightness_get;
234 data->kbd_bl_led.max_brightness = YB_KBD_BL_MAX;
235
236 r = devm_led_classdev_register(dev, &data->kbd_bl_led);
237 if (r < 0) {
238 dev_err_probe(dev, r, "Registering backlight LED device\n");
239 goto error_free_irq;
240 }
241
242 dev_set_drvdata(dev, data);
243 return 0;
244
245 error_free_irq:
246 free_irq(data->backside_hall_irq, data);
247 cancel_work_sync(&data->work);
248 return r;
249 }
250
yogabook_remove(struct yogabook_data * data)251 static void yogabook_remove(struct yogabook_data *data)
252 {
253 int r = 0;
254
255 free_irq(data->backside_hall_irq, data);
256 cancel_work_sync(&data->work);
257
258 if (!test_bit(YB_KBD_IS_ON, &data->flags))
259 r |= device_reprobe(data->kbd_dev);
260
261 if (!test_bit(YB_DIGITIZER_IS_ON, &data->flags))
262 r |= device_reprobe(data->dig_dev);
263
264 if (r)
265 dev_warn(data->dev, "Reprobe of devices failed\n");
266 }
267
yogabook_suspend(struct device * dev)268 static int yogabook_suspend(struct device *dev)
269 {
270 struct yogabook_data *data = dev_get_drvdata(dev);
271
272 set_bit(YB_SUSPENDED, &data->flags);
273 flush_work(&data->work);
274
275 if (test_bit(YB_KBD_IS_ON, &data->flags))
276 data->set_kbd_backlight(data, 0);
277
278 return 0;
279 }
280
yogabook_resume(struct device * dev)281 static int yogabook_resume(struct device *dev)
282 {
283 struct yogabook_data *data = dev_get_drvdata(dev);
284
285 if (test_bit(YB_KBD_IS_ON, &data->flags))
286 data->set_kbd_backlight(data, data->brightness);
287
288 clear_bit(YB_SUSPENDED, &data->flags);
289
290 /* Check for YB_TABLET_MODE changes made during suspend */
291 schedule_work(&data->work);
292
293 return 0;
294 }
295
296 static DEFINE_SIMPLE_DEV_PM_OPS(yogabook_pm_ops, yogabook_suspend, yogabook_resume);
297
298 /********** WMI driver code **********/
299
300 /*
301 * To control keyboard backlight, call the method KBLC() of the TCS1 ACPI
302 * device (Goodix touchpad acts as virtual sensor keyboard).
303 */
yogabook_wmi_set_kbd_backlight(struct yogabook_data * data,uint8_t level)304 static int yogabook_wmi_set_kbd_backlight(struct yogabook_data *data,
305 uint8_t level)
306 {
307 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
308 struct acpi_object_list input;
309 union acpi_object param;
310 acpi_status status;
311
312 dev_dbg(data->dev, "Set KBLC level to %u\n", level);
313
314 /* Ensure keyboard touchpad is on before we call KBLC() */
315 acpi_device_set_power(data->kbd_adev, ACPI_STATE_D0);
316
317 input.count = 1;
318 input.pointer = ¶m;
319
320 param.type = ACPI_TYPE_INTEGER;
321 param.integer.value = YB_KBD_BL_MAX - level;
322
323 status = acpi_evaluate_object(acpi_device_handle(data->kbd_adev), "KBLC",
324 &input, &output);
325 if (ACPI_FAILURE(status)) {
326 dev_err(data->dev, "Failed to call KBLC method: 0x%x\n", status);
327 return status;
328 }
329
330 kfree(output.pointer);
331 return 0;
332 }
333
yogabook_wmi_probe(struct wmi_device * wdev,const void * context)334 static int yogabook_wmi_probe(struct wmi_device *wdev, const void *context)
335 {
336 struct device *dev = &wdev->dev;
337 struct yogabook_data *data;
338 int r;
339
340 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
341 if (data == NULL)
342 return -ENOMEM;
343
344 data->kbd_adev = acpi_dev_get_first_match_dev("GDIX1001", NULL, -1);
345 if (!data->kbd_adev)
346 return dev_err_probe(dev, -ENODEV, "Cannot find the touchpad device in ACPI tables\n");
347
348 data->dig_adev = acpi_dev_get_first_match_dev("WCOM0019", NULL, -1);
349 if (!data->dig_adev) {
350 r = dev_err_probe(dev, -ENODEV, "Cannot find the digitizer device in ACPI tables\n");
351 goto error_put_devs;
352 }
353
354 data->kbd_dev = get_device(acpi_get_first_physical_node(data->kbd_adev));
355 if (!data->kbd_dev || !data->kbd_dev->driver) {
356 r = -EPROBE_DEFER;
357 goto error_put_devs;
358 }
359
360 data->dig_dev = get_device(acpi_get_first_physical_node(data->dig_adev));
361 if (!data->dig_dev || !data->dig_dev->driver) {
362 r = -EPROBE_DEFER;
363 goto error_put_devs;
364 }
365
366 data->set_kbd_backlight = yogabook_wmi_set_kbd_backlight;
367
368 r = yogabook_probe(dev, data, "ybwmi::kbd_backlight");
369 if (r)
370 goto error_put_devs;
371
372 return 0;
373
374 error_put_devs:
375 put_device(data->dig_dev);
376 put_device(data->kbd_dev);
377 acpi_dev_put(data->dig_adev);
378 acpi_dev_put(data->kbd_adev);
379 return r;
380 }
381
yogabook_wmi_remove(struct wmi_device * wdev)382 static void yogabook_wmi_remove(struct wmi_device *wdev)
383 {
384 struct yogabook_data *data = dev_get_drvdata(&wdev->dev);
385
386 yogabook_remove(data);
387
388 put_device(data->dig_dev);
389 put_device(data->kbd_dev);
390 acpi_dev_put(data->dig_adev);
391 acpi_dev_put(data->kbd_adev);
392 }
393
yogabook_wmi_notify(struct wmi_device * wdev,union acpi_object * dummy)394 static void yogabook_wmi_notify(struct wmi_device *wdev, union acpi_object *dummy)
395 {
396 yogabook_toggle_digitizer_mode(dev_get_drvdata(&wdev->dev));
397 }
398
399 static const struct wmi_device_id yogabook_wmi_id_table[] = {
400 {
401 .guid_string = YB_MBTN_EVENT_GUID,
402 },
403 { } /* Terminating entry */
404 };
405 MODULE_DEVICE_TABLE(wmi, yogabook_wmi_id_table);
406
407 static struct wmi_driver yogabook_wmi_driver = {
408 .driver = {
409 .name = "yogabook-wmi",
410 .pm = pm_sleep_ptr(&yogabook_pm_ops),
411 },
412 .no_notify_data = true,
413 .id_table = yogabook_wmi_id_table,
414 .probe = yogabook_wmi_probe,
415 .remove = yogabook_wmi_remove,
416 .notify = yogabook_wmi_notify,
417 };
418
419 /********** platform driver code **********/
420
421 static struct gpiod_lookup_table yogabook_pdev_gpios = {
422 .dev_id = YB_PDEV_NAME,
423 .table = {
424 GPIO_LOOKUP("INT33FF:00", 95, "pen_touch_event", GPIO_ACTIVE_HIGH),
425 GPIO_LOOKUP("INT33FF:03", 52, "enable_keyboard_led", GPIO_ACTIVE_HIGH),
426 {}
427 },
428 };
429
yogabook_pdev_set_kbd_backlight(struct yogabook_data * data,u8 level)430 static int yogabook_pdev_set_kbd_backlight(struct yogabook_data *data, u8 level)
431 {
432 struct pwm_state state = {
433 .period = YB_KBD_BL_PWM_PERIOD,
434 .duty_cycle = YB_KBD_BL_PWM_PERIOD * level / YB_KBD_BL_MAX,
435 .enabled = level,
436 };
437
438 pwm_apply_might_sleep(data->kbd_bl_pwm, &state);
439 gpiod_set_value(data->kbd_bl_led_enable, level ? 1 : 0);
440 return 0;
441 }
442
yogabook_pen_touch_irq(int irq,void * data)443 static irqreturn_t yogabook_pen_touch_irq(int irq, void *data)
444 {
445 yogabook_toggle_digitizer_mode(data);
446 return IRQ_HANDLED;
447 }
448
yogabook_pdev_probe(struct platform_device * pdev)449 static int yogabook_pdev_probe(struct platform_device *pdev)
450 {
451 struct device *dev = &pdev->dev;
452 struct yogabook_data *data;
453 int r;
454
455 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
456 if (data == NULL)
457 return -ENOMEM;
458
459 data->kbd_dev = bus_find_device_by_name(&i2c_bus_type, NULL, "i2c-goodix_ts");
460 if (!data->kbd_dev || !data->kbd_dev->driver) {
461 r = -EPROBE_DEFER;
462 goto error_put_devs;
463 }
464
465 data->dig_dev = bus_find_device_by_name(&i2c_bus_type, NULL, "i2c-wacom");
466 if (!data->dig_dev || !data->dig_dev->driver) {
467 r = -EPROBE_DEFER;
468 goto error_put_devs;
469 }
470
471 gpiod_add_lookup_table(&yogabook_pdev_gpios);
472 data->pen_touch_event = devm_gpiod_get(dev, "pen_touch_event", GPIOD_IN);
473 data->kbd_bl_led_enable = devm_gpiod_get(dev, "enable_keyboard_led", GPIOD_OUT_HIGH);
474 gpiod_remove_lookup_table(&yogabook_pdev_gpios);
475
476 if (IS_ERR(data->pen_touch_event)) {
477 r = dev_err_probe(dev, PTR_ERR(data->pen_touch_event),
478 "Getting pen_touch_event GPIO\n");
479 goto error_put_devs;
480 }
481
482 if (IS_ERR(data->kbd_bl_led_enable)) {
483 r = dev_err_probe(dev, PTR_ERR(data->kbd_bl_led_enable),
484 "Getting enable_keyboard_led GPIO\n");
485 goto error_put_devs;
486 }
487
488 data->kbd_bl_pwm = devm_pwm_get(dev, "pwm_soc_lpss_2");
489 if (IS_ERR(data->kbd_bl_pwm)) {
490 r = dev_err_probe(dev, PTR_ERR(data->kbd_bl_pwm),
491 "Getting keyboard backlight PWM\n");
492 goto error_put_devs;
493 }
494
495 r = gpiod_to_irq(data->pen_touch_event);
496 if (r < 0) {
497 dev_err_probe(dev, r, "Getting pen_touch_event IRQ\n");
498 goto error_put_devs;
499 }
500 data->pen_touch_irq = r;
501
502 r = request_irq(data->pen_touch_irq, yogabook_pen_touch_irq, IRQF_TRIGGER_FALLING,
503 "pen_touch_event", data);
504 if (r) {
505 dev_err_probe(dev, r, "Requesting pen_touch_event IRQ\n");
506 goto error_put_devs;
507 }
508
509 data->set_kbd_backlight = yogabook_pdev_set_kbd_backlight;
510
511 r = yogabook_probe(dev, data, "yogabook::kbd_backlight");
512 if (r)
513 goto error_free_irq;
514
515 return 0;
516
517 error_free_irq:
518 free_irq(data->pen_touch_irq, data);
519 cancel_work_sync(&data->work);
520 error_put_devs:
521 put_device(data->dig_dev);
522 put_device(data->kbd_dev);
523 return r;
524 }
525
yogabook_pdev_remove(struct platform_device * pdev)526 static void yogabook_pdev_remove(struct platform_device *pdev)
527 {
528 struct yogabook_data *data = platform_get_drvdata(pdev);
529
530 yogabook_remove(data);
531 free_irq(data->pen_touch_irq, data);
532 cancel_work_sync(&data->work);
533 put_device(data->dig_dev);
534 put_device(data->kbd_dev);
535 }
536
537 static struct platform_driver yogabook_pdev_driver = {
538 .probe = yogabook_pdev_probe,
539 .remove_new = yogabook_pdev_remove,
540 .driver = {
541 .name = YB_PDEV_NAME,
542 .pm = pm_sleep_ptr(&yogabook_pm_ops),
543 },
544 };
545
yogabook_module_init(void)546 static int __init yogabook_module_init(void)
547 {
548 int r;
549
550 r = wmi_driver_register(&yogabook_wmi_driver);
551 if (r)
552 return r;
553
554 r = platform_driver_register(&yogabook_pdev_driver);
555 if (r)
556 wmi_driver_unregister(&yogabook_wmi_driver);
557
558 return r;
559 }
560
yogabook_module_exit(void)561 static void __exit yogabook_module_exit(void)
562 {
563 platform_driver_unregister(&yogabook_pdev_driver);
564 wmi_driver_unregister(&yogabook_wmi_driver);
565 }
566
567 module_init(yogabook_module_init);
568 module_exit(yogabook_module_exit);
569
570 MODULE_ALIAS("platform:" YB_PDEV_NAME);
571 MODULE_AUTHOR("Yauhen Kharuzhy");
572 MODULE_DESCRIPTION("Lenovo Yoga Book driver");
573 MODULE_LICENSE("GPL v2");
574