rsxface.c revision 272444 
1/*******************************************************************************
2 *
3 * Module Name: rsxface - Public interfaces to the resource manager
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2014, 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 __RSXFACE_C__
45#define EXPORT_ACPI_INTERFACES
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
75static ACPI_STATUS
76AcpiRsMatchVendorResource (
77    ACPI_RESOURCE           *Resource,
78    void                    *Context);
79
80static ACPI_STATUS
81AcpiRsValidateParameters (
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
101static ACPI_STATUS
102AcpiRsValidateParameters (
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
174ACPI_STATUS
175AcpiGetIrqRoutingTable  (
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
198ACPI_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
225ACPI_STATUS
226AcpiGetCurrentResources (
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
249ACPI_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
273ACPI_STATUS
274AcpiGetPossibleResources (
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
297ACPI_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
318ACPI_STATUS
319AcpiSetCurrentResources (
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
351ACPI_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
373ACPI_STATUS
374AcpiGetEventResources (
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
397ACPI_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
417ACPI_STATUS
418AcpiResourceToAddress64 (
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
462ACPI_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
484ACPI_STATUS
485AcpiGetVendorResource (
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
518ACPI_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
533static ACPI_STATUS
534AcpiRsMatchVendorResource (
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
604ACPI_STATUS
605AcpiWalkResourceBuffer (
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
678ACPI_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
701ACPI_STATUS
702AcpiWalkResources (
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
741ACPI_EXPORT_SYMBOL (AcpiWalkResources)
742