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