1
2
3
4
5
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/kernel.h>
15#include <linux/leds.h>
16#include <linux/module.h>
17#include <linux/platform_device.h>
18#include <linux/types.h>
19
20#define LED_DEVICE(_name, max, flag) struct led_classdev _name = { \
21 .name = __stringify(_name), \
22 .max_brightness = max, \
23 .brightness_set = _name##_set, \
24 .brightness_get = _name##_get, \
25 .flags = flag, \
26}
27
28MODULE_AUTHOR("Matan Ziv-Av");
29MODULE_DESCRIPTION("LG WMI Hotkey Driver");
30MODULE_LICENSE("GPL");
31
32#define WMI_EVENT_GUID0 "E4FB94F9-7F2B-4173-AD1A-CD1D95086248"
33#define WMI_EVENT_GUID1 "023B133E-49D1-4E10-B313-698220140DC2"
34#define WMI_EVENT_GUID2 "37BE1AC0-C3F2-4B1F-BFBE-8FDEAF2814D6"
35#define WMI_EVENT_GUID3 "911BAD44-7DF8-4FBB-9319-BABA1C4B293B"
36#define WMI_METHOD_WMAB "C3A72B38-D3EF-42D3-8CBB-D5A57049F66D"
37#define WMI_METHOD_WMBB "2B4F501A-BD3C-4394-8DCF-00A7D2BC8210"
38#define WMI_EVENT_GUID WMI_EVENT_GUID0
39
40#define WMAB_METHOD "\\XINI.WMAB"
41#define WMBB_METHOD "\\XINI.WMBB"
42#define SB_GGOV_METHOD "\\_SB.GGOV"
43#define GOV_TLED 0x2020008
44#define WM_GET 1
45#define WM_SET 2
46#define WM_KEY_LIGHT 0x400
47#define WM_TLED 0x404
48#define WM_FN_LOCK 0x407
49#define WM_BATT_LIMIT 0x61
50#define WM_READER_MODE 0xBF
51#define WM_FAN_MODE 0x33
52#define WMBB_USB_CHARGE 0x10B
53#define WMBB_BATT_LIMIT 0x10C
54
55#define PLATFORM_NAME "lg-laptop"
56
57MODULE_ALIAS("wmi:" WMI_EVENT_GUID0);
58MODULE_ALIAS("wmi:" WMI_EVENT_GUID1);
59MODULE_ALIAS("wmi:" WMI_EVENT_GUID2);
60MODULE_ALIAS("wmi:" WMI_EVENT_GUID3);
61MODULE_ALIAS("wmi:" WMI_METHOD_WMAB);
62MODULE_ALIAS("wmi:" WMI_METHOD_WMBB);
63MODULE_ALIAS("acpi*:LGEX0815:*");
64
65static struct platform_device *pf_device;
66static struct input_dev *wmi_input_dev;
67
68static u32 inited;
69#define INIT_INPUT_WMI_0 0x01
70#define INIT_INPUT_WMI_2 0x02
71#define INIT_INPUT_ACPI 0x04
72#define INIT_SPARSE_KEYMAP 0x80
73
74static int battery_limit_use_wmbb;
75static struct led_classdev kbd_backlight;
76static enum led_brightness get_kbd_backlight_level(void);
77
78static const struct key_entry wmi_keymap[] = {
79 {KE_KEY, 0x70, {KEY_F15} },
80 {KE_KEY, 0x74, {KEY_F21} },
81 {KE_KEY, 0xf020000, {KEY_F14} },
82 {KE_KEY, 0x10000000, {KEY_F16} },
83
84
85
86 {KE_KEY, 0x80, {KEY_RFKILL} },
87 {KE_END, 0}
88};
89
90static int ggov(u32 arg0)
91{
92 union acpi_object args[1];
93 union acpi_object *r;
94 acpi_status status;
95 acpi_handle handle;
96 struct acpi_object_list arg;
97 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
98 int res;
99
100 args[0].type = ACPI_TYPE_INTEGER;
101 args[0].integer.value = arg0;
102
103 status = acpi_get_handle(NULL, (acpi_string) SB_GGOV_METHOD, &handle);
104 if (ACPI_FAILURE(status)) {
105 pr_err("Cannot get handle");
106 return -ENODEV;
107 }
108
109 arg.count = 1;
110 arg.pointer = args;
111
112 status = acpi_evaluate_object(handle, NULL, &arg, &buffer);
113 if (ACPI_FAILURE(status)) {
114 acpi_handle_err(handle, "GGOV: call failed.\n");
115 return -EINVAL;
116 }
117
118 r = buffer.pointer;
119 if (r->type != ACPI_TYPE_INTEGER) {
120 kfree(r);
121 return -EINVAL;
122 }
123
124 res = r->integer.value;
125 kfree(r);
126
127 return res;
128}
129
130static union acpi_object *lg_wmab(u32 method, u32 arg1, u32 arg2)
131{
132 union acpi_object args[3];
133 acpi_status status;
134 acpi_handle handle;
135 struct acpi_object_list arg;
136 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
137
138 args[0].type = ACPI_TYPE_INTEGER;
139 args[0].integer.value = method;
140 args[1].type = ACPI_TYPE_INTEGER;
141 args[1].integer.value = arg1;
142 args[2].type = ACPI_TYPE_INTEGER;
143 args[2].integer.value = arg2;
144
145 status = acpi_get_handle(NULL, (acpi_string) WMAB_METHOD, &handle);
146 if (ACPI_FAILURE(status)) {
147 pr_err("Cannot get handle");
148 return NULL;
149 }
150
151 arg.count = 3;
152 arg.pointer = args;
153
154 status = acpi_evaluate_object(handle, NULL, &arg, &buffer);
155 if (ACPI_FAILURE(status)) {
156 acpi_handle_err(handle, "WMAB: call failed.\n");
157 return NULL;
158 }
159
160 return buffer.pointer;
161}
162
163static union acpi_object *lg_wmbb(u32 method_id, u32 arg1, u32 arg2)
164{
165 union acpi_object args[3];
166 acpi_status status;
167 acpi_handle handle;
168 struct acpi_object_list arg;
169 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
170 u8 buf[32];
171
172 *(u32 *)buf = method_id;
173 *(u32 *)(buf + 4) = arg1;
174 *(u32 *)(buf + 16) = arg2;
175 args[0].type = ACPI_TYPE_INTEGER;
176 args[0].integer.value = 0;
177 args[1].type = ACPI_TYPE_INTEGER;
178 args[1].integer.value = 1;
179 args[2].type = ACPI_TYPE_BUFFER;
180 args[2].buffer.length = 32;
181 args[2].buffer.pointer = buf;
182
183 status = acpi_get_handle(NULL, (acpi_string)WMBB_METHOD, &handle);
184 if (ACPI_FAILURE(status)) {
185 pr_err("Cannot get handle");
186 return NULL;
187 }
188
189 arg.count = 3;
190 arg.pointer = args;
191
192 status = acpi_evaluate_object(handle, NULL, &arg, &buffer);
193 if (ACPI_FAILURE(status)) {
194 acpi_handle_err(handle, "WMAB: call failed.\n");
195 return NULL;
196 }
197
198 return (union acpi_object *)buffer.pointer;
199}
200
201static void wmi_notify(u32 value, void *context)
202{
203 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
204 union acpi_object *obj;
205 acpi_status status;
206 long data = (long)context;
207
208 pr_debug("event guid %li\n", data);
209 status = wmi_get_event_data(value, &response);
210 if (ACPI_FAILURE(status)) {
211 pr_err("Bad event status 0x%x\n", status);
212 return;
213 }
214
215 obj = (union acpi_object *)response.pointer;
216 if (!obj)
217 return;
218
219 if (obj->type == ACPI_TYPE_INTEGER) {
220 int eventcode = obj->integer.value;
221 struct key_entry *key;
222
223 if (eventcode == 0x10000000) {
224 led_classdev_notify_brightness_hw_changed(
225 &kbd_backlight, get_kbd_backlight_level());
226 } else {
227 key = sparse_keymap_entry_from_scancode(
228 wmi_input_dev, eventcode);
229 if (key && key->type == KE_KEY)
230 sparse_keymap_report_entry(wmi_input_dev,
231 key, 1, true);
232 }
233 }
234
235 pr_debug("Type: %i Eventcode: 0x%llx\n", obj->type,
236 obj->integer.value);
237 kfree(response.pointer);
238}
239
240static void wmi_input_setup(void)
241{
242 acpi_status status;
243
244 wmi_input_dev = input_allocate_device();
245 if (wmi_input_dev) {
246 wmi_input_dev->name = "LG WMI hotkeys";
247 wmi_input_dev->phys = "wmi/input0";
248 wmi_input_dev->id.bustype = BUS_HOST;
249
250 if (sparse_keymap_setup(wmi_input_dev, wmi_keymap, NULL) ||
251 input_register_device(wmi_input_dev)) {
252 pr_info("Cannot initialize input device");
253 input_free_device(wmi_input_dev);
254 return;
255 }
256
257 inited |= INIT_SPARSE_KEYMAP;
258 status = wmi_install_notify_handler(WMI_EVENT_GUID0, wmi_notify,
259 (void *)0);
260 if (ACPI_SUCCESS(status))
261 inited |= INIT_INPUT_WMI_0;
262
263 status = wmi_install_notify_handler(WMI_EVENT_GUID2, wmi_notify,
264 (void *)2);
265 if (ACPI_SUCCESS(status))
266 inited |= INIT_INPUT_WMI_2;
267 } else {
268 pr_info("Cannot allocate input device");
269 }
270}
271
272static void acpi_notify(struct acpi_device *device, u32 event)
273{
274 struct key_entry *key;
275
276 acpi_handle_debug(device->handle, "notify: %d\n", event);
277 if (inited & INIT_SPARSE_KEYMAP) {
278 key = sparse_keymap_entry_from_scancode(wmi_input_dev, 0x80);
279 if (key && key->type == KE_KEY)
280 sparse_keymap_report_entry(wmi_input_dev, key, 1, true);
281 }
282}
283
284static ssize_t fan_mode_store(struct device *dev,
285 struct device_attribute *attr,
286 const char *buffer, size_t count)
287{
288 bool value;
289 union acpi_object *r;
290 u32 m;
291 int ret;
292
293 ret = kstrtobool(buffer, &value);
294 if (ret)
295 return ret;
296
297 r = lg_wmab(WM_FAN_MODE, WM_GET, 0);
298 if (!r)
299 return -EIO;
300
301 if (r->type != ACPI_TYPE_INTEGER) {
302 kfree(r);
303 return -EIO;
304 }
305
306 m = r->integer.value;
307 kfree(r);
308 r = lg_wmab(WM_FAN_MODE, WM_SET, (m & 0xffffff0f) | (value << 4));
309 kfree(r);
310 r = lg_wmab(WM_FAN_MODE, WM_SET, (m & 0xfffffff0) | value);
311 kfree(r);
312
313 return count;
314}
315
316static ssize_t fan_mode_show(struct device *dev,
317 struct device_attribute *attr, char *buffer)
318{
319 unsigned int status;
320 union acpi_object *r;
321
322 r = lg_wmab(WM_FAN_MODE, WM_GET, 0);
323 if (!r)
324 return -EIO;
325
326 if (r->type != ACPI_TYPE_INTEGER) {
327 kfree(r);
328 return -EIO;
329 }
330
331 status = r->integer.value & 0x01;
332 kfree(r);
333
334 return snprintf(buffer, PAGE_SIZE, "%d\n", status);
335}
336
337static ssize_t usb_charge_store(struct device *dev,
338 struct device_attribute *attr,
339 const char *buffer, size_t count)
340{
341 bool value;
342 union acpi_object *r;
343 int ret;
344
345 ret = kstrtobool(buffer, &value);
346 if (ret)
347 return ret;
348
349 r = lg_wmbb(WMBB_USB_CHARGE, WM_SET, value);
350 if (!r)
351 return -EIO;
352
353 kfree(r);
354 return count;
355}
356
357static ssize_t usb_charge_show(struct device *dev,
358 struct device_attribute *attr, char *buffer)
359{
360 unsigned int status;
361 union acpi_object *r;
362
363 r = lg_wmbb(WMBB_USB_CHARGE, WM_GET, 0);
364 if (!r)
365 return -EIO;
366
367 if (r->type != ACPI_TYPE_BUFFER) {
368 kfree(r);
369 return -EIO;
370 }
371
372 status = !!r->buffer.pointer[0x10];
373
374 kfree(r);
375
376 return snprintf(buffer, PAGE_SIZE, "%d\n", status);
377}
378
379static ssize_t reader_mode_store(struct device *dev,
380 struct device_attribute *attr,
381 const char *buffer, size_t count)
382{
383 bool value;
384 union acpi_object *r;
385 int ret;
386
387 ret = kstrtobool(buffer, &value);
388 if (ret)
389 return ret;
390
391 r = lg_wmab(WM_READER_MODE, WM_SET, value);
392 if (!r)
393 return -EIO;
394
395 kfree(r);
396 return count;
397}
398
399static ssize_t reader_mode_show(struct device *dev,
400 struct device_attribute *attr, char *buffer)
401{
402 unsigned int status;
403 union acpi_object *r;
404
405 r = lg_wmab(WM_READER_MODE, WM_GET, 0);
406 if (!r)
407 return -EIO;
408
409 if (r->type != ACPI_TYPE_INTEGER) {
410 kfree(r);
411 return -EIO;
412 }
413
414 status = !!r->integer.value;
415
416 kfree(r);
417
418 return snprintf(buffer, PAGE_SIZE, "%d\n", status);
419}
420
421static ssize_t fn_lock_store(struct device *dev,
422 struct device_attribute *attr,
423 const char *buffer, size_t count)
424{
425 bool value;
426 union acpi_object *r;
427 int ret;
428
429 ret = kstrtobool(buffer, &value);
430 if (ret)
431 return ret;
432
433 r = lg_wmab(WM_FN_LOCK, WM_SET, value);
434 if (!r)
435 return -EIO;
436
437 kfree(r);
438 return count;
439}
440
441static ssize_t fn_lock_show(struct device *dev,
442 struct device_attribute *attr, char *buffer)
443{
444 unsigned int status;
445 union acpi_object *r;
446
447 r = lg_wmab(WM_FN_LOCK, WM_GET, 0);
448 if (!r)
449 return -EIO;
450
451 if (r->type != ACPI_TYPE_BUFFER) {
452 kfree(r);
453 return -EIO;
454 }
455
456 status = !!r->buffer.pointer[0];
457 kfree(r);
458
459 return snprintf(buffer, PAGE_SIZE, "%d\n", status);
460}
461
462static ssize_t battery_care_limit_store(struct device *dev,
463 struct device_attribute *attr,
464 const char *buffer, size_t count)
465{
466 unsigned long value;
467 int ret;
468
469 ret = kstrtoul(buffer, 10, &value);
470 if (ret)
471 return ret;
472
473 if (value == 100 || value == 80) {
474 union acpi_object *r;
475
476 if (battery_limit_use_wmbb)
477 r = lg_wmbb(WMBB_BATT_LIMIT, WM_SET, value);
478 else
479 r = lg_wmab(WM_BATT_LIMIT, WM_SET, value);
480 if (!r)
481 return -EIO;
482
483 kfree(r);
484 return count;
485 }
486
487 return -EINVAL;
488}
489
490static ssize_t battery_care_limit_show(struct device *dev,
491 struct device_attribute *attr,
492 char *buffer)
493{
494 unsigned int status;
495 union acpi_object *r;
496
497 if (battery_limit_use_wmbb) {
498 r = lg_wmbb(WMBB_BATT_LIMIT, WM_GET, 0);
499 if (!r)
500 return -EIO;
501
502 if (r->type != ACPI_TYPE_BUFFER) {
503 kfree(r);
504 return -EIO;
505 }
506
507 status = r->buffer.pointer[0x10];
508 } else {
509 r = lg_wmab(WM_BATT_LIMIT, WM_GET, 0);
510 if (!r)
511 return -EIO;
512
513 if (r->type != ACPI_TYPE_INTEGER) {
514 kfree(r);
515 return -EIO;
516 }
517
518 status = r->integer.value;
519 }
520 kfree(r);
521 if (status != 80 && status != 100)
522 status = 0;
523
524 return snprintf(buffer, PAGE_SIZE, "%d\n", status);
525}
526
527static DEVICE_ATTR_RW(fan_mode);
528static DEVICE_ATTR_RW(usb_charge);
529static DEVICE_ATTR_RW(reader_mode);
530static DEVICE_ATTR_RW(fn_lock);
531static DEVICE_ATTR_RW(battery_care_limit);
532
533static struct attribute *dev_attributes[] = {
534 &dev_attr_fan_mode.attr,
535 &dev_attr_usb_charge.attr,
536 &dev_attr_reader_mode.attr,
537 &dev_attr_fn_lock.attr,
538 &dev_attr_battery_care_limit.attr,
539 NULL
540};
541
542static const struct attribute_group dev_attribute_group = {
543 .attrs = dev_attributes,
544};
545
546static void tpad_led_set(struct led_classdev *cdev,
547 enum led_brightness brightness)
548{
549 union acpi_object *r;
550
551 r = lg_wmab(WM_TLED, WM_SET, brightness > LED_OFF);
552 kfree(r);
553}
554
555static enum led_brightness tpad_led_get(struct led_classdev *cdev)
556{
557 return ggov(GOV_TLED) > 0 ? LED_ON : LED_OFF;
558}
559
560static LED_DEVICE(tpad_led, 1, 0);
561
562static void kbd_backlight_set(struct led_classdev *cdev,
563 enum led_brightness brightness)
564{
565 u32 val;
566 union acpi_object *r;
567
568 val = 0x22;
569 if (brightness <= LED_OFF)
570 val = 0;
571 if (brightness >= LED_FULL)
572 val = 0x24;
573 r = lg_wmab(WM_KEY_LIGHT, WM_SET, val);
574 kfree(r);
575}
576
577static enum led_brightness get_kbd_backlight_level(void)
578{
579 union acpi_object *r;
580 int val;
581
582 r = lg_wmab(WM_KEY_LIGHT, WM_GET, 0);
583
584 if (!r)
585 return LED_OFF;
586
587 if (r->type != ACPI_TYPE_BUFFER || r->buffer.pointer[1] != 0x05) {
588 kfree(r);
589 return LED_OFF;
590 }
591
592 switch (r->buffer.pointer[0] & 0x27) {
593 case 0x24:
594 val = LED_FULL;
595 break;
596 case 0x22:
597 val = LED_HALF;
598 break;
599 default:
600 val = LED_OFF;
601 }
602
603 kfree(r);
604
605 return val;
606}
607
608static enum led_brightness kbd_backlight_get(struct led_classdev *cdev)
609{
610 return get_kbd_backlight_level();
611}
612
613static LED_DEVICE(kbd_backlight, 255, LED_BRIGHT_HW_CHANGED);
614
615static void wmi_input_destroy(void)
616{
617 if (inited & INIT_INPUT_WMI_2)
618 wmi_remove_notify_handler(WMI_EVENT_GUID2);
619
620 if (inited & INIT_INPUT_WMI_0)
621 wmi_remove_notify_handler(WMI_EVENT_GUID0);
622
623 if (inited & INIT_SPARSE_KEYMAP)
624 input_unregister_device(wmi_input_dev);
625
626 inited &= ~(INIT_INPUT_WMI_0 | INIT_INPUT_WMI_2 | INIT_SPARSE_KEYMAP);
627}
628
629static struct platform_driver pf_driver = {
630 .driver = {
631 .name = PLATFORM_NAME,
632 }
633};
634
635static int acpi_add(struct acpi_device *device)
636{
637 int ret;
638 const char *product;
639 int year = 2017;
640
641 if (pf_device)
642 return 0;
643
644 ret = platform_driver_register(&pf_driver);
645 if (ret)
646 return ret;
647
648 pf_device = platform_device_register_simple(PLATFORM_NAME,
649 PLATFORM_DEVID_NONE,
650 NULL, 0);
651 if (IS_ERR(pf_device)) {
652 ret = PTR_ERR(pf_device);
653 pf_device = NULL;
654 pr_err("unable to register platform device\n");
655 goto out_platform_registered;
656 }
657 product = dmi_get_system_info(DMI_PRODUCT_NAME);
658 if (product && strlen(product) > 4)
659 switch (product[4]) {
660 case '5':
661 case '6':
662 year = 2016;
663 break;
664 case '7':
665 year = 2017;
666 break;
667 case '8':
668 year = 2018;
669 break;
670 case '9':
671 year = 2019;
672 break;
673 case '0':
674 if (strlen(product) > 5)
675 switch (product[5]) {
676 case 'N':
677 year = 2020;
678 break;
679 case 'P':
680 year = 2021;
681 break;
682 default:
683 year = 2022;
684 }
685 break;
686 default:
687 year = 2019;
688 }
689 pr_info("product: %s year: %d\n", product, year);
690
691 if (year >= 2019)
692 battery_limit_use_wmbb = 1;
693
694 ret = sysfs_create_group(&pf_device->dev.kobj, &dev_attribute_group);
695 if (ret)
696 goto out_platform_device;
697
698
699 led_classdev_register(&pf_device->dev, &kbd_backlight);
700 led_classdev_register(&pf_device->dev, &tpad_led);
701
702 wmi_input_setup();
703
704 return 0;
705
706out_platform_device:
707 platform_device_unregister(pf_device);
708out_platform_registered:
709 platform_driver_unregister(&pf_driver);
710 return ret;
711}
712
713static int acpi_remove(struct acpi_device *device)
714{
715 sysfs_remove_group(&pf_device->dev.kobj, &dev_attribute_group);
716
717 led_classdev_unregister(&tpad_led);
718 led_classdev_unregister(&kbd_backlight);
719
720 wmi_input_destroy();
721 platform_device_unregister(pf_device);
722 pf_device = NULL;
723 platform_driver_unregister(&pf_driver);
724
725 return 0;
726}
727
728static const struct acpi_device_id device_ids[] = {
729 {"LGEX0815", 0},
730 {"", 0}
731};
732MODULE_DEVICE_TABLE(acpi, device_ids);
733
734static struct acpi_driver acpi_driver = {
735 .name = "LG Gram Laptop Support",
736 .class = "lg-laptop",
737 .ids = device_ids,
738 .ops = {
739 .add = acpi_add,
740 .remove = acpi_remove,
741 .notify = acpi_notify,
742 },
743 .owner = THIS_MODULE,
744};
745
746static int __init acpi_init(void)
747{
748 int result;
749
750 result = acpi_bus_register_driver(&acpi_driver);
751 if (result < 0) {
752 pr_debug("Error registering driver\n");
753 return -ENODEV;
754 }
755
756 return 0;
757}
758
759static void __exit acpi_exit(void)
760{
761 acpi_bus_unregister_driver(&acpi_driver);
762}
763
764module_init(acpi_init);
765module_exit(acpi_exit);
766