1 /******************************************************************************* 2 * 3 * Module Name: rsutils - Utilities for the resource manager 4 * 5 ******************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 *****************************************************************************/ 115 116 117 #define __RSUTILS_C__ 118 119 #include "acpi.h" 120 #include "accommon.h" 121 #include "acnamesp.h" 122 #include "acresrc.h" 123 124 125 #define _COMPONENT ACPI_RESOURCES 126 ACPI_MODULE_NAME ("rsutils") 127 128 129 /******************************************************************************* 130 * 131 * FUNCTION: AcpiRsDecodeBitmask 132 * 133 * PARAMETERS: Mask - Bitmask to decode 134 * List - Where the converted list is returned 135 * 136 * RETURN: Count of bits set (length of list) 137 * 138 * DESCRIPTION: Convert a bit mask into a list of values 139 * 140 ******************************************************************************/ 141 142 UINT8 143 AcpiRsDecodeBitmask ( 144 UINT16 Mask, 145 UINT8 *List) 146 { 147 UINT8 i; 148 UINT8 BitCount; 149 150 151 ACPI_FUNCTION_ENTRY (); 152 153 154 /* Decode the mask bits */ 155 156 for (i = 0, BitCount = 0; Mask; i++) 157 { 158 if (Mask & 0x0001) 159 { 160 List[BitCount] = i; 161 BitCount++; 162 } 163 164 Mask >>= 1; 165 } 166 167 return (BitCount); 168 } 169 170 171 /******************************************************************************* 172 * 173 * FUNCTION: AcpiRsEncodeBitmask 174 * 175 * PARAMETERS: List - List of values to encode 176 * Count - Length of list 177 * 178 * RETURN: Encoded bitmask 179 * 180 * DESCRIPTION: Convert a list of values to an encoded bitmask 181 * 182 ******************************************************************************/ 183 184 UINT16 185 AcpiRsEncodeBitmask ( 186 UINT8 *List, 187 UINT8 Count) 188 { 189 UINT32 i; 190 UINT16 Mask; 191 192 193 ACPI_FUNCTION_ENTRY (); 194 195 196 /* Encode the list into a single bitmask */ 197 198 for (i = 0, Mask = 0; i < Count; i++) 199 { 200 Mask |= (0x1 << List[i]); 201 } 202 203 return (Mask); 204 } 205 206 207 /******************************************************************************* 208 * 209 * FUNCTION: AcpiRsMoveData 210 * 211 * PARAMETERS: Destination - Pointer to the destination descriptor 212 * Source - Pointer to the source descriptor 213 * ItemCount - How many items to move 214 * MoveType - Byte width 215 * 216 * RETURN: None 217 * 218 * DESCRIPTION: Move multiple data items from one descriptor to another. Handles 219 * alignment issues and endian issues if necessary, as configured 220 * via the ACPI_MOVE_* macros. (This is why a memcpy is not used) 221 * 222 ******************************************************************************/ 223 224 void 225 AcpiRsMoveData ( 226 void *Destination, 227 void *Source, 228 UINT16 ItemCount, 229 UINT8 MoveType) 230 { 231 UINT32 i; 232 233 234 ACPI_FUNCTION_ENTRY (); 235 236 237 /* One move per item */ 238 239 for (i = 0; i < ItemCount; i++) 240 { 241 switch (MoveType) 242 { 243 /* 244 * For the 8-bit case, we can perform the move all at once 245 * since there are no alignment or endian issues 246 */ 247 case ACPI_RSC_MOVE8: 248 ACPI_MEMCPY (Destination, Source, ItemCount); 249 return; 250 251 /* 252 * 16-, 32-, and 64-bit cases must use the move macros that perform 253 * endian conversion and/or accomodate hardware that cannot perform 254 * misaligned memory transfers 255 */ 256 case ACPI_RSC_MOVE16: 257 ACPI_MOVE_16_TO_16 (&ACPI_CAST_PTR (UINT16, Destination)[i], 258 &ACPI_CAST_PTR (UINT16, Source)[i]); 259 break; 260 261 case ACPI_RSC_MOVE32: 262 ACPI_MOVE_32_TO_32 (&ACPI_CAST_PTR (UINT32, Destination)[i], 263 &ACPI_CAST_PTR (UINT32, Source)[i]); 264 break; 265 266 case ACPI_RSC_MOVE64: 267 ACPI_MOVE_64_TO_64 (&ACPI_CAST_PTR (UINT64, Destination)[i], 268 &ACPI_CAST_PTR (UINT64, Source)[i]); 269 break; 270 271 default: 272 return; 273 } 274 } 275 } 276 277 278 /******************************************************************************* 279 * 280 * FUNCTION: AcpiRsSetResourceLength 281 * 282 * PARAMETERS: TotalLength - Length of the AML descriptor, including 283 * the header and length fields. 284 * Aml - Pointer to the raw AML descriptor 285 * 286 * RETURN: None 287 * 288 * DESCRIPTION: Set the ResourceLength field of an AML 289 * resource descriptor, both Large and Small descriptors are 290 * supported automatically. Note: Descriptor Type field must 291 * be valid. 292 * 293 ******************************************************************************/ 294 295 void 296 AcpiRsSetResourceLength ( 297 ACPI_RSDESC_SIZE TotalLength, 298 AML_RESOURCE *Aml) 299 { 300 ACPI_RS_LENGTH ResourceLength; 301 302 303 ACPI_FUNCTION_ENTRY (); 304 305 306 /* Length is the total descriptor length minus the header length */ 307 308 ResourceLength = (ACPI_RS_LENGTH) 309 (TotalLength - AcpiUtGetResourceHeaderLength (Aml)); 310 311 /* Length is stored differently for large and small descriptors */ 312 313 if (Aml->SmallHeader.DescriptorType & ACPI_RESOURCE_NAME_LARGE) 314 { 315 /* Large descriptor -- bytes 1-2 contain the 16-bit length */ 316 317 ACPI_MOVE_16_TO_16 (&Aml->LargeHeader.ResourceLength, &ResourceLength); 318 } 319 else 320 { 321 /* Small descriptor -- bits 2:0 of byte 0 contain the length */ 322 323 Aml->SmallHeader.DescriptorType = (UINT8) 324 325 /* Clear any existing length, preserving descriptor type bits */ 326 327 ((Aml->SmallHeader.DescriptorType & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK) 328 329 | ResourceLength); 330 } 331 } 332 333 334 /******************************************************************************* 335 * 336 * FUNCTION: AcpiRsSetResourceHeader 337 * 338 * PARAMETERS: DescriptorType - Byte to be inserted as the type 339 * TotalLength - Length of the AML descriptor, including 340 * the header and length fields. 341 * Aml - Pointer to the raw AML descriptor 342 * 343 * RETURN: None 344 * 345 * DESCRIPTION: Set the DescriptorType and ResourceLength fields of an AML 346 * resource descriptor, both Large and Small descriptors are 347 * supported automatically 348 * 349 ******************************************************************************/ 350 351 void 352 AcpiRsSetResourceHeader ( 353 UINT8 DescriptorType, 354 ACPI_RSDESC_SIZE TotalLength, 355 AML_RESOURCE *Aml) 356 { 357 ACPI_FUNCTION_ENTRY (); 358 359 360 /* Set the Resource Type */ 361 362 Aml->SmallHeader.DescriptorType = DescriptorType; 363 364 /* Set the Resource Length */ 365 366 AcpiRsSetResourceLength (TotalLength, Aml); 367 } 368 369 370 /******************************************************************************* 371 * 372 * FUNCTION: AcpiRsStrcpy 373 * 374 * PARAMETERS: Destination - Pointer to the destination string 375 * Source - Pointer to the source string 376 * 377 * RETURN: String length, including NULL terminator 378 * 379 * DESCRIPTION: Local string copy that returns the string length, saving a 380 * strcpy followed by a strlen. 381 * 382 ******************************************************************************/ 383 384 static UINT16 385 AcpiRsStrcpy ( 386 char *Destination, 387 char *Source) 388 { 389 UINT16 i; 390 391 392 ACPI_FUNCTION_ENTRY (); 393 394 395 for (i = 0; Source[i]; i++) 396 { 397 Destination[i] = Source[i]; 398 } 399 400 Destination[i] = 0; 401 402 /* Return string length including the NULL terminator */ 403 404 return ((UINT16) (i + 1)); 405 } 406 407 408 /******************************************************************************* 409 * 410 * FUNCTION: AcpiRsGetResourceSource 411 * 412 * PARAMETERS: ResourceLength - Length field of the descriptor 413 * MinimumLength - Minimum length of the descriptor (minus 414 * any optional fields) 415 * ResourceSource - Where the ResourceSource is returned 416 * Aml - Pointer to the raw AML descriptor 417 * StringPtr - (optional) where to store the actual 418 * ResourceSource string 419 * 420 * RETURN: Length of the string plus NULL terminator, rounded up to native 421 * word boundary 422 * 423 * DESCRIPTION: Copy the optional ResourceSource data from a raw AML descriptor 424 * to an internal resource descriptor 425 * 426 ******************************************************************************/ 427 428 ACPI_RS_LENGTH 429 AcpiRsGetResourceSource ( 430 ACPI_RS_LENGTH ResourceLength, 431 ACPI_RS_LENGTH MinimumLength, 432 ACPI_RESOURCE_SOURCE *ResourceSource, 433 AML_RESOURCE *Aml, 434 char *StringPtr) 435 { 436 ACPI_RSDESC_SIZE TotalLength; 437 UINT8 *AmlResourceSource; 438 439 440 ACPI_FUNCTION_ENTRY (); 441 442 443 TotalLength = ResourceLength + sizeof (AML_RESOURCE_LARGE_HEADER); 444 AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength); 445 446 /* 447 * ResourceSource is present if the length of the descriptor is longer than 448 * the minimum length. 449 * 450 * Note: Some resource descriptors will have an additional null, so 451 * we add 1 to the minimum length. 452 */ 453 if (TotalLength > (ACPI_RSDESC_SIZE) (MinimumLength + 1)) 454 { 455 /* Get the ResourceSourceIndex */ 456 457 ResourceSource->Index = AmlResourceSource[0]; 458 459 ResourceSource->StringPtr = StringPtr; 460 if (!StringPtr) 461 { 462 /* 463 * String destination pointer is not specified; Set the String 464 * pointer to the end of the current ResourceSource structure. 465 */ 466 ResourceSource->StringPtr = ACPI_ADD_PTR (char, ResourceSource, 467 sizeof (ACPI_RESOURCE_SOURCE)); 468 } 469 470 /* 471 * In order for the Resource length to be a multiple of the native 472 * word, calculate the length of the string (+1 for NULL terminator) 473 * and expand to the next word multiple. 474 * 475 * Zero the entire area of the buffer. 476 */ 477 TotalLength = (UINT32) ACPI_STRLEN ( 478 ACPI_CAST_PTR (char, &AmlResourceSource[1])) + 1; 479 TotalLength = (UINT32) ACPI_ROUND_UP_TO_NATIVE_WORD (TotalLength); 480 481 ACPI_MEMSET (ResourceSource->StringPtr, 0, TotalLength); 482 483 /* Copy the ResourceSource string to the destination */ 484 485 ResourceSource->StringLength = AcpiRsStrcpy (ResourceSource->StringPtr, 486 ACPI_CAST_PTR (char, &AmlResourceSource[1])); 487 488 return ((ACPI_RS_LENGTH) TotalLength); 489 } 490 491 /* ResourceSource is not present */ 492 493 ResourceSource->Index = 0; 494 ResourceSource->StringLength = 0; 495 ResourceSource->StringPtr = NULL; 496 return (0); 497 } 498 499 500 /******************************************************************************* 501 * 502 * FUNCTION: AcpiRsSetResourceSource 503 * 504 * PARAMETERS: Aml - Pointer to the raw AML descriptor 505 * MinimumLength - Minimum length of the descriptor (minus 506 * any optional fields) 507 * ResourceSource - Internal ResourceSource 508 509 * 510 * RETURN: Total length of the AML descriptor 511 * 512 * DESCRIPTION: Convert an optional ResourceSource from internal format to a 513 * raw AML resource descriptor 514 * 515 ******************************************************************************/ 516 517 ACPI_RSDESC_SIZE 518 AcpiRsSetResourceSource ( 519 AML_RESOURCE *Aml, 520 ACPI_RS_LENGTH MinimumLength, 521 ACPI_RESOURCE_SOURCE *ResourceSource) 522 { 523 UINT8 *AmlResourceSource; 524 ACPI_RSDESC_SIZE DescriptorLength; 525 526 527 ACPI_FUNCTION_ENTRY (); 528 529 530 DescriptorLength = MinimumLength; 531 532 /* Non-zero string length indicates presence of a ResourceSource */ 533 534 if (ResourceSource->StringLength) 535 { 536 /* Point to the end of the AML descriptor */ 537 538 AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength); 539 540 /* Copy the ResourceSourceIndex */ 541 542 AmlResourceSource[0] = (UINT8) ResourceSource->Index; 543 544 /* Copy the ResourceSource string */ 545 546 ACPI_STRCPY (ACPI_CAST_PTR (char, &AmlResourceSource[1]), 547 ResourceSource->StringPtr); 548 549 /* 550 * Add the length of the string (+ 1 for null terminator) to the 551 * final descriptor length 552 */ 553 DescriptorLength += ((ACPI_RSDESC_SIZE) ResourceSource->StringLength + 1); 554 } 555 556 /* Return the new total length of the AML descriptor */ 557 558 return (DescriptorLength); 559 } 560 561 562 /******************************************************************************* 563 * 564 * FUNCTION: AcpiRsGetPrtMethodData 565 * 566 * PARAMETERS: Node - Device node 567 * RetBuffer - Pointer to a buffer structure for the 568 * results 569 * 570 * RETURN: Status 571 * 572 * DESCRIPTION: This function is called to get the _PRT value of an object 573 * contained in an object specified by the handle passed in 574 * 575 * If the function fails an appropriate status will be returned 576 * and the contents of the callers buffer is undefined. 577 * 578 ******************************************************************************/ 579 580 ACPI_STATUS 581 AcpiRsGetPrtMethodData ( 582 ACPI_NAMESPACE_NODE *Node, 583 ACPI_BUFFER *RetBuffer) 584 { 585 ACPI_OPERAND_OBJECT *ObjDesc; 586 ACPI_STATUS Status; 587 588 589 ACPI_FUNCTION_TRACE (RsGetPrtMethodData); 590 591 592 /* Parameters guaranteed valid by caller */ 593 594 /* Execute the method, no parameters */ 595 596 Status = AcpiUtEvaluateObject (Node, METHOD_NAME__PRT, 597 ACPI_BTYPE_PACKAGE, &ObjDesc); 598 if (ACPI_FAILURE (Status)) 599 { 600 return_ACPI_STATUS (Status); 601 } 602 603 /* 604 * Create a resource linked list from the byte stream buffer that comes 605 * back from the _CRS method execution. 606 */ 607 Status = AcpiRsCreatePciRoutingTable (ObjDesc, RetBuffer); 608 609 /* On exit, we must delete the object returned by EvaluateObject */ 610 611 AcpiUtRemoveReference (ObjDesc); 612 return_ACPI_STATUS (Status); 613 } 614 615 616 /******************************************************************************* 617 * 618 * FUNCTION: AcpiRsGetCrsMethodData 619 * 620 * PARAMETERS: Node - Device node 621 * RetBuffer - Pointer to a buffer structure for the 622 * results 623 * 624 * RETURN: Status 625 * 626 * DESCRIPTION: This function is called to get the _CRS value of an object 627 * contained in an object specified by the handle passed in 628 * 629 * If the function fails an appropriate status will be returned 630 * and the contents of the callers buffer is undefined. 631 * 632 ******************************************************************************/ 633 634 ACPI_STATUS 635 AcpiRsGetCrsMethodData ( 636 ACPI_NAMESPACE_NODE *Node, 637 ACPI_BUFFER *RetBuffer) 638 { 639 ACPI_OPERAND_OBJECT *ObjDesc; 640 ACPI_STATUS Status; 641 642 643 ACPI_FUNCTION_TRACE (RsGetCrsMethodData); 644 645 646 /* Parameters guaranteed valid by caller */ 647 648 /* Execute the method, no parameters */ 649 650 Status = AcpiUtEvaluateObject (Node, METHOD_NAME__CRS, 651 ACPI_BTYPE_BUFFER, &ObjDesc); 652 if (ACPI_FAILURE (Status)) 653 { 654 return_ACPI_STATUS (Status); 655 } 656 657 /* 658 * Make the call to create a resource linked list from the 659 * byte stream buffer that comes back from the _CRS method 660 * execution. 661 */ 662 Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer); 663 664 /* On exit, we must delete the object returned by evaluateObject */ 665 666 AcpiUtRemoveReference (ObjDesc); 667 return_ACPI_STATUS (Status); 668 } 669 670 671 /******************************************************************************* 672 * 673 * FUNCTION: AcpiRsGetPrsMethodData 674 * 675 * PARAMETERS: Node - Device node 676 * RetBuffer - Pointer to a buffer structure for the 677 * results 678 * 679 * RETURN: Status 680 * 681 * DESCRIPTION: This function is called to get the _PRS value of an object 682 * contained in an object specified by the handle passed in 683 * 684 * If the function fails an appropriate status will be returned 685 * and the contents of the callers buffer is undefined. 686 * 687 ******************************************************************************/ 688 689 ACPI_STATUS 690 AcpiRsGetPrsMethodData ( 691 ACPI_NAMESPACE_NODE *Node, 692 ACPI_BUFFER *RetBuffer) 693 { 694 ACPI_OPERAND_OBJECT *ObjDesc; 695 ACPI_STATUS Status; 696 697 698 ACPI_FUNCTION_TRACE (RsGetPrsMethodData); 699 700 701 /* Parameters guaranteed valid by caller */ 702 703 /* Execute the method, no parameters */ 704 705 Status = AcpiUtEvaluateObject (Node, METHOD_NAME__PRS, 706 ACPI_BTYPE_BUFFER, &ObjDesc); 707 if (ACPI_FAILURE (Status)) 708 { 709 return_ACPI_STATUS (Status); 710 } 711 712 /* 713 * Make the call to create a resource linked list from the 714 * byte stream buffer that comes back from the _CRS method 715 * execution. 716 */ 717 Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer); 718 719 /* On exit, we must delete the object returned by evaluateObject */ 720 721 AcpiUtRemoveReference (ObjDesc); 722 return_ACPI_STATUS (Status); 723 } 724 725 726 /******************************************************************************* 727 * 728 * FUNCTION: AcpiRsGetMethodData 729 * 730 * PARAMETERS: Handle - Handle to the containing object 731 * Path - Path to method, relative to Handle 732 * RetBuffer - Pointer to a buffer structure for the 733 * results 734 * 735 * RETURN: Status 736 * 737 * DESCRIPTION: This function is called to get the _CRS or _PRS value of an 738 * object contained in an object specified by the handle passed in 739 * 740 * If the function fails an appropriate status will be returned 741 * and the contents of the callers buffer is undefined. 742 * 743 ******************************************************************************/ 744 745 ACPI_STATUS 746 AcpiRsGetMethodData ( 747 ACPI_HANDLE Handle, 748 char *Path, 749 ACPI_BUFFER *RetBuffer) 750 { 751 ACPI_OPERAND_OBJECT *ObjDesc; 752 ACPI_STATUS Status; 753 754 755 ACPI_FUNCTION_TRACE (RsGetMethodData); 756 757 758 /* Parameters guaranteed valid by caller */ 759 760 /* Execute the method, no parameters */ 761 762 Status = AcpiUtEvaluateObject (Handle, Path, ACPI_BTYPE_BUFFER, &ObjDesc); 763 if (ACPI_FAILURE (Status)) 764 { 765 return_ACPI_STATUS (Status); 766 } 767 768 /* 769 * Make the call to create a resource linked list from the 770 * byte stream buffer that comes back from the method 771 * execution. 772 */ 773 Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer); 774 775 /* On exit, we must delete the object returned by EvaluateObject */ 776 777 AcpiUtRemoveReference (ObjDesc); 778 return_ACPI_STATUS (Status); 779 } 780 781 782 /******************************************************************************* 783 * 784 * FUNCTION: AcpiRsSetSrsMethodData 785 * 786 * PARAMETERS: Node - Device node 787 * InBuffer - Pointer to a buffer structure of the 788 * parameter 789 * 790 * RETURN: Status 791 * 792 * DESCRIPTION: This function is called to set the _SRS of an object contained 793 * in an object specified by the handle passed in 794 * 795 * If the function fails an appropriate status will be returned 796 * and the contents of the callers buffer is undefined. 797 * 798 * Note: Parameters guaranteed valid by caller 799 * 800 ******************************************************************************/ 801 802 ACPI_STATUS 803 AcpiRsSetSrsMethodData ( 804 ACPI_NAMESPACE_NODE *Node, 805 ACPI_BUFFER *InBuffer) 806 { 807 ACPI_EVALUATE_INFO *Info; 808 ACPI_OPERAND_OBJECT *Args[2]; 809 ACPI_STATUS Status; 810 ACPI_BUFFER Buffer; 811 812 813 ACPI_FUNCTION_TRACE (RsSetSrsMethodData); 814 815 816 /* Allocate and initialize the evaluation information block */ 817 818 Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO)); 819 if (!Info) 820 { 821 return_ACPI_STATUS (AE_NO_MEMORY); 822 } 823 824 Info->PrefixNode = Node; 825 Info->Pathname = METHOD_NAME__SRS; 826 Info->Parameters = Args; 827 Info->Flags = ACPI_IGNORE_RETURN_VALUE; 828 829 /* 830 * The InBuffer parameter will point to a linked list of 831 * resource parameters. It needs to be formatted into a 832 * byte stream to be sent in as an input parameter to _SRS 833 * 834 * Convert the linked list into a byte stream 835 */ 836 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 837 Status = AcpiRsCreateAmlResources (InBuffer->Pointer, &Buffer); 838 if (ACPI_FAILURE (Status)) 839 { 840 goto Cleanup; 841 } 842 843 /* Create and initialize the method parameter object */ 844 845 Args[0] = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER); 846 if (!Args[0]) 847 { 848 /* 849 * Must free the buffer allocated above (otherwise it is freed 850 * later) 851 */ 852 ACPI_FREE (Buffer.Pointer); 853 Status = AE_NO_MEMORY; 854 goto Cleanup; 855 } 856 857 Args[0]->Buffer.Length = (UINT32) Buffer.Length; 858 Args[0]->Buffer.Pointer = Buffer.Pointer; 859 Args[0]->Common.Flags = AOPOBJ_DATA_VALID; 860 Args[1] = NULL; 861 862 /* Execute the method, no return value is expected */ 863 864 Status = AcpiNsEvaluate (Info); 865 866 /* Clean up and return the status from AcpiNsEvaluate */ 867 868 AcpiUtRemoveReference (Args[0]); 869 870 Cleanup: 871 ACPI_FREE (Info); 872 return_ACPI_STATUS (Status); 873 } 874 875