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 *) + 140 (element->buffer.length * sizeof(u8)); 141 tail_offset += sizeof(u8 *); 142 break; 143 default: 144 printk(KERN_WARNING PREFIX "Invalid package element" 145 " [%d] got string/buffer," 146 " expecting [%c]\n", 147 i, format_string[i]); 148 return AE_BAD_DATA; 149 break; 150 } 151 break; 152 153 case ACPI_TYPE_PACKAGE: 154 default: 155 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 156 "Found unsupported element at index=%d\n", 157 i)); 158 /* TBD: handle nested packages... */ 159 return AE_SUPPORT; 160 break; 161 } 162 } 163 164 /* 165 * Validate output buffer. 166 */ 167 if (buffer->length == ACPI_ALLOCATE_BUFFER) { 168 buffer->pointer = ACPI_ALLOCATE_ZEROED(size_required); 169 if (!buffer->pointer) 170 return AE_NO_MEMORY; 171 buffer->length = size_required; 172 } else { 173 if (buffer->length < size_required) { 174 buffer->length = size_required; 175 return AE_BUFFER_OVERFLOW; 176 } else if (buffer->length != size_required || 177 !buffer->pointer) { 178 return AE_BAD_PARAMETER; 179 } 180 } 181 182 head = buffer->pointer; 183 tail = buffer->pointer + tail_offset; 184 185 /* 186 * Extract package data. 187 */ 188 for (i = 0; i < format_count; i++) { 189 190 u8 **pointer = NULL; 191 union acpi_object *element = &(package->package.elements[i]); 192 193 if (!element) { 194 return AE_BAD_DATA; 195 } 196 197 switch (element->type) { 198 199 case ACPI_TYPE_INTEGER: 200 switch (format_string[i]) { 201 case 'N': 202 *((u64 *) head) = 203 element->integer.value; 204 head += sizeof(u64); 205 break; 206 case 'S': 207 pointer = (u8 **) head; 208 *pointer = tail; 209 *((u64 *) tail) = 210 element->integer.value; 211 head += sizeof(u64 *); 212 tail += sizeof(u64); 213 /* NULL terminate string */ 214 *tail = (char)0; 215 tail += sizeof(char); 216 break; 217 default: 218 /* Should never get here */ 219 break; 220 } 221 break; 222 223 case ACPI_TYPE_STRING: 224 case ACPI_TYPE_BUFFER: 225 switch (format_string[i]) { 226 case 'S': 227 pointer = (u8 **) head; 228 *pointer = tail; 229 memcpy(tail, element->string.pointer, 230 element->string.length); 231 head += sizeof(char *); 232 tail += element->string.length * sizeof(char); 233 /* NULL terminate string */ 234 *tail = (char)0; 235 tail += sizeof(char); 236 break; 237 case 'B': 238 pointer = (u8 **) head; 239 *pointer = tail; 240 memcpy(tail, element->buffer.pointer, 241 element->buffer.length); 242 head += sizeof(u8 *); 243 tail += element->buffer.length * sizeof(u8); 244 break; 245 default: 246 /* Should never get here */ 247 break; 248 } 249 break; 250 251 case ACPI_TYPE_PACKAGE: 252 /* TBD: handle nested packages... */ 253 default: 254 /* Should never get here */ 255 break; 256 } 257 } 258 259 return AE_OK; 260 } 261 262 EXPORT_SYMBOL(acpi_extract_package); 263 264 acpi_status 265 acpi_evaluate_integer(acpi_handle handle, 266 acpi_string pathname, 267 struct acpi_object_list *arguments, unsigned long long *data) 268 { 269 acpi_status status = AE_OK; 270 union acpi_object element; 271 struct acpi_buffer buffer = { 0, NULL }; 272 273 if (!data) 274 return AE_BAD_PARAMETER; 275 276 buffer.length = sizeof(union acpi_object); 277 buffer.pointer = &element; 278 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 279 if (ACPI_FAILURE(status)) { 280 acpi_util_eval_error(handle, pathname, status); 281 return status; 282 } 283 284 if (element.type != ACPI_TYPE_INTEGER) { 285 acpi_util_eval_error(handle, pathname, AE_BAD_DATA); 286 return AE_BAD_DATA; 287 } 288 289 *data = element.integer.value; 290 291 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%llu]\n", *data)); 292 293 return AE_OK; 294 } 295 296 EXPORT_SYMBOL(acpi_evaluate_integer); 297 298 acpi_status 299 acpi_evaluate_reference(acpi_handle handle, 300 acpi_string pathname, 301 struct acpi_object_list *arguments, 302 struct acpi_handle_list *list) 303 { 304 acpi_status status = AE_OK; 305 union acpi_object *package = NULL; 306 union acpi_object *element = NULL; 307 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 308 u32 i = 0; 309 310 311 if (!list) { 312 return AE_BAD_PARAMETER; 313 } 314 315 /* Evaluate object. */ 316 317 status = acpi_evaluate_object(handle, pathname, arguments, &buffer); 318 if (ACPI_FAILURE(status)) 319 goto end; 320 321 package = buffer.pointer; 322 323 if ((buffer.length == 0) || !package) { 324 printk(KERN_ERR PREFIX "No return object (len %X ptr %p)\n", 325 (unsigned)buffer.length, package); 326 status = AE_BAD_DATA; 327 acpi_util_eval_error(handle, pathname, status); 328 goto end; 329 } 330 if (package->type != ACPI_TYPE_PACKAGE) { 331 printk(KERN_ERR PREFIX "Expecting a [Package], found type %X\n", 332 package->type); 333 status = AE_BAD_DATA; 334 acpi_util_eval_error(handle, pathname, status); 335 goto end; 336 } 337 if (!package->package.count) { 338 printk(KERN_ERR PREFIX "[Package] has zero elements (%p)\n", 339 package); 340 status = AE_BAD_DATA; 341 acpi_util_eval_error(handle, pathname, status); 342 goto end; 343 } 344 345 if (package->package.count > ACPI_MAX_HANDLES) { 346 return AE_NO_MEMORY; 347 } 348 list->count = package->package.count; 349 350 /* Extract package data. */ 351 352 for (i = 0; i < list->count; i++) { 353 354 element = &(package->package.elements[i]); 355 356 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) { 357 status = AE_BAD_DATA; 358 printk(KERN_ERR PREFIX 359 "Expecting a [Reference] package element, found type %X\n", 360 element->type); 361 acpi_util_eval_error(handle, pathname, status); 362 break; 363 } 364 365 if (!element->reference.handle) { 366 printk(KERN_WARNING PREFIX "Invalid reference in" 367 " package %s\n", pathname); 368 status = AE_NULL_ENTRY; 369 break; 370 } 371 /* Get the acpi_handle. */ 372 373 list->handles[i] = element->reference.handle; 374 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found reference [%p]\n", 375 list->handles[i])); 376 } 377 378 end: 379 if (ACPI_FAILURE(status)) { 380 list->count = 0; 381 //kfree(list->handles); 382 } 383 384 kfree(buffer.pointer); 385 386 return status; 387 } 388 389 EXPORT_SYMBOL(acpi_evaluate_reference); 390 391 acpi_status 392 acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld) 393 { 394 acpi_status status; 395 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 396 union acpi_object *output; 397 398 status = acpi_evaluate_object(handle, "_PLD", NULL, &buffer); 399 400 if (ACPI_FAILURE(status)) 401 return status; 402 403 output = buffer.pointer; 404 405 if (!output || output->type != ACPI_TYPE_PACKAGE 406 || !output->package.count 407 || output->package.elements[0].type != ACPI_TYPE_BUFFER 408 || output->package.elements[0].buffer.length < ACPI_PLD_REV1_BUFFER_SIZE) { 409 status = AE_TYPE; 410 goto out; 411 } 412 413 status = acpi_decode_pld_buffer( 414 output->package.elements[0].buffer.pointer, 415 output->package.elements[0].buffer.length, 416 pld); 417 418 out: 419 kfree(buffer.pointer); 420 return status; 421 } 422 EXPORT_SYMBOL(acpi_get_physical_device_location); 423 424 /** 425 * acpi_evaluate_ost: Evaluate _OST for hotplug operations 426 * @handle: ACPI device handle 427 * @source_event: source event code 428 * @status_code: status code 429 * @status_buf: optional detailed information (NULL if none) 430 * 431 * Evaluate _OST for hotplug operations. All ACPI hotplug handlers 432 * must call this function when evaluating _OST for hotplug operations. 433 * When the platform does not support _OST, this function has no effect. 434 */ 435 acpi_status 436 acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code, 437 struct acpi_buffer *status_buf) 438 { 439 union acpi_object params[3] = { 440 {.type = ACPI_TYPE_INTEGER,}, 441 {.type = ACPI_TYPE_INTEGER,}, 442 {.type = ACPI_TYPE_BUFFER,} 443 }; 444 struct acpi_object_list arg_list = {3, params}; 445 446 params[0].integer.value = source_event; 447 params[1].integer.value = status_code; 448 if (status_buf != NULL) { 449 params[2].buffer.pointer = status_buf->pointer; 450 params[2].buffer.length = status_buf->length; 451 } else { 452 params[2].buffer.pointer = NULL; 453 params[2].buffer.length = 0; 454 } 455 456 return acpi_evaluate_object(handle, "_OST", &arg_list, NULL); 457 } 458 EXPORT_SYMBOL(acpi_evaluate_ost); 459 460 /** 461 * acpi_handle_path: Return the object path of handle 462 * 463 * Caller must free the returned buffer 464 */ 465 static char *acpi_handle_path(acpi_handle handle) 466 { 467 struct acpi_buffer buffer = { 468 .length = ACPI_ALLOCATE_BUFFER, 469 .pointer = NULL 470 }; 471 472 if (in_interrupt() || 473 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer) != AE_OK) 474 return NULL; 475 return buffer.pointer; 476 } 477 478 /** 479 * acpi_handle_printk: Print message with ACPI prefix and object path 480 * 481 * This function is called through acpi_handle_<level> macros and prints 482 * a message with ACPI prefix and object path. This function acquires 483 * the global namespace mutex to obtain an object path. In interrupt 484 * context, it shows the object path as <n/a>. 485 */ 486 void 487 acpi_handle_printk(const char *level, acpi_handle handle, const char *fmt, ...) 488 { 489 struct va_format vaf; 490 va_list args; 491 const char *path; 492 493 va_start(args, fmt); 494 vaf.fmt = fmt; 495 vaf.va = &args; 496 497 path = acpi_handle_path(handle); 498 printk("%sACPI: %s: %pV", level, path ? path : "<n/a>" , &vaf); 499 500 va_end(args); 501 kfree(path); 502 } 503 EXPORT_SYMBOL(acpi_handle_printk); 504 505 #if defined(CONFIG_DYNAMIC_DEBUG) 506 /** 507 * __acpi_handle_debug: pr_debug with ACPI prefix and object path 508 * 509 * This function is called through acpi_handle_debug macro and debug 510 * prints a message with ACPI prefix and object path. This function 511 * acquires the global namespace mutex to obtain an object path. In 512 * interrupt context, it shows the object path as <n/a>. 513 */ 514 void 515 __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, 516 const char *fmt, ...) 517 { 518 struct va_format vaf; 519 va_list args; 520 const char *path; 521 522 va_start(args, fmt); 523 vaf.fmt = fmt; 524 vaf.va = &args; 525 526 path = acpi_handle_path(handle); 527 __dynamic_pr_debug(descriptor, "ACPI: %s: %pV", path ? path : "<n/a>", &vaf); 528 529 va_end(args); 530 kfree(path); 531 } 532 EXPORT_SYMBOL(__acpi_handle_debug); 533 #endif 534 535 /** 536 * acpi_has_method: Check whether @handle has a method named @name 537 * @handle: ACPI device handle 538 * @name: name of object or method 539 * 540 * Check whether @handle has a method named @name. 541 */ 542 bool acpi_has_method(acpi_handle handle, char *name) 543 { 544 acpi_handle tmp; 545 546 return ACPI_SUCCESS(acpi_get_handle(handle, name, &tmp)); 547 } 548 EXPORT_SYMBOL(acpi_has_method); 549 550 acpi_status acpi_execute_simple_method(acpi_handle handle, char *method, 551 u64 arg) 552 { 553 union acpi_object obj = { .type = ACPI_TYPE_INTEGER }; 554 struct acpi_object_list arg_list = { .count = 1, .pointer = &obj, }; 555 556 obj.integer.value = arg; 557 558 return acpi_evaluate_object(handle, method, &arg_list, NULL); 559 } 560 EXPORT_SYMBOL(acpi_execute_simple_method); 561 562 /** 563 * acpi_evaluate_ej0: Evaluate _EJ0 method for hotplug operations 564 * @handle: ACPI device handle 565 * 566 * Evaluate device's _EJ0 method for hotplug operations. 567 */ 568 acpi_status acpi_evaluate_ej0(acpi_handle handle) 569 { 570 acpi_status status; 571 572 status = acpi_execute_simple_method(handle, "_EJ0", 1); 573 if (status == AE_NOT_FOUND) 574 acpi_handle_warn(handle, "No _EJ0 support for device\n"); 575 else if (ACPI_FAILURE(status)) 576 acpi_handle_warn(handle, "Eject failed (0x%x)\n", status); 577 578 return status; 579 } 580 581 /** 582 * acpi_evaluate_lck: Evaluate _LCK method to lock/unlock device 583 * @handle: ACPI device handle 584 * @lock: lock device if non-zero, otherwise unlock device 585 * 586 * Evaluate device's _LCK method if present to lock/unlock device 587 */ 588 acpi_status acpi_evaluate_lck(acpi_handle handle, int lock) 589 { 590 acpi_status status; 591 592 status = acpi_execute_simple_method(handle, "_LCK", !!lock); 593 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 594 if (lock) 595 acpi_handle_warn(handle, 596 "Locking device failed (0x%x)\n", status); 597 else 598 acpi_handle_warn(handle, 599 "Unlocking device failed (0x%x)\n", status); 600 } 601 602 return status; 603 } 604 605 /** 606 * acpi_evaluate_dsm - evaluate device's _DSM method 607 * @handle: ACPI device handle 608 * @uuid: UUID of requested functions, should be 16 bytes 609 * @rev: revision number of requested function 610 * @func: requested function number 611 * @argv4: the function specific parameter 612 * 613 * Evaluate device's _DSM method with specified UUID, revision id and 614 * function number. Caller needs to free the returned object. 615 * 616 * Though ACPI defines the fourth parameter for _DSM should be a package, 617 * some old BIOSes do expect a buffer or an integer etc. 618 */ 619 union acpi_object * 620 acpi_evaluate_dsm(acpi_handle handle, const u8 *uuid, int rev, int func, 621 union acpi_object *argv4) 622 { 623 acpi_status ret; 624 struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL}; 625 union acpi_object params[4]; 626 struct acpi_object_list input = { 627 .count = 4, 628 .pointer = params, 629 }; 630 631 params[0].type = ACPI_TYPE_BUFFER; 632 params[0].buffer.length = 16; 633 params[0].buffer.pointer = (char *)uuid; 634 params[1].type = ACPI_TYPE_INTEGER; 635 params[1].integer.value = rev; 636 params[2].type = ACPI_TYPE_INTEGER; 637 params[2].integer.value = func; 638 if (argv4) { 639 params[3] = *argv4; 640 } else { 641 params[3].type = ACPI_TYPE_PACKAGE; 642 params[3].package.count = 0; 643 params[3].package.elements = NULL; 644 } 645 646 ret = acpi_evaluate_object(handle, "_DSM", &input, &buf); 647 if (ACPI_SUCCESS(ret)) 648 return (union acpi_object *)buf.pointer; 649 650 if (ret != AE_NOT_FOUND) 651 acpi_handle_warn(handle, 652 "failed to evaluate _DSM (0x%x)\n", ret); 653 654 return NULL; 655 } 656 EXPORT_SYMBOL(acpi_evaluate_dsm); 657 658 /** 659 * acpi_check_dsm - check if _DSM method supports requested functions. 660 * @handle: ACPI device handle 661 * @uuid: UUID of requested functions, should be 16 bytes at least 662 * @rev: revision number of requested functions 663 * @funcs: bitmap of requested functions 664 * @exclude: excluding special value, used to support i915 and nouveau 665 * 666 * Evaluate device's _DSM method to check whether it supports requested 667 * functions. Currently only support 64 functions at maximum, should be 668 * enough for now. 669 */ 670 bool acpi_check_dsm(acpi_handle handle, const u8 *uuid, int rev, u64 funcs) 671 { 672 int i; 673 u64 mask = 0; 674 union acpi_object *obj; 675 676 if (funcs == 0) 677 return false; 678 679 obj = acpi_evaluate_dsm(handle, uuid, rev, 0, NULL); 680 if (!obj) 681 return false; 682 683 /* For compatibility, old BIOSes may return an integer */ 684 if (obj->type == ACPI_TYPE_INTEGER) 685 mask = obj->integer.value; 686 else if (obj->type == ACPI_TYPE_BUFFER) 687 for (i = 0; i < obj->buffer.length && i < 8; i++) 688 mask |= (((u8)obj->buffer.pointer[i]) << (i * 8)); 689 ACPI_FREE(obj); 690 691 /* 692 * Bit 0 indicates whether there's support for any functions other than 693 * function 0 for the specified UUID and revision. 694 */ 695 if ((mask & 0x1) && (mask & funcs) == funcs) 696 return true; 697 698 return false; 699 } 700 EXPORT_SYMBOL(acpi_check_dsm); 701