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 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 <ayman.bagabas@gmail.com>"); 898 MODULE_DESCRIPTION("Huawei WMI laptop extras driver"); 899 MODULE_LICENSE("GPL v2"); 900