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