sys/contrib/dev/acpica/source/components/resources/rsxface.c

   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 "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 (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)