rsxface.c revision 281687 
1/*******************************************************************************
2 *
3 * Module Name: rsxface - Public interfaces to the resource manager
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2015, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#define EXPORT_ACPI_INTERFACES
45
46#include <contrib/dev/acpica/include/acpi.h>
47#include <contrib/dev/acpica/include/accommon.h>
48#include <contrib/dev/acpica/include/acresrc.h>
49#include <contrib/dev/acpica/include/acnamesp.h>
50
51#define _COMPONENT          ACPI_RESOURCES
52        ACPI_MODULE_NAME    ("rsxface")
53
54/* Local macros for 16,32-bit to 64-bit conversion */
55
56#define ACPI_COPY_FIELD(Out, In, Field)  ((Out)->Field = (In)->Field)
57#define ACPI_COPY_ADDRESS(Out, In)                      \
58    ACPI_COPY_FIELD(Out, In, ResourceType);              \
59    ACPI_COPY_FIELD(Out, In, ProducerConsumer);          \
60    ACPI_COPY_FIELD(Out, In, Decode);                    \
61    ACPI_COPY_FIELD(Out, In, MinAddressFixed);           \
62    ACPI_COPY_FIELD(Out, In, MaxAddressFixed);           \
63    ACPI_COPY_FIELD(Out, In, Info);                      \
64    ACPI_COPY_FIELD(Out, In, Address.Granularity);       \
65    ACPI_COPY_FIELD(Out, In, Address.Minimum);           \
66    ACPI_COPY_FIELD(Out, In, Address.Maximum);           \
67    ACPI_COPY_FIELD(Out, In, Address.TranslationOffset); \
68    ACPI_COPY_FIELD(Out, In, Address.AddressLength);     \
69    ACPI_COPY_FIELD(Out, In, ResourceSource);
70
71
72/* Local prototypes */
73
74static ACPI_STATUS
75AcpiRsMatchVendorResource (
76    ACPI_RESOURCE           *Resource,
77    void                    *Context);
78
79static ACPI_STATUS
80AcpiRsValidateParameters (
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
100static ACPI_STATUS
101AcpiRsValidateParameters (
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
173ACPI_STATUS
174AcpiGetIrqRoutingTable  (
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
197ACPI_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
224ACPI_STATUS
225AcpiGetCurrentResources (
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
248ACPI_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
272ACPI_STATUS
273AcpiGetPossibleResources (
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
296ACPI_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
317ACPI_STATUS
318AcpiSetCurrentResources (
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
350ACPI_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
372ACPI_STATUS
373AcpiGetEventResources (
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
396ACPI_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
416ACPI_STATUS
417AcpiResourceToAddress64 (
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        ACPI_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
461ACPI_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
483ACPI_STATUS
484AcpiGetVendorResource (
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
517ACPI_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
532static ACPI_STATUS
533AcpiRsMatchVendorResource (
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        (ACPI_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    ACPI_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
603ACPI_STATUS
604AcpiWalkResourceBuffer (
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
677ACPI_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
700ACPI_STATUS
701AcpiWalkResources (
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
740ACPI_EXPORT_SYMBOL (AcpiWalkResources)
741