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