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