1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * acpi_utils.c - ACPI Utility Functions ($Revision: 10 $) 4 * 5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 */ 8 9 #define pr_fmt(fmt) "ACPI: utils: " fmt 10 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/slab.h> 14 #include <linux/init.h> 15 #include <linux/types.h> 16 #include <linux/hardirq.h> 17 #include <linux/acpi.h> 18 #include <linux/dynamic_debug.h> 19 20 #include "internal.h" 21 #include "sleep.h" 22 23 /* -------------------------------------------------------------------------- 24 Object Evaluation Helpers 25 -------------------------------------------------------------------------- */ 26 static void acpi_util_eval_error(acpi_handle h, acpi_string p, acpi_status s) 27 { 28 acpi_handle_debug(h, "Evaluate [%s]: %s\n", p, acpi_format_exception(s)); 29 } 30 31 acpi_status 32 acpi_extract_package(union acpi_object *package, 33 struct acpi_buffer *format, struct acpi_buffer *buffer) 34 { 35 u32 size_required = 0; 36 u32 tail_offset = 0; 37 char *format_string = NULL; 38 u32 format_count = 0; 39 u32 i = 0; 40 u8 *head = NULL; 41 u8 *tail = NULL; 42 43 44 if (!package || (package->type != ACPI_TYPE_PACKAGE) 45 || (package->package.count < 1)) { 46 pr_debug("Invalid package argument\n"); 47 return AE_BAD_PARAMETER; 48 } 49 50 if (!format || !format->pointer || (format->length < 1)) { 51 pr_debug("Invalid format argument\n"); 52 return AE_BAD_PARAMETER; 53 } 54 55 if (!buffer) { 56 pr_debug("Invalid buffer argument\n"); 57 return AE_BAD_PARAMETER; 58 } 59 60 format_count = (format->length / sizeof(char)) - 1; 61 if (format_count > package->package.count) { 62 pr_debug("Format specifies more objects [%d] than present [%d]\n", 63 format_count, package->package.count); 64 return AE_BAD_DATA; 65 } 66 67 format_string = format->pointer; 68 69 /* 70 * Calculate size_required. 71 */ 72 for (i = 0; i < format_count; i++) { 73 74 union acpi_object *element = &(package->package.elements[i]); 75 76 switch (element->type) { 77 78 case ACPI_TYPE_INTEGER: 79 switch (format_string[i]) { 80 case 'N': 81 size_required += sizeof(u64); 82 tail_offset += sizeof(u64); 83 break; 84 case 'S': 85 size_required += 86 sizeof(char *) + sizeof(u64) + 87 sizeof(char); 88 tail_offset += sizeof(char *); 89 break; 90 default: 91 pr_debug("Invalid package element [%d]: got number, expected [%c]\n", 92 i, format_string[i]); 93 return AE_BAD_DATA; 94 } 95 break; 96 97 case ACPI_TYPE_STRING: 98 case ACPI_TYPE_BUFFER: 99 switch (format_string[i]) { 100 case 'S': 101 size_required += 102 sizeof(char *) + 103 (element->string.length * sizeof(char)) + 104 sizeof(char); 105 tail_offset += sizeof(char *); 106 break; 107 case 'B': 108 size_required += 109 sizeof(u8 *) + element->buffer.length; 110 tail_offset += sizeof(u8 *); 111 break; 112 default: 113 pr_debug("Invalid package element [%d] got string/buffer, expected [%c]\n", 114 i, format_string[i]); 115 return AE_BAD_DATA; 116 } 117 break; 118 case ACPI_TYPE_LOCAL_REFERENCE: 119 switch (format_string[i]) { 120 case 'R': 121 size_required += sizeof(void *); 122 tail_offset += sizeof(void *); 123 break; 124 default: 125 pr_debug("Invalid package element [%d] got reference, expected [%c]\n", 126 i, format_string[i]); 127 return AE_BAD_DATA; 128 } 129 break; 130 131 case ACPI_TYPE_PACKAGE: 132 default: 133 pr_debug("Unsupported element at index=%d\n", i); 134 /* TBD: handle nested packages... */ 135 return AE_SUPPORT; 136 } 137 } 138 139 /* 140 * Validate output buffer. 141 */ 142 if (buffer->length == ACPI_ALLOCATE_BUFFER) { 143 buffer->pointer = ACPI_ALLOCATE_ZEROED(size_required); 144 if (!buffer->pointer) 145 return AE_NO_MEMORY; 146 buffer->length = size_required; 147 } else { 148 if (buffer->length < size_required) { 149 buffer->length = size_required; 150 return AE_BUFFER_OVERFLOW; 151 } else if (buffer->length != size_required || 152 !buffer->pointer) { 153 return AE_BAD_PARAMETER; 154 } 155 } 156 157 head = buffer->pointer; 158 tail = buffer->pointer + tail_offset; 159 160 /* 161 * Extract package data. 162 */ 163 for (i = 0; i < format_count; i++) { 164 165 u8 **pointer = NULL; 166 union acpi_object *element = &(package->package.elements[i]); 167 168 switch (element->type) { 169 170 case ACPI_TYPE_INTEGER: 171 switch (format_string[i]) { 172 case 'N': 173 *((u64 *) head) = 174 element->integer.value; 175 head += sizeof(u64); 176 break; 177 case 'S': 178 pointer = (u8 **) head; 179 *pointer = tail; 180 *((u64 *) tail) = 181 element->integer.value; 182 head += sizeof(u64 *); 183 tail += sizeof(u64); 184 /* NULL terminate string */ 185 *tail = (char)0; 186 tail += sizeof(char); 187 break; 188 default: 189 /* Should never get here */ 190 break; 191 } 192 break; 193 194 case ACPI_TYPE_STRING: 195 case ACPI_TYPE_BUFFER: 196 switch (format_string[i]) { 197 case 'S': 198 pointer = (u8 **) head; 199 *pointer = tail; 200 memcpy(tail, element->string.pointer, 201 element->string.length); 202 head += sizeof(char *); 203 tail += element->string.length * sizeof(char); 204 /* NULL terminate string */ 205 *tail = (char)0; 206 tail += sizeof(char); 207 break; 208 case 'B': 209 pointer = (u8 **) head; 210 *pointer = tail; 211 memcpy(tail, element->buffer.pointer, 212 element->buffer.length); 213 head += sizeof(u8 *); 214 tail += element->buffer.length; 215 break; 216 default: 217 /* Should never get here */ 218 break; 219 } 220 break; 221 case ACPI_TYPE_LOCAL_REFERENCE: 222 switch (format_string[i]) { 223 case 'R': 224 *(void **)head = 225 (void *)element->reference.handle; 226 head += sizeof(void *); 227 break; 228 default: 229 /* Should never get here */ 230 break; 231 } 232 break; 233 case ACPI_TYPE_PACKAGE: 234 /* TBD: handle nested packages... */ 235 default: 236 /* Should never get here */ 237 break; 238 } 239 } 240 241 return AE_OK; 242 } 243 244 EXPORT_SYMBOL(acpi_extract_package); 245 246 acpi_status 247 acpi_evaluate_integer(acpi_handle handle, 248 acpi_string pathname, 249 struct acpi_object_list *arguments, unsigned long long *data) 250 { 251 acpi_status status = AE_OK; 252 union acpi_object element; 253 struct acpi_buffer buffer = { 0, NULL }; 254 255 if (!data) 256 return AE_BAD_PARAMETER; 257 258 buffer.length = sizeof(union acpi_object); 259 buffer.pointer = &element; 260 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 261 if (ACPI_FAILURE(status)) { 262 acpi_util_eval_error(handle, pathname, status); 263 return status; 264 } 265 266 if (element.type != ACPI_TYPE_INTEGER) { 267 acpi_util_eval_error(handle, pathname, AE_BAD_DATA); 268 return AE_BAD_DATA; 269 } 270 271 *data = element.integer.value; 272 273 acpi_handle_debug(handle, "Return value [%llu]\n", *data); 274 275 return AE_OK; 276 } 277 278 EXPORT_SYMBOL(acpi_evaluate_integer); 279 280 int acpi_get_local_address(acpi_handle handle, u32 *addr) 281 { 282 unsigned long long adr; 283 acpi_status status; 284 285 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr); 286 if (ACPI_FAILURE(status)) 287 return -ENODATA; 288 289 *addr = (u32)adr; 290 return 0; 291 } 292 EXPORT_SYMBOL(acpi_get_local_address); 293 294 #define ACPI_MAX_SUB_BUF_SIZE 9 295 296 const char *acpi_get_subsystem_id(acpi_handle handle) 297 { 298 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 299 union acpi_object *obj; 300 acpi_status status; 301 const char *sub; 302 size_t len; 303 304 status = acpi_evaluate_object(handle, METHOD_NAME__SUB, NULL, &buffer); 305 if (ACPI_FAILURE(status)) { 306 acpi_handle_debug(handle, "Reading ACPI _SUB failed: %#x\n", status); 307 return ERR_PTR(-ENODATA); 308 } 309 310 obj = buffer.pointer; 311 if (obj->type == ACPI_TYPE_STRING) { 312 len = strlen(obj->string.pointer); 313 if (len < ACPI_MAX_SUB_BUF_SIZE && len > 0) { 314 sub = kstrdup(obj->string.pointer, GFP_KERNEL); 315 if (!sub) 316 sub = ERR_PTR(-ENOMEM); 317 } else { 318 acpi_handle_err(handle, "ACPI _SUB Length %zu is Invalid\n", len); 319 sub = ERR_PTR(-ENODATA); 320 } 321 } else { 322 acpi_handle_warn(handle, "Warning ACPI _SUB did not return a string\n"); 323 sub = ERR_PTR(-ENODATA); 324 } 325 326 acpi_os_free(buffer.pointer); 327 328 return sub; 329 } 330 EXPORT_SYMBOL_GPL(acpi_get_subsystem_id); 331 332 acpi_status 333 acpi_evaluate_reference(acpi_handle handle, 334 acpi_string pathname, 335 struct acpi_object_list *arguments, 336 struct acpi_handle_list *list) 337 { 338 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 339 union acpi_object *package; 340 acpi_status status; 341 u32 i; 342 343 if (!list) 344 return AE_BAD_PARAMETER; 345 346 /* Evaluate object. */ 347 348 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 349 if (ACPI_FAILURE(status)) 350 goto end; 351 352 package = buffer.pointer; 353 354 if (buffer.length == 0 || !package || 355 package->type != ACPI_TYPE_PACKAGE || !package->package.count) { 356 status = AE_BAD_DATA; 357 goto err; 358 } 359 360 list->count = package->package.count; 361 list->handles = kcalloc(list->count, sizeof(*list->handles), GFP_KERNEL); 362 if (!list->handles) { 363 status = AE_NO_MEMORY; 364 goto err_clear; 365 } 366 367 /* Extract package data. */ 368 369 for (i = 0; i < list->count; i++) { 370 union acpi_object *element = &(package->package.elements[i]); 371 372 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) { 373 status = AE_BAD_DATA; 374 goto err_free; 375 } 376 377 if (!element->reference.handle) { 378 status = AE_NULL_ENTRY; 379 goto err_free; 380 } 381 /* Get the acpi_handle. */ 382 383 list->handles[i] = element->reference.handle; 384 acpi_handle_debug(list->handles[i], "Found in reference list\n"); 385 } 386 387 end: 388 kfree(buffer.pointer); 389 390 return status; 391 392 err_free: 393 kfree(list->handles); 394 list->handles = NULL; 395 396 err_clear: 397 list->count = 0; 398 399 err: 400 acpi_util_eval_error(handle, pathname, status); 401 goto end; 402 } 403 404 EXPORT_SYMBOL(acpi_evaluate_reference); 405 406 /** 407 * acpi_handle_list_equal - Check if two ACPI handle lists are the same 408 * @list1: First list to compare. 409 * @list2: Second list to compare. 410 * 411 * Return true if the given ACPI handle lists are of the same size and 412 * contain the same ACPI handles in the same order. Otherwise, return false. 413 */ 414 bool acpi_handle_list_equal(struct acpi_handle_list *list1, 415 struct acpi_handle_list *list2) 416 { 417 return list1->count == list2->count && 418 !memcmp(list1->handles, list2->handles, 419 list1->count * sizeof(acpi_handle)); 420 } 421 EXPORT_SYMBOL_GPL(acpi_handle_list_equal); 422 423 /** 424 * acpi_handle_list_replace - Replace one ACPI handle list with another 425 * @dst: ACPI handle list to replace. 426 * @src: Source ACPI handle list. 427 * 428 * Free the handles table in @dst, move the handles table from @src to @dst, 429 * copy count from @src to @dst and clear @src. 430 */ 431 void acpi_handle_list_replace(struct acpi_handle_list *dst, 432 struct acpi_handle_list *src) 433 { 434 if (dst->count) 435 kfree(dst->handles); 436 437 dst->count = src->count; 438 dst->handles = src->handles; 439 440 src->handles = NULL; 441 src->count = 0; 442 } 443 EXPORT_SYMBOL_GPL(acpi_handle_list_replace); 444 445 /** 446 * acpi_handle_list_free - Free the handles table in an ACPI handle list 447 * @list: ACPI handle list to free. 448 * 449 * Free the handles table in @list and clear its count field. 450 */ 451 void acpi_handle_list_free(struct acpi_handle_list *list) 452 { 453 if (!list->count) 454 return; 455 456 kfree(list->handles); 457 list->count = 0; 458 } 459 EXPORT_SYMBOL_GPL(acpi_handle_list_free); 460 461 acpi_status 462 acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld) 463 { 464 acpi_status status; 465 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 466 union acpi_object *output; 467 468 status = acpi_evaluate_object(handle, "_PLD", NULL, &buffer); 469 470 if (ACPI_FAILURE(status)) 471 return status; 472 473 output = buffer.pointer; 474 475 if (!output || output->type != ACPI_TYPE_PACKAGE 476 || !output->package.count 477 || output->package.elements[0].type != ACPI_TYPE_BUFFER 478 || output->package.elements[0].buffer.length < ACPI_PLD_REV1_BUFFER_SIZE) { 479 status = AE_TYPE; 480 goto out; 481 } 482 483 status = acpi_decode_pld_buffer( 484 output->package.elements[0].buffer.pointer, 485 output->package.elements[0].buffer.length, 486 pld); 487 488 out: 489 kfree(buffer.pointer); 490 return status; 491 } 492 EXPORT_SYMBOL(acpi_get_physical_device_location); 493 494 /** 495 * acpi_evaluate_ost: Evaluate _OST for hotplug operations 496 * @handle: ACPI device handle 497 * @source_event: source event code 498 * @status_code: status code 499 * @status_buf: optional detailed information (NULL if none) 500 * 501 * Evaluate _OST for hotplug operations. All ACPI hotplug handlers 502 * must call this function when evaluating _OST for hotplug operations. 503 * When the platform does not support _OST, this function has no effect. 504 */ 505 acpi_status 506 acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code, 507 struct acpi_buffer *status_buf) 508 { 509 union acpi_object params[3] = { 510 {.type = ACPI_TYPE_INTEGER,}, 511 {.type = ACPI_TYPE_INTEGER,}, 512 {.type = ACPI_TYPE_BUFFER,} 513 }; 514 struct acpi_object_list arg_list = {3, params}; 515 516 params[0].integer.value = source_event; 517 params[1].integer.value = status_code; 518 if (status_buf != NULL) { 519 params[2].buffer.pointer = status_buf->pointer; 520 params[2].buffer.length = status_buf->length; 521 } else { 522 params[2].buffer.pointer = NULL; 523 params[2].buffer.length = 0; 524 } 525 526 return acpi_evaluate_object(handle, "_OST", &arg_list, NULL); 527 } 528 EXPORT_SYMBOL(acpi_evaluate_ost); 529 530 /** 531 * acpi_handle_path: Return the object path of handle 532 * @handle: ACPI device handle 533 * 534 * Caller must free the returned buffer 535 */ 536 static char *acpi_handle_path(acpi_handle handle) 537 { 538 struct acpi_buffer buffer = { 539 .length = ACPI_ALLOCATE_BUFFER, 540 .pointer = NULL 541 }; 542 543 if (in_interrupt() || 544 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer) != AE_OK) 545 return NULL; 546 return buffer.pointer; 547 } 548 549 /** 550 * acpi_handle_printk: Print message with ACPI prefix and object path 551 * @level: log level 552 * @handle: ACPI device handle 553 * @fmt: format string 554 * 555 * This function is called through acpi_handle_<level> macros and prints 556 * a message with ACPI prefix and object path. This function acquires 557 * the global namespace mutex to obtain an object path. In interrupt 558 * context, it shows the object path as <n/a>. 559 */ 560 void 561 acpi_handle_printk(const char *level, acpi_handle handle, const char *fmt, ...) 562 { 563 struct va_format vaf; 564 va_list args; 565 const char *path; 566 567 va_start(args, fmt); 568 vaf.fmt = fmt; 569 vaf.va = &args; 570 571 path = acpi_handle_path(handle); 572 printk("%sACPI: %s: %pV", level, path ? path : "<n/a>", &vaf); 573 574 va_end(args); 575 kfree(path); 576 } 577 EXPORT_SYMBOL(acpi_handle_printk); 578 579 #if defined(CONFIG_DYNAMIC_DEBUG) 580 /** 581 * __acpi_handle_debug: pr_debug with ACPI prefix and object path 582 * @descriptor: Dynamic Debug descriptor 583 * @handle: ACPI device handle 584 * @fmt: format string 585 * 586 * This function is called through acpi_handle_debug macro and debug 587 * prints a message with ACPI prefix and object path. This function 588 * acquires the global namespace mutex to obtain an object path. In 589 * interrupt context, it shows the object path as <n/a>. 590 */ 591 void 592 __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, 593 const char *fmt, ...) 594 { 595 struct va_format vaf; 596 va_list args; 597 const char *path; 598 599 va_start(args, fmt); 600 vaf.fmt = fmt; 601 vaf.va = &args; 602 603 path = acpi_handle_path(handle); 604 __dynamic_pr_debug(descriptor, "ACPI: %s: %pV", path ? path : "<n/a>", &vaf); 605 606 va_end(args); 607 kfree(path); 608 } 609 EXPORT_SYMBOL(__acpi_handle_debug); 610 #endif 611 612 /** 613 * acpi_evaluation_failure_warn - Log evaluation failure warning. 614 * @handle: Parent object handle. 615 * @name: Name of the object whose evaluation has failed. 616 * @status: Status value returned by the failing object evaluation. 617 */ 618 void acpi_evaluation_failure_warn(acpi_handle handle, const char *name, 619 acpi_status status) 620 { 621 acpi_handle_warn(handle, "%s evaluation failed: %s\n", name, 622 acpi_format_exception(status)); 623 } 624 EXPORT_SYMBOL_GPL(acpi_evaluation_failure_warn); 625 626 /** 627 * acpi_has_method: Check whether @handle has a method named @name 628 * @handle: ACPI device handle 629 * @name: name of object or method 630 * 631 * Check whether @handle has a method named @name. 632 */ 633 bool acpi_has_method(acpi_handle handle, char *name) 634 { 635 acpi_handle tmp; 636 637 return ACPI_SUCCESS(acpi_get_handle(handle, name, &tmp)); 638 } 639 EXPORT_SYMBOL(acpi_has_method); 640 641 acpi_status acpi_execute_simple_method(acpi_handle handle, char *method, 642 u64 arg) 643 { 644 union acpi_object obj = { .type = ACPI_TYPE_INTEGER }; 645 struct acpi_object_list arg_list = { .count = 1, .pointer = &obj, }; 646 647 obj.integer.value = arg; 648 649 return acpi_evaluate_object(handle, method, &arg_list, NULL); 650 } 651 EXPORT_SYMBOL(acpi_execute_simple_method); 652 653 /** 654 * acpi_evaluate_ej0: Evaluate _EJ0 method for hotplug operations 655 * @handle: ACPI device handle 656 * 657 * Evaluate device's _EJ0 method for hotplug operations. 658 */ 659 acpi_status acpi_evaluate_ej0(acpi_handle handle) 660 { 661 acpi_status status; 662 663 status = acpi_execute_simple_method(handle, "_EJ0", 1); 664 if (status == AE_NOT_FOUND) 665 acpi_handle_warn(handle, "No _EJ0 support for device\n"); 666 else if (ACPI_FAILURE(status)) 667 acpi_handle_warn(handle, "Eject failed (0x%x)\n", status); 668 669 return status; 670 } 671 672 /** 673 * acpi_evaluate_lck: Evaluate _LCK method to lock/unlock device 674 * @handle: ACPI device handle 675 * @lock: lock device if non-zero, otherwise unlock device 676 * 677 * Evaluate device's _LCK method if present to lock/unlock device 678 */ 679 acpi_status acpi_evaluate_lck(acpi_handle handle, int lock) 680 { 681 acpi_status status; 682 683 status = acpi_execute_simple_method(handle, "_LCK", !!lock); 684 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 685 if (lock) 686 acpi_handle_warn(handle, 687 "Locking device failed (0x%x)\n", status); 688 else 689 acpi_handle_warn(handle, 690 "Unlocking device failed (0x%x)\n", status); 691 } 692 693 return status; 694 } 695 696 /** 697 * acpi_evaluate_reg: Evaluate _REG method to register OpRegion presence 698 * @handle: ACPI device handle 699 * @space_id: ACPI address space id to register OpRegion presence for 700 * @function: Parameter to pass to _REG one of ACPI_REG_CONNECT or 701 * ACPI_REG_DISCONNECT 702 * 703 * Evaluate device's _REG method to register OpRegion presence. 704 */ 705 acpi_status acpi_evaluate_reg(acpi_handle handle, u8 space_id, u32 function) 706 { 707 struct acpi_object_list arg_list; 708 union acpi_object params[2]; 709 710 params[0].type = ACPI_TYPE_INTEGER; 711 params[0].integer.value = space_id; 712 params[1].type = ACPI_TYPE_INTEGER; 713 params[1].integer.value = function; 714 arg_list.count = 2; 715 arg_list.pointer = params; 716 717 return acpi_evaluate_object(handle, "_REG", &arg_list, NULL); 718 } 719 EXPORT_SYMBOL(acpi_evaluate_reg); 720 721 /** 722 * acpi_evaluate_dsm - evaluate device's _DSM method 723 * @handle: ACPI device handle 724 * @guid: GUID of requested functions, should be 16 bytes 725 * @rev: revision number of requested function 726 * @func: requested function number 727 * @argv4: the function specific parameter 728 * 729 * Evaluate device's _DSM method with specified GUID, revision id and 730 * function number. Caller needs to free the returned object. 731 * 732 * Though ACPI defines the fourth parameter for _DSM should be a package, 733 * some old BIOSes do expect a buffer or an integer etc. 734 */ 735 union acpi_object * 736 acpi_evaluate_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 func, 737 union acpi_object *argv4) 738 { 739 acpi_status ret; 740 struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL}; 741 union acpi_object params[4]; 742 struct acpi_object_list input = { 743 .count = 4, 744 .pointer = params, 745 }; 746 747 params[0].type = ACPI_TYPE_BUFFER; 748 params[0].buffer.length = 16; 749 params[0].buffer.pointer = (u8 *)guid; 750 params[1].type = ACPI_TYPE_INTEGER; 751 params[1].integer.value = rev; 752 params[2].type = ACPI_TYPE_INTEGER; 753 params[2].integer.value = func; 754 if (argv4) { 755 params[3] = *argv4; 756 } else { 757 params[3].type = ACPI_TYPE_PACKAGE; 758 params[3].package.count = 0; 759 params[3].package.elements = NULL; 760 } 761 762 ret = acpi_evaluate_object(handle, "_DSM", &input, &buf); 763 if (ACPI_SUCCESS(ret)) 764 return (union acpi_object *)buf.pointer; 765 766 if (ret != AE_NOT_FOUND) 767 acpi_handle_warn(handle, 768 "failed to evaluate _DSM %pUb (0x%x)\n", guid, ret); 769 770 return NULL; 771 } 772 EXPORT_SYMBOL(acpi_evaluate_dsm); 773 774 /** 775 * acpi_check_dsm - check if _DSM method supports requested functions. 776 * @handle: ACPI device handle 777 * @guid: GUID of requested functions, should be 16 bytes at least 778 * @rev: revision number of requested functions 779 * @funcs: bitmap of requested functions 780 * 781 * Evaluate device's _DSM method to check whether it supports requested 782 * functions. Currently only support 64 functions at maximum, should be 783 * enough for now. 784 */ 785 bool acpi_check_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 funcs) 786 { 787 int i; 788 u64 mask = 0; 789 union acpi_object *obj; 790 791 if (funcs == 0) 792 return false; 793 794 obj = acpi_evaluate_dsm(handle, guid, rev, 0, NULL); 795 if (!obj) 796 return false; 797 798 /* For compatibility, old BIOSes may return an integer */ 799 if (obj->type == ACPI_TYPE_INTEGER) 800 mask = obj->integer.value; 801 else if (obj->type == ACPI_TYPE_BUFFER) 802 for (i = 0; i < obj->buffer.length && i < 8; i++) 803 mask |= (((u64)obj->buffer.pointer[i]) << (i * 8)); 804 ACPI_FREE(obj); 805 806 /* 807 * Bit 0 indicates whether there's support for any functions other than 808 * function 0 for the specified GUID and revision. 809 */ 810 if ((mask & 0x1) && (mask & funcs) == funcs) 811 return true; 812 813 return false; 814 } 815 EXPORT_SYMBOL(acpi_check_dsm); 816 817 /** 818 * acpi_dev_uid_to_integer - treat ACPI device _UID as integer 819 * @adev: ACPI device to get _UID from 820 * @integer: output buffer for integer 821 * 822 * Considers _UID as integer and converts it to @integer. 823 * 824 * Returns 0 on success, or negative error code otherwise. 825 */ 826 int acpi_dev_uid_to_integer(struct acpi_device *adev, u64 *integer) 827 { 828 const char *uid; 829 830 if (!adev) 831 return -ENODEV; 832 833 uid = acpi_device_uid(adev); 834 if (!uid) 835 return -ENODATA; 836 837 return kstrtou64(uid, 0, integer); 838 } 839 EXPORT_SYMBOL(acpi_dev_uid_to_integer); 840 841 /** 842 * acpi_dev_found - Detect presence of a given ACPI device in the namespace. 843 * @hid: Hardware ID of the device. 844 * 845 * Return %true if the device was present at the moment of invocation. 846 * Note that if the device is pluggable, it may since have disappeared. 847 * 848 * For this function to work, acpi_bus_scan() must have been executed 849 * which happens in the subsys_initcall() subsection. Hence, do not 850 * call from a subsys_initcall() or earlier (use acpi_get_devices() 851 * instead). Calling from module_init() is fine (which is synonymous 852 * with device_initcall()). 853 */ 854 bool acpi_dev_found(const char *hid) 855 { 856 struct acpi_device_bus_id *acpi_device_bus_id; 857 bool found = false; 858 859 mutex_lock(&acpi_device_lock); 860 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) 861 if (!strcmp(acpi_device_bus_id->bus_id, hid)) { 862 found = true; 863 break; 864 } 865 mutex_unlock(&acpi_device_lock); 866 867 return found; 868 } 869 EXPORT_SYMBOL(acpi_dev_found); 870 871 struct acpi_dev_match_info { 872 struct acpi_device_id hid[2]; 873 const char *uid; 874 s64 hrv; 875 }; 876 877 static int acpi_dev_match_cb(struct device *dev, const void *data) 878 { 879 struct acpi_device *adev = to_acpi_device(dev); 880 const struct acpi_dev_match_info *match = data; 881 unsigned long long hrv; 882 acpi_status status; 883 884 if (acpi_match_device_ids(adev, match->hid)) 885 return 0; 886 887 if (match->uid && !acpi_dev_uid_match(adev, match->uid)) 888 return 0; 889 890 if (match->hrv == -1) 891 return 1; 892 893 status = acpi_evaluate_integer(adev->handle, "_HRV", NULL, &hrv); 894 if (ACPI_FAILURE(status)) 895 return 0; 896 897 return hrv == match->hrv; 898 } 899 900 /** 901 * acpi_dev_present - Detect that a given ACPI device is present 902 * @hid: Hardware ID of the device. 903 * @uid: Unique ID of the device, pass NULL to not check _UID 904 * @hrv: Hardware Revision of the device, pass -1 to not check _HRV 905 * 906 * Return %true if a matching device was present at the moment of invocation. 907 * Note that if the device is pluggable, it may since have disappeared. 908 * 909 * Note that unlike acpi_dev_found() this function checks the status 910 * of the device. So for devices which are present in the DSDT, but 911 * which are disabled (their _STA callback returns 0) this function 912 * will return false. 913 * 914 * For this function to work, acpi_bus_scan() must have been executed 915 * which happens in the subsys_initcall() subsection. Hence, do not 916 * call from a subsys_initcall() or earlier (use acpi_get_devices() 917 * instead). Calling from module_init() is fine (which is synonymous 918 * with device_initcall()). 919 */ 920 bool acpi_dev_present(const char *hid, const char *uid, s64 hrv) 921 { 922 struct acpi_dev_match_info match = {}; 923 struct device *dev; 924 925 strscpy(match.hid[0].id, hid, sizeof(match.hid[0].id)); 926 match.uid = uid; 927 match.hrv = hrv; 928 929 dev = bus_find_device(&acpi_bus_type, NULL, &match, acpi_dev_match_cb); 930 put_device(dev); 931 return !!dev; 932 } 933 EXPORT_SYMBOL(acpi_dev_present); 934 935 /** 936 * acpi_dev_get_next_match_dev - Return the next match of ACPI device 937 * @adev: Pointer to the previous ACPI device matching this @hid, @uid and @hrv 938 * @hid: Hardware ID of the device. 939 * @uid: Unique ID of the device, pass NULL to not check _UID 940 * @hrv: Hardware Revision of the device, pass -1 to not check _HRV 941 * 942 * Return the next match of ACPI device if another matching device was present 943 * at the moment of invocation, or NULL otherwise. 944 * 945 * The caller is responsible for invoking acpi_dev_put() on the returned device. 946 * On the other hand the function invokes acpi_dev_put() on the given @adev 947 * assuming that its reference counter had been increased beforehand. 948 * 949 * See additional information in acpi_dev_present() as well. 950 */ 951 struct acpi_device * 952 acpi_dev_get_next_match_dev(struct acpi_device *adev, const char *hid, const char *uid, s64 hrv) 953 { 954 struct device *start = adev ? &adev->dev : NULL; 955 struct acpi_dev_match_info match = {}; 956 struct device *dev; 957 958 strscpy(match.hid[0].id, hid, sizeof(match.hid[0].id)); 959 match.uid = uid; 960 match.hrv = hrv; 961 962 dev = bus_find_device(&acpi_bus_type, start, &match, acpi_dev_match_cb); 963 acpi_dev_put(adev); 964 return dev ? to_acpi_device(dev) : NULL; 965 } 966 EXPORT_SYMBOL(acpi_dev_get_next_match_dev); 967 968 /** 969 * acpi_dev_get_first_match_dev - Return the first match of ACPI device 970 * @hid: Hardware ID of the device. 971 * @uid: Unique ID of the device, pass NULL to not check _UID 972 * @hrv: Hardware Revision of the device, pass -1 to not check _HRV 973 * 974 * Return the first match of ACPI device if a matching device was present 975 * at the moment of invocation, or NULL otherwise. 976 * 977 * The caller is responsible for invoking acpi_dev_put() on the returned device. 978 * 979 * See additional information in acpi_dev_present() as well. 980 */ 981 struct acpi_device * 982 acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv) 983 { 984 return acpi_dev_get_next_match_dev(NULL, hid, uid, hrv); 985 } 986 EXPORT_SYMBOL(acpi_dev_get_first_match_dev); 987 988 /** 989 * acpi_reduced_hardware - Return if this is an ACPI-reduced-hw machine 990 * 991 * Return true when running on an ACPI-reduced-hw machine, false otherwise. 992 */ 993 bool acpi_reduced_hardware(void) 994 { 995 return acpi_gbl_reduced_hardware; 996 } 997 EXPORT_SYMBOL_GPL(acpi_reduced_hardware); 998 999 /* 1000 * acpi_backlight= handling, this is done here rather then in video_detect.c 1001 * because __setup cannot be used in modules. 1002 */ 1003 char acpi_video_backlight_string[16]; 1004 EXPORT_SYMBOL(acpi_video_backlight_string); 1005 1006 static int __init acpi_backlight(char *str) 1007 { 1008 strscpy(acpi_video_backlight_string, str, 1009 sizeof(acpi_video_backlight_string)); 1010 return 1; 1011 } 1012 __setup("acpi_backlight=", acpi_backlight); 1013 1014 /** 1015 * acpi_match_platform_list - Check if the system matches with a given list 1016 * @plat: pointer to acpi_platform_list table terminated by a NULL entry 1017 * 1018 * Return the matched index if the system is found in the platform list. 1019 * Otherwise, return a negative error code. 1020 */ 1021 int acpi_match_platform_list(const struct acpi_platform_list *plat) 1022 { 1023 struct acpi_table_header hdr; 1024 int idx = 0; 1025 1026 if (acpi_disabled) 1027 return -ENODEV; 1028 1029 for (; plat->oem_id[0]; plat++, idx++) { 1030 if (ACPI_FAILURE(acpi_get_table_header(plat->table, 0, &hdr))) 1031 continue; 1032 1033 if (strncmp(plat->oem_id, hdr.oem_id, ACPI_OEM_ID_SIZE)) 1034 continue; 1035 1036 if (strncmp(plat->oem_table_id, hdr.oem_table_id, ACPI_OEM_TABLE_ID_SIZE)) 1037 continue; 1038 1039 if ((plat->pred == all_versions) || 1040 (plat->pred == less_than_or_equal && hdr.oem_revision <= plat->oem_revision) || 1041 (plat->pred == greater_than_or_equal && hdr.oem_revision >= plat->oem_revision) || 1042 (plat->pred == equal && hdr.oem_revision == plat->oem_revision)) 1043 return idx; 1044 } 1045 1046 return -ENODEV; 1047 } 1048 EXPORT_SYMBOL(acpi_match_platform_list); 1049