arch/all-pc/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 - 2013, 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
  45 #define __RSXFACE_C__
  46 #define EXPORT_ACPI_INTERFACES
  47
  48 #include "acpi.h"
  49 #include "accommon.h"
  50 #include "acresrc.h"
  51 #include "acnamesp.h"
  52
  53 #define _COMPONENT          ACPI_RESOURCES
  54         ACPI_MODULE_NAME    ("rsxface")
  55
  56 /* Local macros for 16,32-bit to 64-bit conversion */
  57
  58 #define ACPI_COPY_FIELD(Out, In, Field)  ((Out)->Field = (In)->Field)
  59 #define ACPI_COPY_ADDRESS(Out, In)                      \
  60     ACPI_COPY_FIELD(Out, In, ResourceType);              \
  61     ACPI_COPY_FIELD(Out, In, ProducerConsumer);          \
  62     ACPI_COPY_FIELD(Out, In, Decode);                    \
  63     ACPI_COPY_FIELD(Out, In, MinAddressFixed);           \
  64     ACPI_COPY_FIELD(Out, In, MaxAddressFixed);           \
  65     ACPI_COPY_FIELD(Out, In, Info);                      \
  66     ACPI_COPY_FIELD(Out, In, Granularity);               \
  67     ACPI_COPY_FIELD(Out, In, Minimum);                   \
  68     ACPI_COPY_FIELD(Out, In, Maximum);                   \
  69     ACPI_COPY_FIELD(Out, In, TranslationOffset);         \
  70     ACPI_COPY_FIELD(Out, In, AddressLength);             \
  71     ACPI_COPY_FIELD(Out, In, ResourceSource);
  72
  73
  74 /* Local prototypes */
  75
  76 static ACPI_STATUS
  77 AcpiRsMatchVendorResource (
  78     ACPI_RESOURCE           *Resource,
  79     void                    *Context);
  80
  81 static ACPI_STATUS
  82 AcpiRsValidateParameters (
  83     ACPI_HANDLE             DeviceHandle,
  84     ACPI_BUFFER             *Buffer,
  85     ACPI_NAMESPACE_NODE     **ReturnNode);
  86
  87
  88 /*******************************************************************************
  89  *
  90  * FUNCTION:    AcpiRsValidateParameters
  91  *
  92  * PARAMETERS:  DeviceHandle    - Handle to a device
  93  *              Buffer          - Pointer to a data buffer
  94  *              ReturnNode      - Pointer to where the device node is returned
  95  *
  96  * RETURN:      Status
  97  *
  98  * DESCRIPTION: Common parameter validation for resource interfaces
  99  *
 100  ******************************************************************************/
 101
 102 static ACPI_STATUS
 103 AcpiRsValidateParameters (
 104     ACPI_HANDLE             DeviceHandle,
 105     ACPI_BUFFER             *Buffer,
 106     ACPI_NAMESPACE_NODE     **ReturnNode)
 107 {
 108     ACPI_STATUS             Status;
 109     ACPI_NAMESPACE_NODE     *Node;
 110
 111
 112     ACPI_FUNCTION_TRACE (RsValidateParameters);
 113
 114
 115     /*
 116      * Must have a valid handle to an ACPI device
 117      */
 118     if (!DeviceHandle)
 119     {
 120         return_ACPI_STATUS (AE_BAD_PARAMETER);
 121     }
 122
 123     Node = AcpiNsValidateHandle (DeviceHandle);
 124     if (!Node)
 125     {
 126         return_ACPI_STATUS (AE_BAD_PARAMETER);
 127     }
 128
 129     if (Node->Type != ACPI_TYPE_DEVICE)
 130     {
 131         return_ACPI_STATUS (AE_TYPE);
 132     }
 133
 134     /*
 135      * Validate the user buffer object
 136      *
 137      * if there is a non-zero buffer length we also need a valid pointer in
 138      * the buffer. If it's a zero buffer length, we'll be returning the
 139      * needed buffer size (later), so keep going.
 140      */
 141     Status = AcpiUtValidateBuffer (Buffer);
 142     if (ACPI_FAILURE (Status))
 143     {
 144         return_ACPI_STATUS (Status);
 145     }
 146
 147     *ReturnNode = Node;
 148     return_ACPI_STATUS (AE_OK);
 149 }
 150
 151
 152 /*******************************************************************************
 153  *
 154  * FUNCTION:    AcpiGetIrqRoutingTable
 155  *
 156  * PARAMETERS:  DeviceHandle    - Handle to the Bus device we are querying
 157  *              RetBuffer       - Pointer to a buffer to receive the
 158  *                                current resources for the device
 159  *
 160  * RETURN:      Status
 161  *
 162  * DESCRIPTION: This function is called to get the IRQ routing table for a
 163  *              specific bus. The caller must first acquire a handle for the
 164  *              desired bus. The routine table is placed in the buffer pointed
 165  *              to by the RetBuffer variable parameter.
 166  *
 167  *              If the function fails an appropriate status will be returned
 168  *              and the value of RetBuffer is undefined.
 169  *
 170  *              This function attempts to execute the _PRT method contained in
 171  *              the object indicated by the passed DeviceHandle.
 172  *
 173  ******************************************************************************/
 174
 175 ACPI_STATUS
 176 AcpiGetIrqRoutingTable  (
 177     ACPI_HANDLE             DeviceHandle,
 178     ACPI_BUFFER             *RetBuffer)
 179 {
 180     ACPI_STATUS             Status;
 181     ACPI_NAMESPACE_NODE     *Node;
 182
 183
 184     ACPI_FUNCTION_TRACE (AcpiGetIrqRoutingTable);
 185
 186
 187     /* Validate parameters then dispatch to internal routine */
 188
 189     Status = AcpiRsValidateParameters (DeviceHandle, RetBuffer, &Node);
 190     if (ACPI_FAILURE (Status))
 191     {
 192         return_ACPI_STATUS (Status);
 193     }
 194
 195     Status = AcpiRsGetPrtMethodData (Node, RetBuffer);
 196     return_ACPI_STATUS (Status);
 197 }
 198
 199 ACPI_EXPORT_SYMBOL (AcpiGetIrqRoutingTable)
 200
 201
 202 /*******************************************************************************
 203  *
 204  * FUNCTION:    AcpiGetCurrentResources
 205  *
 206  * PARAMETERS:  DeviceHandle    - Handle to the device object for the
 207  *                                device we are querying
 208  *              RetBuffer       - Pointer to a buffer to receive the
 209  *                                current resources for the device
 210  *
 211  * RETURN:      Status
 212  *
 213  * DESCRIPTION: This function is called to get the current resources for a
 214  *              specific device. The caller must first acquire a handle for
 215  *              the desired device. The resource data is placed in the buffer
 216  *              pointed to by the RetBuffer variable parameter.
 217  *
 218  *              If the function fails an appropriate status will be returned
 219  *              and the value of RetBuffer is undefined.
 220  *
 221  *              This function attempts to execute the _CRS method contained in
 222  *              the object indicated by the passed DeviceHandle.
 223  *
 224  ******************************************************************************/
 225
 226 ACPI_STATUS
 227 AcpiGetCurrentResources (
 228     ACPI_HANDLE             DeviceHandle,
 229     ACPI_BUFFER             *RetBuffer)
 230 {
 231     ACPI_STATUS             Status;
 232     ACPI_NAMESPACE_NODE     *Node;
 233
 234
 235     ACPI_FUNCTION_TRACE (AcpiGetCurrentResources);
 236
 237
 238     /* Validate parameters then dispatch to internal routine */
 239
 240     Status = AcpiRsValidateParameters (DeviceHandle, RetBuffer, &Node);
 241     if (ACPI_FAILURE (Status))
 242     {
 243         return_ACPI_STATUS (Status);
 244     }
 245
 246     Status = AcpiRsGetCrsMethodData (Node, RetBuffer);
 247     return_ACPI_STATUS (Status);
 248 }
 249
 250 ACPI_EXPORT_SYMBOL (AcpiGetCurrentResources)
 251
 252
 253 /*******************************************************************************
 254  *
 255  * FUNCTION:    AcpiGetPossibleResources
 256  *
 257  * PARAMETERS:  DeviceHandle    - Handle to the device object for the
 258  *                                device we are querying
 259  *              RetBuffer       - Pointer to a buffer to receive the
 260  *                                resources for the device
 261  *
 262  * RETURN:      Status
 263  *
 264  * DESCRIPTION: This function is called to get a list of the possible resources
 265  *              for a specific device. The caller must first acquire a handle
 266  *              for the desired device. The resource data is placed in the
 267  *              buffer pointed to by the RetBuffer variable.
 268  *
 269  *              If the function fails an appropriate status will be returned
 270  *              and the value of RetBuffer is undefined.
 271  *
 272  ******************************************************************************/
 273
 274 ACPI_STATUS
 275 AcpiGetPossibleResources (
 276     ACPI_HANDLE             DeviceHandle,
 277     ACPI_BUFFER             *RetBuffer)
 278 {
 279     ACPI_STATUS             Status;
 280     ACPI_NAMESPACE_NODE     *Node;
 281
 282
 283     ACPI_FUNCTION_TRACE (AcpiGetPossibleResources);
 284
 285
 286     /* Validate parameters then dispatch to internal routine */
 287
 288     Status = AcpiRsValidateParameters (DeviceHandle, RetBuffer, &Node);
 289     if (ACPI_FAILURE (Status))
 290     {
 291         return_ACPI_STATUS (Status);
 292     }
 293
 294     Status = AcpiRsGetPrsMethodData (Node, RetBuffer);
 295     return_ACPI_STATUS (Status);
 296 }
 297
 298 ACPI_EXPORT_SYMBOL (AcpiGetPossibleResources)
 299
 300
 301 /*******************************************************************************
 302  *
 303  * FUNCTION:    AcpiSetCurrentResources
 304  *
 305  * PARAMETERS:  DeviceHandle    - Handle to the device object for the
 306  *                                device we are setting resources
 307  *              InBuffer        - Pointer to a buffer containing the
 308  *                                resources to be set for the device
 309  *
 310  * RETURN:      Status
 311  *
 312  * DESCRIPTION: This function is called to set the current resources for a
 313  *              specific device. The caller must first acquire a handle for
 314  *              the desired device. The resource data is passed to the routine
 315  *              the buffer pointed to by the InBuffer variable.
 316  *
 317  ******************************************************************************/
 318
 319 ACPI_STATUS
 320 AcpiSetCurrentResources (
 321     ACPI_HANDLE             DeviceHandle,
 322     ACPI_BUFFER             *InBuffer)
 323 {
 324     ACPI_STATUS             Status;
 325     ACPI_NAMESPACE_NODE     *Node;
 326
 327
 328     ACPI_FUNCTION_TRACE (AcpiSetCurrentResources);
 329
 330
 331     /* Validate the buffer, don't allow zero length */
 332
 333     if ((!InBuffer) ||
 334         (!InBuffer->Pointer) ||
 335         (!InBuffer->Length))
 336     {
 337         return_ACPI_STATUS (AE_BAD_PARAMETER);
 338     }
 339
 340     /* Validate parameters then dispatch to internal routine */
 341
 342     Status = AcpiRsValidateParameters (DeviceHandle, InBuffer, &Node);
 343     if (ACPI_FAILURE (Status))
 344     {
 345         return_ACPI_STATUS (Status);
 346     }
 347
 348     Status = AcpiRsSetSrsMethodData (Node, InBuffer);
 349     return_ACPI_STATUS (Status);
 350 }
 351
 352 ACPI_EXPORT_SYMBOL (AcpiSetCurrentResources)
 353
 354
 355 /*******************************************************************************
 356  *
 357  * FUNCTION:    AcpiGetEventResources
 358  *
 359  * PARAMETERS:  DeviceHandle    - Handle to the device object for the
 360  *                                device we are getting resources
 361  *              InBuffer        - Pointer to a buffer containing the
 362  *                                resources to be set for the device
 363  *
 364  * RETURN:      Status
 365  *
 366  * DESCRIPTION: This function is called to get the event resources for a
 367  *              specific device. The caller must first acquire a handle for
 368  *              the desired device. The resource data is passed to the routine
 369  *              the buffer pointed to by the InBuffer variable. Uses the
 370  *              _AEI method.
 371  *
 372  ******************************************************************************/
 373
 374 ACPI_STATUS
 375 AcpiGetEventResources (
 376     ACPI_HANDLE             DeviceHandle,
 377     ACPI_BUFFER             *RetBuffer)
 378 {
 379     ACPI_STATUS             Status;
 380     ACPI_NAMESPACE_NODE     *Node;
 381
 382
 383     ACPI_FUNCTION_TRACE (AcpiGetEventResources);
 384
 385
 386     /* Validate parameters then dispatch to internal routine */
 387
 388     Status = AcpiRsValidateParameters (DeviceHandle, RetBuffer, &Node);
 389     if (ACPI_FAILURE (Status))
 390     {
 391         return_ACPI_STATUS (Status);
 392     }
 393
 394     Status = AcpiRsGetAeiMethodData (Node, RetBuffer);
 395     return_ACPI_STATUS (Status);
 396 }
 397
 398 ACPI_EXPORT_SYMBOL (AcpiGetEventResources)
 399
 400
 401 /******************************************************************************
 402  *
 403  * FUNCTION:    AcpiResourceToAddress64
 404  *
 405  * PARAMETERS:  Resource        - Pointer to a resource
 406  *              Out             - Pointer to the users's return buffer
 407  *                                (a struct acpi_resource_address64)
 408  *
 409  * RETURN:      Status
 410  *
 411  * DESCRIPTION: If the resource is an address16, address32, or address64,
 412  *              copy it to the address64 return buffer. This saves the
 413  *              caller from having to duplicate code for different-sized
 414  *              addresses.
 415  *
 416  ******************************************************************************/
 417
 418 ACPI_STATUS
 419 AcpiResourceToAddress64 (
 420     ACPI_RESOURCE               *Resource,
 421     ACPI_RESOURCE_ADDRESS64     *Out)
 422 {
 423     ACPI_RESOURCE_ADDRESS16     *Address16;
 424     ACPI_RESOURCE_ADDRESS32     *Address32;
 425
 426
 427     if (!Resource || !Out)
 428     {
 429         return (AE_BAD_PARAMETER);
 430     }
 431
 432     /* Convert 16 or 32 address descriptor to 64 */
 433
 434     switch (Resource->Type)
 435     {
 436     case ACPI_RESOURCE_TYPE_ADDRESS16:
 437
 438         Address16 = ACPI_CAST_PTR (ACPI_RESOURCE_ADDRESS16, &Resource->Data);
 439         ACPI_COPY_ADDRESS (Out, Address16);
 440         break;
 441
 442     case ACPI_RESOURCE_TYPE_ADDRESS32:
 443
 444         Address32 = ACPI_CAST_PTR (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         ACPI_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 (DeviceHandle, Name, AcpiRsMatchVendorResource,
 510                 &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         (ACPI_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     ACPI_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 (ACPI_RESOURCE, Buffer->Pointer, Buffer->Length);
 630
 631     /* Walk the resource list until the EndTag is found (or buffer end) */
 632
 633     while (Resource < ResourceEnd)
 634     {
 635         /* Sanity check the resource type */
 636
 637         if (Resource->Type > ACPI_RESOURCE_TYPE_MAX)
 638         {
 639             Status = AE_AML_INVALID_RESOURCE_TYPE;
 640             break;
 641         }
 642
 643         /* Sanity check the length. It must not be zero, or we loop forever */
 644
 645         if (!Resource->Length)
 646         {
 647             return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH);
 648         }
 649
 650         /* Invoke the user function, abort on any error returned */
 651
 652         Status = UserFunction (Resource, Context);
 653         if (ACPI_FAILURE (Status))
 654         {
 655             if (Status == AE_CTRL_TERMINATE)
 656             {
 657                 /* This is an OK termination by the user function */
 658
 659                 Status = AE_OK;
 660             }
 661             break;
 662         }
 663
 664         /* EndTag indicates end-of-list */
 665
 666         if (Resource->Type == ACPI_RESOURCE_TYPE_END_TAG)
 667         {
 668             break;
 669         }
 670
 671         /* Get the next resource descriptor */
 672
 673         Resource = ACPI_NEXT_RESOURCE (Resource);
 674     }
 675
 676     return_ACPI_STATUS (Status);
 677 }
 678
 679 ACPI_EXPORT_SYMBOL (AcpiWalkResourceBuffer)
 680
 681
 682 /*******************************************************************************
 683  *
 684  * FUNCTION:    AcpiWalkResources
 685  *
 686  * PARAMETERS:  DeviceHandle    - Handle to the device object for the
 687  *                                device we are querying
 688  *              Name            - Method name of the resources we want.
 689  *                                (METHOD_NAME__CRS, METHOD_NAME__PRS, or
 690  *                                METHOD_NAME__AEI)
 691  *              UserFunction    - Called for each resource
 692  *              Context         - Passed to UserFunction
 693  *
 694  * RETURN:      Status
 695  *
 696  * DESCRIPTION: Retrieves the current or possible resource list for the
 697  *              specified device. The UserFunction is called once for
 698  *              each resource in the list.
 699  *
 700  ******************************************************************************/
 701
 702 ACPI_STATUS
 703 AcpiWalkResources (
 704     ACPI_HANDLE                 DeviceHandle,
 705     char                        *Name,
 706     ACPI_WALK_RESOURCE_CALLBACK UserFunction,
 707     void                        *Context)
 708 {
 709     ACPI_STATUS                 Status;
 710     ACPI_BUFFER                 Buffer;
 711
 712
 713     ACPI_FUNCTION_TRACE (AcpiWalkResources);
 714
 715
 716     /* Parameter validation */
 717
 718     if (!DeviceHandle || !UserFunction || !Name ||
 719         (!ACPI_COMPARE_NAME (Name, METHOD_NAME__CRS) &&
 720          !ACPI_COMPARE_NAME (Name, METHOD_NAME__PRS) &&
 721          !ACPI_COMPARE_NAME (Name, METHOD_NAME__AEI)))
 722     {
 723         return_ACPI_STATUS (AE_BAD_PARAMETER);
 724     }
 725
 726     /* Get the _CRS/_PRS/_AEI resource list */
 727
 728     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 729     Status = AcpiRsGetMethodData (DeviceHandle, Name, &Buffer);
 730     if (ACPI_FAILURE (Status))
 731     {
 732         return_ACPI_STATUS (Status);
 733     }
 734
 735     /* Walk the resource list and cleanup */
 736
 737     Status = AcpiWalkResourceBuffer (&Buffer, UserFunction, Context);
 738     ACPI_FREE (Buffer.Pointer);
 739     return_ACPI_STATUS (Status);
 740 }
 741
 742 ACPI_EXPORT_SYMBOL (AcpiWalkResources)