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 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         device_create_file(&battery->dev, &dev_attr_charge_control_start_threshold);
 474         device_create_file(&battery->dev, &dev_attr_charge_control_end_threshold);
 475
 476         return 0;
 477 }
 478
 479 static int huawei_wmi_battery_remove(struct power_supply *battery)
 480 {
 481         device_remove_file(&battery->dev, &dev_attr_charge_control_start_threshold);
 482         device_remove_file(&battery->dev, &dev_attr_charge_control_end_threshold);
 483
 484         return 0;
 485 }
 486
 487 static struct acpi_battery_hook huawei_wmi_battery_hook = {
 488         .add_battery = huawei_wmi_battery_add,
 489         .remove_battery = huawei_wmi_battery_remove,
 490         .name = "Huawei Battery Extension"
 491 };
 492
 493 static void huawei_wmi_battery_setup(struct device *dev)
 494 {
 495         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 496
 497         huawei->battery_available = true;
 498         if (huawei_wmi_battery_get(NULL, NULL)) {
 499                 huawei->battery_available = false;
 500                 return;
 501         }
 502
 503         battery_hook_register(&huawei_wmi_battery_hook);
 504         device_create_file(dev, &dev_attr_charge_control_thresholds);
 505 }
 506
 507 static void huawei_wmi_battery_exit(struct device *dev)
 508 {
 509         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 510
 511         if (huawei->battery_available) {
 512                 battery_hook_unregister(&huawei_wmi_battery_hook);
 513                 device_remove_file(dev, &dev_attr_charge_control_thresholds);
 514         }
 515 }
 516
 517 /* Fn lock */
 518
 519 static int huawei_wmi_fn_lock_get(int *on)
 520 {
 521         u8 ret[0x100] = { 0 };
 522         int err, i;
 523
 524         err = huawei_wmi_cmd(FN_LOCK_GET, ret, 0x100);
 525         if (err)
 526                 return err;
 527
 528         /* Find the first non-zero value. Return status is ignored. */
 529         i = 1;
 530         do {
 531                 if (on)
 532                         *on = ret[i] - 1; // -1 undefined, 0 off, 1 on.
 533         } while (i < 0xff && !ret[i++]);
 534
 535         return 0;
 536 }
 537
 538 static int huawei_wmi_fn_lock_set(int on)
 539 {
 540         union hwmi_arg arg;
 541
 542         arg.cmd = FN_LOCK_SET;
 543         arg.args[2] = on + 1; // 0 undefined, 1 off, 2 on.
 544
 545         return huawei_wmi_cmd(arg.cmd, NULL, 0);
 546 }
 547
 548 static ssize_t fn_lock_state_show(struct device *dev,
 549                 struct device_attribute *attr,
 550                 char *buf)
 551 {
 552         int err, on;
 553
 554         err = huawei_wmi_fn_lock_get(&on);
 555         if (err)
 556                 return err;
 557
 558         return sprintf(buf, "%d\n", on);
 559 }
 560
 561 static ssize_t fn_lock_state_store(struct device *dev,
 562                 struct device_attribute *attr,
 563                 const char *buf, size_t size)
 564 {
 565         int on, err;
 566
 567         if (kstrtoint(buf, 10, &on) ||
 568                         on < 0 || on > 1)
 569                 return -EINVAL;
 570
 571         err = huawei_wmi_fn_lock_set(on);
 572         if (err)
 573                 return err;
 574
 575         return size;
 576 }
 577
 578 static DEVICE_ATTR_RW(fn_lock_state);
 579
 580 static void huawei_wmi_fn_lock_setup(struct device *dev)
 581 {
 582         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 583
 584         huawei->fn_lock_available = true;
 585         if (huawei_wmi_fn_lock_get(NULL)) {
 586                 huawei->fn_lock_available = false;
 587                 return;
 588         }
 589
 590         device_create_file(dev, &dev_attr_fn_lock_state);
 591 }
 592
 593 static void huawei_wmi_fn_lock_exit(struct device *dev)
 594 {
 595         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 596
 597         if (huawei->fn_lock_available)
 598                 device_remove_file(dev, &dev_attr_fn_lock_state);
 599 }
 600
 601 /* debugfs */
 602
 603 static void huawei_wmi_debugfs_call_dump(struct seq_file *m, void *data,
 604                 union acpi_object *obj)
 605 {
 606         struct huawei_wmi *huawei = m->private;
 607         int i;
 608
 609         switch (obj->type) {
 610         case ACPI_TYPE_INTEGER:
 611                 seq_printf(m, "0x%llx", obj->integer.value);
 612                 break;
 613         case ACPI_TYPE_STRING:
 614                 seq_printf(m, "\"%.*s\"", obj->string.length, obj->string.pointer);
 615                 break;
 616         case ACPI_TYPE_BUFFER:
 617                 seq_puts(m, "{");
 618                 for (i = 0; i < obj->buffer.length; i++) {
 619                         seq_printf(m, "0x%02x", obj->buffer.pointer[i]);
 620                         if (i < obj->buffer.length - 1)
 621                                 seq_puts(m, ",");
 622                 }
 623                 seq_puts(m, "}");
 624                 break;
 625         case ACPI_TYPE_PACKAGE:
 626                 seq_puts(m, "[");
 627                 for (i = 0; i < obj->package.count; i++) {
 628                         huawei_wmi_debugfs_call_dump(m, huawei, &obj->package.elements[i]);
 629                         if (i < obj->package.count - 1)
 630                                 seq_puts(m, ",");
 631                 }
 632                 seq_puts(m, "]");
 633                 break;
 634         default:
 635                 dev_err(huawei->dev, "Unexpected obj type, got %d\n", obj->type);
 636                 return;
 637         }
 638 }
 639
 640 static int huawei_wmi_debugfs_call_show(struct seq_file *m, void *data)
 641 {
 642         struct huawei_wmi *huawei = m->private;
 643         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
 644         struct acpi_buffer in;
 645         union acpi_object *obj;
 646         int err;
 647
 648         in.length = sizeof(u64);
 649         in.pointer = &huawei->debug.arg;
 650
 651         err = huawei_wmi_call(huawei, &in, &out);
 652         if (err)
 653                 return err;
 654
 655         obj = out.pointer;
 656         if (!obj) {
 657                 err = -EIO;
 658                 goto fail_debugfs_call;
 659         }
 660
 661         huawei_wmi_debugfs_call_dump(m, huawei, obj);
 662
 663 fail_debugfs_call:
 664         kfree(out.pointer);
 665         return err;
 666 }
 667
 668 DEFINE_SHOW_ATTRIBUTE(huawei_wmi_debugfs_call);
 669
 670 static void huawei_wmi_debugfs_setup(struct device *dev)
 671 {
 672         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 673
 674         huawei->debug.root = debugfs_create_dir("huawei-wmi", NULL);
 675
 676         debugfs_create_x64("arg", 0644, huawei->debug.root,
 677                 &huawei->debug.arg);
 678         debugfs_create_file("call", 0400,
 679                 huawei->debug.root, huawei, &huawei_wmi_debugfs_call_fops);
 680 }
 681
 682 static void huawei_wmi_debugfs_exit(struct device *dev)
 683 {
 684         struct huawei_wmi *huawei = dev_get_drvdata(dev);
 685
 686         debugfs_remove_recursive(huawei->debug.root);
 687 }
 688
 689 /* Input */
 690
 691 static void huawei_wmi_process_key(struct input_dev *idev, int code)
 692 {
 693         const struct key_entry *key;
 694
 695         /*
 696          * WMI0 uses code 0x80 to indicate a hotkey event.
 697          * The actual key is fetched from the method WQ00
 698          * using WMI0_EXPENSIVE_GUID.
 699          */
 700         if (code == 0x80) {
 701                 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 702                 union acpi_object *obj;
 703                 acpi_status status;
 704
 705                 status = wmi_query_block(WMI0_EXPENSIVE_GUID, 0, &response);
 706                 if (ACPI_FAILURE(status))
 707                         return;
 708
 709                 obj = (union acpi_object *)response.pointer;
 710                 if (obj && obj->type == ACPI_TYPE_INTEGER)
 711                         code = obj->integer.value;
 712
 713                 kfree(response.pointer);
 714         }
 715
 716         key = sparse_keymap_entry_from_scancode(idev, code);
 717         if (!key) {
 718                 dev_info(&idev->dev, "Unknown key pressed, code: 0x%04x\n", code);
 719                 return;
 720         }
 721
 722         if (quirks && !quirks->report_brightness &&
 723                         (key->sw.code == KEY_BRIGHTNESSDOWN ||
 724                         key->sw.code == KEY_BRIGHTNESSUP))
 725                 return;
 726
 727         sparse_keymap_report_entry(idev, key, 1, true);
 728 }
 729
 730 static void huawei_wmi_input_notify(u32 value, void *context)
 731 {
 732         struct input_dev *idev = (struct input_dev *)context;
 733         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 734         union acpi_object *obj;
 735         acpi_status status;
 736
 737         status = wmi_get_event_data(value, &response);
 738         if (ACPI_FAILURE(status)) {
 739                 dev_err(&idev->dev, "Unable to get event data\n");
 740                 return;
 741         }
 742
 743         obj = (union acpi_object *)response.pointer;
 744         if (obj && obj->type == ACPI_TYPE_INTEGER)
 745                 huawei_wmi_process_key(idev, obj->integer.value);
 746         else
 747                 dev_err(&idev->dev, "Bad response type\n");
 748
 749         kfree(response.pointer);
 750 }
 751
 752 static int huawei_wmi_input_setup(struct device *dev,
 753                 const char *guid,
 754                 struct input_dev **idev)
 755 {
 756         *idev = devm_input_allocate_device(dev);
 757         if (!*idev)
 758                 return -ENOMEM;
 759
 760         (*idev)->name = "Huawei WMI hotkeys";
 761         (*idev)->phys = "wmi/input0";
 762         (*idev)->id.bustype = BUS_HOST;
 763         (*idev)->dev.parent = dev;
 764
 765         return sparse_keymap_setup(*idev, huawei_wmi_keymap, NULL) ||
 766                 input_register_device(*idev) ||
 767                 wmi_install_notify_handler(guid, huawei_wmi_input_notify,
 768                                 *idev);
 769 }
 770
 771 static void huawei_wmi_input_exit(struct device *dev, const char *guid)
 772 {
 773         wmi_remove_notify_handler(guid);
 774 }
 775
 776 /* Huawei driver */
 777
 778 static const struct wmi_device_id huawei_wmi_events_id_table[] = {
 779         { .guid_string = WMI0_EVENT_GUID },
 780         { .guid_string = HWMI_EVENT_GUID },
 781         {  }
 782 };
 783
 784 static int huawei_wmi_probe(struct platform_device *pdev)
 785 {
 786         const struct wmi_device_id *guid = huawei_wmi_events_id_table;
 787         int err;
 788
 789         platform_set_drvdata(pdev, huawei_wmi);
 790         huawei_wmi->dev = &pdev->dev;
 791
 792         while (*guid->guid_string) {
 793                 struct input_dev *idev = *huawei_wmi->idev;
 794
 795                 if (wmi_has_guid(guid->guid_string)) {
 796                         err = huawei_wmi_input_setup(&pdev->dev, guid->guid_string, &idev);
 797                         if (err) {
 798                                 dev_err(&pdev->dev, "Failed to setup input on %s\n", guid->guid_string);
 799                                 return err;
 800                         }
 801                 }
 802
 803                 idev++;
 804                 guid++;
 805         }
 806
 807         if (wmi_has_guid(HWMI_METHOD_GUID)) {
 808                 mutex_init(&huawei_wmi->wmi_lock);
 809
 810                 huawei_wmi_leds_setup(&pdev->dev);
 811                 huawei_wmi_fn_lock_setup(&pdev->dev);
 812                 huawei_wmi_battery_setup(&pdev->dev);
 813                 huawei_wmi_debugfs_setup(&pdev->dev);
 814         }
 815
 816         return 0;
 817 }
 818
 819 static int huawei_wmi_remove(struct platform_device *pdev)
 820 {
 821         const struct wmi_device_id *guid = huawei_wmi_events_id_table;
 822
 823         while (*guid->guid_string) {
 824                 if (wmi_has_guid(guid->guid_string))
 825                         huawei_wmi_input_exit(&pdev->dev, guid->guid_string);
 826
 827                 guid++;
 828         }
 829
 830         if (wmi_has_guid(HWMI_METHOD_GUID)) {
 831                 huawei_wmi_debugfs_exit(&pdev->dev);
 832                 huawei_wmi_battery_exit(&pdev->dev);
 833                 huawei_wmi_fn_lock_exit(&pdev->dev);
 834         }
 835
 836         return 0;
 837 }
 838
 839 static struct platform_driver huawei_wmi_driver = {
 840         .driver = {
 841                 .name = "huawei-wmi",
 842         },
 843         .probe = huawei_wmi_probe,
 844         .remove = huawei_wmi_remove,
 845 };
 846
 847 static __init int huawei_wmi_init(void)
 848 {
 849         struct platform_device *pdev;
 850         int err;
 851
 852         huawei_wmi = kzalloc(sizeof(struct huawei_wmi), GFP_KERNEL);
 853         if (!huawei_wmi)
 854                 return -ENOMEM;
 855
 856         quirks = &quirk_unknown;
 857         dmi_check_system(huawei_quirks);
 858         if (battery_reset != -1)
 859                 quirks->battery_reset = battery_reset;
 860         if (report_brightness != -1)
 861                 quirks->report_brightness = report_brightness;
 862
 863         err = platform_driver_register(&huawei_wmi_driver);
 864         if (err)
 865                 goto pdrv_err;
 866
 867         pdev = platform_device_register_simple("huawei-wmi", -1, NULL, 0);
 868         if (IS_ERR(pdev)) {
 869                 err = PTR_ERR(pdev);
 870                 goto pdev_err;
 871         }
 872
 873         return 0;
 874
 875 pdev_err:
 876         platform_driver_unregister(&huawei_wmi_driver);
 877 pdrv_err:
 878         kfree(huawei_wmi);
 879         return err;
 880 }
 881
 882 static __exit void huawei_wmi_exit(void)
 883 {
 884         struct platform_device *pdev = to_platform_device(huawei_wmi->dev);
 885
 886         platform_device_unregister(pdev);
 887         platform_driver_unregister(&huawei_wmi_driver);
 888
 889         kfree(huawei_wmi);
 890 }
 891
 892 module_init(huawei_wmi_init);
 893 module_exit(huawei_wmi_exit);
 894
 895 MODULE_ALIAS("wmi:"HWMI_METHOD_GUID);
 896 MODULE_DEVICE_TABLE(wmi, huawei_wmi_events_id_table);
 897 MODULE_AUTHOR("Ayman Bagabas <[email protected]>");
 898 MODULE_DESCRIPTION("Huawei WMI laptop extras driver");
 899 MODULE_LICENSE("GPL v2");