1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * lg-laptop.c - LG Gram ACPI features and hotkeys Driver
4 *
5 * Copyright (C) 2018 Matan Ziv-Av <matan@svgalib.org>
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
28 MODULE_AUTHOR("Matan Ziv-Av");
29 MODULE_DESCRIPTION("LG WMI Hotkey Driver");
30 MODULE_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
57 MODULE_ALIAS("wmi:" WMI_EVENT_GUID0);
58 MODULE_ALIAS("wmi:" WMI_EVENT_GUID1);
59 MODULE_ALIAS("wmi:" WMI_EVENT_GUID2);
60 MODULE_ALIAS("wmi:" WMI_EVENT_GUID3);
61 MODULE_ALIAS("wmi:" WMI_METHOD_WMAB);
62 MODULE_ALIAS("wmi:" WMI_METHOD_WMBB);
63 MODULE_ALIAS("acpi*:LGEX0815:*");
64
65 static struct platform_device *pf_device;
66 static struct input_dev *wmi_input_dev;
67
68 static 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
74 static int battery_limit_use_wmbb;
75 static struct led_classdev kbd_backlight;
76 static enum led_brightness get_kbd_backlight_level(void);
77
78 static const struct key_entry wmi_keymap[] = {
79 {KE_KEY, 0x70, {KEY_F15} }, /* LG control panel (F1) */
80 {KE_KEY, 0x74, {KEY_F21} }, /* Touchpad toggle (F5) */
81 {KE_KEY, 0xf020000, {KEY_F14} }, /* Read mode (F9) */
82 {KE_KEY, 0x10000000, {KEY_F16} },/* Keyboard backlight (F8) - pressing
83 * this key both sends an event and
84 * changes backlight level.
85 */
86 {KE_KEY, 0x80, {KEY_RFKILL} },
87 {KE_END, 0}
88 };
89
ggov(u32 arg0)90 static 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
lg_wmab(u32 method,u32 arg1,u32 arg2)130 static 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
lg_wmbb(u32 method_id,u32 arg1,u32 arg2)163 static 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; /* ignored */
177 args[1].type = ACPI_TYPE_INTEGER;
178 args[1].integer.value = 1; /* Must be 1 or 2. Does not matter which */
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
wmi_notify(u32 value,void * context)201 static 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
wmi_input_setup(void)240 static 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
acpi_notify(struct acpi_device * device,u32 event)272 static 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
fan_mode_store(struct device * dev,struct device_attribute * attr,const char * buffer,size_t count)284 static 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
fan_mode_show(struct device * dev,struct device_attribute * attr,char * buffer)316 static 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
usb_charge_store(struct device * dev,struct device_attribute * attr,const char * buffer,size_t count)337 static 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
usb_charge_show(struct device * dev,struct device_attribute * attr,char * buffer)357 static 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
reader_mode_store(struct device * dev,struct device_attribute * attr,const char * buffer,size_t count)379 static 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
reader_mode_show(struct device * dev,struct device_attribute * attr,char * buffer)399 static 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
fn_lock_store(struct device * dev,struct device_attribute * attr,const char * buffer,size_t count)421 static 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
fn_lock_show(struct device * dev,struct device_attribute * attr,char * buffer)441 static 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
battery_care_limit_store(struct device * dev,struct device_attribute * attr,const char * buffer,size_t count)462 static 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
battery_care_limit_show(struct device * dev,struct device_attribute * attr,char * buffer)490 static 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
527 static DEVICE_ATTR_RW(fan_mode);
528 static DEVICE_ATTR_RW(usb_charge);
529 static DEVICE_ATTR_RW(reader_mode);
530 static DEVICE_ATTR_RW(fn_lock);
531 static DEVICE_ATTR_RW(battery_care_limit);
532
533 static 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
542 static const struct attribute_group dev_attribute_group = {
543 .attrs = dev_attributes,
544 };
545
tpad_led_set(struct led_classdev * cdev,enum led_brightness brightness)546 static 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
tpad_led_get(struct led_classdev * cdev)555 static enum led_brightness tpad_led_get(struct led_classdev *cdev)
556 {
557 return ggov(GOV_TLED) > 0 ? LED_ON : LED_OFF;
558 }
559
560 static LED_DEVICE(tpad_led, 1, 0);
561
kbd_backlight_set(struct led_classdev * cdev,enum led_brightness brightness)562 static 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
get_kbd_backlight_level(void)577 static 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
kbd_backlight_get(struct led_classdev * cdev)608 static enum led_brightness kbd_backlight_get(struct led_classdev *cdev)
609 {
610 return get_kbd_backlight_level();
611 }
612
613 static LED_DEVICE(kbd_backlight, 255, LED_BRIGHT_HW_CHANGED);
614
wmi_input_destroy(void)615 static 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
629 static struct platform_driver pf_driver = {
630 .driver = {
631 .name = PLATFORM_NAME,
632 }
633 };
634
acpi_add(struct acpi_device * device)635 static 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 /* LEDs are optional */
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
706 out_platform_device:
707 platform_device_unregister(pf_device);
708 out_platform_registered:
709 platform_driver_unregister(&pf_driver);
710 return ret;
711 }
712
acpi_remove(struct acpi_device * device)713 static 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
728 static const struct acpi_device_id device_ids[] = {
729 {"LGEX0815", 0},
730 {"", 0}
731 };
732 MODULE_DEVICE_TABLE(acpi, device_ids);
733
734 static 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
acpi_init(void)746 static 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
acpi_exit(void)759 static void __exit acpi_exit(void)
760 {
761 acpi_bus_unregister_driver(&acpi_driver);
762 }
763
764 module_init(acpi_init);
765 module_exit(acpi_exit);
766