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