1 /******************************************************************************* 2 * 3 * Module Name: rsutils - Utilities for the resource manager 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, 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 ACPI_MEMCPY(destination, source, item_count); 151 return; 152 153 /* 154 * 16-, 32-, and 64-bit cases must use the move macros that perform 155 * endian conversion and/or accommodate hardware that cannot perform 156 * misaligned memory transfers 157 */ 158 case ACPI_RSC_MOVE16: 159 case ACPI_RSC_MOVE_GPIO_PIN: 160 ACPI_MOVE_16_TO_16(&ACPI_CAST_PTR(u16, destination)[i], 161 &ACPI_CAST_PTR(u16, source)[i]); 162 break; 163 164 case ACPI_RSC_MOVE32: 165 ACPI_MOVE_32_TO_32(&ACPI_CAST_PTR(u32, destination)[i], 166 &ACPI_CAST_PTR(u32, source)[i]); 167 break; 168 169 case ACPI_RSC_MOVE64: 170 ACPI_MOVE_64_TO_64(&ACPI_CAST_PTR(u64, destination)[i], 171 &ACPI_CAST_PTR(u64, source)[i]); 172 break; 173 174 default: 175 return; 176 } 177 } 178 } 179 180 /******************************************************************************* 181 * 182 * FUNCTION: acpi_rs_set_resource_length 183 * 184 * PARAMETERS: total_length - Length of the AML descriptor, including 185 * the header and length fields. 186 * aml - Pointer to the raw AML descriptor 187 * 188 * RETURN: None 189 * 190 * DESCRIPTION: Set the resource_length field of an AML 191 * resource descriptor, both Large and Small descriptors are 192 * supported automatically. Note: Descriptor Type field must 193 * be valid. 194 * 195 ******************************************************************************/ 196 197 void 198 acpi_rs_set_resource_length(acpi_rsdesc_size total_length, 199 union aml_resource *aml) 200 { 201 acpi_rs_length resource_length; 202 203 ACPI_FUNCTION_ENTRY(); 204 205 /* Length is the total descriptor length minus the header length */ 206 207 resource_length = (acpi_rs_length) 208 (total_length - acpi_ut_get_resource_header_length(aml)); 209 210 /* Length is stored differently for large and small descriptors */ 211 212 if (aml->small_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) { 213 214 /* Large descriptor -- bytes 1-2 contain the 16-bit length */ 215 216 ACPI_MOVE_16_TO_16(&aml->large_header.resource_length, 217 &resource_length); 218 } else { 219 /* Small descriptor -- bits 2:0 of byte 0 contain the length */ 220 221 aml->small_header.descriptor_type = (u8) 222 223 /* Clear any existing length, preserving descriptor type bits */ 224 ((aml->small_header. 225 descriptor_type & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK) 226 227 | resource_length); 228 } 229 } 230 231 /******************************************************************************* 232 * 233 * FUNCTION: acpi_rs_set_resource_header 234 * 235 * PARAMETERS: descriptor_type - Byte to be inserted as the type 236 * total_length - Length of the AML descriptor, including 237 * the header and length fields. 238 * aml - Pointer to the raw AML descriptor 239 * 240 * RETURN: None 241 * 242 * DESCRIPTION: Set the descriptor_type and resource_length fields of an AML 243 * resource descriptor, both Large and Small descriptors are 244 * supported automatically 245 * 246 ******************************************************************************/ 247 248 void 249 acpi_rs_set_resource_header(u8 descriptor_type, 250 acpi_rsdesc_size total_length, 251 union aml_resource *aml) 252 { 253 ACPI_FUNCTION_ENTRY(); 254 255 /* Set the Resource Type */ 256 257 aml->small_header.descriptor_type = descriptor_type; 258 259 /* Set the Resource Length */ 260 261 acpi_rs_set_resource_length(total_length, aml); 262 } 263 264 /******************************************************************************* 265 * 266 * FUNCTION: acpi_rs_strcpy 267 * 268 * PARAMETERS: destination - Pointer to the destination string 269 * source - Pointer to the source string 270 * 271 * RETURN: String length, including NULL terminator 272 * 273 * DESCRIPTION: Local string copy that returns the string length, saving a 274 * strcpy followed by a strlen. 275 * 276 ******************************************************************************/ 277 278 static u16 acpi_rs_strcpy(char *destination, char *source) 279 { 280 u16 i; 281 282 ACPI_FUNCTION_ENTRY(); 283 284 for (i = 0; source[i]; i++) { 285 destination[i] = source[i]; 286 } 287 288 destination[i] = 0; 289 290 /* Return string length including the NULL terminator */ 291 292 return ((u16) (i + 1)); 293 } 294 295 /******************************************************************************* 296 * 297 * FUNCTION: acpi_rs_get_resource_source 298 * 299 * PARAMETERS: resource_length - Length field of the descriptor 300 * minimum_length - Minimum length of the descriptor (minus 301 * any optional fields) 302 * resource_source - Where the resource_source is returned 303 * aml - Pointer to the raw AML descriptor 304 * string_ptr - (optional) where to store the actual 305 * resource_source string 306 * 307 * RETURN: Length of the string plus NULL terminator, rounded up to native 308 * word boundary 309 * 310 * DESCRIPTION: Copy the optional resource_source data from a raw AML descriptor 311 * to an internal resource descriptor 312 * 313 ******************************************************************************/ 314 315 acpi_rs_length 316 acpi_rs_get_resource_source(acpi_rs_length resource_length, 317 acpi_rs_length minimum_length, 318 struct acpi_resource_source * resource_source, 319 union aml_resource * aml, char *string_ptr) 320 { 321 acpi_rsdesc_size total_length; 322 u8 *aml_resource_source; 323 324 ACPI_FUNCTION_ENTRY(); 325 326 total_length = 327 resource_length + sizeof(struct aml_resource_large_header); 328 aml_resource_source = ACPI_ADD_PTR(u8, aml, minimum_length); 329 330 /* 331 * resource_source is present if the length of the descriptor is longer than 332 * the minimum length. 333 * 334 * Note: Some resource descriptors will have an additional null, so 335 * we add 1 to the minimum length. 336 */ 337 if (total_length > (acpi_rsdesc_size) (minimum_length + 1)) { 338 339 /* Get the resource_source_index */ 340 341 resource_source->index = aml_resource_source[0]; 342 343 resource_source->string_ptr = string_ptr; 344 if (!string_ptr) { 345 /* 346 * String destination pointer is not specified; Set the String 347 * pointer to the end of the current resource_source structure. 348 */ 349 resource_source->string_ptr = 350 ACPI_ADD_PTR(char, resource_source, 351 sizeof(struct acpi_resource_source)); 352 } 353 354 /* 355 * In order for the Resource length to be a multiple of the native 356 * word, calculate the length of the string (+1 for NULL terminator) 357 * and expand to the next word multiple. 358 * 359 * Zero the entire area of the buffer. 360 */ 361 total_length = 362 (u32) 363 ACPI_STRLEN(ACPI_CAST_PTR(char, &aml_resource_source[1])) + 364 1; 365 total_length = (u32) ACPI_ROUND_UP_TO_NATIVE_WORD(total_length); 366 367 ACPI_MEMSET(resource_source->string_ptr, 0, total_length); 368 369 /* Copy the resource_source string to the destination */ 370 371 resource_source->string_length = 372 acpi_rs_strcpy(resource_source->string_ptr, 373 ACPI_CAST_PTR(char, 374 &aml_resource_source[1])); 375 376 return ((acpi_rs_length) total_length); 377 } 378 379 /* resource_source is not present */ 380 381 resource_source->index = 0; 382 resource_source->string_length = 0; 383 resource_source->string_ptr = NULL; 384 return (0); 385 } 386 387 /******************************************************************************* 388 * 389 * FUNCTION: acpi_rs_set_resource_source 390 * 391 * PARAMETERS: aml - Pointer to the raw AML descriptor 392 * minimum_length - Minimum length of the descriptor (minus 393 * any optional fields) 394 * resource_source - Internal resource_source 395 396 * 397 * RETURN: Total length of the AML descriptor 398 * 399 * DESCRIPTION: Convert an optional resource_source from internal format to a 400 * raw AML resource descriptor 401 * 402 ******************************************************************************/ 403 404 acpi_rsdesc_size 405 acpi_rs_set_resource_source(union aml_resource * aml, 406 acpi_rs_length minimum_length, 407 struct acpi_resource_source * resource_source) 408 { 409 u8 *aml_resource_source; 410 acpi_rsdesc_size descriptor_length; 411 412 ACPI_FUNCTION_ENTRY(); 413 414 descriptor_length = minimum_length; 415 416 /* Non-zero string length indicates presence of a resource_source */ 417 418 if (resource_source->string_length) { 419 420 /* Point to the end of the AML descriptor */ 421 422 aml_resource_source = ACPI_ADD_PTR(u8, aml, minimum_length); 423 424 /* Copy the resource_source_index */ 425 426 aml_resource_source[0] = (u8) resource_source->index; 427 428 /* Copy the resource_source string */ 429 430 ACPI_STRCPY(ACPI_CAST_PTR(char, &aml_resource_source[1]), 431 resource_source->string_ptr); 432 433 /* 434 * Add the length of the string (+ 1 for null terminator) to the 435 * final descriptor length 436 */ 437 descriptor_length += 438 ((acpi_rsdesc_size) resource_source->string_length + 1); 439 } 440 441 /* Return the new total length of the AML descriptor */ 442 443 return (descriptor_length); 444 } 445 446 /******************************************************************************* 447 * 448 * FUNCTION: acpi_rs_get_prt_method_data 449 * 450 * PARAMETERS: node - Device node 451 * ret_buffer - Pointer to a buffer structure for the 452 * results 453 * 454 * RETURN: Status 455 * 456 * DESCRIPTION: This function is called to get the _PRT value of an object 457 * contained in an object specified by the handle passed in 458 * 459 * If the function fails an appropriate status will be returned 460 * and the contents of the callers buffer is undefined. 461 * 462 ******************************************************************************/ 463 464 acpi_status 465 acpi_rs_get_prt_method_data(struct acpi_namespace_node * node, 466 struct acpi_buffer * ret_buffer) 467 { 468 union acpi_operand_object *obj_desc; 469 acpi_status status; 470 471 ACPI_FUNCTION_TRACE(rs_get_prt_method_data); 472 473 /* Parameters guaranteed valid by caller */ 474 475 /* Execute the method, no parameters */ 476 477 status = acpi_ut_evaluate_object(node, METHOD_NAME__PRT, 478 ACPI_BTYPE_PACKAGE, &obj_desc); 479 if (ACPI_FAILURE(status)) { 480 return_ACPI_STATUS(status); 481 } 482 483 /* 484 * Create a resource linked list from the byte stream buffer that comes 485 * back from the _CRS method execution. 486 */ 487 status = acpi_rs_create_pci_routing_table(obj_desc, ret_buffer); 488 489 /* On exit, we must delete the object returned by evaluate_object */ 490 491 acpi_ut_remove_reference(obj_desc); 492 return_ACPI_STATUS(status); 493 } 494 495 /******************************************************************************* 496 * 497 * FUNCTION: acpi_rs_get_crs_method_data 498 * 499 * PARAMETERS: node - Device node 500 * ret_buffer - Pointer to a buffer structure for the 501 * results 502 * 503 * RETURN: Status 504 * 505 * DESCRIPTION: This function is called to get the _CRS value of an object 506 * contained in an object specified by the handle passed in 507 * 508 * If the function fails an appropriate status will be returned 509 * and the contents of the callers buffer is undefined. 510 * 511 ******************************************************************************/ 512 513 acpi_status 514 acpi_rs_get_crs_method_data(struct acpi_namespace_node *node, 515 struct acpi_buffer *ret_buffer) 516 { 517 union acpi_operand_object *obj_desc; 518 acpi_status status; 519 520 ACPI_FUNCTION_TRACE(rs_get_crs_method_data); 521 522 /* Parameters guaranteed valid by caller */ 523 524 /* Execute the method, no parameters */ 525 526 status = acpi_ut_evaluate_object(node, METHOD_NAME__CRS, 527 ACPI_BTYPE_BUFFER, &obj_desc); 528 if (ACPI_FAILURE(status)) { 529 return_ACPI_STATUS(status); 530 } 531 532 /* 533 * Make the call to create a resource linked list from the 534 * byte stream buffer that comes back from the _CRS method 535 * execution. 536 */ 537 status = acpi_rs_create_resource_list(obj_desc, ret_buffer); 538 539 /* On exit, we must delete the object returned by evaluateObject */ 540 541 acpi_ut_remove_reference(obj_desc); 542 return_ACPI_STATUS(status); 543 } 544 545 /******************************************************************************* 546 * 547 * FUNCTION: acpi_rs_get_prs_method_data 548 * 549 * PARAMETERS: node - Device node 550 * ret_buffer - Pointer to a buffer structure for the 551 * results 552 * 553 * RETURN: Status 554 * 555 * DESCRIPTION: This function is called to get the _PRS value of an object 556 * contained in an object specified by the handle passed in 557 * 558 * If the function fails an appropriate status will be returned 559 * and the contents of the callers buffer is undefined. 560 * 561 ******************************************************************************/ 562 563 #ifdef ACPI_FUTURE_USAGE 564 acpi_status 565 acpi_rs_get_prs_method_data(struct acpi_namespace_node *node, 566 struct acpi_buffer *ret_buffer) 567 { 568 union acpi_operand_object *obj_desc; 569 acpi_status status; 570 571 ACPI_FUNCTION_TRACE(rs_get_prs_method_data); 572 573 /* Parameters guaranteed valid by caller */ 574 575 /* Execute the method, no parameters */ 576 577 status = acpi_ut_evaluate_object(node, METHOD_NAME__PRS, 578 ACPI_BTYPE_BUFFER, &obj_desc); 579 if (ACPI_FAILURE(status)) { 580 return_ACPI_STATUS(status); 581 } 582 583 /* 584 * Make the call to create a resource linked list from the 585 * byte stream buffer that comes back from the _CRS method 586 * execution. 587 */ 588 status = acpi_rs_create_resource_list(obj_desc, ret_buffer); 589 590 /* On exit, we must delete the object returned by evaluateObject */ 591 592 acpi_ut_remove_reference(obj_desc); 593 return_ACPI_STATUS(status); 594 } 595 #endif /* ACPI_FUTURE_USAGE */ 596 597 /******************************************************************************* 598 * 599 * FUNCTION: acpi_rs_get_aei_method_data 600 * 601 * PARAMETERS: node - Device node 602 * ret_buffer - Pointer to a buffer structure for the 603 * results 604 * 605 * RETURN: Status 606 * 607 * DESCRIPTION: This function is called to get the _AEI value of an object 608 * contained in an object specified by the handle passed in 609 * 610 * If the function fails an appropriate status will be returned 611 * and the contents of the callers buffer is undefined. 612 * 613 ******************************************************************************/ 614 615 acpi_status 616 acpi_rs_get_aei_method_data(struct acpi_namespace_node *node, 617 struct acpi_buffer *ret_buffer) 618 { 619 union acpi_operand_object *obj_desc; 620 acpi_status status; 621 622 ACPI_FUNCTION_TRACE(rs_get_aei_method_data); 623 624 /* Parameters guaranteed valid by caller */ 625 626 /* Execute the method, no parameters */ 627 628 status = acpi_ut_evaluate_object(node, METHOD_NAME__AEI, 629 ACPI_BTYPE_BUFFER, &obj_desc); 630 if (ACPI_FAILURE(status)) { 631 return_ACPI_STATUS(status); 632 } 633 634 /* 635 * Make the call to create a resource linked list from the 636 * byte stream buffer that comes back from the _CRS method 637 * execution. 638 */ 639 status = acpi_rs_create_resource_list(obj_desc, ret_buffer); 640 641 /* On exit, we must delete the object returned by evaluateObject */ 642 643 acpi_ut_remove_reference(obj_desc); 644 return_ACPI_STATUS(status); 645 } 646 647 /******************************************************************************* 648 * 649 * FUNCTION: acpi_rs_get_method_data 650 * 651 * PARAMETERS: handle - Handle to the containing object 652 * path - Path to method, relative to Handle 653 * ret_buffer - Pointer to a buffer structure for the 654 * results 655 * 656 * RETURN: Status 657 * 658 * DESCRIPTION: This function is called to get the _CRS or _PRS value of an 659 * object contained in an object specified by the handle passed in 660 * 661 * If the function fails an appropriate status will be returned 662 * and the contents of the callers buffer is undefined. 663 * 664 ******************************************************************************/ 665 666 acpi_status 667 acpi_rs_get_method_data(acpi_handle handle, 668 char *path, struct acpi_buffer *ret_buffer) 669 { 670 union acpi_operand_object *obj_desc; 671 acpi_status status; 672 673 ACPI_FUNCTION_TRACE(rs_get_method_data); 674 675 /* Parameters guaranteed valid by caller */ 676 677 /* Execute the method, no parameters */ 678 679 status = 680 acpi_ut_evaluate_object(ACPI_CAST_PTR 681 (struct acpi_namespace_node, handle), path, 682 ACPI_BTYPE_BUFFER, &obj_desc); 683 if (ACPI_FAILURE(status)) { 684 return_ACPI_STATUS(status); 685 } 686 687 /* 688 * Make the call to create a resource linked list from the 689 * byte stream buffer that comes back from the method 690 * execution. 691 */ 692 status = acpi_rs_create_resource_list(obj_desc, ret_buffer); 693 694 /* On exit, we must delete the object returned by evaluate_object */ 695 696 acpi_ut_remove_reference(obj_desc); 697 return_ACPI_STATUS(status); 698 } 699 700 /******************************************************************************* 701 * 702 * FUNCTION: acpi_rs_set_srs_method_data 703 * 704 * PARAMETERS: node - Device node 705 * in_buffer - Pointer to a buffer structure of the 706 * parameter 707 * 708 * RETURN: Status 709 * 710 * DESCRIPTION: This function is called to set the _SRS of an object contained 711 * in an object specified by the handle passed in 712 * 713 * If the function fails an appropriate status will be returned 714 * and the contents of the callers buffer is undefined. 715 * 716 * Note: Parameters guaranteed valid by caller 717 * 718 ******************************************************************************/ 719 720 acpi_status 721 acpi_rs_set_srs_method_data(struct acpi_namespace_node *node, 722 struct acpi_buffer *in_buffer) 723 { 724 struct acpi_evaluate_info *info; 725 union acpi_operand_object *args[2]; 726 acpi_status status; 727 struct acpi_buffer buffer; 728 729 ACPI_FUNCTION_TRACE(rs_set_srs_method_data); 730 731 /* Allocate and initialize the evaluation information block */ 732 733 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); 734 if (!info) { 735 return_ACPI_STATUS(AE_NO_MEMORY); 736 } 737 738 info->prefix_node = node; 739 info->pathname = METHOD_NAME__SRS; 740 info->parameters = args; 741 info->flags = ACPI_IGNORE_RETURN_VALUE; 742 743 /* 744 * The in_buffer parameter will point to a linked list of 745 * resource parameters. It needs to be formatted into a 746 * byte stream to be sent in as an input parameter to _SRS 747 * 748 * Convert the linked list into a byte stream 749 */ 750 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; 751 status = acpi_rs_create_aml_resources(in_buffer->pointer, &buffer); 752 if (ACPI_FAILURE(status)) { 753 goto cleanup; 754 } 755 756 /* Create and initialize the method parameter object */ 757 758 args[0] = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER); 759 if (!args[0]) { 760 /* 761 * Must free the buffer allocated above (otherwise it is freed 762 * later) 763 */ 764 ACPI_FREE(buffer.pointer); 765 status = AE_NO_MEMORY; 766 goto cleanup; 767 } 768 769 args[0]->buffer.length = (u32) buffer.length; 770 args[0]->buffer.pointer = buffer.pointer; 771 args[0]->common.flags = AOPOBJ_DATA_VALID; 772 args[1] = NULL; 773 774 /* Execute the method, no return value is expected */ 775 776 status = acpi_ns_evaluate(info); 777 778 /* Clean up and return the status from acpi_ns_evaluate */ 779 780 acpi_ut_remove_reference(args[0]); 781 782 cleanup: 783 ACPI_FREE(info); 784 return_ACPI_STATUS(status); 785 } 786