Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*******************************************************************************
  2.  *
  3.  * Module Name: rsutils - Utilities for the resource manager
  4.  *
  5.  ******************************************************************************/
  6.  
  7. /******************************************************************************
  8.  *
  9.  * 1. Copyright Notice
  10.  *
  11.  * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
  12.  * All rights reserved.
  13.  *
  14.  * 2. License
  15.  *
  16.  * 2.1. This is your license from Intel Corp. under its intellectual property
  17.  * rights.  You may have additional license terms from the party that provided
  18.  * you this software, covering your right to use that party's intellectual
  19.  * property rights.
  20.  *
  21.  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22.  * copy of the source code appearing in this file ("Covered Code") an
  23.  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24.  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25.  * make derivatives, distribute, use and display any portion of the Covered
  26.  * Code in any form, with the right to sublicense such rights; and
  27.  *
  28.  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29.  * license (with the right to sublicense), under only those claims of Intel
  30.  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31.  * offer to sell, and import the Covered Code and derivative works thereof
  32.  * solely to the minimum extent necessary to exercise the above copyright
  33.  * license, and in no event shall the patent license extend to any additions
  34.  * to or modifications of the Original Intel Code.  No other license or right
  35.  * is granted directly or by implication, estoppel or otherwise;
  36.  *
  37.  * The above copyright and patent license is granted only if the following
  38.  * conditions are met:
  39.  *
  40.  * 3. Conditions
  41.  *
  42.  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43.  * Redistribution of source code of any substantial portion of the Covered
  44.  * Code or modification with rights to further distribute source must include
  45.  * the above Copyright Notice, the above License, this list of Conditions,
  46.  * and the following Disclaimer and Export Compliance provision.  In addition,
  47.  * Licensee must cause all Covered Code to which Licensee contributes to
  48.  * contain a file documenting the changes Licensee made to create that Covered
  49.  * Code and the date of any change.  Licensee must include in that file the
  50.  * documentation of any changes made by any predecessor Licensee.  Licensee
  51.  * must include a prominent statement that the modification is derived,
  52.  * directly or indirectly, from Original Intel Code.
  53.  *
  54.  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55.  * Redistribution of source code of any substantial portion of the Covered
  56.  * Code or modification without rights to further distribute source must
  57.  * include the following Disclaimer and Export Compliance provision in the
  58.  * documentation and/or other materials provided with distribution.  In
  59.  * addition, Licensee may not authorize further sublicense of source of any
  60.  * portion of the Covered Code, and must include terms to the effect that the
  61.  * license from Licensee to its licensee is limited to the intellectual
  62.  * property embodied in the software Licensee provides to its licensee, and
  63.  * not to intellectual property embodied in modifications its licensee may
  64.  * make.
  65.  *
  66.  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67.  * substantial portion of the Covered Code or modification must reproduce the
  68.  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69.  * provision in the documentation and/or other materials provided with the
  70.  * distribution.
  71.  *
  72.  * 3.4. Intel retains all right, title, and interest in and to the Original
  73.  * Intel Code.
  74.  *
  75.  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76.  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77.  * other dealings in products derived from or relating to the Covered Code
  78.  * without prior written authorization from Intel.
  79.  *
  80.  * 4. Disclaimer and Export Compliance
  81.  *
  82.  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83.  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84.  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85.  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86.  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87.  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88.  * PARTICULAR PURPOSE.
  89.  *
  90.  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91.  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92.  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93.  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94.  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95.  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96.  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97.  * LIMITED REMEDY.
  98.  *
  99.  * 4.3. Licensee shall not export, either directly or indirectly, any of this
  100.  * software or system incorporating such software without first obtaining any
  101.  * required license or other approval from the U. S. Department of Commerce or
  102.  * any other agency or department of the United States Government.  In the
  103.  * event Licensee exports any such software from the United States or
  104.  * re-exports any such software from a foreign destination, Licensee shall
  105.  * ensure that the distribution and export/re-export of the software is in
  106.  * compliance with all laws, regulations, orders, or other restrictions of the
  107.  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
  108.  * any of its subsidiaries will export/re-export any technical data, process,
  109.  * software, or service, directly or indirectly, to any country for which the
  110.  * United States government or any agency thereof requires an export license,
  111.  * other governmental approval, or letter of assurance, without first obtaining
  112.  * such license, approval or letter.
  113.  *
  114.  *****************************************************************************/
  115.  
  116.  
  117. #define __RSUTILS_C__
  118.  
  119. #include "acpi.h"
  120. #include "accommon.h"
  121. #include "acnamesp.h"
  122. #include "acresrc.h"
  123.  
  124.  
  125. #define _COMPONENT          ACPI_RESOURCES
  126.         ACPI_MODULE_NAME    ("rsutils")
  127.  
  128.  
  129. /*******************************************************************************
  130.  *
  131.  * FUNCTION:    AcpiRsDecodeBitmask
  132.  *
  133.  * PARAMETERS:  Mask            - Bitmask to decode
  134.  *              List            - Where the converted list is returned
  135.  *
  136.  * RETURN:      Count of bits set (length of list)
  137.  *
  138.  * DESCRIPTION: Convert a bit mask into a list of values
  139.  *
  140.  ******************************************************************************/
  141.  
  142. UINT8
  143. AcpiRsDecodeBitmask (
  144.     UINT16                  Mask,
  145.     UINT8                   *List)
  146. {
  147.     UINT8                   i;
  148.     UINT8                   BitCount;
  149.  
  150.  
  151.     ACPI_FUNCTION_ENTRY ();
  152.  
  153.  
  154.     /* Decode the mask bits */
  155.  
  156.     for (i = 0, BitCount = 0; Mask; i++)
  157.     {
  158.         if (Mask & 0x0001)
  159.         {
  160.             List[BitCount] = i;
  161.             BitCount++;
  162.         }
  163.  
  164.         Mask >>= 1;
  165.     }
  166.  
  167.     return (BitCount);
  168. }
  169.  
  170.  
  171. /*******************************************************************************
  172.  *
  173.  * FUNCTION:    AcpiRsEncodeBitmask
  174.  *
  175.  * PARAMETERS:  List            - List of values to encode
  176.  *              Count           - Length of list
  177.  *
  178.  * RETURN:      Encoded bitmask
  179.  *
  180.  * DESCRIPTION: Convert a list of values to an encoded bitmask
  181.  *
  182.  ******************************************************************************/
  183.  
  184. UINT16
  185. AcpiRsEncodeBitmask (
  186.     UINT8                   *List,
  187.     UINT8                   Count)
  188. {
  189.     UINT32                  i;
  190.     UINT16                  Mask;
  191.  
  192.  
  193.     ACPI_FUNCTION_ENTRY ();
  194.  
  195.  
  196.     /* Encode the list into a single bitmask */
  197.  
  198.     for (i = 0, Mask = 0; i < Count; i++)
  199.     {
  200.         Mask |= (0x1 << List[i]);
  201.     }
  202.  
  203.     return (Mask);
  204. }
  205.  
  206.  
  207. /*******************************************************************************
  208.  *
  209.  * FUNCTION:    AcpiRsMoveData
  210.  *
  211.  * PARAMETERS:  Destination         - Pointer to the destination descriptor
  212.  *              Source              - Pointer to the source descriptor
  213.  *              ItemCount           - How many items to move
  214.  *              MoveType            - Byte width
  215.  *
  216.  * RETURN:      None
  217.  *
  218.  * DESCRIPTION: Move multiple data items from one descriptor to another. Handles
  219.  *              alignment issues and endian issues if necessary, as configured
  220.  *              via the ACPI_MOVE_* macros. (This is why a memcpy is not used)
  221.  *
  222.  ******************************************************************************/
  223.  
  224. void
  225. AcpiRsMoveData (
  226.     void                    *Destination,
  227.     void                    *Source,
  228.     UINT16                  ItemCount,
  229.     UINT8                   MoveType)
  230. {
  231.     UINT32                  i;
  232.  
  233.  
  234.     ACPI_FUNCTION_ENTRY ();
  235.  
  236.  
  237.     /* One move per item */
  238.  
  239.     for (i = 0; i < ItemCount; i++)
  240.     {
  241.         switch (MoveType)
  242.         {
  243.         /*
  244.          * For the 8-bit case, we can perform the move all at once
  245.          * since there are no alignment or endian issues
  246.          */
  247.         case ACPI_RSC_MOVE8:
  248.             ACPI_MEMCPY (Destination, Source, ItemCount);
  249.             return;
  250.  
  251.         /*
  252.          * 16-, 32-, and 64-bit cases must use the move macros that perform
  253.          * endian conversion and/or accomodate hardware that cannot perform
  254.          * misaligned memory transfers
  255.          */
  256.         case ACPI_RSC_MOVE16:
  257.             ACPI_MOVE_16_TO_16 (&ACPI_CAST_PTR (UINT16, Destination)[i],
  258.                                 &ACPI_CAST_PTR (UINT16, Source)[i]);
  259.             break;
  260.  
  261.         case ACPI_RSC_MOVE32:
  262.             ACPI_MOVE_32_TO_32 (&ACPI_CAST_PTR (UINT32, Destination)[i],
  263.                                 &ACPI_CAST_PTR (UINT32, Source)[i]);
  264.             break;
  265.  
  266.         case ACPI_RSC_MOVE64:
  267.             ACPI_MOVE_64_TO_64 (&ACPI_CAST_PTR (UINT64, Destination)[i],
  268.                                 &ACPI_CAST_PTR (UINT64, Source)[i]);
  269.             break;
  270.  
  271.         default:
  272.             return;
  273.         }
  274.     }
  275. }
  276.  
  277.  
  278. /*******************************************************************************
  279.  *
  280.  * FUNCTION:    AcpiRsSetResourceLength
  281.  *
  282.  * PARAMETERS:  TotalLength         - Length of the AML descriptor, including
  283.  *                                    the header and length fields.
  284.  *              Aml                 - Pointer to the raw AML descriptor
  285.  *
  286.  * RETURN:      None
  287.  *
  288.  * DESCRIPTION: Set the ResourceLength field of an AML
  289.  *              resource descriptor, both Large and Small descriptors are
  290.  *              supported automatically. Note: Descriptor Type field must
  291.  *              be valid.
  292.  *
  293.  ******************************************************************************/
  294.  
  295. void
  296. AcpiRsSetResourceLength (
  297.     ACPI_RSDESC_SIZE        TotalLength,
  298.     AML_RESOURCE            *Aml)
  299. {
  300.     ACPI_RS_LENGTH          ResourceLength;
  301.  
  302.  
  303.     ACPI_FUNCTION_ENTRY ();
  304.  
  305.  
  306.     /* Length is the total descriptor length minus the header length */
  307.  
  308.     ResourceLength = (ACPI_RS_LENGTH)
  309.         (TotalLength - AcpiUtGetResourceHeaderLength (Aml));
  310.  
  311.     /* Length is stored differently for large and small descriptors */
  312.  
  313.     if (Aml->SmallHeader.DescriptorType & ACPI_RESOURCE_NAME_LARGE)
  314.     {
  315.         /* Large descriptor -- bytes 1-2 contain the 16-bit length */
  316.  
  317.         ACPI_MOVE_16_TO_16 (&Aml->LargeHeader.ResourceLength, &ResourceLength);
  318.     }
  319.     else
  320.     {
  321.         /* Small descriptor -- bits 2:0 of byte 0 contain the length */
  322.  
  323.         Aml->SmallHeader.DescriptorType = (UINT8)
  324.  
  325.             /* Clear any existing length, preserving descriptor type bits */
  326.  
  327.             ((Aml->SmallHeader.DescriptorType & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK)
  328.  
  329.             | ResourceLength);
  330.     }
  331. }
  332.  
  333.  
  334. /*******************************************************************************
  335.  *
  336.  * FUNCTION:    AcpiRsSetResourceHeader
  337.  *
  338.  * PARAMETERS:  DescriptorType      - Byte to be inserted as the type
  339.  *              TotalLength         - Length of the AML descriptor, including
  340.  *                                    the header and length fields.
  341.  *              Aml                 - Pointer to the raw AML descriptor
  342.  *
  343.  * RETURN:      None
  344.  *
  345.  * DESCRIPTION: Set the DescriptorType and ResourceLength fields of an AML
  346.  *              resource descriptor, both Large and Small descriptors are
  347.  *              supported automatically
  348.  *
  349.  ******************************************************************************/
  350.  
  351. void
  352. AcpiRsSetResourceHeader (
  353.     UINT8                   DescriptorType,
  354.     ACPI_RSDESC_SIZE        TotalLength,
  355.     AML_RESOURCE            *Aml)
  356. {
  357.     ACPI_FUNCTION_ENTRY ();
  358.  
  359.  
  360.     /* Set the Resource Type */
  361.  
  362.     Aml->SmallHeader.DescriptorType = DescriptorType;
  363.  
  364.     /* Set the Resource Length */
  365.  
  366.     AcpiRsSetResourceLength (TotalLength, Aml);
  367. }
  368.  
  369.  
  370. /*******************************************************************************
  371.  *
  372.  * FUNCTION:    AcpiRsStrcpy
  373.  *
  374.  * PARAMETERS:  Destination         - Pointer to the destination string
  375.  *              Source              - Pointer to the source string
  376.  *
  377.  * RETURN:      String length, including NULL terminator
  378.  *
  379.  * DESCRIPTION: Local string copy that returns the string length, saving a
  380.  *              strcpy followed by a strlen.
  381.  *
  382.  ******************************************************************************/
  383.  
  384. static UINT16
  385. AcpiRsStrcpy (
  386.     char                    *Destination,
  387.     char                    *Source)
  388. {
  389.     UINT16                  i;
  390.  
  391.  
  392.     ACPI_FUNCTION_ENTRY ();
  393.  
  394.  
  395.     for (i = 0; Source[i]; i++)
  396.     {
  397.         Destination[i] = Source[i];
  398.     }
  399.  
  400.     Destination[i] = 0;
  401.  
  402.     /* Return string length including the NULL terminator */
  403.  
  404.     return ((UINT16) (i + 1));
  405. }
  406.  
  407.  
  408. /*******************************************************************************
  409.  *
  410.  * FUNCTION:    AcpiRsGetResourceSource
  411.  *
  412.  * PARAMETERS:  ResourceLength      - Length field of the descriptor
  413.  *              MinimumLength       - Minimum length of the descriptor (minus
  414.  *                                    any optional fields)
  415.  *              ResourceSource      - Where the ResourceSource is returned
  416.  *              Aml                 - Pointer to the raw AML descriptor
  417.  *              StringPtr           - (optional) where to store the actual
  418.  *                                    ResourceSource string
  419.  *
  420.  * RETURN:      Length of the string plus NULL terminator, rounded up to native
  421.  *              word boundary
  422.  *
  423.  * DESCRIPTION: Copy the optional ResourceSource data from a raw AML descriptor
  424.  *              to an internal resource descriptor
  425.  *
  426.  ******************************************************************************/
  427.  
  428. ACPI_RS_LENGTH
  429. AcpiRsGetResourceSource (
  430.     ACPI_RS_LENGTH          ResourceLength,
  431.     ACPI_RS_LENGTH          MinimumLength,
  432.     ACPI_RESOURCE_SOURCE    *ResourceSource,
  433.     AML_RESOURCE            *Aml,
  434.     char                    *StringPtr)
  435. {
  436.     ACPI_RSDESC_SIZE        TotalLength;
  437.     UINT8                   *AmlResourceSource;
  438.  
  439.  
  440.     ACPI_FUNCTION_ENTRY ();
  441.  
  442.  
  443.     TotalLength = ResourceLength + sizeof (AML_RESOURCE_LARGE_HEADER);
  444.     AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength);
  445.  
  446.     /*
  447.      * ResourceSource is present if the length of the descriptor is longer than
  448.      * the minimum length.
  449.      *
  450.      * Note: Some resource descriptors will have an additional null, so
  451.      * we add 1 to the minimum length.
  452.      */
  453.     if (TotalLength > (ACPI_RSDESC_SIZE) (MinimumLength + 1))
  454.     {
  455.         /* Get the ResourceSourceIndex */
  456.  
  457.         ResourceSource->Index = AmlResourceSource[0];
  458.  
  459.         ResourceSource->StringPtr = StringPtr;
  460.         if (!StringPtr)
  461.         {
  462.             /*
  463.              * String destination pointer is not specified; Set the String
  464.              * pointer to the end of the current ResourceSource structure.
  465.              */
  466.             ResourceSource->StringPtr = ACPI_ADD_PTR (char, ResourceSource,
  467.                 sizeof (ACPI_RESOURCE_SOURCE));
  468.         }
  469.  
  470.         /*
  471.          * In order for the Resource length to be a multiple of the native
  472.          * word, calculate the length of the string (+1 for NULL terminator)
  473.          * and expand to the next word multiple.
  474.          *
  475.          * Zero the entire area of the buffer.
  476.          */
  477.         TotalLength = (UINT32) ACPI_STRLEN (
  478.             ACPI_CAST_PTR (char, &AmlResourceSource[1])) + 1;
  479.         TotalLength = (UINT32) ACPI_ROUND_UP_TO_NATIVE_WORD (TotalLength);
  480.  
  481.         ACPI_MEMSET (ResourceSource->StringPtr, 0, TotalLength);
  482.  
  483.         /* Copy the ResourceSource string to the destination */
  484.  
  485.         ResourceSource->StringLength = AcpiRsStrcpy (ResourceSource->StringPtr,
  486.             ACPI_CAST_PTR (char, &AmlResourceSource[1]));
  487.  
  488.         return ((ACPI_RS_LENGTH) TotalLength);
  489.     }
  490.  
  491.     /* ResourceSource is not present */
  492.  
  493.     ResourceSource->Index = 0;
  494.     ResourceSource->StringLength = 0;
  495.     ResourceSource->StringPtr = NULL;
  496.     return (0);
  497. }
  498.  
  499.  
  500. /*******************************************************************************
  501.  *
  502.  * FUNCTION:    AcpiRsSetResourceSource
  503.  *
  504.  * PARAMETERS:  Aml                 - Pointer to the raw AML descriptor
  505.  *              MinimumLength       - Minimum length of the descriptor (minus
  506.  *                                    any optional fields)
  507.  *              ResourceSource      - Internal ResourceSource
  508.  
  509.  *
  510.  * RETURN:      Total length of the AML descriptor
  511.  *
  512.  * DESCRIPTION: Convert an optional ResourceSource from internal format to a
  513.  *              raw AML resource descriptor
  514.  *
  515.  ******************************************************************************/
  516.  
  517. ACPI_RSDESC_SIZE
  518. AcpiRsSetResourceSource (
  519.     AML_RESOURCE            *Aml,
  520.     ACPI_RS_LENGTH          MinimumLength,
  521.     ACPI_RESOURCE_SOURCE    *ResourceSource)
  522. {
  523.     UINT8                   *AmlResourceSource;
  524.     ACPI_RSDESC_SIZE        DescriptorLength;
  525.  
  526.  
  527.     ACPI_FUNCTION_ENTRY ();
  528.  
  529.  
  530.     DescriptorLength = MinimumLength;
  531.  
  532.     /* Non-zero string length indicates presence of a ResourceSource */
  533.  
  534.     if (ResourceSource->StringLength)
  535.     {
  536.         /* Point to the end of the AML descriptor */
  537.  
  538.         AmlResourceSource = ACPI_ADD_PTR (UINT8, Aml, MinimumLength);
  539.  
  540.         /* Copy the ResourceSourceIndex */
  541.  
  542.         AmlResourceSource[0] = (UINT8) ResourceSource->Index;
  543.  
  544.         /* Copy the ResourceSource string */
  545.  
  546.         ACPI_STRCPY (ACPI_CAST_PTR (char, &AmlResourceSource[1]),
  547.             ResourceSource->StringPtr);
  548.  
  549.         /*
  550.          * Add the length of the string (+ 1 for null terminator) to the
  551.          * final descriptor length
  552.          */
  553.         DescriptorLength += ((ACPI_RSDESC_SIZE) ResourceSource->StringLength + 1);
  554.     }
  555.  
  556.     /* Return the new total length of the AML descriptor */
  557.  
  558.     return (DescriptorLength);
  559. }
  560.  
  561.  
  562. /*******************************************************************************
  563.  *
  564.  * FUNCTION:    AcpiRsGetPrtMethodData
  565.  *
  566.  * PARAMETERS:  Node            - Device node
  567.  *              RetBuffer       - Pointer to a buffer structure for the
  568.  *                                results
  569.  *
  570.  * RETURN:      Status
  571.  *
  572.  * DESCRIPTION: This function is called to get the _PRT value of an object
  573.  *              contained in an object specified by the handle passed in
  574.  *
  575.  *              If the function fails an appropriate status will be returned
  576.  *              and the contents of the callers buffer is undefined.
  577.  *
  578.  ******************************************************************************/
  579.  
  580. ACPI_STATUS
  581. AcpiRsGetPrtMethodData (
  582.     ACPI_NAMESPACE_NODE     *Node,
  583.     ACPI_BUFFER             *RetBuffer)
  584. {
  585.     ACPI_OPERAND_OBJECT     *ObjDesc;
  586.     ACPI_STATUS             Status;
  587.  
  588.  
  589.     ACPI_FUNCTION_TRACE (RsGetPrtMethodData);
  590.  
  591.  
  592.     /* Parameters guaranteed valid by caller */
  593.  
  594.     /* Execute the method, no parameters */
  595.  
  596.     Status = AcpiUtEvaluateObject (Node, METHOD_NAME__PRT,
  597.                 ACPI_BTYPE_PACKAGE, &ObjDesc);
  598.     if (ACPI_FAILURE (Status))
  599.     {
  600.         return_ACPI_STATUS (Status);
  601.     }
  602.  
  603.     /*
  604.      * Create a resource linked list from the byte stream buffer that comes
  605.      * back from the _CRS method execution.
  606.      */
  607.     Status = AcpiRsCreatePciRoutingTable (ObjDesc, RetBuffer);
  608.  
  609.     /* On exit, we must delete the object returned by EvaluateObject */
  610.  
  611.     AcpiUtRemoveReference (ObjDesc);
  612.     return_ACPI_STATUS (Status);
  613. }
  614.  
  615.  
  616. /*******************************************************************************
  617.  *
  618.  * FUNCTION:    AcpiRsGetCrsMethodData
  619.  *
  620.  * PARAMETERS:  Node            - Device node
  621.  *              RetBuffer       - Pointer to a buffer structure for the
  622.  *                                results
  623.  *
  624.  * RETURN:      Status
  625.  *
  626.  * DESCRIPTION: This function is called to get the _CRS value of an object
  627.  *              contained in an object specified by the handle passed in
  628.  *
  629.  *              If the function fails an appropriate status will be returned
  630.  *              and the contents of the callers buffer is undefined.
  631.  *
  632.  ******************************************************************************/
  633.  
  634. ACPI_STATUS
  635. AcpiRsGetCrsMethodData (
  636.     ACPI_NAMESPACE_NODE     *Node,
  637.     ACPI_BUFFER             *RetBuffer)
  638. {
  639.     ACPI_OPERAND_OBJECT     *ObjDesc;
  640.     ACPI_STATUS             Status;
  641.  
  642.  
  643.     ACPI_FUNCTION_TRACE (RsGetCrsMethodData);
  644.  
  645.  
  646.     /* Parameters guaranteed valid by caller */
  647.  
  648.     /* Execute the method, no parameters */
  649.  
  650.     Status = AcpiUtEvaluateObject (Node, METHOD_NAME__CRS,
  651.                 ACPI_BTYPE_BUFFER, &ObjDesc);
  652.     if (ACPI_FAILURE (Status))
  653.     {
  654.         return_ACPI_STATUS (Status);
  655.     }
  656.  
  657.     /*
  658.      * Make the call to create a resource linked list from the
  659.      * byte stream buffer that comes back from the _CRS method
  660.      * execution.
  661.      */
  662.     Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
  663.  
  664.     /* On exit, we must delete the object returned by evaluateObject */
  665.  
  666.     AcpiUtRemoveReference (ObjDesc);
  667.     return_ACPI_STATUS (Status);
  668. }
  669.  
  670.  
  671. /*******************************************************************************
  672.  *
  673.  * FUNCTION:    AcpiRsGetPrsMethodData
  674.  *
  675.  * PARAMETERS:  Node            - Device node
  676.  *              RetBuffer       - Pointer to a buffer structure for the
  677.  *                                results
  678.  *
  679.  * RETURN:      Status
  680.  *
  681.  * DESCRIPTION: This function is called to get the _PRS value of an object
  682.  *              contained in an object specified by the handle passed in
  683.  *
  684.  *              If the function fails an appropriate status will be returned
  685.  *              and the contents of the callers buffer is undefined.
  686.  *
  687.  ******************************************************************************/
  688.  
  689. ACPI_STATUS
  690. AcpiRsGetPrsMethodData (
  691.     ACPI_NAMESPACE_NODE     *Node,
  692.     ACPI_BUFFER             *RetBuffer)
  693. {
  694.     ACPI_OPERAND_OBJECT     *ObjDesc;
  695.     ACPI_STATUS             Status;
  696.  
  697.  
  698.     ACPI_FUNCTION_TRACE (RsGetPrsMethodData);
  699.  
  700.  
  701.     /* Parameters guaranteed valid by caller */
  702.  
  703.     /* Execute the method, no parameters */
  704.  
  705.     Status = AcpiUtEvaluateObject (Node, METHOD_NAME__PRS,
  706.                 ACPI_BTYPE_BUFFER, &ObjDesc);
  707.     if (ACPI_FAILURE (Status))
  708.     {
  709.         return_ACPI_STATUS (Status);
  710.     }
  711.  
  712.     /*
  713.      * Make the call to create a resource linked list from the
  714.      * byte stream buffer that comes back from the _CRS method
  715.      * execution.
  716.      */
  717.     Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
  718.  
  719.     /* On exit, we must delete the object returned by evaluateObject */
  720.  
  721.     AcpiUtRemoveReference (ObjDesc);
  722.     return_ACPI_STATUS (Status);
  723. }
  724.  
  725.  
  726. /*******************************************************************************
  727.  *
  728.  * FUNCTION:    AcpiRsGetMethodData
  729.  *
  730.  * PARAMETERS:  Handle          - Handle to the containing object
  731.  *              Path            - Path to method, relative to Handle
  732.  *              RetBuffer       - Pointer to a buffer structure for the
  733.  *                                results
  734.  *
  735.  * RETURN:      Status
  736.  *
  737.  * DESCRIPTION: This function is called to get the _CRS or _PRS value of an
  738.  *              object contained in an object specified by the handle passed in
  739.  *
  740.  *              If the function fails an appropriate status will be returned
  741.  *              and the contents of the callers buffer is undefined.
  742.  *
  743.  ******************************************************************************/
  744.  
  745. ACPI_STATUS
  746. AcpiRsGetMethodData (
  747.     ACPI_HANDLE             Handle,
  748.     char                    *Path,
  749.     ACPI_BUFFER             *RetBuffer)
  750. {
  751.     ACPI_OPERAND_OBJECT     *ObjDesc;
  752.     ACPI_STATUS             Status;
  753.  
  754.  
  755.     ACPI_FUNCTION_TRACE (RsGetMethodData);
  756.  
  757.  
  758.     /* Parameters guaranteed valid by caller */
  759.  
  760.     /* Execute the method, no parameters */
  761.  
  762.     Status = AcpiUtEvaluateObject (Handle, Path, ACPI_BTYPE_BUFFER, &ObjDesc);
  763.     if (ACPI_FAILURE (Status))
  764.     {
  765.         return_ACPI_STATUS (Status);
  766.     }
  767.  
  768.     /*
  769.      * Make the call to create a resource linked list from the
  770.      * byte stream buffer that comes back from the method
  771.      * execution.
  772.      */
  773.     Status = AcpiRsCreateResourceList (ObjDesc, RetBuffer);
  774.  
  775.     /* On exit, we must delete the object returned by EvaluateObject */
  776.  
  777.     AcpiUtRemoveReference (ObjDesc);
  778.     return_ACPI_STATUS (Status);
  779. }
  780.  
  781.  
  782. /*******************************************************************************
  783.  *
  784.  * FUNCTION:    AcpiRsSetSrsMethodData
  785.  *
  786.  * PARAMETERS:  Node            - Device node
  787.  *              InBuffer        - Pointer to a buffer structure of the
  788.  *                                parameter
  789.  *
  790.  * RETURN:      Status
  791.  *
  792.  * DESCRIPTION: This function is called to set the _SRS of an object contained
  793.  *              in an object specified by the handle passed in
  794.  *
  795.  *              If the function fails an appropriate status will be returned
  796.  *              and the contents of the callers buffer is undefined.
  797.  *
  798.  * Note: Parameters guaranteed valid by caller
  799.  *
  800.  ******************************************************************************/
  801.  
  802. ACPI_STATUS
  803. AcpiRsSetSrsMethodData (
  804.     ACPI_NAMESPACE_NODE     *Node,
  805.     ACPI_BUFFER             *InBuffer)
  806. {
  807.     ACPI_EVALUATE_INFO      *Info;
  808.     ACPI_OPERAND_OBJECT     *Args[2];
  809.     ACPI_STATUS             Status;
  810.     ACPI_BUFFER             Buffer;
  811.  
  812.  
  813.     ACPI_FUNCTION_TRACE (RsSetSrsMethodData);
  814.  
  815.  
  816.     /* Allocate and initialize the evaluation information block */
  817.  
  818.     Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
  819.     if (!Info)
  820.     {
  821.         return_ACPI_STATUS (AE_NO_MEMORY);
  822.     }
  823.  
  824.     Info->PrefixNode = Node;
  825.     Info->Pathname = METHOD_NAME__SRS;
  826.     Info->Parameters = Args;
  827.     Info->Flags = ACPI_IGNORE_RETURN_VALUE;
  828.  
  829.     /*
  830.      * The InBuffer parameter will point to a linked list of
  831.      * resource parameters. It needs to be formatted into a
  832.      * byte stream to be sent in as an input parameter to _SRS
  833.      *
  834.      * Convert the linked list into a byte stream
  835.      */
  836.     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
  837.     Status = AcpiRsCreateAmlResources (InBuffer->Pointer, &Buffer);
  838.     if (ACPI_FAILURE (Status))
  839.     {
  840.         goto Cleanup;
  841.     }
  842.  
  843.     /* Create and initialize the method parameter object */
  844.  
  845.     Args[0] = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER);
  846.     if (!Args[0])
  847.     {
  848.         /*
  849.          * Must free the buffer allocated above (otherwise it is freed
  850.          * later)
  851.          */
  852.         ACPI_FREE (Buffer.Pointer);
  853.         Status = AE_NO_MEMORY;
  854.         goto Cleanup;
  855.     }
  856.  
  857.     Args[0]->Buffer.Length  = (UINT32) Buffer.Length;
  858.     Args[0]->Buffer.Pointer = Buffer.Pointer;
  859.     Args[0]->Common.Flags   = AOPOBJ_DATA_VALID;
  860.     Args[1] = NULL;
  861.  
  862.     /* Execute the method, no return value is expected */
  863.  
  864.     Status = AcpiNsEvaluate (Info);
  865.  
  866.     /* Clean up and return the status from AcpiNsEvaluate */
  867.  
  868.     AcpiUtRemoveReference (Args[0]);
  869.  
  870. Cleanup:
  871.     ACPI_FREE (Info);
  872.     return_ACPI_STATUS (Status);
  873. }
  874.  
  875.