reactos/drivers/bus/acpi/acpica/resources/rsxface.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsxface - Public interfaces to the resource manager
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2017, 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 "acpi.h"
  47 #include "accommon.h"
  48 #include "acresrc.h"
  49 #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 (
 437             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 (
 444             ACPI_RESOURCE_ADDRESS32, &Resource->Data);
 445         ACPI_COPY_ADDRESS (Out, Address32);
 446         break;
 447
 448     case ACPI_RESOURCE_TYPE_ADDRESS64:
 449
 450         /* Simple copy for 64 bit source */
 451
 452         memcpy (Out, &Resource->Data, sizeof (ACPI_RESOURCE_ADDRESS64));
 453         break;
 454
 455     default:
 456
 457         return (AE_BAD_PARAMETER);
 458     }
 459
 460     return (AE_OK);
 461 }
 462
 463 ACPI_EXPORT_SYMBOL (AcpiResourceToAddress64)
 464
 465
 466 /*******************************************************************************
 467  *
 468  * FUNCTION:    AcpiGetVendorResource
 469  *
 470  * PARAMETERS:  DeviceHandle    - Handle for the parent device object
 471  *              Name            - Method name for the parent resource
 472  *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)
 473  *              Uuid            - Pointer to the UUID to be matched.
 474  *                                includes both subtype and 16-byte UUID
 475  *              RetBuffer       - Where the vendor resource is returned
 476  *
 477  * RETURN:      Status
 478  *
 479  * DESCRIPTION: Walk a resource template for the specified device to find a
 480  *              vendor-defined resource that matches the supplied UUID and
 481  *              UUID subtype. Returns a ACPI_RESOURCE of type Vendor.
 482  *
 483  ******************************************************************************/
 484
 485 ACPI_STATUS
 486 AcpiGetVendorResource (
 487     ACPI_HANDLE             DeviceHandle,
 488     char                    *Name,
 489     ACPI_VENDOR_UUID        *Uuid,
 490     ACPI_BUFFER             *RetBuffer)
 491 {
 492     ACPI_VENDOR_WALK_INFO   Info;
 493     ACPI_STATUS             Status;
 494
 495
 496     /* Other parameters are validated by AcpiWalkResources */
 497
 498     if (!Uuid || !RetBuffer)
 499     {
 500         return (AE_BAD_PARAMETER);
 501     }
 502
 503     Info.Uuid = Uuid;
 504     Info.Buffer = RetBuffer;
 505     Info.Status = AE_NOT_EXIST;
 506
 507     /* Walk the _CRS or _PRS resource list for this device */
 508
 509     Status = AcpiWalkResources (
 510         DeviceHandle, Name, AcpiRsMatchVendorResource, &Info);
 511     if (ACPI_FAILURE (Status))
 512     {
 513         return (Status);
 514     }
 515
 516     return (Info.Status);
 517 }
 518
 519 ACPI_EXPORT_SYMBOL (AcpiGetVendorResource)
 520
 521
 522 /*******************************************************************************
 523  *
 524  * FUNCTION:    AcpiRsMatchVendorResource
 525  *
 526  * PARAMETERS:  ACPI_WALK_RESOURCE_CALLBACK
 527  *
 528  * RETURN:      Status
 529  *
 530  * DESCRIPTION: Match a vendor resource via the ACPI 3.0 UUID
 531  *
 532  ******************************************************************************/
 533
 534 static ACPI_STATUS
 535 AcpiRsMatchVendorResource (
 536     ACPI_RESOURCE           *Resource,
 537     void                    *Context)
 538 {
 539     ACPI_VENDOR_WALK_INFO       *Info = Context;
 540     ACPI_RESOURCE_VENDOR_TYPED  *Vendor;
 541     ACPI_BUFFER                 *Buffer;
 542     ACPI_STATUS                 Status;
 543
 544
 545     /* Ignore all descriptors except Vendor */
 546
 547     if (Resource->Type != ACPI_RESOURCE_TYPE_VENDOR)
 548     {
 549         return (AE_OK);
 550     }
 551
 552     Vendor = &Resource->Data.VendorTyped;
 553
 554     /*
 555      * For a valid match, these conditions must hold:
 556      *
 557      * 1) Length of descriptor data must be at least as long as a UUID struct
 558      * 2) The UUID subtypes must match
 559      * 3) The UUID data must match
 560      */
 561     if ((Vendor->ByteLength < (ACPI_UUID_LENGTH + 1)) ||
 562         (Vendor->UuidSubtype != Info->Uuid->Subtype)  ||
 563         (memcmp (Vendor->Uuid, Info->Uuid->Data, ACPI_UUID_LENGTH)))
 564     {
 565         return (AE_OK);
 566     }
 567
 568     /* Validate/Allocate/Clear caller buffer */
 569
 570     Buffer = Info->Buffer;
 571     Status = AcpiUtInitializeBuffer (Buffer, Resource->Length);
 572     if (ACPI_FAILURE (Status))
 573     {
 574         return (Status);
 575     }
 576
 577     /* Found the correct resource, copy and return it */
 578
 579     memcpy (Buffer->Pointer, Resource, Resource->Length);
 580     Buffer->Length = Resource->Length;
 581
 582     /* Found the desired descriptor, terminate resource walk */
 583
 584     Info->Status = AE_OK;
 585     return (AE_CTRL_TERMINATE);
 586 }
 587
 588
 589 /*******************************************************************************
 590  *
 591  * FUNCTION:    AcpiWalkResourceBuffer
 592  *
 593  * PARAMETERS:  Buffer          - Formatted buffer returned by one of the
 594  *                                various Get*Resource functions
 595  *              UserFunction    - Called for each resource
 596  *              Context         - Passed to UserFunction
 597  *
 598  * RETURN:      Status
 599  *
 600  * DESCRIPTION: Walks the input resource template. The UserFunction is called
 601  *              once for each resource in the list.
 602  *
 603  ******************************************************************************/
 604
 605 ACPI_STATUS
 606 AcpiWalkResourceBuffer (
 607     ACPI_BUFFER                 *Buffer,
 608     ACPI_WALK_RESOURCE_CALLBACK UserFunction,
 609     void                        *Context)
 610 {
 611     ACPI_STATUS                 Status = AE_OK;
 612     ACPI_RESOURCE               *Resource;
 613     ACPI_RESOURCE               *ResourceEnd;
 614
 615
 616     ACPI_FUNCTION_TRACE (AcpiWalkResourceBuffer);
 617
 618
 619     /* Parameter validation */
 620
 621     if (!Buffer || !Buffer->Pointer || !UserFunction)
 622     {
 623         return_ACPI_STATUS (AE_BAD_PARAMETER);
 624     }
 625
 626     /* Buffer contains the resource list and length */
 627
 628     Resource = ACPI_CAST_PTR (ACPI_RESOURCE, Buffer->Pointer);
 629     ResourceEnd = ACPI_ADD_PTR (
 630         ACPI_RESOURCE, Buffer->Pointer, Buffer->Length);
 631
 632     /* Walk the resource list until the EndTag is found (or buffer end) */
 633
 634     while (Resource < ResourceEnd)
 635     {
 636         /* Sanity check the resource type */
 637
 638         if (Resource->Type > ACPI_RESOURCE_TYPE_MAX)
 639         {
 640             Status = AE_AML_INVALID_RESOURCE_TYPE;
 641             break;
 642         }
 643
 644         /* Sanity check the length. It must not be zero, or we loop forever */
 645
 646         if (!Resource->Length)
 647         {
 648             return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
 649         }
 650
 651         /* Invoke the user function, abort on any error returned */
 652
 653         Status = UserFunction (Resource, Context);
 654         if (ACPI_FAILURE (Status))
 655         {
 656             if (Status == AE_CTRL_TERMINATE)
 657             {
 658                 /* This is an OK termination by the user function */
 659
 660                 Status = AE_OK;
 661             }
 662             break;
 663         }
 664
 665         /* EndTag indicates end-of-list */
 666
 667         if (Resource->Type == ACPI_RESOURCE_TYPE_END_TAG)
 668         {
 669             break;
 670         }
 671
 672         /* Get the next resource descriptor */
 673
 674         Resource = ACPI_NEXT_RESOURCE (Resource);
 675     }
 676
 677     return_ACPI_STATUS (Status);
 678 }
 679
 680 ACPI_EXPORT_SYMBOL (AcpiWalkResourceBuffer)
 681
 682
 683 /*******************************************************************************
 684  *
 685  * FUNCTION:    AcpiWalkResources
 686  *
 687  * PARAMETERS:  DeviceHandle    - Handle to the device object for the
 688  *                                device we are querying
 689  *              Name            - Method name of the resources we want.
 690  *                                (METHOD_NAME__CRS, METHOD_NAME__PRS, or
 691  *                                METHOD_NAME__AEI or METHOD_NAME__DMA)
 692  *              UserFunction    - Called for each resource
 693  *              Context         - Passed to UserFunction
 694  *
 695  * RETURN:      Status
 696  *
 697  * DESCRIPTION: Retrieves the current or possible resource list for the
 698  *              specified device. The UserFunction is called once for
 699  *              each resource in the list.
 700  *
 701  ******************************************************************************/
 702
 703 ACPI_STATUS
 704 AcpiWalkResources (
 705     ACPI_HANDLE                 DeviceHandle,
 706     char                        *Name,
 707     ACPI_WALK_RESOURCE_CALLBACK UserFunction,
 708     void                        *Context)
 709 {
 710     ACPI_STATUS                 Status;
 711     ACPI_BUFFER                 Buffer;
 712
 713
 714     ACPI_FUNCTION_TRACE (AcpiWalkResources);
 715
 716
 717     /* Parameter validation */
 718
 719     if (!DeviceHandle || !UserFunction || !Name ||
 720         (!ACPI_COMPARE_NAME (Name, METHOD_NAME__CRS) &&
 721          !ACPI_COMPARE_NAME (Name, METHOD_NAME__PRS) &&
 722          !ACPI_COMPARE_NAME (Name, METHOD_NAME__AEI) &&
 723          !ACPI_COMPARE_NAME (Name, METHOD_NAME__DMA)))
 724     {
 725         return_ACPI_STATUS (AE_BAD_PARAMETER);
 726     }
 727
 728     /* Get the _CRS/_PRS/_AEI/_DMA resource list */
 729
 730     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 731     Status = AcpiRsGetMethodData (DeviceHandle, Name, &Buffer);
 732     if (ACPI_FAILURE (Status))
 733     {
 734         return_ACPI_STATUS (Status);
 735     }
 736
 737     /* Walk the resource list and cleanup */
 738
 739     Status = AcpiWalkResourceBuffer (&Buffer, UserFunction, Context);
 740     ACPI_FREE (Buffer.Pointer);
 741     return_ACPI_STATUS (Status);
 742 }
 743
 744 ACPI_EXPORT_SYMBOL (AcpiWalkResources)