1 /* 2 * acpi_utils.c - ACPI Utility Functions ($Revision: 10 $) 3 * 4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6 * 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or (at 12 * your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License along 20 * with this program; if not, write to the Free Software Foundation, Inc., 21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 22 * 23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 24 */ 25 26 #include <linux/kernel.h> 27 #include <linux/module.h> 28 #include <linux/slab.h> 29 #include <linux/init.h> 30 #include <linux/types.h> 31 #include <linux/hardirq.h> 32 #include <linux/acpi.h> 33 #include <linux/dynamic_debug.h> 34 35 #include "internal.h" 36 37 #define _COMPONENT ACPI_BUS_COMPONENT 38 ACPI_MODULE_NAME("utils"); 39 40 /* -------------------------------------------------------------------------- 41 Object Evaluation Helpers 42 -------------------------------------------------------------------------- */ 43 static void 44 acpi_util_eval_error(acpi_handle h, acpi_string p, acpi_status s) 45 { 46 #ifdef ACPI_DEBUG_OUTPUT 47 char prefix[80] = {'\0'}; 48 struct acpi_buffer buffer = {sizeof(prefix), prefix}; 49 acpi_get_name(h, ACPI_FULL_PATHNAME, &buffer); 50 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluate [%s.%s]: %s\n", 51 (char *) prefix, p, acpi_format_exception(s))); 52 #else 53 return; 54 #endif 55 } 56 57 acpi_status 58 acpi_extract_package(union acpi_object *package, 59 struct acpi_buffer *format, struct acpi_buffer *buffer) 60 { 61 u32 size_required = 0; 62 u32 tail_offset = 0; 63 char *format_string = NULL; 64 u32 format_count = 0; 65 u32 i = 0; 66 u8 *head = NULL; 67 u8 *tail = NULL; 68 69 70 if (!package || (package->type != ACPI_TYPE_PACKAGE) 71 || (package->package.count < 1)) { 72 printk(KERN_WARNING PREFIX "Invalid package argument\n"); 73 return AE_BAD_PARAMETER; 74 } 75 76 if (!format || !format->pointer || (format->length < 1)) { 77 printk(KERN_WARNING PREFIX "Invalid format argument\n"); 78 return AE_BAD_PARAMETER; 79 } 80 81 if (!buffer) { 82 printk(KERN_WARNING PREFIX "Invalid buffer argument\n"); 83 return AE_BAD_PARAMETER; 84 } 85 86 format_count = (format->length / sizeof(char)) - 1; 87 if (format_count > package->package.count) { 88 printk(KERN_WARNING PREFIX "Format specifies more objects [%d]" 89 " than exist in package [%d].\n", 90 format_count, package->package.count); 91 return AE_BAD_DATA; 92 } 93 94 format_string = format->pointer; 95 96 /* 97 * Calculate size_required. 98 */ 99 for (i = 0; i < format_count; i++) { 100 101 union acpi_object *element = &(package->package.elements[i]); 102 103 switch (element->type) { 104 105 case ACPI_TYPE_INTEGER: 106 switch (format_string[i]) { 107 case 'N': 108 size_required += sizeof(u64); 109 tail_offset += sizeof(u64); 110 break; 111 case 'S': 112 size_required += 113 sizeof(char *) + sizeof(u64) + 114 sizeof(char); 115 tail_offset += sizeof(char *); 116 break; 117 default: 118 printk(KERN_WARNING PREFIX "Invalid package element" 119 " [%d]: got number, expecting" 120 " [%c]\n", 121 i, format_string[i]); 122 return AE_BAD_DATA; 123 break; 124 } 125 break; 126 127 case ACPI_TYPE_STRING: 128 case ACPI_TYPE_BUFFER: 129 switch (format_string[i]) { 130 case 'S': 131 size_required += 132 sizeof(char *) + 133 (element->string.length * sizeof(char)) + 134 sizeof(char); 135 tail_offset += sizeof(char *); 136 break; 137 case 'B': 138 size_required += 139 sizeof(u8 *) + element->buffer.length; 140 tail_offset += sizeof(u8 *); 141 break; 142 default: 143 printk(KERN_WARNING PREFIX "Invalid package element" 144 " [%d] got string/buffer," 145 " expecting [%c]\n", 146 i, format_string[i]); 147 return AE_BAD_DATA; 148 break; 149 } 150 break; 151 case ACPI_TYPE_LOCAL_REFERENCE: 152 switch (format_string[i]) { 153 case 'R': 154 size_required += sizeof(void *); 155 tail_offset += sizeof(void *); 156 break; 157 default: 158 printk(KERN_WARNING PREFIX "Invalid package element" 159 " [%d] got reference," 160 " expecting [%c]\n", 161 i, format_string[i]); 162 return AE_BAD_DATA; 163 break; 164 } 165 break; 166 167 case ACPI_TYPE_PACKAGE: 168 default: 169 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 170 "Found unsupported element at index=%d\n", 171 i)); 172 /* TBD: handle nested packages... */ 173 return AE_SUPPORT; 174 break; 175 } 176 } 177 178 /* 179 * Validate output buffer. 180 */ 181 if (buffer->length == ACPI_ALLOCATE_BUFFER) { 182 buffer->pointer = ACPI_ALLOCATE_ZEROED(size_required); 183 if (!buffer->pointer) 184 return AE_NO_MEMORY; 185 buffer->length = size_required; 186 } else { 187 if (buffer->length < size_required) { 188 buffer->length = size_required; 189 return AE_BUFFER_OVERFLOW; 190 } else if (buffer->length != size_required || 191 !buffer->pointer) { 192 return AE_BAD_PARAMETER; 193 } 194 } 195 196 head = buffer->pointer; 197 tail = buffer->pointer + tail_offset; 198 199 /* 200 * Extract package data. 201 */ 202 for (i = 0; i < format_count; i++) { 203 204 u8 **pointer = NULL; 205 union acpi_object *element = &(package->package.elements[i]); 206 207 if (!element) { 208 return AE_BAD_DATA; 209 } 210 211 switch (element->type) { 212 213 case ACPI_TYPE_INTEGER: 214 switch (format_string[i]) { 215 case 'N': 216 *((u64 *) head) = 217 element->integer.value; 218 head += sizeof(u64); 219 break; 220 case 'S': 221 pointer = (u8 **) head; 222 *pointer = tail; 223 *((u64 *) tail) = 224 element->integer.value; 225 head += sizeof(u64 *); 226 tail += sizeof(u64); 227 /* NULL terminate string */ 228 *tail = (char)0; 229 tail += sizeof(char); 230 break; 231 default: 232 /* Should never get here */ 233 break; 234 } 235 break; 236 237 case ACPI_TYPE_STRING: 238 case ACPI_TYPE_BUFFER: 239 switch (format_string[i]) { 240 case 'S': 241 pointer = (u8 **) head; 242 *pointer = tail; 243 memcpy(tail, element->string.pointer, 244 element->string.length); 245 head += sizeof(char *); 246 tail += element->string.length * sizeof(char); 247 /* NULL terminate string */ 248 *tail = (char)0; 249 tail += sizeof(char); 250 break; 251 case 'B': 252 pointer = (u8 **) head; 253 *pointer = tail; 254 memcpy(tail, element->buffer.pointer, 255 element->buffer.length); 256 head += sizeof(u8 *); 257 tail += element->buffer.length; 258 break; 259 default: 260 /* Should never get here */ 261 break; 262 } 263 break; 264 case ACPI_TYPE_LOCAL_REFERENCE: 265 switch (format_string[i]) { 266 case 'R': 267 *(void **)head = 268 (void *)element->reference.handle; 269 head += sizeof(void *); 270 break; 271 default: 272 /* Should never get here */ 273 break; 274 } 275 break; 276 case ACPI_TYPE_PACKAGE: 277 /* TBD: handle nested packages... */ 278 default: 279 /* Should never get here */ 280 break; 281 } 282 } 283 284 return AE_OK; 285 } 286 287 EXPORT_SYMBOL(acpi_extract_package); 288 289 acpi_status 290 acpi_evaluate_integer(acpi_handle handle, 291 acpi_string pathname, 292 struct acpi_object_list *arguments, unsigned long long *data) 293 { 294 acpi_status status = AE_OK; 295 union acpi_object element; 296 struct acpi_buffer buffer = { 0, NULL }; 297 298 if (!data) 299 return AE_BAD_PARAMETER; 300 301 buffer.length = sizeof(union acpi_object); 302 buffer.pointer = &element; 303 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 304 if (ACPI_FAILURE(status)) { 305 acpi_util_eval_error(handle, pathname, status); 306 return status; 307 } 308 309 if (element.type != ACPI_TYPE_INTEGER) { 310 acpi_util_eval_error(handle, pathname, AE_BAD_DATA); 311 return AE_BAD_DATA; 312 } 313 314 *data = element.integer.value; 315 316 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%llu]\n", *data)); 317 318 return AE_OK; 319 } 320 321 EXPORT_SYMBOL(acpi_evaluate_integer); 322 323 acpi_status 324 acpi_evaluate_reference(acpi_handle handle, 325 acpi_string pathname, 326 struct acpi_object_list *arguments, 327 struct acpi_handle_list *list) 328 { 329 acpi_status status = AE_OK; 330 union acpi_object *package = NULL; 331 union acpi_object *element = NULL; 332 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 333 u32 i = 0; 334 335 336 if (!list) { 337 return AE_BAD_PARAMETER; 338 } 339 340 /* Evaluate object. */ 341 342 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 343 if (ACPI_FAILURE(status)) 344 goto end; 345 346 package = buffer.pointer; 347 348 if ((buffer.length == 0) || !package) { 349 status = AE_BAD_DATA; 350 acpi_util_eval_error(handle, pathname, status); 351 goto end; 352 } 353 if (package->type != ACPI_TYPE_PACKAGE) { 354 status = AE_BAD_DATA; 355 acpi_util_eval_error(handle, pathname, status); 356 goto end; 357 } 358 if (!package->package.count) { 359 status = AE_BAD_DATA; 360 acpi_util_eval_error(handle, pathname, status); 361 goto end; 362 } 363 364 if (package->package.count > ACPI_MAX_HANDLES) { 365 return AE_NO_MEMORY; 366 } 367 list->count = package->package.count; 368 369 /* Extract package data. */ 370 371 for (i = 0; i < list->count; i++) { 372 373 element = &(package->package.elements[i]); 374 375 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) { 376 status = AE_BAD_DATA; 377 acpi_util_eval_error(handle, pathname, status); 378 break; 379 } 380 381 if (!element->reference.handle) { 382 status = AE_NULL_ENTRY; 383 acpi_util_eval_error(handle, pathname, status); 384 break; 385 } 386 /* Get the acpi_handle. */ 387 388 list->handles[i] = element->reference.handle; 389 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found reference [%p]\n", 390 list->handles[i])); 391 } 392 393 end: 394 if (ACPI_FAILURE(status)) { 395 list->count = 0; 396 //kfree(list->handles); 397 } 398 399 kfree(buffer.pointer); 400 401 return status; 402 } 403 404 EXPORT_SYMBOL(acpi_evaluate_reference); 405 406 acpi_status 407 acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld) 408 { 409 acpi_status status; 410 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 411 union acpi_object *output; 412 413 status = acpi_evaluate_object(handle, "_PLD", NULL, &buffer); 414 415 if (ACPI_FAILURE(status)) 416 return status; 417 418 output = buffer.pointer; 419 420 if (!output || output->type != ACPI_TYPE_PACKAGE 421 || !output->package.count 422 || output->package.elements[0].type != ACPI_TYPE_BUFFER 423 || output->package.elements[0].buffer.length < ACPI_PLD_REV1_BUFFER_SIZE) { 424 status = AE_TYPE; 425 goto out; 426 } 427 428 status = acpi_decode_pld_buffer( 429 output->package.elements[0].buffer.pointer, 430 output->package.elements[0].buffer.length, 431 pld); 432 433 out: 434 kfree(buffer.pointer); 435 return status; 436 } 437 EXPORT_SYMBOL(acpi_get_physical_device_location); 438 439 /** 440 * acpi_evaluate_ost: Evaluate _OST for hotplug operations 441 * @handle: ACPI device handle 442 * @source_event: source event code 443 * @status_code: status code 444 * @status_buf: optional detailed information (NULL if none) 445 * 446 * Evaluate _OST for hotplug operations. All ACPI hotplug handlers 447 * must call this function when evaluating _OST for hotplug operations. 448 * When the platform does not support _OST, this function has no effect. 449 */ 450 acpi_status 451 acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code, 452 struct acpi_buffer *status_buf) 453 { 454 union acpi_object params[3] = { 455 {.type = ACPI_TYPE_INTEGER,}, 456 {.type = ACPI_TYPE_INTEGER,}, 457 {.type = ACPI_TYPE_BUFFER,} 458 }; 459 struct acpi_object_list arg_list = {3, params}; 460 461 params[0].integer.value = source_event; 462 params[1].integer.value = status_code; 463 if (status_buf != NULL) { 464 params[2].buffer.pointer = status_buf->pointer; 465 params[2].buffer.length = status_buf->length; 466 } else { 467 params[2].buffer.pointer = NULL; 468 params[2].buffer.length = 0; 469 } 470 471 return acpi_evaluate_object(handle, "_OST", &arg_list, NULL); 472 } 473 EXPORT_SYMBOL(acpi_evaluate_ost); 474 475 /** 476 * acpi_handle_path: Return the object path of handle 477 * 478 * Caller must free the returned buffer 479 */ 480 static char *acpi_handle_path(acpi_handle handle) 481 { 482 struct acpi_buffer buffer = { 483 .length = ACPI_ALLOCATE_BUFFER, 484 .pointer = NULL 485 }; 486 487 if (in_interrupt() || 488 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer) != AE_OK) 489 return NULL; 490 return buffer.pointer; 491 } 492 493 /** 494 * acpi_handle_printk: Print message with ACPI prefix and object path 495 * 496 * This function is called through acpi_handle_<level> macros and prints 497 * a message with ACPI prefix and object path. This function acquires 498 * the global namespace mutex to obtain an object path. In interrupt 499 * context, it shows the object path as <n/a>. 500 */ 501 void 502 acpi_handle_printk(const char *level, acpi_handle handle, const char *fmt, ...) 503 { 504 struct va_format vaf; 505 va_list args; 506 const char *path; 507 508 va_start(args, fmt); 509 vaf.fmt = fmt; 510 vaf.va = &args; 511 512 path = acpi_handle_path(handle); 513 printk("%sACPI: %s: %pV", level, path ? path : "<n/a>" , &vaf); 514 515 va_end(args); 516 kfree(path); 517 } 518 EXPORT_SYMBOL(acpi_handle_printk); 519 520 #if defined(CONFIG_DYNAMIC_DEBUG) 521 /** 522 * __acpi_handle_debug: pr_debug with ACPI prefix and object path 523 * 524 * This function is called through acpi_handle_debug macro and debug 525 * prints a message with ACPI prefix and object path. This function 526 * acquires the global namespace mutex to obtain an object path. In 527 * interrupt context, it shows the object path as <n/a>. 528 */ 529 void 530 __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, 531 const char *fmt, ...) 532 { 533 struct va_format vaf; 534 va_list args; 535 const char *path; 536 537 va_start(args, fmt); 538 vaf.fmt = fmt; 539 vaf.va = &args; 540 541 path = acpi_handle_path(handle); 542 __dynamic_pr_debug(descriptor, "ACPI: %s: %pV", path ? path : "<n/a>", &vaf); 543 544 va_end(args); 545 kfree(path); 546 } 547 EXPORT_SYMBOL(__acpi_handle_debug); 548 #endif 549 550 /** 551 * acpi_has_method: Check whether @handle has a method named @name 552 * @handle: ACPI device handle 553 * @name: name of object or method 554 * 555 * Check whether @handle has a method named @name. 556 */ 557 bool acpi_has_method(acpi_handle handle, char *name) 558 { 559 acpi_handle tmp; 560 561 return ACPI_SUCCESS(acpi_get_handle(handle, name, &tmp)); 562 } 563 EXPORT_SYMBOL(acpi_has_method); 564 565 acpi_status acpi_execute_simple_method(acpi_handle handle, char *method, 566 u64 arg) 567 { 568 union acpi_object obj = { .type = ACPI_TYPE_INTEGER }; 569 struct acpi_object_list arg_list = { .count = 1, .pointer = &obj, }; 570 571 obj.integer.value = arg; 572 573 return acpi_evaluate_object(handle, method, &arg_list, NULL); 574 } 575 EXPORT_SYMBOL(acpi_execute_simple_method); 576 577 /** 578 * acpi_evaluate_ej0: Evaluate _EJ0 method for hotplug operations 579 * @handle: ACPI device handle 580 * 581 * Evaluate device's _EJ0 method for hotplug operations. 582 */ 583 acpi_status acpi_evaluate_ej0(acpi_handle handle) 584 { 585 acpi_status status; 586 587 status = acpi_execute_simple_method(handle, "_EJ0", 1); 588 if (status == AE_NOT_FOUND) 589 acpi_handle_warn(handle, "No _EJ0 support for device\n"); 590 else if (ACPI_FAILURE(status)) 591 acpi_handle_warn(handle, "Eject failed (0x%x)\n", status); 592 593 return status; 594 } 595 596 /** 597 * acpi_evaluate_lck: Evaluate _LCK method to lock/unlock device 598 * @handle: ACPI device handle 599 * @lock: lock device if non-zero, otherwise unlock device 600 * 601 * Evaluate device's _LCK method if present to lock/unlock device 602 */ 603 acpi_status acpi_evaluate_lck(acpi_handle handle, int lock) 604 { 605 acpi_status status; 606 607 status = acpi_execute_simple_method(handle, "_LCK", !!lock); 608 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 609 if (lock) 610 acpi_handle_warn(handle, 611 "Locking device failed (0x%x)\n", status); 612 else 613 acpi_handle_warn(handle, 614 "Unlocking device failed (0x%x)\n", status); 615 } 616 617 return status; 618 } 619 620 /** 621 * acpi_evaluate_dsm - evaluate device's _DSM method 622 * @handle: ACPI device handle 623 * @uuid: UUID of requested functions, should be 16 bytes 624 * @rev: revision number of requested function 625 * @func: requested function number 626 * @argv4: the function specific parameter 627 * 628 * Evaluate device's _DSM method with specified UUID, revision id and 629 * function number. Caller needs to free the returned object. 630 * 631 * Though ACPI defines the fourth parameter for _DSM should be a package, 632 * some old BIOSes do expect a buffer or an integer etc. 633 */ 634 union acpi_object * 635 acpi_evaluate_dsm(acpi_handle handle, const u8 *uuid, int rev, int func, 636 union acpi_object *argv4) 637 { 638 acpi_status ret; 639 struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL}; 640 union acpi_object params[4]; 641 struct acpi_object_list input = { 642 .count = 4, 643 .pointer = params, 644 }; 645 646 params[0].type = ACPI_TYPE_BUFFER; 647 params[0].buffer.length = 16; 648 params[0].buffer.pointer = (char *)uuid; 649 params[1].type = ACPI_TYPE_INTEGER; 650 params[1].integer.value = rev; 651 params[2].type = ACPI_TYPE_INTEGER; 652 params[2].integer.value = func; 653 if (argv4) { 654 params[3] = *argv4; 655 } else { 656 params[3].type = ACPI_TYPE_PACKAGE; 657 params[3].package.count = 0; 658 params[3].package.elements = NULL; 659 } 660 661 ret = acpi_evaluate_object(handle, "_DSM", &input, &buf); 662 if (ACPI_SUCCESS(ret)) 663 return (union acpi_object *)buf.pointer; 664 665 if (ret != AE_NOT_FOUND) 666 acpi_handle_warn(handle, 667 "failed to evaluate _DSM (0x%x)\n", ret); 668 669 return NULL; 670 } 671 EXPORT_SYMBOL(acpi_evaluate_dsm); 672 673 /** 674 * acpi_check_dsm - check if _DSM method supports requested functions. 675 * @handle: ACPI device handle 676 * @uuid: UUID of requested functions, should be 16 bytes at least 677 * @rev: revision number of requested functions 678 * @funcs: bitmap of requested functions 679 * 680 * Evaluate device's _DSM method to check whether it supports requested 681 * functions. Currently only support 64 functions at maximum, should be 682 * enough for now. 683 */ 684 bool acpi_check_dsm(acpi_handle handle, const u8 *uuid, int rev, u64 funcs) 685 { 686 int i; 687 u64 mask = 0; 688 union acpi_object *obj; 689 690 if (funcs == 0) 691 return false; 692 693 obj = acpi_evaluate_dsm(handle, uuid, rev, 0, NULL); 694 if (!obj) 695 return false; 696 697 /* For compatibility, old BIOSes may return an integer */ 698 if (obj->type == ACPI_TYPE_INTEGER) 699 mask = obj->integer.value; 700 else if (obj->type == ACPI_TYPE_BUFFER) 701 for (i = 0; i < obj->buffer.length && i < 8; i++) 702 mask |= (((u8)obj->buffer.pointer[i]) << (i * 8)); 703 ACPI_FREE(obj); 704 705 /* 706 * Bit 0 indicates whether there's support for any functions other than 707 * function 0 for the specified UUID and revision. 708 */ 709 if ((mask & 0x1) && (mask & funcs) == funcs) 710 return true; 711 712 return false; 713 } 714 EXPORT_SYMBOL(acpi_check_dsm); 715