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: exfield - ACPI AML (p-code) execution - field manipulation
  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 __EXFIELD_C__
  118.  
  119. #include "acpi.h"
  120. #include "accommon.h"
  121. #include "acdispat.h"
  122. #include "acinterp.h"
  123.  
  124.  
  125. #define _COMPONENT          ACPI_EXECUTER
  126.         ACPI_MODULE_NAME    ("exfield")
  127.  
  128.  
  129. /*******************************************************************************
  130.  *
  131.  * FUNCTION:    AcpiExReadDataFromField
  132.  *
  133.  * PARAMETERS:  WalkState           - Current execution state
  134.  *              ObjDesc             - The named field
  135.  *              RetBufferDesc       - Where the return data object is stored
  136.  *
  137.  * RETURN:      Status
  138.  *
  139.  * DESCRIPTION: Read from a named field.  Returns either an Integer or a
  140.  *              Buffer, depending on the size of the field.
  141.  *
  142.  ******************************************************************************/
  143.  
  144. ACPI_STATUS
  145. AcpiExReadDataFromField (
  146.     ACPI_WALK_STATE         *WalkState,
  147.     ACPI_OPERAND_OBJECT     *ObjDesc,
  148.     ACPI_OPERAND_OBJECT     **RetBufferDesc)
  149. {
  150.     ACPI_STATUS             Status;
  151.     ACPI_OPERAND_OBJECT     *BufferDesc;
  152.     ACPI_SIZE               Length;
  153.     void                    *Buffer;
  154.     UINT32                  Function;
  155.  
  156.  
  157.     ACPI_FUNCTION_TRACE_PTR (ExReadDataFromField, ObjDesc);
  158.  
  159.  
  160.     /* Parameter validation */
  161.  
  162.     if (!ObjDesc)
  163.     {
  164.         return_ACPI_STATUS (AE_AML_NO_OPERAND);
  165.     }
  166.     if (!RetBufferDesc)
  167.     {
  168.         return_ACPI_STATUS (AE_BAD_PARAMETER);
  169.     }
  170.  
  171.     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
  172.     {
  173.         /*
  174.          * If the BufferField arguments have not been previously evaluated,
  175.          * evaluate them now and save the results.
  176.          */
  177.         if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
  178.         {
  179.             Status = AcpiDsGetBufferFieldArguments (ObjDesc);
  180.             if (ACPI_FAILURE (Status))
  181.             {
  182.                 return_ACPI_STATUS (Status);
  183.             }
  184.         }
  185.     }
  186.     else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
  187.              (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||
  188.               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))
  189.     {
  190.         /*
  191.          * This is an SMBus or IPMI read. We must create a buffer to hold
  192.          * the data and then directly access the region handler.
  193.          *
  194.          * Note: Smbus protocol value is passed in upper 16-bits of Function
  195.          */
  196.         if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)
  197.         {
  198.             Length = ACPI_SMBUS_BUFFER_SIZE;
  199.             Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);
  200.         }
  201.         else /* IPMI */
  202.         {
  203.             Length = ACPI_IPMI_BUFFER_SIZE;
  204.             Function = ACPI_READ;
  205.         }
  206.  
  207.         BufferDesc = AcpiUtCreateBufferObject (Length);
  208.         if (!BufferDesc)
  209.         {
  210.             return_ACPI_STATUS (AE_NO_MEMORY);
  211.         }
  212.  
  213.         /* Lock entire transaction if requested */
  214.  
  215.         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
  216.  
  217.         /* Call the region handler for the read */
  218.  
  219.         Status = AcpiExAccessRegion (ObjDesc, 0,
  220.                     ACPI_CAST_PTR (UINT64, BufferDesc->Buffer.Pointer),
  221.                     Function);
  222.         AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
  223.         goto Exit;
  224.     }
  225.  
  226.     /*
  227.      * Allocate a buffer for the contents of the field.
  228.      *
  229.      * If the field is larger than the current integer width, create
  230.      * a BUFFER to hold it.  Otherwise, use an INTEGER.  This allows
  231.      * the use of arithmetic operators on the returned value if the
  232.      * field size is equal or smaller than an Integer.
  233.      *
  234.      * Note: Field.length is in bits.
  235.      */
  236.     Length = (ACPI_SIZE) ACPI_ROUND_BITS_UP_TO_BYTES (ObjDesc->Field.BitLength);
  237.     if (Length > AcpiGbl_IntegerByteWidth)
  238.     {
  239.         /* Field is too large for an Integer, create a Buffer instead */
  240.  
  241.         BufferDesc = AcpiUtCreateBufferObject (Length);
  242.         if (!BufferDesc)
  243.         {
  244.             return_ACPI_STATUS (AE_NO_MEMORY);
  245.         }
  246.         Buffer = BufferDesc->Buffer.Pointer;
  247.     }
  248.     else
  249.     {
  250.         /* Field will fit within an Integer (normal case) */
  251.  
  252.         BufferDesc = AcpiUtCreateIntegerObject ((UINT64) 0);
  253.         if (!BufferDesc)
  254.         {
  255.             return_ACPI_STATUS (AE_NO_MEMORY);
  256.         }
  257.  
  258.         Length = AcpiGbl_IntegerByteWidth;
  259.         Buffer = &BufferDesc->Integer.Value;
  260.     }
  261.  
  262.     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
  263.         "FieldRead [TO]:   Obj %p, Type %X, Buf %p, ByteLen %X\n",
  264.         ObjDesc, ObjDesc->Common.Type, Buffer, (UINT32) Length));
  265.     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
  266.         "FieldRead [FROM]: BitLen %X, BitOff %X, ByteOff %X\n",
  267.         ObjDesc->CommonField.BitLength,
  268.         ObjDesc->CommonField.StartFieldBitOffset,
  269.         ObjDesc->CommonField.BaseByteOffset));
  270.  
  271.     /* Lock entire transaction if requested */
  272.  
  273.     AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
  274.  
  275.     /* Read from the field */
  276.  
  277.     Status = AcpiExExtractFromField (ObjDesc, Buffer, (UINT32) Length);
  278.     AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
  279.  
  280.  
  281. Exit:
  282.     if (ACPI_FAILURE (Status))
  283.     {
  284.         AcpiUtRemoveReference (BufferDesc);
  285.     }
  286.     else
  287.     {
  288.         *RetBufferDesc = BufferDesc;
  289.     }
  290.  
  291.     return_ACPI_STATUS (Status);
  292. }
  293.  
  294.  
  295. /*******************************************************************************
  296.  *
  297.  * FUNCTION:    AcpiExWriteDataToField
  298.  *
  299.  * PARAMETERS:  SourceDesc          - Contains data to write
  300.  *              ObjDesc             - The named field
  301.  *              ResultDesc          - Where the return value is returned, if any
  302.  *
  303.  * RETURN:      Status
  304.  *
  305.  * DESCRIPTION: Write to a named field
  306.  *
  307.  ******************************************************************************/
  308.  
  309. ACPI_STATUS
  310. AcpiExWriteDataToField (
  311.     ACPI_OPERAND_OBJECT     *SourceDesc,
  312.     ACPI_OPERAND_OBJECT     *ObjDesc,
  313.     ACPI_OPERAND_OBJECT     **ResultDesc)
  314. {
  315.     ACPI_STATUS             Status;
  316.     UINT32                  Length;
  317.     void                    *Buffer;
  318.     ACPI_OPERAND_OBJECT     *BufferDesc;
  319.     UINT32                  Function;
  320.  
  321.  
  322.     ACPI_FUNCTION_TRACE_PTR (ExWriteDataToField, ObjDesc);
  323.  
  324.  
  325.     /* Parameter validation */
  326.  
  327.     if (!SourceDesc || !ObjDesc)
  328.     {
  329.         return_ACPI_STATUS (AE_AML_NO_OPERAND);
  330.     }
  331.  
  332.     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
  333.     {
  334.         /*
  335.          * If the BufferField arguments have not been previously evaluated,
  336.          * evaluate them now and save the results.
  337.          */
  338.         if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
  339.         {
  340.             Status = AcpiDsGetBufferFieldArguments (ObjDesc);
  341.             if (ACPI_FAILURE (Status))
  342.             {
  343.                 return_ACPI_STATUS (Status);
  344.             }
  345.         }
  346.     }
  347.     else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
  348.              (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||
  349.               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))
  350.     {
  351.         /*
  352.          * This is an SMBus or IPMI write. We will bypass the entire field
  353.          * mechanism and handoff the buffer directly to the handler. For
  354.          * these address spaces, the buffer is bi-directional; on a write,
  355.          * return data is returned in the same buffer.
  356.          *
  357.          * Source must be a buffer of sufficient size:
  358.          * ACPI_SMBUS_BUFFER_SIZE or ACPI_IPMI_BUFFER_SIZE.
  359.          *
  360.          * Note: SMBus protocol type is passed in upper 16-bits of Function
  361.          */
  362.         if (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)
  363.         {
  364.             ACPI_ERROR ((AE_INFO,
  365.                 "SMBus or IPMI write requires Buffer, found type %s",
  366.                 AcpiUtGetObjectTypeName (SourceDesc)));
  367.  
  368.             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
  369.         }
  370.  
  371.         if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)
  372.         {
  373.             Length = ACPI_SMBUS_BUFFER_SIZE;
  374.             Function = ACPI_WRITE | (ObjDesc->Field.Attribute << 16);
  375.         }
  376.         else /* IPMI */
  377.         {
  378.             Length = ACPI_IPMI_BUFFER_SIZE;
  379.             Function = ACPI_WRITE;
  380.         }
  381.  
  382.         if (SourceDesc->Buffer.Length < Length)
  383.         {
  384.             ACPI_ERROR ((AE_INFO,
  385.                 "SMBus or IPMI write requires Buffer of length %u, found length %u",
  386.                 Length, SourceDesc->Buffer.Length));
  387.  
  388.             return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
  389.         }
  390.  
  391.         /* Create the bi-directional buffer */
  392.  
  393.         BufferDesc = AcpiUtCreateBufferObject (Length);
  394.         if (!BufferDesc)
  395.         {
  396.             return_ACPI_STATUS (AE_NO_MEMORY);
  397.         }
  398.  
  399.         Buffer = BufferDesc->Buffer.Pointer;
  400.         ACPI_MEMCPY (Buffer, SourceDesc->Buffer.Pointer, Length);
  401.  
  402.         /* Lock entire transaction if requested */
  403.  
  404.         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
  405.  
  406.         /*
  407.          * Perform the write (returns status and perhaps data in the
  408.          * same buffer)
  409.          */
  410.         Status = AcpiExAccessRegion (ObjDesc, 0,
  411.                     (UINT64 *) Buffer, Function);
  412.         AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
  413.  
  414.         *ResultDesc = BufferDesc;
  415.         return_ACPI_STATUS (Status);
  416.     }
  417.  
  418.     /* Get a pointer to the data to be written */
  419.  
  420.     switch (SourceDesc->Common.Type)
  421.     {
  422.     case ACPI_TYPE_INTEGER:
  423.         Buffer = &SourceDesc->Integer.Value;
  424.         Length = sizeof (SourceDesc->Integer.Value);
  425.         break;
  426.  
  427.     case ACPI_TYPE_BUFFER:
  428.         Buffer = SourceDesc->Buffer.Pointer;
  429.         Length = SourceDesc->Buffer.Length;
  430.         break;
  431.  
  432.     case ACPI_TYPE_STRING:
  433.         Buffer = SourceDesc->String.Pointer;
  434.         Length = SourceDesc->String.Length;
  435.         break;
  436.  
  437.     default:
  438.         return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
  439.     }
  440.  
  441.     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
  442.         "FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n",
  443.         SourceDesc, AcpiUtGetTypeName (SourceDesc->Common.Type),
  444.         SourceDesc->Common.Type, Buffer, Length));
  445.  
  446.     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
  447.         "FieldWrite [TO]:   Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n",
  448.         ObjDesc, AcpiUtGetTypeName (ObjDesc->Common.Type),
  449.         ObjDesc->Common.Type,
  450.         ObjDesc->CommonField.BitLength,
  451.         ObjDesc->CommonField.StartFieldBitOffset,
  452.         ObjDesc->CommonField.BaseByteOffset));
  453.  
  454.     /* Lock entire transaction if requested */
  455.  
  456.     AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
  457.  
  458.     /* Write to the field */
  459.  
  460.     Status = AcpiExInsertIntoField (ObjDesc, Buffer, Length);
  461.     AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
  462.  
  463.     return_ACPI_STATUS (Status);
  464. }
  465.  
  466.  
  467.