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"); 907