FILE
utils.c
File preview with syntax highlighting.
linux-6.19.14/drivers/acpi/utils.c
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 -------------------------------------------------------------------------- */ 26static 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 31acpi_status 32acpi_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 244EXPORT_SYMBOL(acpi_extract_package); 245 246acpi_status 247acpi_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 278EXPORT_SYMBOL(acpi_evaluate_integer); 279 280int acpi_get_local_u64_address(acpi_handle handle, u64 *addr) 281{ 282 acpi_status status; 283 284 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, addr); 285 if (ACPI_FAILURE(status)) 286 return -ENODATA; 287 return 0; 288} 289EXPORT_SYMBOL(acpi_get_local_u64_address); 290 291int acpi_get_local_address(acpi_handle handle, u32 *addr) 292{ 293 u64 adr; 294 int ret; 295 296 ret = acpi_get_local_u64_address(handle, &adr); 297 if (ret < 0) 298 return ret; 299 *addr = (u32)adr; 300 return 0; 301} 302EXPORT_SYMBOL(acpi_get_local_address); 303 304#define ACPI_MAX_SUB_BUF_SIZE 9 305 306const char *acpi_get_subsystem_id(acpi_handle handle) 307{ 308 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 309 union acpi_object *obj; 310 acpi_status status; 311 const char *sub; 312 size_t len; 313 314 status = acpi_evaluate_object(handle, METHOD_NAME__SUB, NULL, &buffer); 315 if (ACPI_FAILURE(status)) { 316 acpi_handle_debug(handle, "Reading ACPI _SUB failed: %#x\n", status); 317 return ERR_PTR(-ENODATA); 318 } 319 320 obj = buffer.pointer; 321 if (obj->type == ACPI_TYPE_STRING) { 322 len = strlen(obj->string.pointer); 323 if (len < ACPI_MAX_SUB_BUF_SIZE && len > 0) { 324 sub = kstrdup(obj->string.pointer, GFP_KERNEL); 325 if (!sub) 326 sub = ERR_PTR(-ENOMEM); 327 } else { 328 acpi_handle_err(handle, "ACPI _SUB Length %zu is Invalid\n", len); 329 sub = ERR_PTR(-ENODATA); 330 } 331 } else { 332 acpi_handle_warn(handle, "Warning ACPI _SUB did not return a string\n"); 333 sub = ERR_PTR(-ENODATA); 334 } 335 336 acpi_os_free(buffer.pointer); 337 338 return sub; 339} 340EXPORT_SYMBOL_GPL(acpi_get_subsystem_id); 341 342bool acpi_evaluate_reference(acpi_handle handle, acpi_string pathname, 343 struct acpi_object_list *arguments, 344 struct acpi_handle_list *list) 345{ 346 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 347 union acpi_object *package; 348 acpi_status status; 349 bool ret = false; 350 u32 i; 351 352 if (!list) 353 return false; 354 355 /* Evaluate object. */ 356 357 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 358 if (ACPI_FAILURE(status)) 359 goto end; 360 361 package = buffer.pointer; 362 363 if (buffer.length == 0 || !package || 364 package->type != ACPI_TYPE_PACKAGE || !package->package.count) 365 goto err; 366 367 list->count = package->package.count; 368 list->handles = kcalloc(list->count, sizeof(*list->handles), GFP_KERNEL); 369 if (!list->handles) 370 goto err_clear; 371 372 /* Extract package data. */ 373 374 for (i = 0; i < list->count; i++) { 375 union acpi_object *element = &(package->package.elements[i]); 376 377 if (element->type != ACPI_TYPE_LOCAL_REFERENCE || 378 !element->reference.handle) 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 ret = true; 388 389end: 390 kfree(buffer.pointer); 391 392 return ret; 393 394err_free: 395 kfree(list->handles); 396 list->handles = NULL; 397 398err_clear: 399 list->count = 0; 400 401err: 402 acpi_util_eval_error(handle, pathname, status); 403 goto end; 404} 405 406EXPORT_SYMBOL(acpi_evaluate_reference); 407 408/** 409 * acpi_handle_list_equal - Check if two ACPI handle lists are the same 410 * @list1: First list to compare. 411 * @list2: Second list to compare. 412 * 413 * Return true if the given ACPI handle lists are of the same size and 414 * contain the same ACPI handles in the same order. Otherwise, return false. 415 */ 416bool acpi_handle_list_equal(struct acpi_handle_list *list1, 417 struct acpi_handle_list *list2) 418{ 419 return list1->count == list2->count && 420 !memcmp(list1->handles, list2->handles, 421 list1->count * sizeof(*list1->handles)); 422} 423EXPORT_SYMBOL_GPL(acpi_handle_list_equal); 424 425/** 426 * acpi_handle_list_replace - Replace one ACPI handle list with another 427 * @dst: ACPI handle list to replace. 428 * @src: Source ACPI handle list. 429 * 430 * Free the handles table in @dst, move the handles table from @src to @dst, 431 * copy count from @src to @dst and clear @src. 432 */ 433void acpi_handle_list_replace(struct acpi_handle_list *dst, 434 struct acpi_handle_list *src) 435{ 436 if (dst->count) 437 kfree(dst->handles); 438 439 dst->count = src->count; 440 dst->handles = src->handles; 441 442 src->handles = NULL; 443 src->count = 0; 444} 445EXPORT_SYMBOL_GPL(acpi_handle_list_replace); 446 447/** 448 * acpi_handle_list_free - Free the handles table in an ACPI handle list 449 * @list: ACPI handle list to free. 450 * 451 * Free the handles table in @list and clear its count field. 452 */ 453void acpi_handle_list_free(struct acpi_handle_list *list) 454{ 455 if (!list->count) 456 return; 457 458 kfree(list->handles); 459 list->count = 0; 460} 461EXPORT_SYMBOL_GPL(acpi_handle_list_free); 462 463/** 464 * acpi_device_dep - Check ACPI device dependency 465 * @target: ACPI handle of the target ACPI device. 466 * @match: ACPI handle to look up in the target's _DEP list. 467 * 468 * Return true if @match is present in the list returned by _DEP for 469 * @target or false otherwise. 470 */ 471bool acpi_device_dep(acpi_handle target, acpi_handle match) 472{ 473 struct acpi_handle_list dep_devices; 474 bool ret = false; 475 int i; 476 477 if (!acpi_has_method(target, "_DEP")) 478 return false; 479 480 if (!acpi_evaluate_reference(target, "_DEP", NULL, &dep_devices)) { 481 acpi_handle_debug(target, "Failed to evaluate _DEP.\n"); 482 return false; 483 } 484 485 for (i = 0; i < dep_devices.count; i++) { 486 if (dep_devices.handles[i] == match) { 487 ret = true; 488 break; 489 } 490 } 491 492 acpi_handle_list_free(&dep_devices); 493 return ret; 494} 495EXPORT_SYMBOL_GPL(acpi_device_dep); 496 497bool 498acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld) 499{ 500 acpi_status status; 501 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 502 union acpi_object *output; 503 504 status = acpi_evaluate_object(handle, "_PLD", NULL, &buffer); 505 if (ACPI_FAILURE(status)) 506 return false; 507 508 output = buffer.pointer; 509 510 if (!output || output->type != ACPI_TYPE_PACKAGE 511 || !output->package.count 512 || output->package.elements[0].type != ACPI_TYPE_BUFFER 513 || output->package.elements[0].buffer.length < ACPI_PLD_REV1_BUFFER_SIZE) { 514 status = AE_TYPE; 515 goto out; 516 } 517 518 status = acpi_decode_pld_buffer( 519 output->package.elements[0].buffer.pointer, 520 output->package.elements[0].buffer.length, 521 pld); 522 523out: 524 kfree(buffer.pointer); 525 return ACPI_SUCCESS(status); 526} 527EXPORT_SYMBOL(acpi_get_physical_device_location); 528 529/** 530 * acpi_evaluate_ost: Evaluate _OST for hotplug operations 531 * @handle: ACPI device handle 532 * @source_event: source event code 533 * @status_code: status code 534 * @status_buf: optional detailed information (NULL if none) 535 * 536 * Evaluate _OST for hotplug operations. All ACPI hotplug handlers 537 * must call this function when evaluating _OST for hotplug operations. 538 * When the platform does not support _OST, this function has no effect. 539 */ 540acpi_status 541acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code, 542 struct acpi_buffer *status_buf) 543{ 544 union acpi_object params[3] = { 545 {.type = ACPI_TYPE_INTEGER,}, 546 {.type = ACPI_TYPE_INTEGER,}, 547 {.type = ACPI_TYPE_BUFFER,} 548 }; 549 struct acpi_object_list arg_list = {3, params}; 550 551 params[0].integer.value = source_event; 552 params[1].integer.value = status_code; 553 if (status_buf != NULL) { 554 params[2].buffer.pointer = status_buf->pointer; 555 params[2].buffer.length = status_buf->length; 556 } else { 557 params[2].buffer.pointer = NULL; 558 params[2].buffer.length = 0; 559 } 560 561 return acpi_evaluate_object(handle, "_OST", &arg_list, NULL); 562} 563EXPORT_SYMBOL(acpi_evaluate_ost); 564 565/** 566 * acpi_handle_path: Return the object path of handle 567 * @handle: ACPI device handle 568 * 569 * Caller must free the returned buffer 570 */ 571char *acpi_handle_path(acpi_handle handle) 572{ 573 struct acpi_buffer buffer = { 574 .length = ACPI_ALLOCATE_BUFFER, 575 .pointer = NULL 576 }; 577 578 if (in_interrupt() || 579 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer) != AE_OK) 580 return NULL; 581 return buffer.pointer; 582} 583 584/** 585 * acpi_handle_printk: Print message with ACPI prefix and object path 586 * @level: log level 587 * @handle: ACPI device handle 588 * @fmt: format string 589 * 590 * This function is called through acpi_handle_<level> macros and prints 591 * a message with ACPI prefix and object path. This function acquires 592 * the global namespace mutex to obtain an object path. In interrupt 593 * context, it shows the object path as <n/a>. 594 */ 595void 596acpi_handle_printk(const char *level, acpi_handle handle, const char *fmt, ...) 597{ 598 struct va_format vaf; 599 va_list args; 600 const char *path; 601 602 va_start(args, fmt); 603 vaf.fmt = fmt; 604 vaf.va = &args; 605 606 path = acpi_handle_path(handle); 607 printk("%sACPI: %s: %pV", level, path ? path : "<n/a>", &vaf); 608 609 va_end(args); 610 kfree(path); 611} 612EXPORT_SYMBOL(acpi_handle_printk); 613 614#if defined(CONFIG_DYNAMIC_DEBUG) 615/** 616 * __acpi_handle_debug: pr_debug with ACPI prefix and object path 617 * @descriptor: Dynamic Debug descriptor 618 * @handle: ACPI device handle 619 * @fmt: format string 620 * 621 * This function is called through acpi_handle_debug macro and debug 622 * prints a message with ACPI prefix and object path. This function 623 * acquires the global namespace mutex to obtain an object path. In 624 * interrupt context, it shows the object path as <n/a>. 625 */ 626void 627__acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, 628 const char *fmt, ...) 629{ 630 struct va_format vaf; 631 va_list args; 632 const char *path; 633 634 va_start(args, fmt); 635 vaf.fmt = fmt; 636 vaf.va = &args; 637 638 path = acpi_handle_path(handle); 639 __dynamic_pr_debug(descriptor, "ACPI: %s: %pV", path ? path : "<n/a>", &vaf); 640 641 va_end(args); 642 kfree(path); 643} 644EXPORT_SYMBOL(__acpi_handle_debug); 645#endif 646 647/** 648 * acpi_evaluation_failure_warn - Log evaluation failure warning. 649 * @handle: Parent object handle. 650 * @name: Name of the object whose evaluation has failed. 651 * @status: Status value returned by the failing object evaluation. 652 */ 653void acpi_evaluation_failure_warn(acpi_handle handle, const char *name, 654 acpi_status status) 655{ 656 acpi_handle_warn(handle, "%s evaluation failed: %s\n", name, 657 acpi_format_exception(status)); 658} 659EXPORT_SYMBOL_GPL(acpi_evaluation_failure_warn); 660 661/** 662 * acpi_has_method: Check whether @handle has a method named @name 663 * @handle: ACPI device handle 664 * @name: name of object or method 665 * 666 * Check whether @handle has a method named @name. 667 */ 668bool acpi_has_method(acpi_handle handle, char *name) 669{ 670 acpi_handle tmp; 671 672 return ACPI_SUCCESS(acpi_get_handle(handle, name, &tmp)); 673} 674EXPORT_SYMBOL(acpi_has_method); 675 676acpi_status acpi_execute_simple_method(acpi_handle handle, char *method, 677 u64 arg) 678{ 679 union acpi_object obj = { .type = ACPI_TYPE_INTEGER }; 680 struct acpi_object_list arg_list = { .count = 1, .pointer = &obj, }; 681 682 obj.integer.value = arg; 683 684 return acpi_evaluate_object(handle, method, &arg_list, NULL); 685} 686EXPORT_SYMBOL(acpi_execute_simple_method); 687 688/** 689 * acpi_evaluate_ej0: Evaluate _EJ0 method for hotplug operations 690 * @handle: ACPI device handle 691 * 692 * Evaluate device's _EJ0 method for hotplug operations. 693 */ 694acpi_status acpi_evaluate_ej0(acpi_handle handle) 695{ 696 acpi_status status; 697 698 status = acpi_execute_simple_method(handle, "_EJ0", 1); 699 if (status == AE_NOT_FOUND) 700 acpi_handle_warn(handle, "No _EJ0 support for device\n"); 701 else if (ACPI_FAILURE(status)) 702 acpi_handle_warn(handle, "Eject failed (0x%x)\n", status); 703 704 return status; 705} 706 707/** 708 * acpi_evaluate_lck: Evaluate _LCK method to lock/unlock device 709 * @handle: ACPI device handle 710 * @lock: lock device if non-zero, otherwise unlock device 711 * 712 * Evaluate device's _LCK method if present to lock/unlock device 713 */ 714acpi_status acpi_evaluate_lck(acpi_handle handle, int lock) 715{ 716 acpi_status status; 717 718 status = acpi_execute_simple_method(handle, "_LCK", !!lock); 719 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 720 if (lock) 721 acpi_handle_warn(handle, 722 "Locking device failed (0x%x)\n", status); 723 else 724 acpi_handle_warn(handle, 725 "Unlocking device failed (0x%x)\n", status); 726 } 727 728 return status; 729} 730 731/** 732 * acpi_evaluate_reg: Evaluate _REG method to register OpRegion presence 733 * @handle: ACPI device handle 734 * @space_id: ACPI address space id to register OpRegion presence for 735 * @function: Parameter to pass to _REG one of ACPI_REG_CONNECT or 736 * ACPI_REG_DISCONNECT 737 * 738 * Evaluate device's _REG method to register OpRegion presence. 739 */ 740acpi_status acpi_evaluate_reg(acpi_handle handle, u8 space_id, u32 function) 741{ 742 struct acpi_object_list arg_list; 743 union acpi_object params[2]; 744 745 params[0].type = ACPI_TYPE_INTEGER; 746 params[0].integer.value = space_id; 747 params[1].type = ACPI_TYPE_INTEGER; 748 params[1].integer.value = function; 749 arg_list.count = 2; 750 arg_list.pointer = params; 751 752 return acpi_evaluate_object(handle, "_REG", &arg_list, NULL); 753} 754EXPORT_SYMBOL(acpi_evaluate_reg); 755 756/** 757 * acpi_evaluate_dsm - evaluate device's _DSM method 758 * @handle: ACPI device handle 759 * @guid: GUID of requested functions, should be 16 bytes 760 * @rev: revision number of requested function 761 * @func: requested function number 762 * @argv4: the function specific parameter 763 * 764 * Evaluate device's _DSM method with specified GUID, revision id and 765 * function number. Caller needs to free the returned object. 766 * 767 * Though ACPI defines the fourth parameter for _DSM should be a package, 768 * some old BIOSes do expect a buffer or an integer etc. 769 */ 770union acpi_object * 771acpi_evaluate_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 func, 772 union acpi_object *argv4) 773{ 774 acpi_status ret; 775 struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL}; 776 union acpi_object params[4]; 777 struct acpi_object_list input = { 778 .count = 4, 779 .pointer = params, 780 }; 781 782 params[0].type = ACPI_TYPE_BUFFER; 783 params[0].buffer.length = 16; 784 params[0].buffer.pointer = (u8 *)guid; 785 params[1].type = ACPI_TYPE_INTEGER; 786 params[1].integer.value = rev; 787 params[2].type = ACPI_TYPE_INTEGER; 788 params[2].integer.value = func; 789 if (argv4) { 790 params[3] = *argv4; 791 } else { 792 params[3].type = ACPI_TYPE_PACKAGE; 793 params[3].package.count = 0; 794 params[3].package.elements = NULL; 795 } 796 797 ret = acpi_evaluate_object(handle, "_DSM", &input, &buf); 798 if (ACPI_SUCCESS(ret)) 799 return (union acpi_object *)buf.pointer; 800 801 if (ret != AE_NOT_FOUND) 802 acpi_handle_warn(handle, 803 "failed to evaluate _DSM %pUb rev:%lld func:%lld (0x%x)\n", 804 guid, rev, func, ret); 805 806 return NULL; 807} 808EXPORT_SYMBOL(acpi_evaluate_dsm); 809 810/** 811 * acpi_check_dsm - check if _DSM method supports requested functions. 812 * @handle: ACPI device handle 813 * @guid: GUID of requested functions, should be 16 bytes at least 814 * @rev: revision number of requested functions 815 * @funcs: bitmap of requested functions 816 * 817 * Evaluate device's _DSM method to check whether it supports requested 818 * functions. Currently only support 64 functions at maximum, should be 819 * enough for now. 820 */ 821bool acpi_check_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 funcs) 822{ 823 int i; 824 u64 mask = 0; 825 union acpi_object *obj; 826 827 if (funcs == 0) 828 return false; 829 830 obj = acpi_evaluate_dsm(handle, guid, rev, 0, NULL); 831 if (!obj) 832 return false; 833 834 /* For compatibility, old BIOSes may return an integer */ 835 if (obj->type == ACPI_TYPE_INTEGER) 836 mask = obj->integer.value; 837 else if (obj->type == ACPI_TYPE_BUFFER) 838 for (i = 0; i < obj->buffer.length && i < 8; i++) 839 mask |= (((u64)obj->buffer.pointer[i]) << (i * 8)); 840 ACPI_FREE(obj); 841 842 /* 843 * Bit 0 indicates whether there's support for any functions other than 844 * function 0 for the specified GUID and revision. 845 */ 846 if ((mask & 0x1) && (mask & funcs) == funcs) 847 return true; 848 849 return false; 850} 851EXPORT_SYMBOL(acpi_check_dsm); 852 853/** 854 * acpi_dev_uid_to_integer - treat ACPI device _UID as integer 855 * @adev: ACPI device to get _UID from 856 * @integer: output buffer for integer 857 * 858 * Considers _UID as integer and converts it to @integer. 859 * 860 * Returns 0 on success, or negative error code otherwise. 861 */ 862int acpi_dev_uid_to_integer(struct acpi_device *adev, u64 *integer) 863{ 864 const char *uid; 865 866 if (!adev) 867 return -ENODEV; 868 869 uid = acpi_device_uid(adev); 870 if (!uid) 871 return -ENODATA; 872 873 return kstrtou64(uid, 0, integer); 874} 875EXPORT_SYMBOL(acpi_dev_uid_to_integer); 876 877/** 878 * acpi_dev_found - Detect presence of a given ACPI device in the namespace. 879 * @hid: Hardware ID of the device. 880 * 881 * Return %true if the device was present at the moment of invocation. 882 * Note that if the device is pluggable, it may since have disappeared. 883 * 884 * For this function to work, acpi_bus_scan() must have been executed 885 * which happens in the subsys_initcall() subsection. Hence, do not 886 * call from a subsys_initcall() or earlier (use acpi_get_devices() 887 * instead). Calling from module_init() is fine (which is synonymous 888 * with device_initcall()). 889 */ 890bool acpi_dev_found(const char *hid) 891{ 892 struct acpi_device_bus_id *acpi_device_bus_id; 893 bool found = false; 894 895 mutex_lock(&acpi_device_lock); 896 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) 897 if (!strcmp(acpi_device_bus_id->bus_id, hid)) { 898 found = true; 899 break; 900 } 901 mutex_unlock(&acpi_device_lock); 902 903 return found; 904} 905EXPORT_SYMBOL(acpi_dev_found); 906 907struct acpi_dev_match_info { 908 struct acpi_device_id hid[2]; 909 const char *uid; 910 s64 hrv; 911}; 912 913static int acpi_dev_match_cb(struct device *dev, const void *data) 914{ 915 struct acpi_device *adev = to_acpi_device(dev); 916 const struct acpi_dev_match_info *match = data; 917 unsigned long long hrv; 918 acpi_status status; 919 920 if (acpi_match_device_ids(adev, match->hid)) 921 return 0; 922 923 if (match->uid && !acpi_dev_uid_match(adev, match->uid)) 924 return 0; 925 926 if (match->hrv == -1) 927 return 1; 928 929 status = acpi_evaluate_integer(adev->handle, "_HRV", NULL, &hrv); 930 if (ACPI_FAILURE(status)) 931 return 0; 932 933 return hrv == match->hrv; 934} 935 936/** 937 * acpi_dev_present - Detect that a given ACPI device is present 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 %true if a matching device was present at the moment of invocation. 943 * Note that if the device is pluggable, it may since have disappeared. 944 * 945 * Note that unlike acpi_dev_found() this function checks the status 946 * of the device. So for devices which are present in the DSDT, but 947 * which are disabled (their _STA callback returns 0) this function 948 * will return false. 949 * 950 * For this function to work, acpi_bus_scan() must have been executed 951 * which happens in the subsys_initcall() subsection. Hence, do not 952 * call from a subsys_initcall() or earlier (use acpi_get_devices() 953 * instead). Calling from module_init() is fine (which is synonymous 954 * with device_initcall()). 955 */ 956bool acpi_dev_present(const char *hid, const char *uid, s64 hrv) 957{ 958 struct acpi_dev_match_info match = {}; 959 struct device *dev; 960 961 strscpy(match.hid[0].id, hid, sizeof(match.hid[0].id)); 962 match.uid = uid; 963 match.hrv = hrv; 964 965 dev = bus_find_device(&acpi_bus_type, NULL, &match, acpi_dev_match_cb); 966 put_device(dev); 967 return !!dev; 968} 969EXPORT_SYMBOL(acpi_dev_present); 970 971/** 972 * acpi_dev_get_next_match_dev - Return the next match of ACPI device 973 * @adev: Pointer to the previous ACPI device matching this @hid, @uid and @hrv 974 * @hid: Hardware ID of the device. 975 * @uid: Unique ID of the device, pass NULL to not check _UID 976 * @hrv: Hardware Revision of the device, pass -1 to not check _HRV 977 * 978 * Return the next match of ACPI device if another matching device was present 979 * at the moment of invocation, or NULL otherwise. 980 * 981 * The caller is responsible for invoking acpi_dev_put() on the returned device. 982 * On the other hand the function invokes acpi_dev_put() on the given @adev 983 * assuming that its reference counter had been increased beforehand. 984 * 985 * See additional information in acpi_dev_present() as well. 986 */ 987struct acpi_device * 988acpi_dev_get_next_match_dev(struct acpi_device *adev, const char *hid, const char *uid, s64 hrv) 989{ 990 struct device *start = adev ? &adev->dev : NULL; 991 struct acpi_dev_match_info match = {}; 992 struct device *dev; 993 994 strscpy(match.hid[0].id, hid, sizeof(match.hid[0].id)); 995 match.uid = uid; 996 match.hrv = hrv; 997 998 dev = bus_find_device(&acpi_bus_type, start, &match, acpi_dev_match_cb); 999 acpi_dev_put(adev); 1000 return dev ? to_acpi_device(dev) : NULL; 1001} 1002EXPORT_SYMBOL(acpi_dev_get_next_match_dev); 1003 1004/** 1005 * acpi_dev_get_first_match_dev - Return the first match of ACPI device 1006 * @hid: Hardware ID of the device. 1007 * @uid: Unique ID of the device, pass NULL to not check _UID 1008 * @hrv: Hardware Revision of the device, pass -1 to not check _HRV 1009 * 1010 * Return the first match of ACPI device if a matching device was present 1011 * at the moment of invocation, or NULL otherwise. 1012 * 1013 * The caller is responsible for invoking acpi_dev_put() on the returned device. 1014 * 1015 * See additional information in acpi_dev_present() as well. 1016 */ 1017struct acpi_device * 1018acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv) 1019{ 1020 return acpi_dev_get_next_match_dev(NULL, hid, uid, hrv); 1021} 1022EXPORT_SYMBOL(acpi_dev_get_first_match_dev); 1023 1024/** 1025 * acpi_reduced_hardware - Return if this is an ACPI-reduced-hw machine 1026 * 1027 * Return true when running on an ACPI-reduced-hw machine, false otherwise. 1028 */ 1029bool acpi_reduced_hardware(void) 1030{ 1031 return acpi_gbl_reduced_hardware; 1032} 1033EXPORT_SYMBOL_GPL(acpi_reduced_hardware); 1034 1035/* 1036 * acpi_backlight= handling, this is done here rather then in video_detect.c 1037 * because __setup cannot be used in modules. 1038 */ 1039char acpi_video_backlight_string[16]; 1040EXPORT_SYMBOL(acpi_video_backlight_string); 1041 1042static int __init acpi_backlight(char *str) 1043{ 1044 strscpy(acpi_video_backlight_string, str, 1045 sizeof(acpi_video_backlight_string)); 1046 return 1; 1047} 1048__setup("acpi_backlight=", acpi_backlight); 1049 1050/** 1051 * acpi_match_platform_list - Check if the system matches with a given list 1052 * @plat: pointer to acpi_platform_list table terminated by a NULL entry 1053 * 1054 * Return the matched index if the system is found in the platform list. 1055 * Otherwise, return a negative error code. 1056 */ 1057int acpi_match_platform_list(const struct acpi_platform_list *plat) 1058{ 1059 struct acpi_table_header hdr; 1060 int idx = 0; 1061 1062 if (acpi_disabled) 1063 return -ENODEV; 1064 1065 for (; plat->oem_id[0]; plat++, idx++) { 1066 if (ACPI_FAILURE(acpi_get_table_header(plat->table, 0, &hdr))) 1067 continue; 1068 1069 if (strncmp(plat->oem_id, hdr.oem_id, ACPI_OEM_ID_SIZE)) 1070 continue; 1071 1072 if (strncmp(plat->oem_table_id, hdr.oem_table_id, ACPI_OEM_TABLE_ID_SIZE)) 1073 continue; 1074 1075 if ((plat->pred == all_versions) || 1076 (plat->pred == less_than_or_equal && hdr.oem_revision <= plat->oem_revision) || 1077 (plat->pred == greater_than_or_equal && hdr.oem_revision >= plat->oem_revision) || 1078 (plat->pred == equal && hdr.oem_revision == plat->oem_revision)) 1079 return idx; 1080 } 1081 1082 return -ENODEV; 1083} 1084EXPORT_SYMBOL(acpi_match_platform_list);
~/
Read-only file preview.