Subversion Repositories or1k

/******************************************************************************

 *

 * Module Name: exmisc - ACPI AML (p-code) execution - specific opcodes

 *

 *****************************************************************************/

/*

 * Copyright (C) 2000 - 2004, R. Byron Moore

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions, and the following disclaimer,

 *    without modification.

 * 2. Redistributions in binary form must reproduce at minimum a disclaimer

 *    substantially similar to the "NO WARRANTY" disclaimer below

 *    ("Disclaimer") and any redistribution must be conditioned upon

 *    including a substantially similar Disclaimer requirement for further

 *    binary redistribution.

 * 3. Neither the names of the above-listed copyright holders nor the names

 *    of any contributors may be used to endorse or promote products derived

 *    from this software without specific prior written permission.

 *

 * Alternatively, this software may be distributed under the terms of the

 * GNU General Public License ("GPL") version 2 as published by the Free

 * Software Foundation.

 *

 * NO WARRANTY

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING

 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGES.

 */

#include <acpi/acpi.h>

#include <acpi/acinterp.h>

#include <acpi/amlcode.h>

#define _COMPONENT          ACPI_EXECUTER

         ACPI_MODULE_NAME    ("exmisc")

/*******************************************************************************

 *

 * FUNCTION:    acpi_ex_get_object_reference

 *

 * PARAMETERS:  obj_desc            - Create a reference to this object

 *              return_desc         - Where to store the reference

 *              walk_state          - Current state

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Obtain and return a "reference" to the target object

 *              Common code for the ref_of_op and the cond_ref_of_op.

 *

 ******************************************************************************/

acpi_status

acpi_ex_get_object_reference (

        union acpi_operand_object       *obj_desc,

        union acpi_operand_object       **return_desc,

        struct acpi_walk_state          *walk_state)

{

        union acpi_operand_object       *reference_obj;

        union acpi_operand_object       *referenced_obj;

        ACPI_FUNCTION_TRACE_PTR ("ex_get_object_reference", obj_desc);

        *return_desc = NULL;

        switch (ACPI_GET_DESCRIPTOR_TYPE (obj_desc)) {

        case ACPI_DESC_TYPE_OPERAND:

                if (ACPI_GET_OBJECT_TYPE (obj_desc) != ACPI_TYPE_LOCAL_REFERENCE) {

                        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);

                }

                /*

                 * Must be a reference to a Local or Arg

                 */

                switch (obj_desc->reference.opcode) {

                case AML_LOCAL_OP:

                case AML_ARG_OP:

                        /* The referenced object is the pseudo-node for the local/arg */

                        referenced_obj = obj_desc->reference.object;

                        break;

                default:

                        ACPI_REPORT_ERROR (("Unknown Reference subtype in get ref %X\n",

                                obj_desc->reference.opcode));

                        return_ACPI_STATUS (AE_AML_INTERNAL);

                }

                break;

        case ACPI_DESC_TYPE_NAMED:

                /*

                 * A named reference that has already been resolved to a Node

                 */

                referenced_obj = obj_desc;

                break;

        default:

                ACPI_REPORT_ERROR (("Invalid descriptor type in get ref: %X\n",

                                ACPI_GET_DESCRIPTOR_TYPE (obj_desc)));

                return_ACPI_STATUS (AE_TYPE);

        }

        /* Create a new reference object */

        reference_obj = acpi_ut_create_internal_object (ACPI_TYPE_LOCAL_REFERENCE);

        if (!reference_obj) {

                return_ACPI_STATUS (AE_NO_MEMORY);

        }

        reference_obj->reference.opcode = AML_REF_OF_OP;

        reference_obj->reference.object = referenced_obj;

        *return_desc = reference_obj;

        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p Type [%s], returning Reference %p\n",

                        obj_desc, acpi_ut_get_object_type_name (obj_desc), *return_desc));

        return_ACPI_STATUS (AE_OK);

}

/*******************************************************************************

 *

 * FUNCTION:    acpi_ex_concat_template

 *

 * PARAMETERS:  *obj_desc           - Object to be converted.  Must be an

 *                                    Integer, Buffer, or String

 *              walk_state          - Current walk state

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Concatenate two resource templates

 *

 ******************************************************************************/

acpi_status

acpi_ex_concat_template (

        union acpi_operand_object       *obj_desc1,

        union acpi_operand_object       *obj_desc2,

        union acpi_operand_object       **actual_return_desc,

        struct acpi_walk_state          *walk_state)

{

        union acpi_operand_object       *return_desc;

        u8                              *new_buf;

        u8                              *end_tag1;

        u8                              *end_tag2;

        acpi_size                       length1;

        acpi_size                       length2;

        ACPI_FUNCTION_TRACE ("ex_concat_template");

