1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * ACPI-WMI mapping driver 4 * 5 * Copyright (C) 2007-2008 Carlos Corbacho <carlos@strangeworlds.co.uk> 6 * 7 * GUID parsing code from ldm.c is: 8 * Copyright (C) 2001,2002 Richard Russon <ldm@flatcap.org> 9 * Copyright (c) 2001-2007 Anton Altaparmakov 10 * Copyright (C) 2001,2002 Jakob Kemi <jakob.kemi@telia.com> 11 * 12 * WMI bus infrastructure by Andrew Lutomirski and Darren Hart: 13 * Copyright (C) 2015 Andrew Lutomirski 14 * Copyright (C) 2017 VMware, Inc. All Rights Reserved. 15 */ 16 17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18 19 #include <linux/acpi.h> 20 #include <linux/bits.h> 21 #include <linux/build_bug.h> 22 #include <linux/device.h> 23 #include <linux/init.h> 24 #include <linux/kernel.h> 25 #include <linux/list.h> 26 #include <linux/module.h> 27 #include <linux/platform_device.h> 28 #include <linux/rwsem.h> 29 #include <linux/slab.h> 30 #include <linux/sysfs.h> 31 #include <linux/types.h> 32 #include <linux/uuid.h> 33 #include <linux/wmi.h> 34 #include <linux/fs.h> 35 36 MODULE_AUTHOR("Carlos Corbacho"); 37 MODULE_DESCRIPTION("ACPI-WMI Mapping Driver"); 38 MODULE_LICENSE("GPL"); 39 40 static LIST_HEAD(wmi_block_list); 41 42 struct guid_block { 43 guid_t guid; 44 union { 45 char object_id[2]; 46 struct { 47 unsigned char notify_id; 48 unsigned char reserved; 49 }; 50 }; 51 u8 instance_count; 52 u8 flags; 53 } __packed; 54 static_assert(sizeof(typeof_member(struct guid_block, guid)) == 16); 55 static_assert(sizeof(struct guid_block) == 20); 56 static_assert(__alignof__(struct guid_block) == 1); 57 58 enum { /* wmi_block flags */ 59 WMI_READ_TAKES_NO_ARGS, 60 }; 61 62 struct wmi_block { 63 struct wmi_device dev; 64 struct list_head list; 65 struct guid_block gblock; 66 struct acpi_device *acpi_device; 67 struct rw_semaphore notify_lock; /* Protects notify callback add/remove */ 68 wmi_notify_handler handler; 69 void *handler_data; 70 bool driver_ready; 71 unsigned long flags; 72 }; 73 74 75 /* 76 * If the GUID data block is marked as expensive, we must enable and 77 * explicitily disable data collection. 78 */ 79 #define ACPI_WMI_EXPENSIVE BIT(0) 80 #define ACPI_WMI_METHOD BIT(1) /* GUID is a method */ 81 #define ACPI_WMI_STRING BIT(2) /* GUID takes & returns a string */ 82 #define ACPI_WMI_EVENT BIT(3) /* GUID is an event */ 83 84 static const struct acpi_device_id wmi_device_ids[] = { 85 {"PNP0C14", 0}, 86 {"pnp0c14", 0}, 87 { } 88 }; 89 MODULE_DEVICE_TABLE(acpi, wmi_device_ids); 90 91 /* allow duplicate GUIDs as these device drivers use struct wmi_driver */ 92 static const char * const allow_duplicates[] = { 93 "05901221-D566-11D1-B2F0-00A0C9062910", /* wmi-bmof */ 94 "8A42EA14-4F2A-FD45-6422-0087F7A7E608", /* dell-wmi-ddv */ 95 "44FADEB1-B204-40F2-8581-394BBDC1B651", /* intel-wmi-sbl-fw-update */ 96 "86CCFD48-205E-4A77-9C48-2021CBEDE341", /* intel-wmi-thunderbolt */ 97 "F1DDEE52-063C-4784-A11E-8A06684B9B01", /* dell-smm-hwmon */ 98 NULL 99 }; 100 101 #define dev_to_wblock(__dev) container_of_const(__dev, struct wmi_block, dev.dev) 102 #define dev_to_wdev(__dev) container_of_const(__dev, struct wmi_device, dev) 103 104 /* 105 * GUID parsing functions 106 */ 107 108 static bool guid_parse_and_compare(const char *string, const guid_t *guid) 109 { 110 guid_t guid_input; 111 112 if (guid_parse(string, &guid_input)) 113 return false; 114 115 return guid_equal(&guid_input, guid); 116 } 117 118 static const void *find_guid_context(struct wmi_block *wblock, 119 struct wmi_driver *wdriver) 120 { 121 const struct wmi_device_id *id; 122 123 id = wdriver->id_table; 124 if (!id) 125 return NULL; 126 127 while (*id->guid_string) { 128 if (guid_parse_and_compare(id->guid_string, &wblock->gblock.guid)) 129 return id->context; 130 id++; 131 } 132 return NULL; 133 } 134 135 static int get_subobj_info(acpi_handle handle, const char *pathname, 136 struct acpi_device_info **info) 137 { 138 acpi_handle subobj_handle; 139 acpi_status status; 140 141 status = acpi_get_handle(handle, pathname, &subobj_handle); 142 if (status == AE_NOT_FOUND) 143 return -ENOENT; 144 145 if (ACPI_FAILURE(status)) 146 return -EIO; 147 148 status = acpi_get_object_info(subobj_handle, info); 149 if (ACPI_FAILURE(status)) 150 return -EIO; 151 152 return 0; 153 } 154 155 static acpi_status wmi_method_enable(struct wmi_block *wblock, bool enable) 156 { 157 struct guid_block *block; 158 char method[5]; 159 acpi_status status; 160 acpi_handle handle; 161 162 block = &wblock->gblock; 163 handle = wblock->acpi_device->handle; 164 165 snprintf(method, 5, "WE%02X", block->notify_id); 166 status = acpi_execute_simple_method(handle, method, enable); 167 if (status == AE_NOT_FOUND) 168 return AE_OK; 169 170 return status; 171 } 172 173 #define WMI_ACPI_METHOD_NAME_SIZE 5 174 175 static inline void get_acpi_method_name(const struct wmi_block *wblock, 176 const char method, 177 char buffer[static WMI_ACPI_METHOD_NAME_SIZE]) 178 { 179 static_assert(ARRAY_SIZE(wblock->gblock.object_id) == 2); 180 static_assert(WMI_ACPI_METHOD_NAME_SIZE >= 5); 181 182 buffer[0] = 'W'; 183 buffer[1] = method; 184 buffer[2] = wblock->gblock.object_id[0]; 185 buffer[3] = wblock->gblock.object_id[1]; 186 buffer[4] = '\0'; 187 } 188 189 static inline acpi_object_type get_param_acpi_type(const struct wmi_block *wblock) 190 { 191 if (wblock->gblock.flags & ACPI_WMI_STRING) 192 return ACPI_TYPE_STRING; 193 else 194 return ACPI_TYPE_BUFFER; 195 } 196 197 static acpi_status get_event_data(const struct wmi_block *wblock, struct acpi_buffer *out) 198 { 199 union acpi_object param = { 200 .integer = { 201 .type = ACPI_TYPE_INTEGER, 202 .value = wblock->gblock.notify_id, 203 } 204 }; 205 struct acpi_object_list input = { 206 .count = 1, 207 .pointer = ¶m, 208 }; 209 210 return acpi_evaluate_object(wblock->acpi_device->handle, "_WED", &input, out); 211 } 212 213 static int wmidev_match_guid(struct device *dev, const void *data) 214 { 215 struct wmi_block *wblock = dev_to_wblock(dev); 216 const guid_t *guid = data; 217 218 if (guid_equal(guid, &wblock->gblock.guid)) 219 return 1; 220 221 return 0; 222 } 223 224 static int wmidev_match_notify_id(struct device *dev, const void *data) 225 { 226 struct wmi_block *wblock = dev_to_wblock(dev); 227 const u32 *notify_id = data; 228 229 if (wblock->gblock.flags & ACPI_WMI_EVENT && wblock->gblock.notify_id == *notify_id) 230 return 1; 231 232 return 0; 233 } 234 235 static struct bus_type wmi_bus_type; 236 237 static struct wmi_device *wmi_find_device_by_guid(const char *guid_string) 238 { 239 struct device *dev; 240 guid_t guid; 241 int ret; 242 243 ret = guid_parse(guid_string, &guid); 244 if (ret < 0) 245 return ERR_PTR(ret); 246 247 dev = bus_find_device(&wmi_bus_type, NULL, &guid, wmidev_match_guid); 248 if (!dev) 249 return ERR_PTR(-ENODEV); 250 251 return dev_to_wdev(dev); 252 } 253 254 static struct wmi_device *wmi_find_event_by_notify_id(const u32 notify_id) 255 { 256 struct device *dev; 257 258 dev = bus_find_device(&wmi_bus_type, NULL, ¬ify_id, wmidev_match_notify_id); 259 if (!dev) 260 return ERR_PTR(-ENODEV); 261 262 return to_wmi_device(dev); 263 } 264 265 static void wmi_device_put(struct wmi_device *wdev) 266 { 267 put_device(&wdev->dev); 268 } 269 270 /* 271 * Exported WMI functions 272 */ 273 274 /** 275 * wmi_instance_count - Get number of WMI object instances 276 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 277 * 278 * Get the number of WMI object instances. 279 * 280 * Returns: Number of WMI object instances or negative error code. 281 */ 282 int wmi_instance_count(const char *guid_string) 283 { 284 struct wmi_device *wdev; 285 int ret; 286 287 wdev = wmi_find_device_by_guid(guid_string); 288 if (IS_ERR(wdev)) 289 return PTR_ERR(wdev); 290 291 ret = wmidev_instance_count(wdev); 292 wmi_device_put(wdev); 293 294 return ret; 295 } 296 EXPORT_SYMBOL_GPL(wmi_instance_count); 297 298 /** 299 * wmidev_instance_count - Get number of WMI object instances 300 * @wdev: A wmi bus device from a driver 301 * 302 * Get the number of WMI object instances. 303 * 304 * Returns: Number of WMI object instances. 305 */ 306 u8 wmidev_instance_count(struct wmi_device *wdev) 307 { 308 struct wmi_block *wblock = container_of(wdev, struct wmi_block, dev); 309 310 return wblock->gblock.instance_count; 311 } 312 EXPORT_SYMBOL_GPL(wmidev_instance_count); 313 314 /** 315 * wmi_evaluate_method - Evaluate a WMI method (deprecated) 316 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 317 * @instance: Instance index 318 * @method_id: Method ID to call 319 * @in: Buffer containing input for the method call 320 * @out: Empty buffer to return the method results 321 * 322 * Call an ACPI-WMI method, the caller must free @out. 323 * 324 * Return: acpi_status signaling success or error. 325 */ 326 acpi_status wmi_evaluate_method(const char *guid_string, u8 instance, u32 method_id, 327 const struct acpi_buffer *in, struct acpi_buffer *out) 328 { 329 struct wmi_device *wdev; 330 acpi_status status; 331 332 wdev = wmi_find_device_by_guid(guid_string); 333 if (IS_ERR(wdev)) 334 return AE_ERROR; 335 336 status = wmidev_evaluate_method(wdev, instance, method_id, in, out); 337 338 wmi_device_put(wdev); 339 340 return status; 341 } 342 EXPORT_SYMBOL_GPL(wmi_evaluate_method); 343 344 /** 345 * wmidev_evaluate_method - Evaluate a WMI method 346 * @wdev: A wmi bus device from a driver 347 * @instance: Instance index 348 * @method_id: Method ID to call 349 * @in: Buffer containing input for the method call 350 * @out: Empty buffer to return the method results 351 * 352 * Call an ACPI-WMI method, the caller must free @out. 353 * 354 * Return: acpi_status signaling success or error. 355 */ 356 acpi_status wmidev_evaluate_method(struct wmi_device *wdev, u8 instance, u32 method_id, 357 const struct acpi_buffer *in, struct acpi_buffer *out) 358 { 359 struct guid_block *block; 360 struct wmi_block *wblock; 361 acpi_handle handle; 362 struct acpi_object_list input; 363 union acpi_object params[3]; 364 char method[WMI_ACPI_METHOD_NAME_SIZE]; 365 366 wblock = container_of(wdev, struct wmi_block, dev); 367 block = &wblock->gblock; 368 handle = wblock->acpi_device->handle; 369 370 if (!(block->flags & ACPI_WMI_METHOD)) 371 return AE_BAD_DATA; 372 373 if (block->instance_count <= instance) 374 return AE_BAD_PARAMETER; 375 376 input.count = 2; 377 input.pointer = params; 378 params[0].type = ACPI_TYPE_INTEGER; 379 params[0].integer.value = instance; 380 params[1].type = ACPI_TYPE_INTEGER; 381 params[1].integer.value = method_id; 382 383 if (in) { 384 input.count = 3; 385 386 params[2].type = get_param_acpi_type(wblock); 387 params[2].buffer.length = in->length; 388 params[2].buffer.pointer = in->pointer; 389 } 390 391 get_acpi_method_name(wblock, 'M', method); 392 393 return acpi_evaluate_object(handle, method, &input, out); 394 } 395 EXPORT_SYMBOL_GPL(wmidev_evaluate_method); 396 397 static acpi_status __query_block(struct wmi_block *wblock, u8 instance, 398 struct acpi_buffer *out) 399 { 400 struct guid_block *block; 401 acpi_handle handle; 402 acpi_status status, wc_status = AE_ERROR; 403 struct acpi_object_list input; 404 union acpi_object wq_params[1]; 405 char wc_method[WMI_ACPI_METHOD_NAME_SIZE]; 406 char method[WMI_ACPI_METHOD_NAME_SIZE]; 407 408 if (!out) 409 return AE_BAD_PARAMETER; 410 411 block = &wblock->gblock; 412 handle = wblock->acpi_device->handle; 413 414 if (block->instance_count <= instance) 415 return AE_BAD_PARAMETER; 416 417 /* Check GUID is a data block */ 418 if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD)) 419 return AE_ERROR; 420 421 input.count = 1; 422 input.pointer = wq_params; 423 wq_params[0].type = ACPI_TYPE_INTEGER; 424 wq_params[0].integer.value = instance; 425 426 if (instance == 0 && test_bit(WMI_READ_TAKES_NO_ARGS, &wblock->flags)) 427 input.count = 0; 428 429 /* 430 * If ACPI_WMI_EXPENSIVE, call the relevant WCxx method first to 431 * enable collection. 432 */ 433 if (block->flags & ACPI_WMI_EXPENSIVE) { 434 get_acpi_method_name(wblock, 'C', wc_method); 435 436 /* 437 * Some GUIDs break the specification by declaring themselves 438 * expensive, but have no corresponding WCxx method. So we 439 * should not fail if this happens. 440 */ 441 wc_status = acpi_execute_simple_method(handle, wc_method, 1); 442 } 443 444 get_acpi_method_name(wblock, 'Q', method); 445 status = acpi_evaluate_object(handle, method, &input, out); 446 447 /* 448 * If ACPI_WMI_EXPENSIVE, call the relevant WCxx method, even if 449 * the WQxx method failed - we should disable collection anyway. 450 */ 451 if ((block->flags & ACPI_WMI_EXPENSIVE) && ACPI_SUCCESS(wc_status)) { 452 /* 453 * Ignore whether this WCxx call succeeds or not since 454 * the previously executed WQxx method call might have 455 * succeeded, and returning the failing status code 456 * of this call would throw away the result of the WQxx 457 * call, potentially leaking memory. 458 */ 459 acpi_execute_simple_method(handle, wc_method, 0); 460 } 461 462 return status; 463 } 464 465 /** 466 * wmi_query_block - Return contents of a WMI block (deprecated) 467 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 468 * @instance: Instance index 469 * @out: Empty buffer to return the contents of the data block to 470 * 471 * Query a ACPI-WMI block, the caller must free @out. 472 * 473 * Return: ACPI object containing the content of the WMI block. 474 */ 475 acpi_status wmi_query_block(const char *guid_string, u8 instance, 476 struct acpi_buffer *out) 477 { 478 struct wmi_block *wblock; 479 struct wmi_device *wdev; 480 acpi_status status; 481 482 wdev = wmi_find_device_by_guid(guid_string); 483 if (IS_ERR(wdev)) 484 return AE_ERROR; 485 486 wblock = container_of(wdev, struct wmi_block, dev); 487 status = __query_block(wblock, instance, out); 488 489 wmi_device_put(wdev); 490 491 return status; 492 } 493 EXPORT_SYMBOL_GPL(wmi_query_block); 494 495 /** 496 * wmidev_block_query - Return contents of a WMI block 497 * @wdev: A wmi bus device from a driver 498 * @instance: Instance index 499 * 500 * Query an ACPI-WMI block, the caller must free the result. 501 * 502 * Return: ACPI object containing the content of the WMI block. 503 */ 504 union acpi_object *wmidev_block_query(struct wmi_device *wdev, u8 instance) 505 { 506 struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL }; 507 struct wmi_block *wblock = container_of(wdev, struct wmi_block, dev); 508 509 if (ACPI_FAILURE(__query_block(wblock, instance, &out))) 510 return NULL; 511 512 return out.pointer; 513 } 514 EXPORT_SYMBOL_GPL(wmidev_block_query); 515 516 /** 517 * wmi_set_block - Write to a WMI block (deprecated) 518 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 519 * @instance: Instance index 520 * @in: Buffer containing new values for the data block 521 * 522 * Write the contents of the input buffer to an ACPI-WMI data block. 523 * 524 * Return: acpi_status signaling success or error. 525 */ 526 acpi_status wmi_set_block(const char *guid_string, u8 instance, const struct acpi_buffer *in) 527 { 528 struct wmi_device *wdev; 529 acpi_status status; 530 531 wdev = wmi_find_device_by_guid(guid_string); 532 if (IS_ERR(wdev)) 533 return AE_ERROR; 534 535 status = wmidev_block_set(wdev, instance, in); 536 wmi_device_put(wdev); 537 538 return status; 539 } 540 EXPORT_SYMBOL_GPL(wmi_set_block); 541 542 /** 543 * wmidev_block_set - Write to a WMI block 544 * @wdev: A wmi bus device from a driver 545 * @instance: Instance index 546 * @in: Buffer containing new values for the data block 547 * 548 * Write contents of the input buffer to an ACPI-WMI data block. 549 * 550 * Return: acpi_status signaling success or error. 551 */ 552 acpi_status wmidev_block_set(struct wmi_device *wdev, u8 instance, const struct acpi_buffer *in) 553 { 554 struct wmi_block *wblock = container_of(wdev, struct wmi_block, dev); 555 acpi_handle handle = wblock->acpi_device->handle; 556 struct guid_block *block = &wblock->gblock; 557 char method[WMI_ACPI_METHOD_NAME_SIZE]; 558 struct acpi_object_list input; 559 union acpi_object params[2]; 560 561 if (!in) 562 return AE_BAD_DATA; 563 564 if (block->instance_count <= instance) 565 return AE_BAD_PARAMETER; 566 567 /* Check GUID is a data block */ 568 if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD)) 569 return AE_ERROR; 570 571 input.count = 2; 572 input.pointer = params; 573 params[0].type = ACPI_TYPE_INTEGER; 574 params[0].integer.value = instance; 575 params[1].type = get_param_acpi_type(wblock); 576 params[1].buffer.length = in->length; 577 params[1].buffer.pointer = in->pointer; 578 579 get_acpi_method_name(wblock, 'S', method); 580 581 return acpi_evaluate_object(handle, method, &input, NULL); 582 } 583 EXPORT_SYMBOL_GPL(wmidev_block_set); 584 585 /** 586 * wmi_install_notify_handler - Register handler for WMI events (deprecated) 587 * @guid: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 588 * @handler: Function to handle notifications 589 * @data: Data to be returned to handler when event is fired 590 * 591 * Register a handler for events sent to the ACPI-WMI mapper device. 592 * 593 * Return: acpi_status signaling success or error. 594 */ 595 acpi_status wmi_install_notify_handler(const char *guid, 596 wmi_notify_handler handler, 597 void *data) 598 { 599 struct wmi_block *wblock; 600 struct wmi_device *wdev; 601 acpi_status status; 602 603 wdev = wmi_find_device_by_guid(guid); 604 if (IS_ERR(wdev)) 605 return AE_ERROR; 606 607 wblock = container_of(wdev, struct wmi_block, dev); 608 609 down_write(&wblock->notify_lock); 610 if (wblock->handler) { 611 status = AE_ALREADY_ACQUIRED; 612 } else { 613 wblock->handler = handler; 614 wblock->handler_data = data; 615 616 if (ACPI_FAILURE(wmi_method_enable(wblock, true))) 617 dev_warn(&wblock->dev.dev, "Failed to enable device\n"); 618 619 status = AE_OK; 620 } 621 up_write(&wblock->notify_lock); 622 623 wmi_device_put(wdev); 624 625 return status; 626 } 627 EXPORT_SYMBOL_GPL(wmi_install_notify_handler); 628 629 /** 630 * wmi_remove_notify_handler - Unregister handler for WMI events (deprecated) 631 * @guid: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 632 * 633 * Unregister handler for events sent to the ACPI-WMI mapper device. 634 * 635 * Return: acpi_status signaling success or error. 636 */ 637 acpi_status wmi_remove_notify_handler(const char *guid) 638 { 639 struct wmi_block *wblock; 640 struct wmi_device *wdev; 641 acpi_status status; 642 643 wdev = wmi_find_device_by_guid(guid); 644 if (IS_ERR(wdev)) 645 return AE_ERROR; 646 647 wblock = container_of(wdev, struct wmi_block, dev); 648 649 down_write(&wblock->notify_lock); 650 if (!wblock->handler) { 651 status = AE_NULL_ENTRY; 652 } else { 653 if (ACPI_FAILURE(wmi_method_enable(wblock, false))) 654 dev_warn(&wblock->dev.dev, "Failed to disable device\n"); 655 656 wblock->handler = NULL; 657 wblock->handler_data = NULL; 658 659 status = AE_OK; 660 } 661 up_write(&wblock->notify_lock); 662 663 wmi_device_put(wdev); 664 665 return status; 666 } 667 EXPORT_SYMBOL_GPL(wmi_remove_notify_handler); 668 669 /** 670 * wmi_get_event_data - Get WMI data associated with an event (deprecated) 671 * 672 * @event: Event to find 673 * @out: Buffer to hold event data 674 * 675 * Get extra data associated with an WMI event, the caller needs to free @out. 676 * 677 * Return: acpi_status signaling success or error. 678 */ 679 acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out) 680 { 681 struct wmi_block *wblock; 682 struct wmi_device *wdev; 683 acpi_status status; 684 685 wdev = wmi_find_event_by_notify_id(event); 686 if (IS_ERR(wdev)) 687 return AE_NOT_FOUND; 688 689 wblock = container_of(wdev, struct wmi_block, dev); 690 status = get_event_data(wblock, out); 691 692 wmi_device_put(wdev); 693 694 return status; 695 } 696 EXPORT_SYMBOL_GPL(wmi_get_event_data); 697 698 /** 699 * wmi_has_guid - Check if a GUID is available 700 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 701 * 702 * Check if a given GUID is defined by _WDG. 703 * 704 * Return: True if GUID is available, false otherwise. 705 */ 706 bool wmi_has_guid(const char *guid_string) 707 { 708 struct wmi_device *wdev; 709 710 wdev = wmi_find_device_by_guid(guid_string); 711 if (IS_ERR(wdev)) 712 return false; 713 714 wmi_device_put(wdev); 715 716 return true; 717 } 718 EXPORT_SYMBOL_GPL(wmi_has_guid); 719 720 /** 721 * wmi_get_acpi_device_uid() - Get _UID name of ACPI device that defines GUID (deprecated) 722 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba 723 * 724 * Find the _UID of ACPI device associated with this WMI GUID. 725 * 726 * Return: The ACPI _UID field value or NULL if the WMI GUID was not found. 727 */ 728 char *wmi_get_acpi_device_uid(const char *guid_string) 729 { 730 struct wmi_block *wblock; 731 struct wmi_device *wdev; 732 char *uid; 733 734 wdev = wmi_find_device_by_guid(guid_string); 735 if (IS_ERR(wdev)) 736 return NULL; 737 738 wblock = container_of(wdev, struct wmi_block, dev); 739 uid = acpi_device_uid(wblock->acpi_device); 740 741 wmi_device_put(wdev); 742 743 return uid; 744 } 745 EXPORT_SYMBOL_GPL(wmi_get_acpi_device_uid); 746 747 static inline struct wmi_driver *drv_to_wdrv(struct device_driver *drv) 748 { 749 return container_of(drv, struct wmi_driver, driver); 750 } 751 752 /* 753 * sysfs interface 754 */ 755 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 756 char *buf) 757 { 758 struct wmi_block *wblock = dev_to_wblock(dev); 759 760 return sysfs_emit(buf, "wmi:%pUL\n", &wblock->gblock.guid); 761 } 762 static DEVICE_ATTR_RO(modalias); 763 764 static ssize_t guid_show(struct device *dev, struct device_attribute *attr, 765 char *buf) 766 { 767 struct wmi_block *wblock = dev_to_wblock(dev); 768 769 return sysfs_emit(buf, "%pUL\n", &wblock->gblock.guid); 770 } 771 static DEVICE_ATTR_RO(guid); 772 773 static ssize_t instance_count_show(struct device *dev, 774 struct device_attribute *attr, char *buf) 775 { 776 struct wmi_block *wblock = dev_to_wblock(dev); 777 778 return sysfs_emit(buf, "%d\n", (int)wblock->gblock.instance_count); 779 } 780 static DEVICE_ATTR_RO(instance_count); 781 782 static ssize_t expensive_show(struct device *dev, 783 struct device_attribute *attr, char *buf) 784 { 785 struct wmi_block *wblock = dev_to_wblock(dev); 786 787 return sysfs_emit(buf, "%d\n", 788 (wblock->gblock.flags & ACPI_WMI_EXPENSIVE) != 0); 789 } 790 static DEVICE_ATTR_RO(expensive); 791 792 static struct attribute *wmi_attrs[] = { 793 &dev_attr_modalias.attr, 794 &dev_attr_guid.attr, 795 &dev_attr_instance_count.attr, 796 &dev_attr_expensive.attr, 797 NULL 798 }; 799 ATTRIBUTE_GROUPS(wmi); 800 801 static ssize_t notify_id_show(struct device *dev, struct device_attribute *attr, 802 char *buf) 803 { 804 struct wmi_block *wblock = dev_to_wblock(dev); 805 806 return sysfs_emit(buf, "%02X\n", (unsigned int)wblock->gblock.notify_id); 807 } 808 static DEVICE_ATTR_RO(notify_id); 809 810 static struct attribute *wmi_event_attrs[] = { 811 &dev_attr_notify_id.attr, 812 NULL 813 }; 814 ATTRIBUTE_GROUPS(wmi_event); 815 816 static ssize_t object_id_show(struct device *dev, struct device_attribute *attr, 817 char *buf) 818 { 819 struct wmi_block *wblock = dev_to_wblock(dev); 820 821 return sysfs_emit(buf, "%c%c\n", wblock->gblock.object_id[0], 822 wblock->gblock.object_id[1]); 823 } 824 static DEVICE_ATTR_RO(object_id); 825 826 static ssize_t setable_show(struct device *dev, struct device_attribute *attr, 827 char *buf) 828 { 829 struct wmi_device *wdev = dev_to_wdev(dev); 830 831 return sysfs_emit(buf, "%d\n", (int)wdev->setable); 832 } 833 static DEVICE_ATTR_RO(setable); 834 835 static struct attribute *wmi_data_attrs[] = { 836 &dev_attr_object_id.attr, 837 &dev_attr_setable.attr, 838 NULL 839 }; 840 ATTRIBUTE_GROUPS(wmi_data); 841 842 static struct attribute *wmi_method_attrs[] = { 843 &dev_attr_object_id.attr, 844 NULL 845 }; 846 ATTRIBUTE_GROUPS(wmi_method); 847 848 static int wmi_dev_uevent(const struct device *dev, struct kobj_uevent_env *env) 849 { 850 const struct wmi_block *wblock = dev_to_wblock(dev); 851 852 if (add_uevent_var(env, "MODALIAS=wmi:%pUL", &wblock->gblock.guid)) 853 return -ENOMEM; 854 855 if (add_uevent_var(env, "WMI_GUID=%pUL", &wblock->gblock.guid)) 856 return -ENOMEM; 857 858 return 0; 859 } 860 861 static void wmi_dev_release(struct device *dev) 862 { 863 struct wmi_block *wblock = dev_to_wblock(dev); 864 865 kfree(wblock); 866 } 867 868 static int wmi_dev_match(struct device *dev, struct device_driver *driver) 869 { 870 struct wmi_driver *wmi_driver = drv_to_wdrv(driver); 871 struct wmi_block *wblock = dev_to_wblock(dev); 872 const struct wmi_device_id *id = wmi_driver->id_table; 873 874 if (id == NULL) 875 return 0; 876 877 while (*id->guid_string) { 878 if (guid_parse_and_compare(id->guid_string, &wblock->gblock.guid)) 879 return 1; 880 881 id++; 882 } 883 884 return 0; 885 } 886 887 static int wmi_dev_probe(struct device *dev) 888 { 889 struct wmi_block *wblock = dev_to_wblock(dev); 890 struct wmi_driver *wdriver = drv_to_wdrv(dev->driver); 891 int ret = 0; 892 893 if (ACPI_FAILURE(wmi_method_enable(wblock, true))) 894 dev_warn(dev, "failed to enable device -- probing anyway\n"); 895 896 if (wdriver->probe) { 897 ret = wdriver->probe(dev_to_wdev(dev), 898 find_guid_context(wblock, wdriver)); 899 if (ret) { 900 if (ACPI_FAILURE(wmi_method_enable(wblock, false))) 901 dev_warn(dev, "Failed to disable device\n"); 902 903 return ret; 904 } 905 } 906 907 down_write(&wblock->notify_lock); 908 wblock->driver_ready = true; 909 up_write(&wblock->notify_lock); 910 911 return 0; 912 } 913 914 static void wmi_dev_remove(struct device *dev) 915 { 916 struct wmi_block *wblock = dev_to_wblock(dev); 917 struct wmi_driver *wdriver = drv_to_wdrv(dev->driver); 918 919 down_write(&wblock->notify_lock); 920 wblock->driver_ready = false; 921 up_write(&wblock->notify_lock); 922 923 if (wdriver->remove) 924 wdriver->remove(dev_to_wdev(dev)); 925 926 if (ACPI_FAILURE(wmi_method_enable(wblock, false))) 927 dev_warn(dev, "failed to disable device\n"); 928 } 929 930 static struct class wmi_bus_class = { 931 .name = "wmi_bus", 932 }; 933 934 static struct bus_type wmi_bus_type = { 935 .name = "wmi", 936 .dev_groups = wmi_groups, 937 .match = wmi_dev_match, 938 .uevent = wmi_dev_uevent, 939 .probe = wmi_dev_probe, 940 .remove = wmi_dev_remove, 941 }; 942 943 static const struct device_type wmi_type_event = { 944 .name = "event", 945 .groups = wmi_event_groups, 946 .release = wmi_dev_release, 947 }; 948 949 static const struct device_type wmi_type_method = { 950 .name = "method", 951 .groups = wmi_method_groups, 952 .release = wmi_dev_release, 953 }; 954 955 static const struct device_type wmi_type_data = { 956 .name = "data", 957 .groups = wmi_data_groups, 958 .release = wmi_dev_release, 959 }; 960 961 /* 962 * _WDG is a static list that is only parsed at startup, 963 * so it's safe to count entries without extra protection. 964 */ 965 static int guid_count(const guid_t *guid) 966 { 967 struct wmi_block *wblock; 968 int count = 0; 969 970 list_for_each_entry(wblock, &wmi_block_list, list) { 971 if (guid_equal(&wblock->gblock.guid, guid)) 972 count++; 973 } 974 975 return count; 976 } 977 978 static int wmi_create_device(struct device *wmi_bus_dev, 979 struct wmi_block *wblock, 980 struct acpi_device *device) 981 { 982 struct acpi_device_info *info; 983 char method[WMI_ACPI_METHOD_NAME_SIZE]; 984 int result; 985 uint count; 986 987 if (wblock->gblock.flags & ACPI_WMI_EVENT) { 988 wblock->dev.dev.type = &wmi_type_event; 989 goto out_init; 990 } 991 992 if (wblock->gblock.flags & ACPI_WMI_METHOD) { 993 wblock->dev.dev.type = &wmi_type_method; 994 goto out_init; 995 } 996 997 /* 998 * Data Block Query Control Method (WQxx by convention) is 999 * required per the WMI documentation. If it is not present, 1000 * we ignore this data block. 1001 */ 1002 get_acpi_method_name(wblock, 'Q', method); 1003 result = get_subobj_info(device->handle, method, &info); 1004 1005 if (result) { 1006 dev_warn(wmi_bus_dev, 1007 "%s data block query control method not found\n", 1008 method); 1009 return result; 1010 } 1011 1012 wblock->dev.dev.type = &wmi_type_data; 1013 1014 /* 1015 * The Microsoft documentation specifically states: 1016 * 1017 * Data blocks registered with only a single instance 1018 * can ignore the parameter. 1019 * 1020 * ACPICA will get mad at us if we call the method with the wrong number 1021 * of arguments, so check what our method expects. (On some Dell 1022 * laptops, WQxx may not be a method at all.) 1023 */ 1024 if (info->type != ACPI_TYPE_METHOD || info->param_count == 0) 1025 set_bit(WMI_READ_TAKES_NO_ARGS, &wblock->flags); 1026 1027 kfree(info); 1028 1029 get_acpi_method_name(wblock, 'S', method); 1030 if (acpi_has_method(device->handle, method)) 1031 wblock->dev.setable = true; 1032 1033 out_init: 1034 init_rwsem(&wblock->notify_lock); 1035 wblock->driver_ready = false; 1036 wblock->dev.dev.bus = &wmi_bus_type; 1037 wblock->dev.dev.parent = wmi_bus_dev; 1038 1039 count = guid_count(&wblock->gblock.guid); 1040 if (count) 1041 dev_set_name(&wblock->dev.dev, "%pUL-%d", &wblock->gblock.guid, count); 1042 else 1043 dev_set_name(&wblock->dev.dev, "%pUL", &wblock->gblock.guid); 1044 1045 device_initialize(&wblock->dev.dev); 1046 1047 return 0; 1048 } 1049 1050 static int wmi_add_device(struct platform_device *pdev, struct wmi_device *wdev) 1051 { 1052 struct device_link *link; 1053 1054 /* 1055 * Many aggregate WMI drivers do not use -EPROBE_DEFER when they 1056 * are unable to find a WMI device during probe, instead they require 1057 * all WMI devices associated with an platform device to become available 1058 * at once. This device link thus prevents WMI drivers from probing until 1059 * the associated platform device has finished probing (and has registered 1060 * all discovered WMI devices). 1061 */ 1062 1063 link = device_link_add(&wdev->dev, &pdev->dev, DL_FLAG_AUTOREMOVE_SUPPLIER); 1064 if (!link) 1065 return -EINVAL; 1066 1067 return device_add(&wdev->dev); 1068 } 1069 1070 static bool guid_already_parsed_for_legacy(struct acpi_device *device, const guid_t *guid) 1071 { 1072 struct wmi_block *wblock; 1073 1074 list_for_each_entry(wblock, &wmi_block_list, list) { 1075 /* skip warning and register if we know the driver will use struct wmi_driver */ 1076 for (int i = 0; allow_duplicates[i] != NULL; i++) { 1077 if (guid_parse_and_compare(allow_duplicates[i], guid)) 1078 return false; 1079 } 1080 if (guid_equal(&wblock->gblock.guid, guid)) { 1081 /* 1082 * Because we historically didn't track the relationship 1083 * between GUIDs and ACPI nodes, we don't know whether 1084 * we need to suppress GUIDs that are unique on a 1085 * given node but duplicated across nodes. 1086 */ 1087 dev_warn(&device->dev, "duplicate WMI GUID %pUL (first instance was on %s)\n", 1088 guid, dev_name(&wblock->acpi_device->dev)); 1089 return true; 1090 } 1091 } 1092 1093 return false; 1094 } 1095 1096 /* 1097 * Parse the _WDG method for the GUID data blocks 1098 */ 1099 static int parse_wdg(struct device *wmi_bus_dev, struct platform_device *pdev) 1100 { 1101 struct acpi_device *device = ACPI_COMPANION(&pdev->dev); 1102 struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL}; 1103 const struct guid_block *gblock; 1104 struct wmi_block *wblock; 1105 union acpi_object *obj; 1106 acpi_status status; 1107 u32 i, total; 1108 int retval; 1109 1110 status = acpi_evaluate_object(device->handle, "_WDG", NULL, &out); 1111 if (ACPI_FAILURE(status)) 1112 return -ENXIO; 1113 1114 obj = out.pointer; 1115 if (!obj) 1116 return -ENXIO; 1117 1118 if (obj->type != ACPI_TYPE_BUFFER) { 1119 kfree(obj); 1120 return -ENXIO; 1121 } 1122 1123 gblock = (const struct guid_block *)obj->buffer.pointer; 1124 total = obj->buffer.length / sizeof(struct guid_block); 1125 1126 for (i = 0; i < total; i++) { 1127 if (!gblock[i].instance_count) { 1128 dev_info(wmi_bus_dev, FW_INFO "%pUL has zero instances\n", &gblock[i].guid); 1129 continue; 1130 } 1131 1132 if (guid_already_parsed_for_legacy(device, &gblock[i].guid)) 1133 continue; 1134 1135 wblock = kzalloc(sizeof(*wblock), GFP_KERNEL); 1136 if (!wblock) { 1137 dev_err(wmi_bus_dev, "Failed to allocate %pUL\n", &gblock[i].guid); 1138 continue; 1139 } 1140 1141 wblock->acpi_device = device; 1142 wblock->gblock = gblock[i]; 1143 1144 retval = wmi_create_device(wmi_bus_dev, wblock, device); 1145 if (retval) { 1146 kfree(wblock); 1147 continue; 1148 } 1149 1150 list_add_tail(&wblock->list, &wmi_block_list); 1151 1152 retval = wmi_add_device(pdev, &wblock->dev); 1153 if (retval) { 1154 dev_err(wmi_bus_dev, "failed to register %pUL\n", 1155 &wblock->gblock.guid); 1156 1157 list_del(&wblock->list); 1158 put_device(&wblock->dev.dev); 1159 } 1160 } 1161 1162 kfree(obj); 1163 1164 return 0; 1165 } 1166 1167 /* 1168 * WMI can have EmbeddedControl access regions. In which case, we just want to 1169 * hand these off to the EC driver. 1170 */ 1171 static acpi_status 1172 acpi_wmi_ec_space_handler(u32 function, acpi_physical_address address, 1173 u32 bits, u64 *value, 1174 void *handler_context, void *region_context) 1175 { 1176 int result = 0; 1177 u8 temp = 0; 1178 1179 if ((address > 0xFF) || !value) 1180 return AE_BAD_PARAMETER; 1181 1182 if (function != ACPI_READ && function != ACPI_WRITE) 1183 return AE_BAD_PARAMETER; 1184 1185 if (bits != 8) 1186 return AE_BAD_PARAMETER; 1187 1188 if (function == ACPI_READ) { 1189 result = ec_read(address, &temp); 1190 *value = temp; 1191 } else { 1192 temp = 0xff & *value; 1193 result = ec_write(address, temp); 1194 } 1195 1196 switch (result) { 1197 case -EINVAL: 1198 return AE_BAD_PARAMETER; 1199 case -ENODEV: 1200 return AE_NOT_FOUND; 1201 case -ETIME: 1202 return AE_TIME; 1203 default: 1204 return AE_OK; 1205 } 1206 } 1207 1208 static void wmi_notify_driver(struct wmi_block *wblock) 1209 { 1210 struct wmi_driver *driver = drv_to_wdrv(wblock->dev.dev.driver); 1211 struct acpi_buffer data = { ACPI_ALLOCATE_BUFFER, NULL }; 1212 acpi_status status; 1213 1214 if (!driver->no_notify_data) { 1215 status = get_event_data(wblock, &data); 1216 if (ACPI_FAILURE(status)) { 1217 dev_warn(&wblock->dev.dev, "Failed to get event data\n"); 1218 return; 1219 } 1220 } 1221 1222 if (driver->notify) 1223 driver->notify(&wblock->dev, data.pointer); 1224 1225 kfree(data.pointer); 1226 } 1227 1228 static int wmi_notify_device(struct device *dev, void *data) 1229 { 1230 struct wmi_block *wblock = dev_to_wblock(dev); 1231 u32 *event = data; 1232 1233 if (!(wblock->gblock.flags & ACPI_WMI_EVENT && wblock->gblock.notify_id == *event)) 1234 return 0; 1235 1236 down_read(&wblock->notify_lock); 1237 /* The WMI driver notify handler conflicts with the legacy WMI handler. 1238 * Because of this the WMI driver notify handler takes precedence. 1239 */ 1240 if (wblock->dev.dev.driver && wblock->driver_ready) { 1241 wmi_notify_driver(wblock); 1242 } else { 1243 if (wblock->handler) 1244 wblock->handler(*event, wblock->handler_data); 1245 } 1246 up_read(&wblock->notify_lock); 1247 1248 acpi_bus_generate_netlink_event(wblock->acpi_device->pnp.device_class, 1249 dev_name(&wblock->dev.dev), *event, 0); 1250 1251 return -EBUSY; 1252 } 1253 1254 static void acpi_wmi_notify_handler(acpi_handle handle, u32 event, void *context) 1255 { 1256 struct device *wmi_bus_dev = context; 1257 1258 device_for_each_child(wmi_bus_dev, &event, wmi_notify_device); 1259 } 1260 1261 static int wmi_remove_device(struct device *dev, void *data) 1262 { 1263 struct wmi_block *wblock = dev_to_wblock(dev); 1264 1265 list_del(&wblock->list); 1266 device_unregister(dev); 1267 1268 return 0; 1269 } 1270 1271 static void acpi_wmi_remove(struct platform_device *device) 1272 { 1273 struct device *wmi_bus_device = dev_get_drvdata(&device->dev); 1274 1275 device_for_each_child_reverse(wmi_bus_device, NULL, wmi_remove_device); 1276 } 1277 1278 static void acpi_wmi_remove_notify_handler(void *data) 1279 { 1280 struct acpi_device *acpi_device = data; 1281 1282 acpi_remove_notify_handler(acpi_device->handle, ACPI_ALL_NOTIFY, acpi_wmi_notify_handler); 1283 } 1284 1285 static void acpi_wmi_remove_address_space_handler(void *data) 1286 { 1287 struct acpi_device *acpi_device = data; 1288 1289 acpi_remove_address_space_handler(acpi_device->handle, ACPI_ADR_SPACE_EC, 1290 &acpi_wmi_ec_space_handler); 1291 } 1292 1293 static void acpi_wmi_remove_bus_device(void *data) 1294 { 1295 struct device *wmi_bus_dev = data; 1296 1297 device_unregister(wmi_bus_dev); 1298 } 1299 1300 static int acpi_wmi_probe(struct platform_device *device) 1301 { 1302 struct acpi_device *acpi_device; 1303 struct device *wmi_bus_dev; 1304 acpi_status status; 1305 int error; 1306 1307 acpi_device = ACPI_COMPANION(&device->dev); 1308 if (!acpi_device) { 1309 dev_err(&device->dev, "ACPI companion is missing\n"); 1310 return -ENODEV; 1311 } 1312 1313 wmi_bus_dev = device_create(&wmi_bus_class, &device->dev, MKDEV(0, 0), NULL, "wmi_bus-%s", 1314 dev_name(&device->dev)); 1315 if (IS_ERR(wmi_bus_dev)) 1316 return PTR_ERR(wmi_bus_dev); 1317 1318 error = devm_add_action_or_reset(&device->dev, acpi_wmi_remove_bus_device, wmi_bus_dev); 1319 if (error < 0) 1320 return error; 1321 1322 dev_set_drvdata(&device->dev, wmi_bus_dev); 1323 1324 status = acpi_install_address_space_handler(acpi_device->handle, 1325 ACPI_ADR_SPACE_EC, 1326 &acpi_wmi_ec_space_handler, 1327 NULL, NULL); 1328 if (ACPI_FAILURE(status)) { 1329 dev_err(&device->dev, "Error installing EC region handler\n"); 1330 return -ENODEV; 1331 } 1332 error = devm_add_action_or_reset(&device->dev, acpi_wmi_remove_address_space_handler, 1333 acpi_device); 1334 if (error < 0) 1335 return error; 1336 1337 status = acpi_install_notify_handler(acpi_device->handle, ACPI_ALL_NOTIFY, 1338 acpi_wmi_notify_handler, wmi_bus_dev); 1339 if (ACPI_FAILURE(status)) { 1340 dev_err(&device->dev, "Error installing notify handler\n"); 1341 return -ENODEV; 1342 } 1343 error = devm_add_action_or_reset(&device->dev, acpi_wmi_remove_notify_handler, 1344 acpi_device); 1345 if (error < 0) 1346 return error; 1347 1348 error = parse_wdg(wmi_bus_dev, device); 1349 if (error) { 1350 pr_err("Failed to parse WDG method\n"); 1351 return error; 1352 } 1353 1354 return 0; 1355 } 1356 1357 int __must_check __wmi_driver_register(struct wmi_driver *driver, 1358 struct module *owner) 1359 { 1360 driver->driver.owner = owner; 1361 driver->driver.bus = &wmi_bus_type; 1362 1363 return driver_register(&driver->driver); 1364 } 1365 EXPORT_SYMBOL(__wmi_driver_register); 1366 1367 /** 1368 * wmi_driver_unregister() - Unregister a WMI driver 1369 * @driver: WMI driver to unregister 1370 * 1371 * Unregisters a WMI driver from the WMI bus. 1372 */ 1373 void wmi_driver_unregister(struct wmi_driver *driver) 1374 { 1375 driver_unregister(&driver->driver); 1376 } 1377 EXPORT_SYMBOL(wmi_driver_unregister); 1378 1379 static struct platform_driver acpi_wmi_driver = { 1380 .driver = { 1381 .name = "acpi-wmi", 1382 .acpi_match_table = wmi_device_ids, 1383 }, 1384 .probe = acpi_wmi_probe, 1385 .remove_new = acpi_wmi_remove, 1386 }; 1387 1388 static int __init acpi_wmi_init(void) 1389 { 1390 int error; 1391 1392 if (acpi_disabled) 1393 return -ENODEV; 1394 1395 error = class_register(&wmi_bus_class); 1396 if (error) 1397 return error; 1398 1399 error = bus_register(&wmi_bus_type); 1400 if (error) 1401 goto err_unreg_class; 1402 1403 error = platform_driver_register(&acpi_wmi_driver); 1404 if (error) { 1405 pr_err("Error loading mapper\n"); 1406 goto err_unreg_bus; 1407 } 1408 1409 return 0; 1410 1411 err_unreg_bus: 1412 bus_unregister(&wmi_bus_type); 1413 1414 err_unreg_class: 1415 class_unregister(&wmi_bus_class); 1416 1417 return error; 1418 } 1419 1420 static void __exit acpi_wmi_exit(void) 1421 { 1422 platform_driver_unregister(&acpi_wmi_driver); 1423 bus_unregister(&wmi_bus_type); 1424 class_unregister(&wmi_bus_class); 1425 } 1426 1427 subsys_initcall_sync(acpi_wmi_init); 1428 module_exit(acpi_wmi_exit); 1429