drivers/platform/x86/huawei-wmi.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Huawei WMI laptop extras driver
   4  *
   5  *  Copyright (C) 2018        Ayman Bagabas <[email protected]>
   6  */
   7
   8 #include <linux/acpi.h>
   9 #include <linux/debugfs.h>
  10 #include <linux/delay.h>
  11 #include <linux/dmi.h>
  12 #include <linux/input.h>
  13 #include <linux/input/sparse-keymap.h>
  14 #include <linux/leds.h>
  15 #include <linux/module.h>
  16 #include <linux/mutex.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/power_supply.h>
  19 #include <linux/sysfs.h>
  20 #include <linux/wmi.h>
  21 #include <acpi/battery.h>
  22
  23 /*
  24  * Huawei WMI GUIDs
  25  */
  26 #define HWMI_METHOD_GUID "ABBC0F5B-8EA1-11D1-A000-C90629100000"
  27 #define HWMI_EVENT_GUID "ABBC0F5C-8EA1-11D1-A000-C90629100000"
  28
  29 /* Legacy GUIDs */
  30 #define WMI0_EXPENSIVE_GUID "39142400-C6A3-40fa-BADB-8A2652834100"
  31 #define WMI0_EVENT_GUID "59142400-C6A3-40fa-BADB-8A2652834100"
  32
  33 /* HWMI commands */
  34
  35 enum {
  36         BATTERY_THRESH_GET              = 0x00001103, /* \GBTT */
  37         BATTERY_THRESH_SET              = 0x00001003, /* \SBTT */
  38         FN_LOCK_GET                     = 0x00000604, /* \GFRS */
  39         FN_LOCK_SET                     = 0x00000704, /* \SFRS */
  40         MICMUTE_LED_SET                 = 0x00000b04, /* \SMLS */
  41 };
  42
  43 union hwmi_arg {
  44         u64 cmd;
  45         u8 args[8];
  46 };
  47
  48 struct quirk_entry {
  49         bool battery_reset;
  50         bool ec_micmute;
  51         bool report_brightness;
  52 };
  53
  54 static struct quirk_entry *quirks;
  55
  56 struct huawei_wmi_debug {
  57         struct dentry *root;
  58         u64 arg;
  59 };
  60
  61 struct huawei_wmi {
  62         bool battery_available;
  63         bool fn_lock_available;
  64
  65         struct huawei_wmi_debug debug;
  66         struct led_classdev cdev;
  67         struct device *dev;
  68
  69         struct mutex wmi_lock;
  70 };
  71
  72 static struct huawei_wmi *huawei_wmi;
  73
  74 static const struct key_entry huawei_wmi_keymap[] = {
  75         { KE_KEY,    0x281, { KEY_BRIGHTNESSDOWN } },
  76         { KE_KEY,    0x282, { KEY_BRIGHTNESSUP } },
  77         { KE_KEY,    0x284, { KEY_MUTE } },
  78         { KE_KEY,    0x285, { KEY_VOLUMEDOWN } },
  79         { KE_KEY,    0x286, { KEY_VOLUMEUP } },
  80         { KE_KEY,    0x287, { KEY_MICMUTE } },
  81         { KE_KEY,    0x289, { KEY_WLAN } },
  82         // Huawei |M| key
  83         { KE_KEY,    0x28a, { KEY_CONFIG } },
  84         // Keyboard backlit
  85         { KE_IGNORE, 0x293, { KEY_KBDILLUMTOGGLE } },
  86         { KE_IGNORE, 0x294, { KEY_KBDILLUMUP } },
  87         { KE_IGNORE, 0x295, { KEY_KBDILLUMUP } },
  88         // Ignore Ambient Light Sensoring
  89         { KE_KEY,    0x2c1, { KEY_RESERVED } },
  90         { KE_END,        0 }
  91 };
  92
  93 static int battery_reset = -1;
  94 static int report_brightness = -1;
  95
  96 module_param(battery_reset, bint, 0444);
  97 MODULE_PARM_DESC(battery_reset,
  98                 "Reset battery charge values to (0-0) before disabling it using (0-100)");
  99 module_param(report_brightness, bint, 0444);
 100 MODULE_PARM_DESC(report_brightness,
 101                 "Report brightness keys.");
 102
 103 /* Quirks */
 104
 105 static int __init dmi_matched(const struct dmi_system_id *dmi)
 106 {
 107         quirks = dmi->driver_data;
 108         return 1;
 109 }
 110
 111 static struct quirk_entry quirk_unknown = {
 112 };
 113
 114 static struct quirk_entry quirk_battery_reset = {
 115         .battery_reset = true,
 116 };
 117
 118 static struct quirk_entry quirk_matebook_x = {
 119         .ec_micmute = true,
 120         .report_brightness = true,
 121 };
 122
 123 static const struct dmi_system_id huawei_quirks[] = {
 124         {
 125                 .callback = dmi_matched,
 126                 .ident = "Huawei MACH-WX9",
 127                 .matches = {
 128                         DMI_MATCH(DMI_SYS_VENDOR, "HUAWEI"),
 129                         DMI_MATCH(DMI_PRODUCT_NAME, "MACH-WX9"),
 130                 },
 131                 .driver_data = &quirk_battery_reset
 132         },
 133         {
 134                 .callback = dmi_matched,
 135                 .ident = "Huawei MateBook X",
 136                 .matches = {
 137                         DMI_MATCH(DMI_SYS_VENDOR, "HUAWEI"),
 138                         DMI_MATCH(DMI_PRODUCT_NAME, "HUAWEI MateBook X")
 139                 },
 140                 .driver_data = &quirk_matebook_x
 141         },
 142         {  }
 143 };
 144
 145 /* Utils */
 146
 147 static int huawei_wmi_call(struct huawei_wmi *huawei,
 148                            struct acpi_buffer *in, struct acpi_buffer *out)
 149 {
 150         acpi_status status;
 151
 152         mutex_lock(&huawei->wmi_lock);
 153         status = wmi_evaluate_method(HWMI_METHOD_GUID, 0, 1, in, out);
 154         mutex_unlock(&huawei->wmi_lock);
 155         if (ACPI_FAILURE(status)) {
 156                 dev_err(huawei->dev, "Failed to evaluate wmi method\n");
 157                 return -ENODEV;
 158         }
 159
 160         return 0;
 161 }
 162
 163 /* HWMI takes a 64 bit input and returns either a package with 2 buffers, one of
 164  * 4 bytes and the other of 256 bytes, or one buffer of size 0x104 (260) bytes.
 165  * The first 4 bytes are ignored, we ignore the first 4 bytes buffer if we got a
 166  * package, or skip the first 4 if a buffer of 0x104 is used. The first byte of
 167  * the remaining 0x100 sized buffer has the return status of every call. In case
 168  * the return status is non-zero, we return -ENODEV but still copy the returned
 169  * buffer to the given buffer parameter (buf).
 170  */
 171 static int huawei_wmi_cmd(u64 arg, u8 *buf, size_t buflen)
 172 {
 173         struct huawei_wmi *huawei = huawei_wmi;
 174         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
 175         struct acpi_buffer in;
 176         union acpi_object *obj;
 177         size_t len;
 178         int err, i;
 179
 180         in.length = sizeof(arg);
 181         in.pointer = &arg;
 182
 183         /* Some models require calling HWMI twice to execute a command. We evaluate
 184          * HWMI and if we get a non-zero return status we evaluate it again.
 185          */
 186         for (i = 0; i < 2; i++) {
 187                 err = huawei_wmi_call(huawei, &in, &out);
 188                 if (err)
 189                         goto fail_cmd;
 190
 191                 obj = out.pointer;
 192                 if (!obj) {
 193                         err = -EIO;
 194                         goto fail_cmd;
 195                 }
 196
 197                 switch (obj->type) {
 198                 /* Models that implement both "legacy" and HWMI tend to return a 0x104
 199                  * sized buffer instead of a package of 0x4 and 0x100 buffers.
 200                  */
 201                 case ACPI_TYPE_BUFFER:
 202                         if (obj->buffer.length == 0x104) {
 203                                 // Skip the first 4 bytes.
 204                                 obj->buffer.pointer += 4;
 205                                 len = 0x100;
 206                         } else {
 207                                 dev_err(huawei->dev, "Bad buffer length, got %d\n", obj->buffer.length);
 208                                 err = -EIO;
 209                                 goto fail_cmd;
 210                         }
 211
 212                         break;
 213                 /* HWMI returns a package with 2 buffer elements, one of 4 bytes and the
 214                  * other is 256 bytes.
 215                  */
 216                 case ACPI_TYPE_PACKAGE:
 217                         if (obj->package.count != 2) {
 218                                 dev_err(huawei->dev, "Bad package count, got %d\n", obj->package.count);
 219                                 err = -EIO;
 220                                 goto fail_cmd;
 221                         }
 222
 223                         obj = &obj->package.elements[1];
 224                         if (obj->type != ACPI_TYPE_BUFFER) {
 225                                 dev_err(huawei->dev, "Bad package element type, got %d\n", obj->type);
 226                                 err = -EIO;
 227                                 goto fail_cmd;
 228                         }
 229                         len = obj->buffer.length;
 230
 231                         break;
 232                 /* Shouldn't get here! */
 233                 default:
 234                         dev_err(huawei->dev, "Unexpected obj type, got: %d\n", obj->type);
 235                         err = -EIO;
 236                         goto fail_cmd;
 237                 }
 238
 239                 if (!*obj->buffer.pointer)
 240                         break;
 241         }
 242
 243         err = (*obj->buffer.pointer) ? -ENODEV : 0;
 244
 245         if (buf) {
 246                 len = min(buflen, len);
 247                 memcpy(buf, obj->buffer.pointer, len);
 248         }
 249
 250 fail_cmd:
 251         kfree(out.pointer);
 252         return err;
 253 }
 254
 255 /* LEDs */
 256
 257 static int huawei_wmi_micmute_led_set(struct led_classdev *led_cdev,
 258                 enum led_brightness brightness)
 259 {
 260         /* This is a workaround until the "legacy" interface is implemented. */
 261         if (quirks && quirks->ec_micmute) {
 262                 char *acpi_method;
 263                 acpi_handle handle;
 264                 acpi_status status;
 265                 union acpi_object args[3];
 266                 struct acpi_object_list arg_list = {
 267                         .pointer = args,
 268                         .count = ARRAY_SIZE(args),
 269                 };
 270
 271                 handle = ec_get_handle();
 272                 if (!handle)
 273                         return -ENODEV;
 274
 275                 args[0].type = args[1].type = args[2].type = ACPI_TYPE_INTEGER;
 276                 args[1].integer.value = 0x04;
 277
 278                 if (acpi_has_method(handle, "SPIN")) {
 279                         acpi_method = "SPIN";
 280                         args[0].integer.value = 0;
 281                         args[2].integer.value = brightness ? 1 : 0;
 282                 } else if (acpi_has_method(handle, "WPIN")) {
 283                         acpi_method = "WPIN";
 284                         args[0].integer.value = 1;
 285                         args[2].integer.value = brightness ? 0 : 1;
 286                 } else {
 287                         return -ENODEV;
 288                 }
 289
 290                 status = acpi_evaluate_object(handle, acpi_method, &arg_list, NULL);
 291                 if (ACPI_FAILURE(status))
 292                         return -ENODEV;
 293
 294                 return 0;
 295         } else {
 296                 union hwmi_arg arg;
 297
 298                 arg.cmd = MICMUTE_LED_SET;
 299                 arg.args[2] = brightness;
 300
 301                 return huawei_wmi_cmd(arg.cmd, NULL, 0);
 302         }
 303 }
 304
 305 static void huawei_wmi_leds_setup(struct device *dev)
 306 {
 307         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 308
 309         huawei->cdev.name = "platform::micmute";
 310         huawei->cdev.max_brightness = 1;
 311         huawei->cdev.brightness_set_blocking = &huawei_wmi_micmute_led_set;
 312         huawei->cdev.default_trigger = "audio-micmute";
 313         huawei->cdev.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE);
 314         huawei->cdev.dev = dev;
 315         huawei->cdev.flags = LED_CORE_SUSPENDRESUME;
 316
 317         devm_led_classdev_register(dev, &huawei->cdev);
 318 }
 319
 320 /* Battery protection */
 321
 322 static int huawei_wmi_battery_get(int *start, int *end)
 323 {
 324         u8 ret[0x100];
 325         int err, i;
 326
 327         err = huawei_wmi_cmd(BATTERY_THRESH_GET, ret, sizeof(ret));
 328         if (err)
 329                 return err;
 330
 331         /* Find the last two non-zero values. Return status is ignored. */
 332         i = ARRAY_SIZE(ret) - 1;
 333         do {
 334                 if (start)
 335                         *start = ret[i-1];
 336                 if (end)
 337                         *end = ret[i];
 338         } while (i > 2 && !ret[i--]);
 339
 340         return 0;
 341 }
 342
 343 static int huawei_wmi_battery_set(int start, int end)
 344 {
 345         union hwmi_arg arg;
 346         int err;
 347
 348         if (start < 0 || end < 0 || start > 100 || end > 100)
 349                 return -EINVAL;
 350
 351         arg.cmd = BATTERY_THRESH_SET;
 352         arg.args[2] = start;
 353         arg.args[3] = end;
 354
 355         /* This is an edge case were some models turn battery protection
 356          * off without changing their thresholds values. We clear the
 357          * values before turning off protection. Sometimes we need a sleep delay to
 358          * make sure these values make their way to EC memory.
 359          */
 360         if (quirks && quirks->battery_reset && start == 0 && end == 100) {
 361                 err = huawei_wmi_battery_set(0, 0);
 362                 if (err)
 363                         return err;
 364
 365                 msleep(1000);
 366         }
 367
 368         err = huawei_wmi_cmd(arg.cmd, NULL, 0);
 369
 370         return err;
 371 }
 372
 373 static ssize_t charge_control_start_threshold_show(struct device *dev,
 374                 struct device_attribute *attr,
 375                 char *buf)
 376 {
 377         int err, start;
 378
 379         err = huawei_wmi_battery_get(&start, NULL);
 380         if (err)
 381                 return err;
 382
 383         return sprintf(buf, "%d\n", start);
 384 }
 385
 386 static ssize_t charge_control_end_threshold_show(struct device *dev,
 387                 struct device_attribute *attr,
 388                 char *buf)
 389 {
 390         int err, end;
 391
 392         err = huawei_wmi_battery_get(NULL, &end);
 393         if (err)
 394                 return err;
 395
 396         return sprintf(buf, "%d\n", end);
 397 }
 398
 399 static ssize_t charge_control_thresholds_show(struct device *dev,
 400                 struct device_attribute *attr,
 401                 char *buf)
 402 {
 403         int err, start, end;
 404
 405         err = huawei_wmi_battery_get(&start, &end);
 406         if (err)
 407                 return err;
 408
 409         return sprintf(buf, "%d %d\n", start, end);
 410 }
 411
 412 static ssize_t charge_control_start_threshold_store(struct device *dev,
 413                 struct device_attribute *attr,
 414                 const char *buf, size_t size)
 415 {
 416         int err, start, end;
 417
 418         err = huawei_wmi_battery_get(NULL, &end);
 419         if (err)
 420                 return err;
 421
 422         if (sscanf(buf, "%d", &start) != 1)
 423                 return -EINVAL;
 424
 425         err = huawei_wmi_battery_set(start, end);
 426         if (err)
 427                 return err;
 428
 429         return size;
 430 }
 431
 432 static ssize_t charge_control_end_threshold_store(struct device *dev,
 433                 struct device_attribute *attr,
 434                 const char *buf, size_t size)
 435 {
 436         int err, start, end;
 437
 438         err = huawei_wmi_battery_get(&start, NULL);
 439         if (err)
 440                 return err;
 441
 442         if (sscanf(buf, "%d", &end) != 1)
 443                 return -EINVAL;
 444
 445         err = huawei_wmi_battery_set(start, end);
 446         if (err)
 447                 return err;
 448
 449         return size;
 450 }
 451
 452 static ssize_t charge_control_thresholds_store(struct device *dev,
 453                 struct device_attribute *attr,
 454                 const char *buf, size_t size)
 455 {
 456         int err, start, end;
 457
 458         if (sscanf(buf, "%d %d", &start, &end) != 2)
 459                 return -EINVAL;
 460
 461         err = huawei_wmi_battery_set(start, end);
 462         if (err)
 463                 return err;
 464
 465         return size;
 466 }
 467
 468 static DEVICE_ATTR_RW(charge_control_start_threshold);
 469 static DEVICE_ATTR_RW(charge_control_end_threshold);
 470 static DEVICE_ATTR_RW(charge_control_thresholds);
 471
 472 static int huawei_wmi_battery_add(struct power_supply *battery, struct acpi_battery_hook *hook)
 473 {
 474         int err = 0;
 475
 476         err = device_create_file(&battery->dev, &dev_attr_charge_control_start_threshold);
 477         if (err)
 478                 return err;
 479
 480         err = device_create_file(&battery->dev, &dev_attr_charge_control_end_threshold);
 481         if (err)
 482                 device_remove_file(&battery->dev, &dev_attr_charge_control_start_threshold);
 483
 484         return err;
 485 }
 486
 487 static int huawei_wmi_battery_remove(struct power_supply *battery, struct acpi_battery_hook *hook)
 488 {
 489         device_remove_file(&battery->dev, &dev_attr_charge_control_start_threshold);
 490         device_remove_file(&battery->dev, &dev_attr_charge_control_end_threshold);
 491
 492         return 0;
 493 }
 494
 495 static struct acpi_battery_hook huawei_wmi_battery_hook = {
 496         .add_battery = huawei_wmi_battery_add,
 497         .remove_battery = huawei_wmi_battery_remove,
 498         .name = "Huawei Battery Extension"
 499 };
 500
 501 static void huawei_wmi_battery_setup(struct device *dev)
 502 {
 503         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 504
 505         huawei->battery_available = true;
 506         if (huawei_wmi_battery_get(NULL, NULL)) {
 507                 huawei->battery_available = false;
 508                 return;
 509         }
 510
 511         battery_hook_register(&huawei_wmi_battery_hook);
 512         device_create_file(dev, &dev_attr_charge_control_thresholds);
 513 }
 514
 515 static void huawei_wmi_battery_exit(struct device *dev)
 516 {
 517         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 518
 519         if (huawei->battery_available) {
 520                 battery_hook_unregister(&huawei_wmi_battery_hook);
 521                 device_remove_file(dev, &dev_attr_charge_control_thresholds);
 522         }
 523 }
 524
 525 /* Fn lock */
 526
 527 static int huawei_wmi_fn_lock_get(int *on)
 528 {
 529         u8 ret[0x100] = { 0 };
 530         int err, i;
 531
 532         err = huawei_wmi_cmd(FN_LOCK_GET, ret, 0x100);
 533         if (err)
 534                 return err;
 535
 536         /* Find the first non-zero value. Return status is ignored. */
 537         i = 1;
 538         do {
 539                 if (on)
 540                         *on = ret[i] - 1; // -1 undefined, 0 off, 1 on.
 541         } while (i < 0xff && !ret[i++]);
 542
 543         return 0;
 544 }
 545
 546 static int huawei_wmi_fn_lock_set(int on)
 547 {
 548         union hwmi_arg arg;
 549
 550         arg.cmd = FN_LOCK_SET;
 551         arg.args[2] = on + 1; // 0 undefined, 1 off, 2 on.
 552
 553         return huawei_wmi_cmd(arg.cmd, NULL, 0);
 554 }
 555
 556 static ssize_t fn_lock_state_show(struct device *dev,
 557                 struct device_attribute *attr,
 558                 char *buf)
 559 {
 560         int err, on;
 561
 562         err = huawei_wmi_fn_lock_get(&on);
 563         if (err)
 564                 return err;
 565
 566         return sprintf(buf, "%d\n", on);
 567 }
 568
 569 static ssize_t fn_lock_state_store(struct device *dev,
 570                 struct device_attribute *attr,
 571                 const char *buf, size_t size)
 572 {
 573         int on, err;
 574
 575         if (kstrtoint(buf, 10, &on) ||
 576                         on < 0 || on > 1)
 577                 return -EINVAL;
 578
 579         err = huawei_wmi_fn_lock_set(on);
 580         if (err)
 581                 return err;
 582
 583         return size;
 584 }
 585
 586 static DEVICE_ATTR_RW(fn_lock_state);
 587
 588 static void huawei_wmi_fn_lock_setup(struct device *dev)
 589 {
 590         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 591
 592         huawei->fn_lock_available = true;
 593         if (huawei_wmi_fn_lock_get(NULL)) {
 594                 huawei->fn_lock_available = false;
 595                 return;
 596         }
 597
 598         device_create_file(dev, &dev_attr_fn_lock_state);
 599 }
 600
 601 static void huawei_wmi_fn_lock_exit(struct device *dev)
 602 {
 603         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 604
 605         if (huawei->fn_lock_available)
 606                 device_remove_file(dev, &dev_attr_fn_lock_state);
 607 }
 608
 609 /* debugfs */
 610
 611 static void huawei_wmi_debugfs_call_dump(struct seq_file *m, void *data,
 612                 union acpi_object *obj)
 613 {
 614         struct huawei_wmi *huawei = m->private;
 615         int i;
 616
 617         switch (obj->type) {
 618         case ACPI_TYPE_INTEGER:
 619                 seq_printf(m, "0x%llx", obj->integer.value);
 620                 break;
 621         case ACPI_TYPE_STRING:
 622                 seq_printf(m, "\"%.*s\"", obj->string.length, obj->string.pointer);
 623                 break;
 624         case ACPI_TYPE_BUFFER:
 625                 seq_puts(m, "{");
 626                 for (i = 0; i < obj->buffer.length; i++) {
 627                         seq_printf(m, "0x%02x", obj->buffer.pointer[i]);
 628                         if (i < obj->buffer.length - 1)
 629                                 seq_puts(m, ",");
 630                 }
 631                 seq_puts(m, "}");
 632                 break;
 633         case ACPI_TYPE_PACKAGE:
 634                 seq_puts(m, "[");
 635                 for (i = 0; i < obj->package.count; i++) {
 636                         huawei_wmi_debugfs_call_dump(m, huawei, &obj->package.elements[i]);
 637                         if (i < obj->package.count - 1)
 638                                 seq_puts(m, ",");
 639                 }
 640                 seq_puts(m, "]");
 641                 break;
 642         default:
 643                 dev_err(huawei->dev, "Unexpected obj type, got %d\n", obj->type);
 644                 return;
 645         }
 646 }
 647
 648 static int huawei_wmi_debugfs_call_show(struct seq_file *m, void *data)
 649 {
 650         struct huawei_wmi *huawei = m->private;
 651         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
 652         struct acpi_buffer in;
 653         union acpi_object *obj;
 654         int err;
 655
 656         in.length = sizeof(u64);
 657         in.pointer = &huawei->debug.arg;
 658
 659         err = huawei_wmi_call(huawei, &in, &out);
 660         if (err)
 661                 return err;
 662
 663         obj = out.pointer;
 664         if (!obj) {
 665                 err = -EIO;
 666                 goto fail_debugfs_call;
 667         }
 668
 669         huawei_wmi_debugfs_call_dump(m, huawei, obj);
 670
 671 fail_debugfs_call:
 672         kfree(out.pointer);
 673         return err;
 674 }
 675
 676 DEFINE_SHOW_ATTRIBUTE(huawei_wmi_debugfs_call);
 677
 678 static void huawei_wmi_debugfs_setup(struct device *dev)
 679 {
 680         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 681
 682         huawei->debug.root = debugfs_create_dir("huawei-wmi", NULL);
 683
 684         debugfs_create_x64("arg", 0644, huawei->debug.root,
 685                 &huawei->debug.arg);
 686         debugfs_create_file("call", 0400,
 687                 huawei->debug.root, huawei, &huawei_wmi_debugfs_call_fops);
 688 }
 689
 690 static void huawei_wmi_debugfs_exit(struct device *dev)
 691 {
 692         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 693
 694         debugfs_remove_recursive(huawei->debug.root);
 695 }
 696
 697 /* Input */
 698
 699 static void huawei_wmi_process_key(struct input_dev *idev, int code)
 700 {
 701         const struct key_entry *key;
 702
 703         /*
 704          * WMI0 uses code 0x80 to indicate a hotkey event.
 705          * The actual key is fetched from the method WQ00
 706          * using WMI0_EXPENSIVE_GUID.
 707          */
 708         if (code == 0x80) {
 709                 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 710                 union acpi_object *obj;
 711                 acpi_status status;
 712
 713                 status = wmi_query_block(WMI0_EXPENSIVE_GUID, 0, &response);
 714                 if (ACPI_FAILURE(status))
 715                         return;
 716
 717                 obj = (union acpi_object *)response.pointer;
 718                 if (obj && obj->type == ACPI_TYPE_INTEGER)
 719                         code = obj->integer.value;
 720
 721                 kfree(response.pointer);
 722         }
 723
 724         key = sparse_keymap_entry_from_scancode(idev, code);
 725         if (!key) {
 726                 dev_info(&idev->dev, "Unknown key pressed, code: 0x%04x\n", code);
 727                 return;
 728         }
 729
 730         if (quirks && !quirks->report_brightness &&
 731                         (key->sw.code == KEY_BRIGHTNESSDOWN ||
 732                         key->sw.code == KEY_BRIGHTNESSUP))
 733                 return;
 734
 735         sparse_keymap_report_entry(idev, key, 1, true);
 736 }
 737
 738 static void huawei_wmi_input_notify(u32 value, void *context)
 739 {
 740         struct input_dev *idev = (struct input_dev *)context;
 741         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 742         union acpi_object *obj;
 743         acpi_status status;
 744
 745         status = wmi_get_event_data(value, &response);
 746         if (ACPI_FAILURE(status)) {
 747                 dev_err(&idev->dev, "Unable to get event data\n");
 748                 return;
 749         }
 750
 751         obj = (union acpi_object *)response.pointer;
 752         if (obj && obj->type == ACPI_TYPE_INTEGER)
 753                 huawei_wmi_process_key(idev, obj->integer.value);
 754         else
 755                 dev_err(&idev->dev, "Bad response type\n");
 756
 757         kfree(response.pointer);
 758 }
 759
 760 static int huawei_wmi_input_setup(struct device *dev, const char *guid)
 761 {
 762         struct input_dev *idev;
 763         acpi_status status;
 764         int err;
 765
 766         idev = devm_input_allocate_device(dev);
 767         if (!idev)
 768                 return -ENOMEM;
 769
 770         idev->name = "Huawei WMI hotkeys";
 771         idev->phys = "wmi/input0";
 772         idev->id.bustype = BUS_HOST;
 773         idev->dev.parent = dev;
 774
 775         err = sparse_keymap_setup(idev, huawei_wmi_keymap, NULL);
 776         if (err)
 777                 return err;
 778
 779         err = input_register_device(idev);
 780         if (err)
 781                 return err;
 782
 783         status = wmi_install_notify_handler(guid, huawei_wmi_input_notify, idev);
 784         if (ACPI_FAILURE(status))
 785                 return -EIO;
 786
 787         return 0;
 788 }
 789
 790 static void huawei_wmi_input_exit(struct device *dev, const char *guid)
 791 {
 792         wmi_remove_notify_handler(guid);
 793 }
 794
 795 /* Huawei driver */
 796
 797 static const struct wmi_device_id huawei_wmi_events_id_table[] = {
 798         { .guid_string = WMI0_EVENT_GUID },
 799         { .guid_string = HWMI_EVENT_GUID },
 800         {  }
 801 };
 802
 803 static int huawei_wmi_probe(struct platform_device *pdev)
 804 {
 805         const struct wmi_device_id *guid = huawei_wmi_events_id_table;
 806         int err;
 807
 808         platform_set_drvdata(pdev, huawei_wmi);
 809         huawei_wmi->dev = &pdev->dev;
 810
 811         while (*guid->guid_string) {
 812                 if (wmi_has_guid(guid->guid_string)) {
 813                         err = huawei_wmi_input_setup(&pdev->dev, guid->guid_string);
 814                         if (err) {
 815                                 dev_err(&pdev->dev, "Failed to setup input on %s\n", guid->guid_string);
 816                                 return err;
 817                         }
 818                 }
 819
 820                 guid++;
 821         }
 822
 823         if (wmi_has_guid(HWMI_METHOD_GUID)) {
 824                 mutex_init(&huawei_wmi->wmi_lock);
 825
 826                 huawei_wmi_leds_setup(&pdev->dev);
 827                 huawei_wmi_fn_lock_setup(&pdev->dev);
 828                 huawei_wmi_battery_setup(&pdev->dev);
 829                 huawei_wmi_debugfs_setup(&pdev->dev);
 830         }
 831
 832         return 0;
 833 }
 834
 835 static void huawei_wmi_remove(struct platform_device *pdev)
 836 {
 837         const struct wmi_device_id *guid = huawei_wmi_events_id_table;
 838
 839         while (*guid->guid_string) {
 840                 if (wmi_has_guid(guid->guid_string))
 841                         huawei_wmi_input_exit(&pdev->dev, guid->guid_string);
 842
 843                 guid++;
 844         }
 845
 846         if (wmi_has_guid(HWMI_METHOD_GUID)) {
 847                 huawei_wmi_debugfs_exit(&pdev->dev);
 848                 huawei_wmi_battery_exit(&pdev->dev);
 849                 huawei_wmi_fn_lock_exit(&pdev->dev);
 850         }
 851 }
 852
 853 static struct platform_driver huawei_wmi_driver = {
 854         .driver = {
 855                 .name = "huawei-wmi",
 856         },
 857         .probe = huawei_wmi_probe,
 858         .remove_new = huawei_wmi_remove,
 859 };
 860
 861 static __init int huawei_wmi_init(void)
 862 {
 863         struct platform_device *pdev;
 864         int err;
 865
 866         huawei_wmi = kzalloc(sizeof(struct huawei_wmi), GFP_KERNEL);
 867         if (!huawei_wmi)
 868                 return -ENOMEM;
 869
 870         quirks = &quirk_unknown;
 871         dmi_check_system(huawei_quirks);
 872         if (battery_reset != -1)
 873                 quirks->battery_reset = battery_reset;
 874         if (report_brightness != -1)
 875                 quirks->report_brightness = report_brightness;
 876
 877         err = platform_driver_register(&huawei_wmi_driver);
 878         if (err)
 879                 goto pdrv_err;
 880
 881         pdev = platform_device_register_simple("huawei-wmi", PLATFORM_DEVID_NONE, NULL, 0);
 882         if (IS_ERR(pdev)) {
 883                 err = PTR_ERR(pdev);
 884                 goto pdev_err;
 885         }
 886
 887         return 0;
 888
 889 pdev_err:
 890         platform_driver_unregister(&huawei_wmi_driver);
 891 pdrv_err:
 892         kfree(huawei_wmi);
 893         return err;
 894 }
 895
 896 static __exit void huawei_wmi_exit(void)
 897 {
 898         struct platform_device *pdev = to_platform_device(huawei_wmi->dev);
 899
 900         platform_device_unregister(pdev);
 901         platform_driver_unregister(&huawei_wmi_driver);
 902
 903         kfree(huawei_wmi);
 904 }
 905
 906 module_init(huawei_wmi_init);
 907 module_exit(huawei_wmi_exit);
 908
 909 MODULE_ALIAS("wmi:"HWMI_METHOD_GUID);
 910 MODULE_DEVICE_TABLE(wmi, huawei_wmi_events_id_table);
 911 MODULE_AUTHOR("Ayman Bagabas <[email protected]>");
 912 MODULE_DESCRIPTION("Huawei WMI laptop extras driver");
 913 MODULE_LICENSE("GPL v2");