        /* Find the end_tags in each resource template */

        end_tag1 = acpi_ut_get_resource_end_tag (obj_desc1);

        end_tag2 = acpi_ut_get_resource_end_tag (obj_desc2);

        if (!end_tag1 || !end_tag2) {

                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);

        }

        /* Compute the length of each part */

        length1 = ACPI_PTR_DIFF (end_tag1, obj_desc1->buffer.pointer);

        length2 = ACPI_PTR_DIFF (end_tag2, obj_desc2->buffer.pointer) +

                          2; /* Size of END_TAG */

        /* Create a new buffer object for the result */

        return_desc = acpi_ut_create_buffer_object (length1 + length2);

        if (!return_desc) {

                return_ACPI_STATUS (AE_NO_MEMORY);

        }

        /* Copy the templates to the new descriptor */

        new_buf = return_desc->buffer.pointer;

        ACPI_MEMCPY (new_buf, obj_desc1->buffer.pointer, length1);

        ACPI_MEMCPY (new_buf + length1, obj_desc2->buffer.pointer, length2);

        /* Compute the new checksum */

        new_buf[return_desc->buffer.length - 1] =

                        acpi_ut_generate_checksum (return_desc->buffer.pointer,

                                           (return_desc->buffer.length - 1));

        /* Return the completed template descriptor */

        *actual_return_desc = return_desc;

        return_ACPI_STATUS (AE_OK);

}

/*******************************************************************************

 *

 * FUNCTION:    acpi_ex_do_concatenate

 *

 * PARAMETERS:  obj_desc1           - First source object

 *              obj_desc2           - Second source object

 *              actual_return_desc  - Where to place the return object

 *              walk_state          - Current walk state

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Concatenate two objects OF THE SAME TYPE.

 *

 ******************************************************************************/

acpi_status

acpi_ex_do_concatenate (

        union acpi_operand_object       *obj_desc1,

        union acpi_operand_object       *obj_desc2,

        union acpi_operand_object       **actual_return_desc,

        struct acpi_walk_state          *walk_state)

{

        acpi_status                     status;

        u32                             i;

        acpi_integer                    this_integer;

        union acpi_operand_object       *return_desc;

        char                            *new_buf;

        ACPI_FUNCTION_ENTRY ();

        /*

         * There are three cases to handle:

         *

         * 1) Two Integers concatenated to produce a new Buffer

         * 2) Two Strings concatenated to produce a new String

         * 3) Two Buffers concatenated to produce a new Buffer

         */

        switch (ACPI_GET_OBJECT_TYPE (obj_desc1)) {

        case ACPI_TYPE_INTEGER:

                /* Result of two Integers is a Buffer */

                /* Need enough buffer space for two integers */

                return_desc = acpi_ut_create_buffer_object (acpi_gbl_integer_byte_width * 2);

                if (!return_desc) {

                        return (AE_NO_MEMORY);

                }

                new_buf = (char *) return_desc->buffer.pointer;

                /* Convert the first integer */

                this_integer = obj_desc1->integer.value;

                for (i = 0; i < acpi_gbl_integer_byte_width; i++) {

                        new_buf[i] = (char) this_integer;

                        this_integer >>= 8;

                }

                /* Convert the second integer */

                this_integer = obj_desc2->integer.value;

                for (; i < (ACPI_MUL_2 (acpi_gbl_integer_byte_width)); i++) {

                        new_buf[i] = (char) this_integer;

                        this_integer >>= 8;

                }

                break;

        case ACPI_TYPE_STRING:

                /* Result of two Strings is a String */

                return_desc = acpi_ut_create_internal_object (ACPI_TYPE_STRING);

                if (!return_desc) {

                        return (AE_NO_MEMORY);

                }

                /* Operand0 is string  */

                new_buf = ACPI_MEM_CALLOCATE ((acpi_size) obj_desc1->string.length +

                                   (acpi_size) obj_desc2->string.length + 1);

                if (!new_buf) {

                        ACPI_REPORT_ERROR

                                (("ex_do_concatenate: String allocation failure\n"));

                        status = AE_NO_MEMORY;

                        goto cleanup;

                }

                /* Concatenate the strings */

                ACPI_STRCPY (new_buf, obj_desc1->string.pointer);

                ACPI_STRCPY (new_buf + obj_desc1->string.length,

                                  obj_desc2->string.pointer);

                /* Complete the String object initialization */

                return_desc->string.pointer = new_buf;

                return_desc->string.length = obj_desc1->string.length +

                                   obj_desc2->string.length;

                break;

        case ACPI_TYPE_BUFFER:

                /* Result of two Buffers is a Buffer */

                return_desc = acpi_ut_create_buffer_object (

                                   (acpi_size) obj_desc1->buffer.length +

                                   (acpi_size) obj_desc2->buffer.length);

                if (!return_desc) {

                        return (AE_NO_MEMORY);

                }

                new_buf = (char *) return_desc->buffer.pointer;

                /* Concatenate the buffers */

                ACPI_MEMCPY (new_buf, obj_desc1->buffer.pointer,

                                  obj_desc1->buffer.length);

                ACPI_MEMCPY (new_buf + obj_desc1->buffer.length, obj_desc2->buffer.pointer,

                                   obj_desc2->buffer.length);

                break;

        default:

                /* Invalid object type, should not happen here */

                ACPI_REPORT_ERROR (("Concat - invalid obj type: %X\n",

                                ACPI_GET_OBJECT_TYPE (obj_desc1)));

                status = AE_AML_INTERNAL;

                return_desc = NULL;

        }

