xref: /freebsd/sys/contrib/dev/acpica/components/resources/rsutils.c (revision a98ff317388a00b992f1bf8404dee596f9383f5e)
1 /*******************************************************************************
2  *
3  * Module Name: rsutils - Utilities for 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 __RSUTILS_C__
46 
47 #include <contrib/dev/acpica/include/acpi.h>
48 #include <contrib/dev/acpica/include/accommon.h>
49 #include <contrib/dev/acpica/include/acnamesp.h>
50 #include <contrib/dev/acpica/include/acresrc.h>
51 
52 
53 #define _COMPONENT          ACPI_RESOURCES
54         ACPI_MODULE_NAME    ("rsutils")
55 
56 
57 /*******************************************************************************
58  *
59  * FUNCTION:    AcpiRsDecodeBitmask
60  *
61  * PARAMETERS:  Mask            - Bitmask to decode
62  *              List            - Where the converted list is returned
63  *
64  * RETURN:      Count of bits set (length of list)
65  *
66  * DESCRIPTION: Convert a bit mask into a list of values
67  *
68  ******************************************************************************/
69 
70 UINT8
71 AcpiRsDecodeBitmask (
72     UINT16                  Mask,
73     UINT8                   *List)
74 {
75     UINT8                   i;
76     UINT8                   BitCount;
77 
78 
79     ACPI_FUNCTION_ENTRY ();
80 
81 
82     /* Decode the mask bits */
83 
84     for (i = 0, BitCount = 0; Mask; i++)
85     {
86         if (Mask & 0x0001)
87         {
88             List[BitCount] = i;
89             BitCount++;
90         }
91 
92         Mask >>= 1;
93     }
94 
95     return (BitCount);
96 }
97 
98 
99 /*******************************************************************************
100  *
101  * FUNCTION:    AcpiRsEncodeBitmask
102  *
103  * PARAMETERS:  List            - List of values to encode
104  *              Count           - Length of list
105  *
106  * RETURN:      Encoded bitmask
107  *
108  * DESCRIPTION: Convert a list of values to an encoded bitmask
109  *
110  ******************************************************************************/
111 
112 UINT16
113 AcpiRsEncodeBitmask (
114     UINT8                   *List,
115     UINT8                   Count)
116 {
117     UINT32                  i;
118     UINT16                  Mask;
119 
120 
121     ACPI_FUNCTION_ENTRY ();
122 
123 
124     /* Encode the list into a single bitmask */
125 
126     for (i = 0, Mask = 0; i < Count; i++)
127     {
128         Mask |= (0x1 << List[i]);
129     }
130 
131     return (Mask);
132 }
133 
134 
135 /*******************************************************************************
136  *
137  * FUNCTION:    AcpiRsMoveData
138  *
139  * PARAMETERS:  Destination         - Pointer to the destination descriptor
140  *              Source              - Pointer to the source descriptor
141  *              ItemCount           - How many items to move
142  *              MoveType            - Byte width
143  *
144  * RETURN:      None
145  *
146  * DESCRIPTION: Move multiple data items from one descriptor to another. Handles
147  *              alignment issues and endian issues if necessary, as configured
148  *              via the ACPI_MOVE_* macros. (This is why a memcpy is not used)
149  *
150  ******************************************************************************/
151 
152 void
153 AcpiRsMoveData (
154     void                    *Destination,
155     void                    *Source,
156     UINT16                  ItemCount,
157     UINT8                   MoveType)
158 {
159     UINT32                  i;
160 
161 
162     ACPI_FUNCTION_ENTRY ();
163 
164 
165     /* One move per item */
166 
167     for (i = 0; i < ItemCount; i++)
168     {
169         switch (MoveType)
170         {
171         /*
172          * For the 8-bit case, we can perform the move all at once
173          * since there are no alignment or endian issues
174          */
175         case ACPI_RSC_MOVE8:
176         case ACPI_RSC_MOVE_GPIO_RES:
177         case ACPI_RSC_MOVE_SERIAL_VEN:
178         case ACPI_RSC_MOVE_SERIAL_RES:
179 
180             ACPI_MEMCPY (Destination, Source, ItemCount);
181             return;
182 
183         /*
184          * 16-, 32-, and 64-bit cases must use the move macros that perform
185          * endian conversion and/or accommodate hardware that cannot perform
186          * misaligned memory transfers
187          */
188         case ACPI_RSC_MOVE16:
189         case ACPI_RSC_MOVE_GPIO_PIN:
190 
191             ACPI_MOVE_16_TO_16 (&ACPI_CAST_PTR (UINT16, Destination)[i],
192                                 &ACPI_CAST_PTR (UINT16, Source)[i]);
193             break;
194 
195         case ACPI_RSC_MOVE32:
196 
197             ACPI_MOVE_32_TO_32 (&ACPI_CAST_PTR (UINT32, Destination)[i],
198                                 &ACPI_CAST_PTR (UINT32, Source)[i]);
199             break;
200 
201         case ACPI_RSC_MOVE64:
202 
203             ACPI_MOVE_64_TO_64 (&ACPI_CAST_PTR (UINT64, Destination)[i],
204                                 &ACPI_CAST_PTR (UINT64, Source)[i]);
205             break;
206 
207         default:
208 
209             return;
210         }
211     }
212 }
213 
214 
215 /*******************************************************************************
216  *
217  * FUNCTION:    AcpiRsSetResourceLength
218  *
219  * PARAMETERS:  TotalLength         - Length of the AML descriptor, including
220  *                                    the header and length fields.
221  *              Aml                 - Pointer to the raw AML descriptor
222  *
223  * RETURN:      None
224  *
225  * DESCRIPTION: Set the ResourceLength field of an AML
226  *              resource descriptor, both Large and Small descriptors are
227  *              supported automatically. Note: Descriptor Type field must
228  *              be valid.
229  *
230  ******************************************************************************/
231 
232 void
233 AcpiRsSetResourceLength (
234     ACPI_RSDESC_SIZE        TotalLength,
235     AML_RESOURCE            *Aml)
236 {
237     ACPI_RS_LENGTH          ResourceLength;
238 
239 
240     ACPI_FUNCTION_ENTRY ();
241 
242 
243     /* Length is the total descriptor length minus the header length */
244 
245     ResourceLength = (ACPI_RS_LENGTH)
246         (TotalLength - AcpiUtGetResourceHeaderLength (Aml));
247 
248     /* Length is stored differently for large and small descriptors */
249 
250     if (Aml->SmallHeader.DescriptorType & ACPI_RESOURCE_NAME_LARGE)
251     {
252         /* Large descriptor -- bytes 1-2 contain the 16-bit length */
253 
254         ACPI_MOVE_16_TO_16 (&Aml->LargeHeader.ResourceLength, &ResourceLength);
255     }
256     else
257     {
258         /* Small descriptor -- bits 2:0 of byte 0 contain the length */
259 
260         Aml->SmallHeader.DescriptorType = (UINT8)
261 
262             /* Clear any existing length, preserving descriptor type bits */
263 
264             ((Aml->SmallHeader.DescriptorType & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK)
265 
266             | ResourceLength);
267     }
268 }
269 
270 
271 /*******************************************************************************
272  *
273  * FUNCTION:    AcpiRsSetResourceHeader
274  *
275  * PARAMETERS:  DescriptorType      - Byte to be inserted as the type
276  *              TotalLength         - Length of the AML descriptor, including
277  *                                    the header and length fields.
278  *              Aml                 - Pointer to the raw AML descriptor
279  *
280  * RETURN:      None
281  *
282  * DESCRIPTION: Set the DescriptorType and ResourceLength fields of an AML
283  *              resource descriptor, both Large and Small descriptors are
284  *              supported automatically
285  *
286  ******************************************************************************/
287 
288 void
289 AcpiRsSetResourceHeader (
290     UINT8                   DescriptorType,
291     ACPI_RSDESC_SIZE        TotalLength,
292     AML_RESOURCE            *Aml)
293 {
294     ACPI_FUNCTION_ENTRY ();
295 
296 
297     /* Set the Resource Type */
298 
299     Aml->SmallHeader.DescriptorType = DescriptorType;
300 
301     /* Set the Resource Length */
302 
303     AcpiRsSetResourceLength (TotalLength, Aml);
304 }
305 
306 
307 /*******************************************************************************
308  *
309  * FUNCTION:    AcpiRsStrcpy
310  *
311  * PARAMETERS:  Destination         - Pointer to the destination string
312  *              Source              - Pointer to the source string
313  *
314  * RETURN:      String length, including NULL terminator
315  *
316  * DESCRIPTION: Local string copy that returns the string length, saving a
317  *              strcpy followed by a strlen.
318  *
319  ******************************************************************************/
320 
321 static UINT16
322 AcpiRsStrcpy (
323     char                    *Destination,
324     char                    *Source)
325 {
326     UINT16                  i;
327 
328 
329     ACPI_FUNCTION_ENTRY ();
330 
331 
332     for (i = 0; Source[i]; i++)
333     {
334         Destination[i] = Source[i];
335     }
336 
337     Destination[i] = 0;
338 
339     /* Return string length including the NULL terminator */
340 
341     return ((UINT16) (i + 1));
342 }
343 
344 
345 /*******************************************************************************
346  *
347  * FUNCTION:    AcpiRsGetResourceSource
348  *
349  * PARAMETERS:  ResourceLength      - Length field of the descriptor
350  *              MinimumLength       - Minimum length of the descriptor (minus
351  *                                    any optional fields)
352  *              ResourceSource      - Where the ResourceSource is returned
353  *              Aml                 - Pointer to the raw AML descriptor
354  *              StringPtr           - (optional) where to store the actual
355  *                                    ResourceSource string
356  *
357  * RETURN:      Length of the string plus NULL terminator, rounded up to native
358  *              word boundary
359  *
360  * DESCRIPTION: Copy the optional ResourceSource data from a raw AML descriptor
361  *              to an internal resource descriptor
362  *
363  ******************************************************************************/
364 
365 ACPI_RS_LENGTH
366 AcpiRsGetResourceSource (
367     ACPI_RS_LENGTH          ResourceLength,
368     ACPI_RS_LENGTH          MinimumLength,
369     ACPI_RESOURCE_SOURCE    *ResourceSource,
370     AML_RESOURCE            *Aml,
371     char                    *StringPtr)
372 {
373     ACPI_RSDESC_SIZE        TotalLength;
374     UINT8                   *AmlResourceSource;
375 
376 
377     ACPI_FUNCTION_ENTRY ();
378 
379 
380     TotalLength = ResourceLength + sizeof (AML_RESOURCE_LARGE_HEADER);
381     AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength);
382 
383     /*
384      * ResourceSource is present if the length of the descriptor is longer than
385      * the minimum length.
386      *
387      * Note: Some resource descriptors will have an additional null, so
388      * we add 1 to the minimum length.
389      */
390     if (TotalLength > (ACPI_RSDESC_SIZE) (MinimumLength + 1))
391     {
392         /* Get the ResourceSourceIndex */
393 
394         ResourceSource->Index = AmlResourceSource[0];
395 
396         ResourceSource->StringPtr = StringPtr;
397         if (!StringPtr)
398         {
399             /*
400              * String destination pointer is not specified; Set the String
401              * pointer to the end of the current ResourceSource structure.
402              */
403             ResourceSource->StringPtr = ACPI_ADD_PTR (char, ResourceSource,
404                 sizeof (ACPI_RESOURCE_SOURCE));
405         }
406 
407         /*
408          * In order for the Resource length to be a multiple of the native
409          * word, calculate the length of the string (+1 for NULL terminator)
410          * and expand to the next word multiple.
411          *
412          * Zero the entire area of the buffer.
413          */
414         TotalLength = (UINT32) ACPI_STRLEN (
415             ACPI_CAST_PTR (char, &AmlResourceSource[1])) + 1;
416         TotalLength = (UINT32) ACPI_ROUND_UP_TO_NATIVE_WORD (TotalLength);
417 
418         ACPI_MEMSET (ResourceSource->StringPtr, 0, TotalLength);
419 
420         /* Copy the ResourceSource string to the destination */
421 
422         ResourceSource->StringLength = AcpiRsStrcpy (ResourceSource->StringPtr,
423             ACPI_CAST_PTR (char, &AmlResourceSource[1]));
424 
425         return ((ACPI_RS_LENGTH) TotalLength);
426     }
427 
428     /* ResourceSource is not present */
429 
430     ResourceSource->Index = 0;
431     ResourceSource->StringLength = 0;
432     ResourceSource->StringPtr = NULL;
433     return (0);
434 }
435 
436 
437 /*******************************************************************************
438  *
439  * FUNCTION:    AcpiRsSetResourceSource
440  *
441  * PARAMETERS:  Aml                 - Pointer to the raw AML descriptor
442  *              MinimumLength       - Minimum length of the descriptor (minus
443  *                                    any optional fields)
444  *              ResourceSource      - Internal ResourceSource
445 
446  *
447  * RETURN:      Total length of the AML descriptor
448  *
449  * DESCRIPTION: Convert an optional ResourceSource from internal format to a
450  *              raw AML resource descriptor
451  *
452  ******************************************************************************/
453 
454 ACPI_RSDESC_SIZE
455 AcpiRsSetResourceSource (
456     AML_RESOURCE            *Aml,
457     ACPI_RS_LENGTH          MinimumLength,
458     ACPI_RESOURCE_SOURCE    *ResourceSource)
459 {
460     UINT8                   *AmlResourceSource;
461     ACPI_RSDESC_SIZE        DescriptorLength;
462 
463 
464     ACPI_FUNCTION_ENTRY ();
465 
466 
467     DescriptorLength = MinimumLength;
468 
469     /* Non-zero string length indicates presence of a ResourceSource */
470 
471     if (ResourceSource->StringLength)
472     {
473         /* Point to the end of the AML descriptor */
474 
475         AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength);
476 
477         /* Copy the ResourceSourceIndex */
478 
479         AmlResourceSource[0] = (UINT8) ResourceSource->Index;
480 
481         /* Copy the ResourceSource string */
482 
483         ACPI_STRCPY (ACPI_CAST_PTR (char, &AmlResourceSource[1]),
484             ResourceSource->StringPtr);
485 
486         /*
487          * Add the length of the string (+ 1 for null terminator) to the
488          * final descriptor length
489          */
490         DescriptorLength += ((ACPI_RSDESC_SIZE) ResourceSource->StringLength + 1);
491     }
492 
493     /* Return the new total length of the AML descriptor */
494 
495     return (DescriptorLength);
496 }
497 
498 
499 /*******************************************************************************
500  *
501  * FUNCTION:    AcpiRsGetPrtMethodData
502  *
503  * PARAMETERS:  Node            - Device node
504  *              RetBuffer       - Pointer to a buffer structure for the
505  *                                results
506  *
507  * RETURN:      Status
508  *
509  * DESCRIPTION: This function is called to get the _PRT value of an object
510  *              contained in an object specified by the handle passed in
511  *
512  *              If the function fails an appropriate status will be returned
513  *              and the contents of the callers buffer is undefined.
514  *
515  ******************************************************************************/
516 
517 ACPI_STATUS
518 AcpiRsGetPrtMethodData (
519     ACPI_NAMESPACE_NODE     *Node,
520     ACPI_BUFFER             *RetBuffer)
521 {
522     ACPI_OPERAND_OBJECT     *ObjDesc;
523     ACPI_STATUS             Status;
524 
525 
526     ACPI_FUNCTION_TRACE (RsGetPrtMethodData);
527 
528 
529     /* Parameters guaranteed valid by caller */
530 
531     /* Execute the method, no parameters */
532 
533     Status = AcpiUtEvaluateObject (Node, METHOD_NAME__PRT,
534                 ACPI_BTYPE_PACKAGE, &ObjDesc);
535     if (ACPI_FAILURE (Status))
536     {
537         return_ACPI_STATUS (Status);
538     }
539 
540     /*
541      * Create a resource linked list from the byte stream buffer that comes
542      * back from the _CRS method execution.
543      */
544     Status = AcpiRsCreatePciRoutingTable (ObjDesc, RetBuffer);
545 
546     /* On exit, we must delete the object returned by EvaluateObject */
547 
548     AcpiUtRemoveReference (ObjDesc);
549     return_ACPI_STATUS (Status);
550 }
551 
552 
553 /*******************************************************************************
554  *
555  * FUNCTION:    AcpiRsGetCrsMethodData
556  *
557  * PARAMETERS:  Node            - Device node
558  *              RetBuffer       - Pointer to a buffer structure for the
559  *                                results
560  *
561  * RETURN:      Status
562  *
563  * DESCRIPTION: This function is called to get the _CRS value of an object
564  *              contained in an object specified by the handle passed in
565  *
566  *              If the function fails an appropriate status will be returned
567  *              and the contents of the callers buffer is undefined.
568  *
569  ******************************************************************************/
570 
571 ACPI_STATUS
572 AcpiRsGetCrsMethodData (
573     ACPI_NAMESPACE_NODE     *Node,
574     ACPI_BUFFER             *RetBuffer)
575 {
576     ACPI_OPERAND_OBJECT     *ObjDesc;
577     ACPI_STATUS             Status;
578 
579 
580     ACPI_FUNCTION_TRACE (RsGetCrsMethodData);
581 
582 
583     /* Parameters guaranteed valid by caller */
584 
585     /* Execute the method, no parameters */
586 
587     Status = AcpiUtEvaluateObject (Node, METHOD_NAME__CRS,
588                 ACPI_BTYPE_BUFFER, &ObjDesc);
589     if (ACPI_FAILURE (Status))
590     {
591         return_ACPI_STATUS (Status);
592     }
593 
594     /*
595      * Make the call to create a resource linked list from the
596      * byte stream buffer that comes back from the _CRS method
597      * execution.
598      */
599     Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
600 
601     /* On exit, we must delete the object returned by evaluateObject */
602 
603     AcpiUtRemoveReference (ObjDesc);
604     return_ACPI_STATUS (Status);
605 }
606 
607 
608 /*******************************************************************************
609  *
610  * FUNCTION:    AcpiRsGetPrsMethodData
611  *
612  * PARAMETERS:  Node            - Device node
613  *              RetBuffer       - Pointer to a buffer structure for the
614  *                                results
615  *
616  * RETURN:      Status
617  *
618  * DESCRIPTION: This function is called to get the _PRS value of an object
619  *              contained in an object specified by the handle passed in
620  *
621  *              If the function fails an appropriate status will be returned
622  *              and the contents of the callers buffer is undefined.
623  *
624  ******************************************************************************/
625 
626 ACPI_STATUS
627 AcpiRsGetPrsMethodData (
628     ACPI_NAMESPACE_NODE     *Node,
629     ACPI_BUFFER             *RetBuffer)
630 {
631     ACPI_OPERAND_OBJECT     *ObjDesc;
632     ACPI_STATUS             Status;
633 
634 
635     ACPI_FUNCTION_TRACE (RsGetPrsMethodData);
636 
637 
638     /* Parameters guaranteed valid by caller */
639 
640     /* Execute the method, no parameters */
641 
642     Status = AcpiUtEvaluateObject (Node, METHOD_NAME__PRS,
643                 ACPI_BTYPE_BUFFER, &ObjDesc);
644     if (ACPI_FAILURE (Status))
645     {
646         return_ACPI_STATUS (Status);
647     }
648 
649     /*
650      * Make the call to create a resource linked list from the
651      * byte stream buffer that comes back from the _CRS method
652      * execution.
653      */
654     Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
655 
656     /* On exit, we must delete the object returned by evaluateObject */
657 
658     AcpiUtRemoveReference (ObjDesc);
659     return_ACPI_STATUS (Status);
660 }
661 
662 
663 /*******************************************************************************
664  *
665  * FUNCTION:    AcpiRsGetAeiMethodData
666  *
667  * PARAMETERS:  Node            - Device node
668  *              RetBuffer       - Pointer to a buffer structure for the
669  *                                results
670  *
671  * RETURN:      Status
672  *
673  * DESCRIPTION: This function is called to get the _AEI value of an object
674  *              contained in an object specified by the handle passed in
675  *
676  *              If the function fails an appropriate status will be returned
677  *              and the contents of the callers buffer is undefined.
678  *
679  ******************************************************************************/
680 
681 ACPI_STATUS
682 AcpiRsGetAeiMethodData (
683     ACPI_NAMESPACE_NODE     *Node,
684     ACPI_BUFFER             *RetBuffer)
685 {
686     ACPI_OPERAND_OBJECT     *ObjDesc;
687     ACPI_STATUS             Status;
688 
689 
690     ACPI_FUNCTION_TRACE (RsGetAeiMethodData);
691 
692 
693     /* Parameters guaranteed valid by caller */
694 
695     /* Execute the method, no parameters */
696 
697     Status = AcpiUtEvaluateObject (Node, METHOD_NAME__AEI,
698                 ACPI_BTYPE_BUFFER, &ObjDesc);
699     if (ACPI_FAILURE (Status))
700     {
701         return_ACPI_STATUS (Status);
702     }
703 
704     /*
705      * Make the call to create a resource linked list from the
706      * byte stream buffer that comes back from the _CRS method
707      * execution.
708      */
709     Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
710 
711     /* On exit, we must delete the object returned by evaluateObject */
712 
713     AcpiUtRemoveReference (ObjDesc);
714     return_ACPI_STATUS (Status);
715 }
716 
717 
718 /*******************************************************************************
719  *
720  * FUNCTION:    AcpiRsGetMethodData
721  *
722  * PARAMETERS:  Handle          - Handle to the containing object
723  *              Path            - Path to method, relative to Handle
724  *              RetBuffer       - Pointer to a buffer structure for the
725  *                                results
726  *
727  * RETURN:      Status
728  *
729  * DESCRIPTION: This function is called to get the _CRS or _PRS value of an
730  *              object contained in an object specified by the handle passed in
731  *
732  *              If the function fails an appropriate status will be returned
733  *              and the contents of the callers buffer is undefined.
734  *
735  ******************************************************************************/
736 
737 ACPI_STATUS
738 AcpiRsGetMethodData (
739     ACPI_HANDLE             Handle,
740     char                    *Path,
741     ACPI_BUFFER             *RetBuffer)
742 {
743     ACPI_OPERAND_OBJECT     *ObjDesc;
744     ACPI_STATUS             Status;
745 
746 
747     ACPI_FUNCTION_TRACE (RsGetMethodData);
748 
749 
750     /* Parameters guaranteed valid by caller */
751 
752     /* Execute the method, no parameters */
753 
754     Status = AcpiUtEvaluateObject (ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Handle),
755         Path, ACPI_BTYPE_BUFFER, &ObjDesc);
756     if (ACPI_FAILURE (Status))
757     {
758         return_ACPI_STATUS (Status);
759     }
760 
761     /*
762      * Make the call to create a resource linked list from the
763      * byte stream buffer that comes back from the method
764      * execution.
765      */
766     Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
767 
768     /* On exit, we must delete the object returned by EvaluateObject */
769 
770     AcpiUtRemoveReference (ObjDesc);
771     return_ACPI_STATUS (Status);
772 }
773 
774 
775 /*******************************************************************************
776  *
777  * FUNCTION:    AcpiRsSetSrsMethodData
778  *
779  * PARAMETERS:  Node            - Device node
780  *              InBuffer        - Pointer to a buffer structure of the
781  *                                parameter
782  *
783  * RETURN:      Status
784  *
785  * DESCRIPTION: This function is called to set the _SRS of an object contained
786  *              in an object specified by the handle passed in
787  *
788  *              If the function fails an appropriate status will be returned
789  *              and the contents of the callers buffer is undefined.
790  *
791  * Note: Parameters guaranteed valid by caller
792  *
793  ******************************************************************************/
794 
795 ACPI_STATUS
796 AcpiRsSetSrsMethodData (
797     ACPI_NAMESPACE_NODE     *Node,
798     ACPI_BUFFER             *InBuffer)
799 {
800     ACPI_EVALUATE_INFO      *Info;
801     ACPI_OPERAND_OBJECT     *Args[2];
802     ACPI_STATUS             Status;
803     ACPI_BUFFER             Buffer;
804 
805 
806     ACPI_FUNCTION_TRACE (RsSetSrsMethodData);
807 
808 
809     /* Allocate and initialize the evaluation information block */
810 
811     Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
812     if (!Info)
813     {
814         return_ACPI_STATUS (AE_NO_MEMORY);
815     }
816 
817     Info->PrefixNode = Node;
818     Info->RelativePathname = METHOD_NAME__SRS;
819     Info->Parameters = Args;
820     Info->Flags = ACPI_IGNORE_RETURN_VALUE;
821 
822     /*
823      * The InBuffer parameter will point to a linked list of
824      * resource parameters. It needs to be formatted into a
825      * byte stream to be sent in as an input parameter to _SRS
826      *
827      * Convert the linked list into a byte stream
828      */
829     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
830     Status = AcpiRsCreateAmlResources (InBuffer->Pointer, &Buffer);
831     if (ACPI_FAILURE (Status))
832     {
833         goto Cleanup;
834     }
835 
836     /* Create and initialize the method parameter object */
837 
838     Args[0] = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER);
839     if (!Args[0])
840     {
841         /*
842          * Must free the buffer allocated above (otherwise it is freed
843          * later)
844          */
845         ACPI_FREE (Buffer.Pointer);
846         Status = AE_NO_MEMORY;
847         goto Cleanup;
848     }
849 
850     Args[0]->Buffer.Length  = (UINT32) Buffer.Length;
851     Args[0]->Buffer.Pointer = Buffer.Pointer;
852     Args[0]->Common.Flags   = AOPOBJ_DATA_VALID;
853     Args[1] = NULL;
854 
855     /* Execute the method, no return value is expected */
856 
857     Status = AcpiNsEvaluate (Info);
858 
859     /* Clean up and return the status from AcpiNsEvaluate */
860 
861     AcpiUtRemoveReference (Args[0]);
862 
863 Cleanup:
864     ACPI_FREE (Info);
865     return_ACPI_STATUS (Status);
866 }
867