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