        *actual_return_desc = return_desc;

        return (AE_OK);

cleanup:

        acpi_ut_remove_reference (return_desc);

        return (status);

}

/*******************************************************************************

 *

 * FUNCTION:    acpi_ex_do_math_op

 *

 * PARAMETERS:  Opcode              - AML opcode

 *              Operand0            - Integer operand #0

 *              Operand1            - Integer operand #1

 *

 * RETURN:      Integer result of the operation

 *

 * DESCRIPTION: Execute a math AML opcode. The purpose of having all of the

 *              math functions here is to prevent a lot of pointer dereferencing

 *              to obtain the operands.

 *

 ******************************************************************************/

acpi_integer

acpi_ex_do_math_op (

        u16                             opcode,

        acpi_integer                    operand0,

        acpi_integer                    operand1)

{

        switch (opcode) {

        case AML_ADD_OP:                /* Add (Operand0, Operand1, Result) */

                return (operand0 + operand1);

        case AML_BIT_AND_OP:            /* And (Operand0, Operand1, Result) */

                return (operand0 & operand1);

        case AML_BIT_NAND_OP:           /* NAnd (Operand0, Operand1, Result) */

                return (~(operand0 & operand1));

        case AML_BIT_OR_OP:             /* Or (Operand0, Operand1, Result) */

                return (operand0 | operand1);

        case AML_BIT_NOR_OP:            /* NOr (Operand0, Operand1, Result) */

                return (~(operand0 | operand1));

        case AML_BIT_XOR_OP:            /* XOr (Operand0, Operand1, Result) */

                return (operand0 ^ operand1);

        case AML_MULTIPLY_OP:           /* Multiply (Operand0, Operand1, Result) */

                return (operand0 * operand1);

        case AML_SHIFT_LEFT_OP:         /* shift_left (Operand, shift_count, Result) */

                return (operand0 << operand1);

        case AML_SHIFT_RIGHT_OP:        /* shift_right (Operand, shift_count, Result) */

                return (operand0 >> operand1);

        case AML_SUBTRACT_OP:           /* Subtract (Operand0, Operand1, Result) */

                return (operand0 - operand1);

        default:

                return (0);

        }

}

/*******************************************************************************

 *

 * FUNCTION:    acpi_ex_do_logical_op

 *

 * PARAMETERS:  Opcode              - AML opcode

 *              Operand0            - Integer operand #0

 *              Operand1            - Integer operand #1

 *

 * RETURN:      TRUE/FALSE result of the operation

 *

 * DESCRIPTION: Execute a logical AML opcode. The purpose of having all of the

 *              functions here is to prevent a lot of pointer dereferencing

 *              to obtain the operands and to simplify the generation of the

 *              logical value.

 *

 *              Note: cleanest machine code seems to be produced by the code

 *              below, rather than using statements of the form:

 *                  Result = (Operand0 == Operand1);

 *

 ******************************************************************************/

u8

acpi_ex_do_logical_op (

        u16                             opcode,

        acpi_integer                    operand0,

        acpi_integer                    operand1)

{

        switch (opcode) {

        case AML_LAND_OP:               /* LAnd (Operand0, Operand1) */

                if (operand0 && operand1) {

                        return (TRUE);

                }

                break;

        case AML_LEQUAL_OP:             /* LEqual (Operand0, Operand1) */

                if (operand0 == operand1) {

                        return (TRUE);

                }

                break;

        case AML_LGREATER_OP:           /* LGreater (Operand0, Operand1) */

                if (operand0 > operand1) {

                        return (TRUE);

                }

                break;

        case AML_LLESS_OP:              /* LLess (Operand0, Operand1) */

                if (operand0 < operand1) {

                        return (TRUE);

                }

                break;

        case AML_LOR_OP:                 /* LOr (Operand0, Operand1) */

                if (operand0 || operand1) {

                        return (TRUE);

                }

                break;

        default:

                break;

        }

        return (FALSE);

}