1 /******************************************************************************* 2 * 3 * Module Name: rsutils - Utilities for the resource manager 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include <acpi/acpi.h> 45 #include "accommon.h" 46 #include "acnamesp.h" 47 #include "acresrc.h" 48 49 #define _COMPONENT ACPI_RESOURCES 50 ACPI_MODULE_NAME("rsutils") 51 52 /******************************************************************************* 53 * 54 * FUNCTION: acpi_rs_decode_bitmask 55 * 56 * PARAMETERS: mask - Bitmask to decode 57 * list - Where the converted list is returned 58 * 59 * RETURN: Count of bits set (length of list) 60 * 61 * DESCRIPTION: Convert a bit mask into a list of values 62 * 63 ******************************************************************************/ 64 u8 acpi_rs_decode_bitmask(u16 mask, u8 * list) 65 { 66 u8 i; 67 u8 bit_count; 68 69 ACPI_FUNCTION_ENTRY(); 70 71 /* Decode the mask bits */ 72 73 for (i = 0, bit_count = 0; mask; i++) { 74 if (mask & 0x0001) { 75 list[bit_count] = i; 76 bit_count++; 77 } 78 79 mask >>= 1; 80 } 81 82 return (bit_count); 83 } 84 85 /******************************************************************************* 86 * 87 * FUNCTION: acpi_rs_encode_bitmask 88 * 89 * PARAMETERS: list - List of values to encode 90 * count - Length of list 91 * 92 * RETURN: Encoded bitmask 93 * 94 * DESCRIPTION: Convert a list of values to an encoded bitmask 95 * 96 ******************************************************************************/ 97 98 u16 acpi_rs_encode_bitmask(u8 * list, u8 count) 99 { 100 u32 i; 101 u16 mask; 102 103 ACPI_FUNCTION_ENTRY(); 104 105 /* Encode the list into a single bitmask */ 106 107 for (i = 0, mask = 0; i < count; i++) { 108 mask |= (0x1 << list[i]); 109 } 110 111 return (mask); 112 } 113 114 /******************************************************************************* 115 * 116 * FUNCTION: acpi_rs_move_data 117 * 118 * PARAMETERS: destination - Pointer to the destination descriptor 119 * source - Pointer to the source descriptor 120 * item_count - How many items to move 121 * move_type - Byte width 122 * 123 * RETURN: None 124 * 125 * DESCRIPTION: Move multiple data items from one descriptor to another. Handles 126 * alignment issues and endian issues if necessary, as configured 127 * via the ACPI_MOVE_* macros. (This is why a memcpy is not used) 128 * 129 ******************************************************************************/ 130 131 void 132 acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type) 133 { 134 u32 i; 135 136 ACPI_FUNCTION_ENTRY(); 137 138 /* One move per item */ 139 140 for (i = 0; i < item_count; i++) { 141 switch (move_type) { 142 /* 143 * For the 8-bit case, we can perform the move all at once 144 * since there are no alignment or endian issues 145 */ 146 case ACPI_RSC_MOVE8: 147 case ACPI_RSC_MOVE_GPIO_RES: 148 case ACPI_RSC_MOVE_SERIAL_VEN: 149 case ACPI_RSC_MOVE_SERIAL_RES: 150 151 memcpy(destination, source, item_count); 152 return; 153 154 /* 155 * 16-, 32-, and 64-bit cases must use the move macros that perform 156 * endian conversion and/or accommodate hardware that cannot perform 157 * misaligned memory transfers 158 */ 159 case ACPI_RSC_MOVE16: 160 case ACPI_RSC_MOVE_GPIO_PIN: 161 162 ACPI_MOVE_16_TO_16(&ACPI_CAST_PTR(u16, destination)[i], 163 &ACPI_CAST_PTR(u16, source)[i]); 164 break; 165 166 case ACPI_RSC_MOVE32: 167 168 ACPI_MOVE_32_TO_32(&ACPI_CAST_PTR(u32, destination)[i], 169 &ACPI_CAST_PTR(u32, source)[i]); 170 break; 171 172 case ACPI_RSC_MOVE64: 173 174 ACPI_MOVE_64_TO_64(&ACPI_CAST_PTR(u64, destination)[i], 175 &ACPI_CAST_PTR(u64, source)[i]); 176 break; 177 178 default: 179 180 return; 181 } 182 } 183 } 184 185 /******************************************************************************* 186 * 187 * FUNCTION: acpi_rs_set_resource_length 188 * 189 * PARAMETERS: total_length - Length of the AML descriptor, including 190 * the header and length fields. 191 * aml - Pointer to the raw AML descriptor 192 * 193 * RETURN: None 194 * 195 * DESCRIPTION: Set the resource_length field of an AML 196 * resource descriptor, both Large and Small descriptors are 197 * supported automatically. Note: Descriptor Type field must 198 * be valid. 199 * 200 ******************************************************************************/ 201 202 void 203 acpi_rs_set_resource_length(acpi_rsdesc_size total_length, 204 union aml_resource *aml) 205 { 206 acpi_rs_length resource_length; 207 208 ACPI_FUNCTION_ENTRY(); 209 210 /* Length is the total descriptor length minus the header length */ 211 212 resource_length = (acpi_rs_length) 213 (total_length - acpi_ut_get_resource_header_length(aml)); 214 215 /* Length is stored differently for large and small descriptors */ 216 217 if (aml->small_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) { 218 219 /* Large descriptor -- bytes 1-2 contain the 16-bit length */ 220 221 ACPI_MOVE_16_TO_16(&aml->large_header.resource_length, 222 &resource_length); 223 } else { 224 /* Small descriptor -- bits 2:0 of byte 0 contain the length */ 225 226 aml->small_header.descriptor_type = (u8) 227 228 /* Clear any existing length, preserving descriptor type bits */ 229 ((aml->small_header. 230 descriptor_type & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK) 231 232 | resource_length); 233 } 234 } 235 236 /******************************************************************************* 237 * 238 * FUNCTION: acpi_rs_set_resource_header 239 * 240 * PARAMETERS: descriptor_type - Byte to be inserted as the type 241 * total_length - Length of the AML descriptor, including 242 * the header and length fields. 243 * aml - Pointer to the raw AML descriptor 244 * 245 * RETURN: None 246 * 247 * DESCRIPTION: Set the descriptor_type and resource_length fields of an AML 248 * resource descriptor, both Large and Small descriptors are 249 * supported automatically 250 * 251 ******************************************************************************/ 252 253 void 254 acpi_rs_set_resource_header(u8 descriptor_type, 255 acpi_rsdesc_size total_length, 256 union aml_resource *aml) 257 { 258 ACPI_FUNCTION_ENTRY(); 259 260 /* Set the Resource Type */ 261 262 aml->small_header.descriptor_type = descriptor_type; 263 264 /* Set the Resource Length */ 265 266 acpi_rs_set_resource_length(total_length, aml); 267 } 268 269 /******************************************************************************* 270 * 271 * FUNCTION: acpi_rs_strcpy 272 * 273 * PARAMETERS: destination - Pointer to the destination string 274 * source - Pointer to the source string 275 * 276 * RETURN: String length, including NULL terminator 277 * 278 * DESCRIPTION: Local string copy that returns the string length, saving a 279 * strcpy followed by a strlen. 280 * 281 ******************************************************************************/ 282 283 static u16 acpi_rs_strcpy(char *destination, char *source) 284 { 285 u16 i; 286 287 ACPI_FUNCTION_ENTRY(); 288 289 for (i = 0; source[i]; i++) { 290 destination[i] = source[i]; 291 } 292 293 destination[i] = 0; 294 295 /* Return string length including the NULL terminator */ 296 297 return ((u16) (i + 1)); 298 } 299 300 /******************************************************************************* 301 * 302 * FUNCTION: acpi_rs_get_resource_source 303 * 304 * PARAMETERS: resource_length - Length field of the descriptor 305 * minimum_length - Minimum length of the descriptor (minus 306 * any optional fields) 307 * resource_source - Where the resource_source is returned 308 * aml - Pointer to the raw AML descriptor 309 * string_ptr - (optional) where to store the actual 310 * resource_source string 311 * 312 * RETURN: Length of the string plus NULL terminator, rounded up to native 313 * word boundary 314 * 315 * DESCRIPTION: Copy the optional resource_source data from a raw AML descriptor 316 * to an internal resource descriptor 317 * 318 ******************************************************************************/ 319 320 acpi_rs_length 321 acpi_rs_get_resource_source(acpi_rs_length resource_length, 322 acpi_rs_length minimum_length, 323 struct acpi_resource_source * resource_source, 324 union aml_resource * aml, char *string_ptr) 325 { 326 acpi_rsdesc_size total_length; 327 u8 *aml_resource_source; 328 329 ACPI_FUNCTION_ENTRY(); 330 331 total_length = 332 resource_length + sizeof(struct aml_resource_large_header); 333 aml_resource_source = ACPI_ADD_PTR(u8, aml, minimum_length); 334 335 /* 336 * resource_source is present if the length of the descriptor is longer than 337 * the minimum length. 338 * 339 * Note: Some resource descriptors will have an additional null, so 340 * we add 1 to the minimum length. 341 */ 342 if (total_length > (acpi_rsdesc_size) (minimum_length + 1)) { 343 344 /* Get the resource_source_index */ 345 346 resource_source->index = aml_resource_source[0]; 347 348 resource_source->string_ptr = string_ptr; 349 if (!string_ptr) { 350 /* 351 * String destination pointer is not specified; Set the String 352 * pointer to the end of the current resource_source structure. 353 */ 354 resource_source->string_ptr = 355 ACPI_ADD_PTR(char, resource_source, 356 sizeof(struct acpi_resource_source)); 357 } 358 359 /* 360 * In order for the Resource length to be a multiple of the native 361 * word, calculate the length of the string (+1 for NULL terminator) 362 * and expand to the next word multiple. 363 * 364 * Zero the entire area of the buffer. 365 */ 366 total_length = 367 (u32)strlen(ACPI_CAST_PTR(char, &aml_resource_source[1])) + 368 1; 369 total_length = (u32)ACPI_ROUND_UP_TO_NATIVE_WORD(total_length); 370 371 memset(resource_source->string_ptr, 0, total_length); 372 373 /* Copy the resource_source string to the destination */ 374 375 resource_source->string_length = 376 acpi_rs_strcpy(resource_source->string_ptr, 377 ACPI_CAST_PTR(char, 378 &aml_resource_source[1])); 379 380 return ((acpi_rs_length) total_length); 381 } 382 383 /* resource_source is not present */ 384 385 resource_source->index = 0; 386 resource_source->string_length = 0; 387 resource_source->string_ptr = NULL; 388 return (0); 389 } 390 391 /******************************************************************************* 392 * 393 * FUNCTION: acpi_rs_set_resource_source 394 * 395 * PARAMETERS: aml - Pointer to the raw AML descriptor 396 * minimum_length - Minimum length of the descriptor (minus 397 * any optional fields) 398 * resource_source - Internal resource_source 399 400 * 401 * RETURN: Total length of the AML descriptor 402 * 403 * DESCRIPTION: Convert an optional resource_source from internal format to a 404 * raw AML resource descriptor 405 * 406 ******************************************************************************/ 407 408 acpi_rsdesc_size 409 acpi_rs_set_resource_source(union aml_resource * aml, 410 acpi_rs_length minimum_length, 411 struct acpi_resource_source * resource_source) 412 { 413 u8 *aml_resource_source; 414 acpi_rsdesc_size descriptor_length; 415 416 ACPI_FUNCTION_ENTRY(); 417 418 descriptor_length = minimum_length; 419 420 /* Non-zero string length indicates presence of a resource_source */ 421 422 if (resource_source->string_length) { 423 424 /* Point to the end of the AML descriptor */ 425 426 aml_resource_source = ACPI_ADD_PTR(u8, aml, minimum_length); 427 428 /* Copy the resource_source_index */ 429 430 aml_resource_source[0] = (u8) resource_source->index; 431 432 /* Copy the resource_source string */ 433 434 strcpy(ACPI_CAST_PTR(char, &aml_resource_source[1]), 435 resource_source->string_ptr); 436 437 /* 438 * Add the length of the string (+ 1 for null terminator) to the 439 * final descriptor length 440 */ 441 descriptor_length += 442 ((acpi_rsdesc_size) resource_source->string_length + 1); 443 } 444 445 /* Return the new total length of the AML descriptor */ 446 447 return (descriptor_length); 448 } 449 450 /******************************************************************************* 451 * 452 * FUNCTION: acpi_rs_get_prt_method_data 453 * 454 * PARAMETERS: node - Device node 455 * ret_buffer - Pointer to a buffer structure for the 456 * results 457 * 458 * RETURN: Status 459 * 460 * DESCRIPTION: This function is called to get the _PRT value of an object 461 * contained in an object specified by the handle passed in 462 * 463 * If the function fails an appropriate status will be returned 464 * and the contents of the callers buffer is undefined. 465 * 466 ******************************************************************************/ 467 468 acpi_status 469 acpi_rs_get_prt_method_data(struct acpi_namespace_node * node, 470 struct acpi_buffer * ret_buffer) 471 { 472 union acpi_operand_object *obj_desc; 473 acpi_status status; 474 475 ACPI_FUNCTION_TRACE(rs_get_prt_method_data); 476 477 /* Parameters guaranteed valid by caller */ 478 479 /* Execute the method, no parameters */ 480 481 status = acpi_ut_evaluate_object(node, METHOD_NAME__PRT, 482 ACPI_BTYPE_PACKAGE, &obj_desc); 483 if (ACPI_FAILURE(status)) { 484 return_ACPI_STATUS(status); 485 } 486 487 /* 488 * Create a resource linked list from the byte stream buffer that comes 489 * back from the _CRS method execution. 490 */ 491 status = acpi_rs_create_pci_routing_table(obj_desc, ret_buffer); 492 493 /* On exit, we must delete the object returned by evaluate_object */ 494 495 acpi_ut_remove_reference(obj_desc); 496 return_ACPI_STATUS(status); 497 } 498 499 /******************************************************************************* 500 * 501 * FUNCTION: acpi_rs_get_crs_method_data 502 * 503 * PARAMETERS: node - Device node 504 * ret_buffer - Pointer to a buffer structure for the 505 * results 506 * 507 * RETURN: Status 508 * 509 * DESCRIPTION: This function is called to get the _CRS value of an object 510 * contained in an object specified by the handle passed in 511 * 512 * If the function fails an appropriate status will be returned 513 * and the contents of the callers buffer is undefined. 514 * 515 ******************************************************************************/ 516 517 acpi_status 518 acpi_rs_get_crs_method_data(struct acpi_namespace_node *node, 519 struct acpi_buffer *ret_buffer) 520 { 521 union acpi_operand_object *obj_desc; 522 acpi_status status; 523 524 ACPI_FUNCTION_TRACE(rs_get_crs_method_data); 525 526 /* Parameters guaranteed valid by caller */ 527 528 /* Execute the method, no parameters */ 529 530 status = acpi_ut_evaluate_object(node, METHOD_NAME__CRS, 531 ACPI_BTYPE_BUFFER, &obj_desc); 532 if (ACPI_FAILURE(status)) { 533 return_ACPI_STATUS(status); 534 } 535 536 /* 537 * Make the call to create a resource linked list from the 538 * byte stream buffer that comes back from the _CRS method 539 * execution. 540 */ 541 status = acpi_rs_create_resource_list(obj_desc, ret_buffer); 542 543 /* On exit, we must delete the object returned by evaluateObject */ 544 545 acpi_ut_remove_reference(obj_desc); 546 return_ACPI_STATUS(status); 547 } 548 549 /******************************************************************************* 550 * 551 * FUNCTION: acpi_rs_get_prs_method_data 552 * 553 * PARAMETERS: node - Device node 554 * ret_buffer - Pointer to a buffer structure for the 555 * results 556 * 557 * RETURN: Status 558 * 559 * DESCRIPTION: This function is called to get the _PRS value of an object 560 * contained in an object specified by the handle passed in 561 * 562 * If the function fails an appropriate status will be returned 563 * and the contents of the callers buffer is undefined. 564 * 565 ******************************************************************************/ 566 567 #ifdef ACPI_FUTURE_USAGE 568 acpi_status 569 acpi_rs_get_prs_method_data(struct acpi_namespace_node *node, 570 struct acpi_buffer *ret_buffer) 571 { 572 union acpi_operand_object *obj_desc; 573 acpi_status status; 574 575 ACPI_FUNCTION_TRACE(rs_get_prs_method_data); 576 577 /* Parameters guaranteed valid by caller */ 578 579 /* Execute the method, no parameters */ 580 581 status = acpi_ut_evaluate_object(node, METHOD_NAME__PRS, 582 ACPI_BTYPE_BUFFER, &obj_desc); 583 if (ACPI_FAILURE(status)) { 584 return_ACPI_STATUS(status); 585 } 586 587 /* 588 * Make the call to create a resource linked list from the 589 * byte stream buffer that comes back from the _CRS method 590 * execution. 591 */ 592 status = acpi_rs_create_resource_list(obj_desc, ret_buffer); 593 594 /* On exit, we must delete the object returned by evaluateObject */ 595 596 acpi_ut_remove_reference(obj_desc); 597 return_ACPI_STATUS(status); 598 } 599 #endif /* ACPI_FUTURE_USAGE */ 600 601 /******************************************************************************* 602 * 603 * FUNCTION: acpi_rs_get_aei_method_data 604 * 605 * PARAMETERS: node - Device node 606 * ret_buffer - Pointer to a buffer structure for the 607 * results 608 * 609 * RETURN: Status 610 * 611 * DESCRIPTION: This function is called to get the _AEI value of an object 612 * contained in an object specified by the handle passed in 613 * 614 * If the function fails an appropriate status will be returned 615 * and the contents of the callers buffer is undefined. 616 * 617 ******************************************************************************/ 618 619 acpi_status 620 acpi_rs_get_aei_method_data(struct acpi_namespace_node *node, 621 struct acpi_buffer *ret_buffer) 622 { 623 union acpi_operand_object *obj_desc; 624 acpi_status status; 625 626 ACPI_FUNCTION_TRACE(rs_get_aei_method_data); 627 628 /* Parameters guaranteed valid by caller */ 629 630 /* Execute the method, no parameters */ 631 632 status = acpi_ut_evaluate_object(node, METHOD_NAME__AEI, 633 ACPI_BTYPE_BUFFER, &obj_desc); 634 if (ACPI_FAILURE(status)) { 635 return_ACPI_STATUS(status); 636 } 637 638 /* 639 * Make the call to create a resource linked list from the 640 * byte stream buffer that comes back from the _CRS method 641 * execution. 642 */ 643 status = acpi_rs_create_resource_list(obj_desc, ret_buffer); 644 645 /* On exit, we must delete the object returned by evaluateObject */ 646 647 acpi_ut_remove_reference(obj_desc); 648 return_ACPI_STATUS(status); 649 } 650 651 /******************************************************************************* 652 * 653 * FUNCTION: acpi_rs_get_method_data 654 * 655 * PARAMETERS: handle - Handle to the containing object 656 * path - Path to method, relative to Handle 657 * ret_buffer - Pointer to a buffer structure for the 658 * results 659 * 660 * RETURN: Status 661 * 662 * DESCRIPTION: This function is called to get the _CRS or _PRS value of an 663 * object contained in an object specified by the handle passed in 664 * 665 * If the function fails an appropriate status will be returned 666 * and the contents of the callers buffer is undefined. 667 * 668 ******************************************************************************/ 669 670 acpi_status 671 acpi_rs_get_method_data(acpi_handle handle, 672 char *path, struct acpi_buffer *ret_buffer) 673 { 674 union acpi_operand_object *obj_desc; 675 acpi_status status; 676 677 ACPI_FUNCTION_TRACE(rs_get_method_data); 678 679 /* Parameters guaranteed valid by caller */ 680 681 /* Execute the method, no parameters */ 682 683 status = 684 acpi_ut_evaluate_object(ACPI_CAST_PTR 685 (struct acpi_namespace_node, handle), path, 686 ACPI_BTYPE_BUFFER, &obj_desc); 687 if (ACPI_FAILURE(status)) { 688 return_ACPI_STATUS(status); 689 } 690 691 /* 692 * Make the call to create a resource linked list from the 693 * byte stream buffer that comes back from the method 694 * execution. 695 */ 696 status = acpi_rs_create_resource_list(obj_desc, ret_buffer); 697 698 /* On exit, we must delete the object returned by evaluate_object */ 699 700 acpi_ut_remove_reference(obj_desc); 701 return_ACPI_STATUS(status); 702 } 703 704 /******************************************************************************* 705 * 706 * FUNCTION: acpi_rs_set_srs_method_data 707 * 708 * PARAMETERS: node - Device node 709 * in_buffer - Pointer to a buffer structure of the 710 * parameter 711 * 712 * RETURN: Status 713 * 714 * DESCRIPTION: This function is called to set the _SRS of an object contained 715 * in an object specified by the handle passed in 716 * 717 * If the function fails an appropriate status will be returned 718 * and the contents of the callers buffer is undefined. 719 * 720 * Note: Parameters guaranteed valid by caller 721 * 722 ******************************************************************************/ 723 724 acpi_status 725 acpi_rs_set_srs_method_data(struct acpi_namespace_node *node, 726 struct acpi_buffer *in_buffer) 727 { 728 struct acpi_evaluate_info *info; 729 union acpi_operand_object *args[2]; 730 acpi_status status; 731 struct acpi_buffer buffer; 732 733 ACPI_FUNCTION_TRACE(rs_set_srs_method_data); 734 735 /* Allocate and initialize the evaluation information block */ 736 737 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); 738 if (!info) { 739 return_ACPI_STATUS(AE_NO_MEMORY); 740 } 741 742 info->prefix_node = node; 743 info->relative_pathname = METHOD_NAME__SRS; 744 info->parameters = args; 745 info->flags = ACPI_IGNORE_RETURN_VALUE; 746 747 /* 748 * The in_buffer parameter will point to a linked list of 749 * resource parameters. It needs to be formatted into a 750 * byte stream to be sent in as an input parameter to _SRS 751 * 752 * Convert the linked list into a byte stream 753 */ 754 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; 755 status = acpi_rs_create_aml_resources(in_buffer, &buffer); 756 if (ACPI_FAILURE(status)) { 757 goto cleanup; 758 } 759 760 /* Create and initialize the method parameter object */ 761 762 args[0] = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER); 763 if (!args[0]) { 764 /* 765 * Must free the buffer allocated above (otherwise it is freed 766 * later) 767 */ 768 ACPI_FREE(buffer.pointer); 769 status = AE_NO_MEMORY; 770 goto cleanup; 771 } 772 773 args[0]->buffer.length = (u32) buffer.length; 774 args[0]->buffer.pointer = buffer.pointer; 775 args[0]->common.flags = AOPOBJ_DATA_VALID; 776 args[1] = NULL; 777 778 /* Execute the method, no return value is expected */ 779 780 status = acpi_ns_evaluate(info); 781 782 /* Clean up and return the status from acpi_ns_evaluate */ 783 784 acpi_ut_remove_reference(args[0]); 785 786 cleanup: 787 ACPI_FREE(info); 788 return_ACPI_STATUS(status); 789 } 790