1 /******************************************************************************* 2 * 3 * Module Name: rsxface - Public interfaces to the resource manager 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 #define __RSXFACE_C__ 45 #define EXPORT_ACPI_INTERFACES 46 47 #include <contrib/dev/acpica/include/acpi.h> 48 #include <contrib/dev/acpica/include/accommon.h> 49 #include <contrib/dev/acpica/include/acresrc.h> 50 #include <contrib/dev/acpica/include/acnamesp.h> 51 52 #define _COMPONENT ACPI_RESOURCES 53 ACPI_MODULE_NAME ("rsxface") 54 55 /* Local macros for 16,32-bit to 64-bit conversion */ 56 57 #define ACPI_COPY_FIELD(Out, In, Field) ((Out)->Field = (In)->Field) 58 #define ACPI_COPY_ADDRESS(Out, In) \ 59 ACPI_COPY_FIELD(Out, In, ResourceType); \ 60 ACPI_COPY_FIELD(Out, In, ProducerConsumer); \ 61 ACPI_COPY_FIELD(Out, In, Decode); \ 62 ACPI_COPY_FIELD(Out, In, MinAddressFixed); \ 63 ACPI_COPY_FIELD(Out, In, MaxAddressFixed); \ 64 ACPI_COPY_FIELD(Out, In, Info); \ 65 ACPI_COPY_FIELD(Out, In, Granularity); \ 66 ACPI_COPY_FIELD(Out, In, Minimum); \ 67 ACPI_COPY_FIELD(Out, In, Maximum); \ 68 ACPI_COPY_FIELD(Out, In, TranslationOffset); \ 69 ACPI_COPY_FIELD(Out, In, AddressLength); \ 70 ACPI_COPY_FIELD(Out, In, ResourceSource); 71 72 73 /* Local prototypes */ 74 75 static ACPI_STATUS 76 AcpiRsMatchVendorResource ( 77 ACPI_RESOURCE *Resource, 78 void *Context); 79 80 static ACPI_STATUS 81 AcpiRsValidateParameters ( 82 ACPI_HANDLE DeviceHandle, 83 ACPI_BUFFER *Buffer, 84 ACPI_NAMESPACE_NODE **ReturnNode); 85 86 87 /******************************************************************************* 88 * 89 * FUNCTION: AcpiRsValidateParameters 90 * 91 * PARAMETERS: DeviceHandle - Handle to a device 92 * Buffer - Pointer to a data buffer 93 * ReturnNode - Pointer to where the device node is returned 94 * 95 * RETURN: Status 96 * 97 * DESCRIPTION: Common parameter validation for resource interfaces 98 * 99 ******************************************************************************/ 100 101 static ACPI_STATUS 102 AcpiRsValidateParameters ( 103 ACPI_HANDLE DeviceHandle, 104 ACPI_BUFFER *Buffer, 105 ACPI_NAMESPACE_NODE **ReturnNode) 106 { 107 ACPI_STATUS Status; 108 ACPI_NAMESPACE_NODE *Node; 109 110 111 ACPI_FUNCTION_TRACE (RsValidateParameters); 112 113 114 /* 115 * Must have a valid handle to an ACPI device 116 */ 117 if (!DeviceHandle) 118 { 119 return_ACPI_STATUS (AE_BAD_PARAMETER); 120 } 121 122 Node = AcpiNsValidateHandle (DeviceHandle); 123 if (!Node) 124 { 125 return_ACPI_STATUS (AE_BAD_PARAMETER); 126 } 127 128 if (Node->Type != ACPI_TYPE_DEVICE) 129 { 130 return_ACPI_STATUS (AE_TYPE); 131 } 132 133 /* 134 * Validate the user buffer object 135 * 136 * if there is a non-zero buffer length we also need a valid pointer in 137 * the buffer. If it's a zero buffer length, we'll be returning the 138 * needed buffer size (later), so keep going. 139 */ 140 Status = AcpiUtValidateBuffer (Buffer); 141 if (ACPI_FAILURE (Status)) 142 { 143 return_ACPI_STATUS (Status); 144 } 145 146 *ReturnNode = Node; 147 return_ACPI_STATUS (AE_OK); 148 } 149 150 151 /******************************************************************************* 152 * 153 * FUNCTION: AcpiGetIrqRoutingTable 154 * 155 * PARAMETERS: DeviceHandle - Handle to the Bus device we are querying 156 * RetBuffer - Pointer to a buffer to receive the 157 * current resources for the device 158 * 159 * RETURN: Status 160 * 161 * DESCRIPTION: This function is called to get the IRQ routing table for a 162 * specific bus. The caller must first acquire a handle for the 163 * desired bus. The routine table is placed in the buffer pointed 164 * to by the RetBuffer variable parameter. 165 * 166 * If the function fails an appropriate status will be returned 167 * and the value of RetBuffer is undefined. 168 * 169 * This function attempts to execute the _PRT method contained in 170 * the object indicated by the passed DeviceHandle. 171 * 172 ******************************************************************************/ 173 174 ACPI_STATUS 175 AcpiGetIrqRoutingTable ( 176 ACPI_HANDLE DeviceHandle, 177 ACPI_BUFFER *RetBuffer) 178 { 179 ACPI_STATUS Status; 180 ACPI_NAMESPACE_NODE *Node; 181 182 183 ACPI_FUNCTION_TRACE (AcpiGetIrqRoutingTable); 184 185 186 /* Validate parameters then dispatch to internal routine */ 187 188 Status = AcpiRsValidateParameters (DeviceHandle, RetBuffer, &Node); 189 if (ACPI_FAILURE (Status)) 190 { 191 return_ACPI_STATUS (Status); 192 } 193 194 Status = AcpiRsGetPrtMethodData (Node, RetBuffer); 195 return_ACPI_STATUS (Status); 196 } 197 198 ACPI_EXPORT_SYMBOL (AcpiGetIrqRoutingTable) 199 200 201 /******************************************************************************* 202 * 203 * FUNCTION: AcpiGetCurrentResources 204 * 205 * PARAMETERS: DeviceHandle - Handle to the device object for the 206 * device we are querying 207 * RetBuffer - Pointer to a buffer to receive the 208 * current resources for the device 209 * 210 * RETURN: Status 211 * 212 * DESCRIPTION: This function is called to get the current resources for a 213 * specific device. The caller must first acquire a handle for 214 * the desired device. The resource data is placed in the buffer 215 * pointed to by the RetBuffer variable parameter. 216 * 217 * If the function fails an appropriate status will be returned 218 * and the value of RetBuffer is undefined. 219 * 220 * This function attempts to execute the _CRS method contained in 221 * the object indicated by the passed DeviceHandle. 222 * 223 ******************************************************************************/ 224 225 ACPI_STATUS 226 AcpiGetCurrentResources ( 227 ACPI_HANDLE DeviceHandle, 228 ACPI_BUFFER *RetBuffer) 229 { 230 ACPI_STATUS Status; 231 ACPI_NAMESPACE_NODE *Node; 232 233 234 ACPI_FUNCTION_TRACE (AcpiGetCurrentResources); 235 236 237 /* Validate parameters then dispatch to internal routine */ 238 239 Status = AcpiRsValidateParameters (DeviceHandle, RetBuffer, &Node); 240 if (ACPI_FAILURE (Status)) 241 { 242 return_ACPI_STATUS (Status); 243 } 244 245 Status = AcpiRsGetCrsMethodData (Node, RetBuffer); 246 return_ACPI_STATUS (Status); 247 } 248 249 ACPI_EXPORT_SYMBOL (AcpiGetCurrentResources) 250 251 252 /******************************************************************************* 253 * 254 * FUNCTION: AcpiGetPossibleResources 255 * 256 * PARAMETERS: DeviceHandle - Handle to the device object for the 257 * device we are querying 258 * RetBuffer - Pointer to a buffer to receive the 259 * resources for the device 260 * 261 * RETURN: Status 262 * 263 * DESCRIPTION: This function is called to get a list of the possible resources 264 * for a specific device. The caller must first acquire a handle 265 * for the desired device. The resource data is placed in the 266 * buffer pointed to by the RetBuffer variable. 267 * 268 * If the function fails an appropriate status will be returned 269 * and the value of RetBuffer is undefined. 270 * 271 ******************************************************************************/ 272 273 ACPI_STATUS 274 AcpiGetPossibleResources ( 275 ACPI_HANDLE DeviceHandle, 276 ACPI_BUFFER *RetBuffer) 277 { 278 ACPI_STATUS Status; 279 ACPI_NAMESPACE_NODE *Node; 280 281 282 ACPI_FUNCTION_TRACE (AcpiGetPossibleResources); 283 284 285 /* Validate parameters then dispatch to internal routine */ 286 287 Status = AcpiRsValidateParameters (DeviceHandle, RetBuffer, &Node); 288 if (ACPI_FAILURE (Status)) 289 { 290 return_ACPI_STATUS (Status); 291 } 292 293 Status = AcpiRsGetPrsMethodData (Node, RetBuffer); 294 return_ACPI_STATUS (Status); 295 } 296 297 ACPI_EXPORT_SYMBOL (AcpiGetPossibleResources) 298 299 300 /******************************************************************************* 301 * 302 * FUNCTION: AcpiSetCurrentResources 303 * 304 * PARAMETERS: DeviceHandle - Handle to the device object for the 305 * device we are setting resources 306 * InBuffer - Pointer to a buffer containing the 307 * resources to be set for the device 308 * 309 * RETURN: Status 310 * 311 * DESCRIPTION: This function is called to set the current resources for a 312 * specific device. The caller must first acquire a handle for 313 * the desired device. The resource data is passed to the routine 314 * the buffer pointed to by the InBuffer variable. 315 * 316 ******************************************************************************/ 317 318 ACPI_STATUS 319 AcpiSetCurrentResources ( 320 ACPI_HANDLE DeviceHandle, 321 ACPI_BUFFER *InBuffer) 322 { 323 ACPI_STATUS Status; 324 ACPI_NAMESPACE_NODE *Node; 325 326 327 ACPI_FUNCTION_TRACE (AcpiSetCurrentResources); 328 329 330 /* Validate the buffer, don't allow zero length */ 331 332 if ((!InBuffer) || 333 (!InBuffer->Pointer) || 334 (!InBuffer->Length)) 335 { 336 return_ACPI_STATUS (AE_BAD_PARAMETER); 337 } 338 339 /* Validate parameters then dispatch to internal routine */ 340 341 Status = AcpiRsValidateParameters (DeviceHandle, InBuffer, &Node); 342 if (ACPI_FAILURE (Status)) 343 { 344 return_ACPI_STATUS (Status); 345 } 346 347 Status = AcpiRsSetSrsMethodData (Node, InBuffer); 348 return_ACPI_STATUS (Status); 349 } 350 351 ACPI_EXPORT_SYMBOL (AcpiSetCurrentResources) 352 353 354 /******************************************************************************* 355 * 356 * FUNCTION: AcpiGetEventResources 357 * 358 * PARAMETERS: DeviceHandle - Handle to the device object for the 359 * device we are getting resources 360 * InBuffer - Pointer to a buffer containing the 361 * resources to be set for the device 362 * 363 * RETURN: Status 364 * 365 * DESCRIPTION: This function is called to get the event resources for a 366 * specific device. The caller must first acquire a handle for 367 * the desired device. The resource data is passed to the routine 368 * the buffer pointed to by the InBuffer variable. Uses the 369 * _AEI method. 370 * 371 ******************************************************************************/ 372 373 ACPI_STATUS 374 AcpiGetEventResources ( 375 ACPI_HANDLE DeviceHandle, 376 ACPI_BUFFER *RetBuffer) 377 { 378 ACPI_STATUS Status; 379 ACPI_NAMESPACE_NODE *Node; 380 381 382 ACPI_FUNCTION_TRACE (AcpiGetEventResources); 383 384 385 /* Validate parameters then dispatch to internal routine */ 386 387 Status = AcpiRsValidateParameters (DeviceHandle, RetBuffer, &Node); 388 if (ACPI_FAILURE (Status)) 389 { 390 return_ACPI_STATUS (Status); 391 } 392 393 Status = AcpiRsGetAeiMethodData (Node, RetBuffer); 394 return_ACPI_STATUS (Status); 395 } 396 397 ACPI_EXPORT_SYMBOL (AcpiGetEventResources) 398 399 400 /****************************************************************************** 401 * 402 * FUNCTION: AcpiResourceToAddress64 403 * 404 * PARAMETERS: Resource - Pointer to a resource 405 * Out - Pointer to the users's return buffer 406 * (a struct acpi_resource_address64) 407 * 408 * RETURN: Status 409 * 410 * DESCRIPTION: If the resource is an address16, address32, or address64, 411 * copy it to the address64 return buffer. This saves the 412 * caller from having to duplicate code for different-sized 413 * addresses. 414 * 415 ******************************************************************************/ 416 417 ACPI_STATUS 418 AcpiResourceToAddress64 ( 419 ACPI_RESOURCE *Resource, 420 ACPI_RESOURCE_ADDRESS64 *Out) 421 { 422 ACPI_RESOURCE_ADDRESS16 *Address16; 423 ACPI_RESOURCE_ADDRESS32 *Address32; 424 425 426 if (!Resource || !Out) 427 { 428 return (AE_BAD_PARAMETER); 429 } 430 431 /* Convert 16 or 32 address descriptor to 64 */ 432 433 switch (Resource->Type) 434 { 435 case ACPI_RESOURCE_TYPE_ADDRESS16: 436 437 Address16 = ACPI_CAST_PTR (ACPI_RESOURCE_ADDRESS16, &Resource->Data); 438 ACPI_COPY_ADDRESS (Out, Address16); 439 break; 440 441 case ACPI_RESOURCE_TYPE_ADDRESS32: 442 443 Address32 = ACPI_CAST_PTR (ACPI_RESOURCE_ADDRESS32, &Resource->Data); 444 ACPI_COPY_ADDRESS (Out, Address32); 445 break; 446 447 case ACPI_RESOURCE_TYPE_ADDRESS64: 448 449 /* Simple copy for 64 bit source */ 450 451 ACPI_MEMCPY (Out, &Resource->Data, sizeof (ACPI_RESOURCE_ADDRESS64)); 452 break; 453 454 default: 455 456 return (AE_BAD_PARAMETER); 457 } 458 459 return (AE_OK); 460 } 461 462 ACPI_EXPORT_SYMBOL (AcpiResourceToAddress64) 463 464 465 /******************************************************************************* 466 * 467 * FUNCTION: AcpiGetVendorResource 468 * 469 * PARAMETERS: DeviceHandle - Handle for the parent device object 470 * Name - Method name for the parent resource 471 * (METHOD_NAME__CRS or METHOD_NAME__PRS) 472 * Uuid - Pointer to the UUID to be matched. 473 * includes both subtype and 16-byte UUID 474 * RetBuffer - Where the vendor resource is returned 475 * 476 * RETURN: Status 477 * 478 * DESCRIPTION: Walk a resource template for the specified device to find a 479 * vendor-defined resource that matches the supplied UUID and 480 * UUID subtype. Returns a ACPI_RESOURCE of type Vendor. 481 * 482 ******************************************************************************/ 483 484 ACPI_STATUS 485 AcpiGetVendorResource ( 486 ACPI_HANDLE DeviceHandle, 487 char *Name, 488 ACPI_VENDOR_UUID *Uuid, 489 ACPI_BUFFER *RetBuffer) 490 { 491 ACPI_VENDOR_WALK_INFO Info; 492 ACPI_STATUS Status; 493 494 495 /* Other parameters are validated by AcpiWalkResources */ 496 497 if (!Uuid || !RetBuffer) 498 { 499 return (AE_BAD_PARAMETER); 500 } 501 502 Info.Uuid = Uuid; 503 Info.Buffer = RetBuffer; 504 Info.Status = AE_NOT_EXIST; 505 506 /* Walk the _CRS or _PRS resource list for this device */ 507 508 Status = AcpiWalkResources (DeviceHandle, Name, AcpiRsMatchVendorResource, 509 &Info); 510 if (ACPI_FAILURE (Status)) 511 { 512 return (Status); 513 } 514 515 return (Info.Status); 516 } 517 518 ACPI_EXPORT_SYMBOL (AcpiGetVendorResource) 519 520 521 /******************************************************************************* 522 * 523 * FUNCTION: AcpiRsMatchVendorResource 524 * 525 * PARAMETERS: ACPI_WALK_RESOURCE_CALLBACK 526 * 527 * RETURN: Status 528 * 529 * DESCRIPTION: Match a vendor resource via the ACPI 3.0 UUID 530 * 531 ******************************************************************************/ 532 533 static ACPI_STATUS 534 AcpiRsMatchVendorResource ( 535 ACPI_RESOURCE *Resource, 536 void *Context) 537 { 538 ACPI_VENDOR_WALK_INFO *Info = Context; 539 ACPI_RESOURCE_VENDOR_TYPED *Vendor; 540 ACPI_BUFFER *Buffer; 541 ACPI_STATUS Status; 542 543 544 /* Ignore all descriptors except Vendor */ 545 546 if (Resource->Type != ACPI_RESOURCE_TYPE_VENDOR) 547 { 548 return (AE_OK); 549 } 550 551 Vendor = &Resource->Data.VendorTyped; 552 553 /* 554 * For a valid match, these conditions must hold: 555 * 556 * 1) Length of descriptor data must be at least as long as a UUID struct 557 * 2) The UUID subtypes must match 558 * 3) The UUID data must match 559 */ 560 if ((Vendor->ByteLength < (ACPI_UUID_LENGTH + 1)) || 561 (Vendor->UuidSubtype != Info->Uuid->Subtype) || 562 (ACPI_MEMCMP (Vendor->Uuid, Info->Uuid->Data, ACPI_UUID_LENGTH))) 563 { 564 return (AE_OK); 565 } 566 567 /* Validate/Allocate/Clear caller buffer */ 568 569 Buffer = Info->Buffer; 570 Status = AcpiUtInitializeBuffer (Buffer, Resource->Length); 571 if (ACPI_FAILURE (Status)) 572 { 573 return (Status); 574 } 575 576 /* Found the correct resource, copy and return it */ 577 578 ACPI_MEMCPY (Buffer->Pointer, Resource, Resource->Length); 579 Buffer->Length = Resource->Length; 580 581 /* Found the desired descriptor, terminate resource walk */ 582 583 Info->Status = AE_OK; 584 return (AE_CTRL_TERMINATE); 585 } 586 587 588 /******************************************************************************* 589 * 590 * FUNCTION: AcpiWalkResourceBuffer 591 * 592 * PARAMETERS: Buffer - Formatted buffer returned by one of the 593 * various Get*Resource functions 594 * UserFunction - Called for each resource 595 * Context - Passed to UserFunction 596 * 597 * RETURN: Status 598 * 599 * DESCRIPTION: Walks the input resource template. The UserFunction is called 600 * once for each resource in the list. 601 * 602 ******************************************************************************/ 603 604 ACPI_STATUS 605 AcpiWalkResourceBuffer ( 606 ACPI_BUFFER *Buffer, 607 ACPI_WALK_RESOURCE_CALLBACK UserFunction, 608 void *Context) 609 { 610 ACPI_STATUS Status = AE_OK; 611 ACPI_RESOURCE *Resource; 612 ACPI_RESOURCE *ResourceEnd; 613 614 615 ACPI_FUNCTION_TRACE (AcpiWalkResourceBuffer); 616 617 618 /* Parameter validation */ 619 620 if (!Buffer || !Buffer->Pointer || !UserFunction) 621 { 622 return_ACPI_STATUS (AE_BAD_PARAMETER); 623 } 624 625 /* Buffer contains the resource list and length */ 626 627 Resource = ACPI_CAST_PTR (ACPI_RESOURCE, Buffer->Pointer); 628 ResourceEnd = ACPI_ADD_PTR (ACPI_RESOURCE, Buffer->Pointer, Buffer->Length); 629 630 /* Walk the resource list until the EndTag is found (or buffer end) */ 631 632 while (Resource < ResourceEnd) 633 { 634 /* Sanity check the resource type */ 635 636 if (Resource->Type > ACPI_RESOURCE_TYPE_MAX) 637 { 638 Status = AE_AML_INVALID_RESOURCE_TYPE; 639 break; 640 } 641 642 /* Sanity check the length. It must not be zero, or we loop forever */ 643 644 if (!Resource->Length) 645 { 646 return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH); 647 } 648 649 /* Invoke the user function, abort on any error returned */ 650 651 Status = UserFunction (Resource, Context); 652 if (ACPI_FAILURE (Status)) 653 { 654 if (Status == AE_CTRL_TERMINATE) 655 { 656 /* This is an OK termination by the user function */ 657 658 Status = AE_OK; 659 } 660 break; 661 } 662 663 /* EndTag indicates end-of-list */ 664 665 if (Resource->Type == ACPI_RESOURCE_TYPE_END_TAG) 666 { 667 break; 668 } 669 670 /* Get the next resource descriptor */ 671 672 Resource = ACPI_NEXT_RESOURCE (Resource); 673 } 674 675 return_ACPI_STATUS (Status); 676 } 677 678 ACPI_EXPORT_SYMBOL (AcpiWalkResourceBuffer) 679 680 681 /******************************************************************************* 682 * 683 * FUNCTION: AcpiWalkResources 684 * 685 * PARAMETERS: DeviceHandle - Handle to the device object for the 686 * device we are querying 687 * Name - Method name of the resources we want. 688 * (METHOD_NAME__CRS, METHOD_NAME__PRS, or 689 * METHOD_NAME__AEI) 690 * UserFunction - Called for each resource 691 * Context - Passed to UserFunction 692 * 693 * RETURN: Status 694 * 695 * DESCRIPTION: Retrieves the current or possible resource list for the 696 * specified device. The UserFunction is called once for 697 * each resource in the list. 698 * 699 ******************************************************************************/ 700 701 ACPI_STATUS 702 AcpiWalkResources ( 703 ACPI_HANDLE DeviceHandle, 704 char *Name, 705 ACPI_WALK_RESOURCE_CALLBACK UserFunction, 706 void *Context) 707 { 708 ACPI_STATUS Status; 709 ACPI_BUFFER Buffer; 710 711 712 ACPI_FUNCTION_TRACE (AcpiWalkResources); 713 714 715 /* Parameter validation */ 716 717 if (!DeviceHandle || !UserFunction || !Name || 718 (!ACPI_COMPARE_NAME (Name, METHOD_NAME__CRS) && 719 !ACPI_COMPARE_NAME (Name, METHOD_NAME__PRS) && 720 !ACPI_COMPARE_NAME (Name, METHOD_NAME__AEI))) 721 { 722 return_ACPI_STATUS (AE_BAD_PARAMETER); 723 } 724 725 /* Get the _CRS/_PRS/_AEI resource list */ 726 727 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 728 Status = AcpiRsGetMethodData (DeviceHandle, Name, &Buffer); 729 if (ACPI_FAILURE (Status)) 730 { 731 return_ACPI_STATUS (Status); 732 } 733 734 /* Walk the resource list and cleanup */ 735 736 Status = AcpiWalkResourceBuffer (&Buffer, UserFunction, Context); 737 ACPI_FREE (Buffer.Pointer); 738 return_ACPI_STATUS (Status); 739 } 740 741 ACPI_EXPORT_SYMBOL (AcpiWalkResources) 742