drivers/platform/x86/lg-laptop.c

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