2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* Module Name: exprep - ACPI AML (p-code) execution - field prep utilities
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
/*
|
2006-01-14 05:22:00 +08:00
|
|
|
* Copyright (C) 2000 - 2006, R. Byron Moore
|
2005-04-17 06:20:36 +08:00
|
|
|
* 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>
|
|
|
|
#include <acpi/acnamesp.h>
|
|
|
|
|
|
|
|
#define _COMPONENT ACPI_EXECUTER
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_MODULE_NAME("exprep")
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-04-19 10:49:35 +08:00
|
|
|
/* Local prototypes */
|
|
|
|
static u32
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ex_decode_field_access(union acpi_operand_object *obj_desc,
|
|
|
|
u8 field_flags, u32 * return_byte_alignment);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#ifdef ACPI_UNDER_DEVELOPMENT
|
2005-04-19 10:49:35 +08:00
|
|
|
|
|
|
|
static u32
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ex_generate_access(u32 field_bit_offset,
|
|
|
|
u32 field_bit_length, u32 region_length);
|
2005-04-19 10:49:35 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_ex_generate_access
|
|
|
|
*
|
|
|
|
* PARAMETERS: field_bit_offset - Start of field within parent region/buffer
|
|
|
|
* field_bit_length - Length of field in bits
|
|
|
|
* region_length - Length of parent in bytes
|
|
|
|
*
|
|
|
|
* RETURN: Field granularity (8, 16, 32 or 64) and
|
|
|
|
* byte_alignment (1, 2, 3, or 4)
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Generate an optimal access width for fields defined with the
|
|
|
|
* any_acc keyword.
|
|
|
|
*
|
|
|
|
* NOTE: Need to have the region_length in order to check for boundary
|
|
|
|
* conditions (end-of-region). However, the region_length is a deferred
|
|
|
|
* operation. Therefore, to complete this implementation, the generation
|
|
|
|
* of this access width must be deferred until the region length has
|
|
|
|
* been evaluated.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
static u32
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ex_generate_access(u32 field_bit_offset,
|
|
|
|
u32 field_bit_length, u32 region_length)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-08-05 12:44:28 +08:00
|
|
|
u32 field_byte_length;
|
|
|
|
u32 field_byte_offset;
|
|
|
|
u32 field_byte_end_offset;
|
|
|
|
u32 access_byte_width;
|
|
|
|
u32 field_start_offset;
|
|
|
|
u32 field_end_offset;
|
|
|
|
u32 minimum_access_width = 0xFFFFFFFF;
|
|
|
|
u32 minimum_accesses = 0xFFFFFFFF;
|
|
|
|
u32 accesses;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("ex_generate_access");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Round Field start offset and length to "minimal" byte boundaries */
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
field_byte_offset = ACPI_DIV_8(ACPI_ROUND_DOWN(field_bit_offset, 8));
|
|
|
|
field_byte_end_offset = ACPI_DIV_8(ACPI_ROUND_UP(field_bit_length +
|
|
|
|
field_bit_offset, 8));
|
|
|
|
field_byte_length = field_byte_end_offset - field_byte_offset;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"Bit length %d, Bit offset %d\n",
|
|
|
|
field_bit_length, field_bit_offset));
|
2005-04-19 10:49:35 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"Byte Length %d, Byte Offset %d, End Offset %d\n",
|
|
|
|
field_byte_length, field_byte_offset,
|
|
|
|
field_byte_end_offset));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Iterative search for the maximum access width that is both aligned
|
|
|
|
* and does not go beyond the end of the region
|
|
|
|
*
|
|
|
|
* Start at byte_acc and work upwards to qword_acc max. (1,2,4,8 bytes)
|
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
for (access_byte_width = 1; access_byte_width <= 8;
|
|
|
|
access_byte_width <<= 1) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2005-04-19 10:49:35 +08:00
|
|
|
* 1) Round end offset up to next access boundary and make sure that
|
|
|
|
* this does not go beyond the end of the parent region.
|
|
|
|
* 2) When the Access width is greater than the field_byte_length, we
|
|
|
|
* are done. (This does not optimize for the perfectly aligned
|
|
|
|
* case yet).
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
if (ACPI_ROUND_UP(field_byte_end_offset, access_byte_width) <=
|
|
|
|
region_length) {
|
2005-04-19 10:49:35 +08:00
|
|
|
field_start_offset =
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_ROUND_DOWN(field_byte_offset,
|
|
|
|
access_byte_width) /
|
|
|
|
access_byte_width;
|
2005-04-19 10:49:35 +08:00
|
|
|
|
|
|
|
field_end_offset =
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_ROUND_UP((field_byte_length +
|
|
|
|
field_byte_offset),
|
|
|
|
access_byte_width) /
|
|
|
|
access_byte_width;
|
2005-04-19 10:49:35 +08:00
|
|
|
|
|
|
|
accesses = field_end_offset - field_start_offset;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"access_width %d end is within region\n",
|
|
|
|
access_byte_width));
|
2005-04-19 10:49:35 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"Field Start %d, Field End %d -- requires %d accesses\n",
|
|
|
|
field_start_offset, field_end_offset,
|
|
|
|
accesses));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Single access is optimal */
|
|
|
|
|
|
|
|
if (accesses <= 1) {
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"Entire field can be accessed with one operation of size %d\n",
|
|
|
|
access_byte_width));
|
|
|
|
return_VALUE(access_byte_width);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fits in the region, but requires more than one read/write.
|
|
|
|
* try the next wider access on next iteration
|
|
|
|
*/
|
|
|
|
if (accesses < minimum_accesses) {
|
2005-08-05 12:44:28 +08:00
|
|
|
minimum_accesses = accesses;
|
2005-04-17 06:20:36 +08:00
|
|
|
minimum_access_width = access_byte_width;
|
|
|
|
}
|
2005-08-05 12:44:28 +08:00
|
|
|
} else {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"access_width %d end is NOT within region\n",
|
|
|
|
access_byte_width));
|
2005-04-17 06:20:36 +08:00
|
|
|
if (access_byte_width == 1) {
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"Field goes beyond end-of-region!\n"));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-04-19 10:49:35 +08:00
|
|
|
/* Field does not fit in the region at all */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
return_VALUE(0);
|
2005-04-19 10:49:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This width goes beyond the end-of-region, back off to
|
|
|
|
* previous access
|
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"Backing off to previous optimal access width of %d\n",
|
|
|
|
minimum_access_width));
|
|
|
|
return_VALUE(minimum_access_width);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-19 10:49:35 +08:00
|
|
|
/*
|
|
|
|
* Could not read/write field with one operation,
|
|
|
|
* just use max access width
|
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"Cannot access field in one operation, using width 8\n"));
|
|
|
|
return_VALUE(8);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2005-08-05 12:44:28 +08:00
|
|
|
#endif /* ACPI_UNDER_DEVELOPMENT */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_ex_decode_field_access
|
|
|
|
*
|
2005-04-19 10:49:35 +08:00
|
|
|
* PARAMETERS: obj_desc - Field object
|
|
|
|
* field_flags - Encoded fieldflags (contains access bits)
|
|
|
|
* return_byte_alignment - Where the byte alignment is returned
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* RETURN: Field granularity (8, 16, 32 or 64) and
|
|
|
|
* byte_alignment (1, 2, 3, or 4)
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Decode the access_type bits of a field definition.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
static u32
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ex_decode_field_access(union acpi_operand_object *obj_desc,
|
|
|
|
u8 field_flags, u32 * return_byte_alignment)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-08-05 12:44:28 +08:00
|
|
|
u32 access;
|
|
|
|
u32 byte_alignment;
|
|
|
|
u32 bit_length;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_FUNCTION_TRACE("ex_decode_field_access");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
access = (field_flags & AML_FIELD_ACCESS_TYPE_MASK);
|
|
|
|
|
|
|
|
switch (access) {
|
|
|
|
case AML_FIELD_ACCESS_ANY:
|
|
|
|
|
|
|
|
#ifdef ACPI_UNDER_DEVELOPMENT
|
2005-04-19 10:49:35 +08:00
|
|
|
byte_alignment =
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ex_generate_access(obj_desc->common_field.
|
|
|
|
start_field_bit_offset,
|
|
|
|
obj_desc->common_field.bit_length,
|
|
|
|
0xFFFFFFFF
|
|
|
|
/* Temp until we pass region_length as parameter */
|
|
|
|
);
|
2005-04-17 06:20:36 +08:00
|
|
|
bit_length = byte_alignment * 8;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
byte_alignment = 1;
|
|
|
|
bit_length = 8;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AML_FIELD_ACCESS_BYTE:
|
2005-08-05 12:44:28 +08:00
|
|
|
case AML_FIELD_ACCESS_BUFFER: /* ACPI 2.0 (SMBus Buffer) */
|
2005-04-17 06:20:36 +08:00
|
|
|
byte_alignment = 1;
|
2005-08-05 12:44:28 +08:00
|
|
|
bit_length = 8;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case AML_FIELD_ACCESS_WORD:
|
|
|
|
byte_alignment = 2;
|
2005-08-05 12:44:28 +08:00
|
|
|
bit_length = 16;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case AML_FIELD_ACCESS_DWORD:
|
|
|
|
byte_alignment = 4;
|
2005-08-05 12:44:28 +08:00
|
|
|
bit_length = 32;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
case AML_FIELD_ACCESS_QWORD: /* ACPI 2.0 */
|
2005-04-17 06:20:36 +08:00
|
|
|
byte_alignment = 8;
|
2005-08-05 12:44:28 +08:00
|
|
|
bit_length = 64;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/* Invalid field access type */
|
|
|
|
|
2006-01-28 05:43:00 +08:00
|
|
|
ACPI_ERROR((AE_INFO, "Unknown field access type %X", access));
|
[ACPI] ACPICA 20050930
Completed a major overhaul of the Resource Manager code -
specifically, optimizations in the area of the AML/internal
resource conversion code. The code has been optimized to
simplify and eliminate duplicated code, CPU stack use has
been decreased by optimizing function parameters and local
variables, and naming conventions across the manager have
been standardized for clarity and ease of maintenance (this
includes function, parameter, variable, and struct/typedef
names.)
All Resource Manager dispatch and information tables have
been moved to a single location for clarity and ease of
maintenance. One new file was created, named "rsinfo.c".
The ACPI return macros (return_ACPI_STATUS, etc.) have
been modified to guarantee that the argument is
not evaluated twice, making them less prone to macro
side-effects. However, since there exists the possibility
of additional stack use if a particular compiler cannot
optimize them (such as in the debug generation case),
the original macros are optionally available. Note that
some invocations of the return_VALUE macro may now cause
size mismatch warnings; the return_UINT8 and return_UINT32
macros are provided to eliminate these. (From Randy Dunlap)
Implemented a new mechanism to enable debug tracing for
individual control methods. A new external interface,
acpi_debug_trace(), is provided to enable this mechanism. The
intent is to allow the host OS to easily enable and disable
tracing for problematic control methods. This interface
can be easily exposed to a user or debugger interface if
desired. See the file psxface.c for details.
acpi_ut_callocate() will now return a valid pointer if a
length of zero is specified - a length of one is used
and a warning is issued. This matches the behavior of
acpi_ut_allocate().
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2005-10-01 07:03:00 +08:00
|
|
|
return_UINT32(0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_BUFFER_FIELD) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* buffer_field access can be on any byte boundary, so the
|
|
|
|
* byte_alignment is always 1 byte -- regardless of any byte_alignment
|
|
|
|
* implied by the field access type.
|
|
|
|
*/
|
|
|
|
byte_alignment = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*return_byte_alignment = byte_alignment;
|
[ACPI] ACPICA 20050930
Completed a major overhaul of the Resource Manager code -
specifically, optimizations in the area of the AML/internal
resource conversion code. The code has been optimized to
simplify and eliminate duplicated code, CPU stack use has
been decreased by optimizing function parameters and local
variables, and naming conventions across the manager have
been standardized for clarity and ease of maintenance (this
includes function, parameter, variable, and struct/typedef
names.)
All Resource Manager dispatch and information tables have
been moved to a single location for clarity and ease of
maintenance. One new file was created, named "rsinfo.c".
The ACPI return macros (return_ACPI_STATUS, etc.) have
been modified to guarantee that the argument is
not evaluated twice, making them less prone to macro
side-effects. However, since there exists the possibility
of additional stack use if a particular compiler cannot
optimize them (such as in the debug generation case),
the original macros are optionally available. Note that
some invocations of the return_VALUE macro may now cause
size mismatch warnings; the return_UINT8 and return_UINT32
macros are provided to eliminate these. (From Randy Dunlap)
Implemented a new mechanism to enable debug tracing for
individual control methods. A new external interface,
acpi_debug_trace(), is provided to enable this mechanism. The
intent is to allow the host OS to easily enable and disable
tracing for problematic control methods. This interface
can be easily exposed to a user or debugger interface if
desired. See the file psxface.c for details.
acpi_ut_callocate() will now return a valid pointer if a
length of zero is specified - a length of one is used
and a warning is issued. This matches the behavior of
acpi_ut_allocate().
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2005-10-01 07:03:00 +08:00
|
|
|
return_UINT32(bit_length);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_ex_prep_common_field_object
|
|
|
|
*
|
|
|
|
* PARAMETERS: obj_desc - The field object
|
|
|
|
* field_flags - Access, lock_rule, and update_rule.
|
|
|
|
* The format of a field_flag is described
|
|
|
|
* in the ACPI specification
|
2005-04-19 10:49:35 +08:00
|
|
|
* field_attribute - Special attributes (not used)
|
2005-04-17 06:20:36 +08:00
|
|
|
* field_bit_position - Field start position
|
|
|
|
* field_bit_length - Field length in number of bits
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Initialize the areas of the field object that are common
|
|
|
|
* to the various types of fields. Note: This is very "sensitive"
|
|
|
|
* code because we are solving the general case for field
|
|
|
|
* alignment.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
acpi_status
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ex_prep_common_field_object(union acpi_operand_object *obj_desc,
|
|
|
|
u8 field_flags,
|
|
|
|
u8 field_attribute,
|
|
|
|
u32 field_bit_position, u32 field_bit_length)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-08-05 12:44:28 +08:00
|
|
|
u32 access_bit_width;
|
|
|
|
u32 byte_alignment;
|
|
|
|
u32 nearest_byte_address;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_FUNCTION_TRACE("ex_prep_common_field_object");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: the structure being initialized is the
|
|
|
|
* ACPI_COMMON_FIELD_INFO; No structure fields outside of the common
|
|
|
|
* area are initialized by this procedure.
|
|
|
|
*/
|
|
|
|
obj_desc->common_field.field_flags = field_flags;
|
|
|
|
obj_desc->common_field.attribute = field_attribute;
|
|
|
|
obj_desc->common_field.bit_length = field_bit_length;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode the access type so we can compute offsets. The access type gives
|
|
|
|
* two pieces of information - the width of each field access and the
|
|
|
|
* necessary byte_alignment (address granularity) of the access.
|
|
|
|
*
|
|
|
|
* For any_acc, the access_bit_width is the largest width that is both
|
|
|
|
* necessary and possible in an attempt to access the whole field in one
|
|
|
|
* I/O operation. However, for any_acc, the byte_alignment is always one
|
|
|
|
* byte.
|
|
|
|
*
|
|
|
|
* For all Buffer Fields, the byte_alignment is always one byte.
|
|
|
|
*
|
|
|
|
* For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
|
|
|
|
* the same (equivalent) as the byte_alignment.
|
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
access_bit_width = acpi_ex_decode_field_access(obj_desc, field_flags,
|
|
|
|
&byte_alignment);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!access_bit_width) {
|
2005-08-05 12:44:28 +08:00
|
|
|
return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Setup width (access granularity) fields */
|
|
|
|
|
|
|
|
obj_desc->common_field.access_byte_width = (u8)
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DIV_8(access_bit_width); /* 1, 2, 4, 8 */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
obj_desc->common_field.access_bit_width = (u8) access_bit_width;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* base_byte_offset is the address of the start of the field within the
|
|
|
|
* region. It is the byte address of the first *datum* (field-width data
|
|
|
|
* unit) of the field. (i.e., the first datum that contains at least the
|
|
|
|
* first *bit* of the field.)
|
|
|
|
*
|
|
|
|
* Note: byte_alignment is always either equal to the access_bit_width or 8
|
|
|
|
* (Byte access), and it defines the addressing granularity of the parent
|
|
|
|
* region or buffer.
|
|
|
|
*/
|
|
|
|
nearest_byte_address =
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_ROUND_BITS_DOWN_TO_BYTES(field_bit_position);
|
2005-04-17 06:20:36 +08:00
|
|
|
obj_desc->common_field.base_byte_offset = (u32)
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_ROUND_DOWN(nearest_byte_address, byte_alignment);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* start_field_bit_offset is the offset of the first bit of the field within
|
|
|
|
* a field datum.
|
|
|
|
*/
|
|
|
|
obj_desc->common_field.start_field_bit_offset = (u8)
|
2005-08-05 12:44:28 +08:00
|
|
|
(field_bit_position -
|
|
|
|
ACPI_MUL_8(obj_desc->common_field.base_byte_offset));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Does the entire field fit within a single field access element? (datum)
|
|
|
|
* (i.e., without crossing a datum boundary)
|
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
if ((obj_desc->common_field.start_field_bit_offset +
|
|
|
|
field_bit_length) <= (u16) access_bit_width) {
|
2005-04-17 06:20:36 +08:00
|
|
|
obj_desc->common.flags |= AOPOBJ_SINGLE_DATUM;
|
|
|
|
}
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
return_ACPI_STATUS(AE_OK);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_ex_prep_field_value
|
|
|
|
*
|
2005-04-19 10:49:35 +08:00
|
|
|
* PARAMETERS: Info - Contains all field creation info
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Construct an union acpi_operand_object of type def_field and
|
|
|
|
* connect it to the parent Node.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_status acpi_ex_prep_field_value(struct acpi_create_field_info *info)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-08-05 12:44:28 +08:00
|
|
|
union acpi_operand_object *obj_desc;
|
|
|
|
u32 type;
|
|
|
|
acpi_status status;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_FUNCTION_TRACE("ex_prep_field_value");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Parameter validation */
|
|
|
|
|
|
|
|
if (info->field_type != ACPI_TYPE_LOCAL_INDEX_FIELD) {
|
|
|
|
if (!info->region_node) {
|
2006-01-28 05:43:00 +08:00
|
|
|
ACPI_ERROR((AE_INFO, "Null region_node"));
|
2005-08-05 12:44:28 +08:00
|
|
|
return_ACPI_STATUS(AE_AML_NO_OPERAND);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
type = acpi_ns_get_type(info->region_node);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (type != ACPI_TYPE_REGION) {
|
2006-01-28 05:43:00 +08:00
|
|
|
ACPI_ERROR((AE_INFO,
|
|
|
|
"Needed Region, found type %X (%s)",
|
|
|
|
type, acpi_ut_get_type_name(type)));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a new field object */
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
obj_desc = acpi_ut_create_internal_object(info->field_type);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!obj_desc) {
|
2005-08-05 12:44:28 +08:00
|
|
|
return_ACPI_STATUS(AE_NO_MEMORY);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize areas of the object that are common to all fields */
|
|
|
|
|
|
|
|
obj_desc->common_field.node = info->field_node;
|
2005-08-05 12:44:28 +08:00
|
|
|
status = acpi_ex_prep_common_field_object(obj_desc, info->field_flags,
|
|
|
|
info->attribute,
|
|
|
|
info->field_bit_position,
|
|
|
|
info->field_bit_length);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
acpi_ut_delete_object_desc(obj_desc);
|
|
|
|
return_ACPI_STATUS(status);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize areas of the object that are specific to the field type */
|
|
|
|
|
|
|
|
switch (info->field_type) {
|
|
|
|
case ACPI_TYPE_LOCAL_REGION_FIELD:
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
obj_desc->field.region_obj =
|
|
|
|
acpi_ns_get_attached_object(info->region_node);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* An additional reference for the container */
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ut_add_reference(obj_desc->field.region_obj);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"region_field: bit_off %X, Off %X, Gran %X, Region %p\n",
|
|
|
|
obj_desc->field.start_field_bit_offset,
|
|
|
|
obj_desc->field.base_byte_offset,
|
|
|
|
obj_desc->field.access_byte_width,
|
|
|
|
obj_desc->field.region_obj));
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_TYPE_LOCAL_BANK_FIELD:
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
obj_desc->bank_field.value = info->bank_value;
|
|
|
|
obj_desc->bank_field.region_obj =
|
|
|
|
acpi_ns_get_attached_object(info->region_node);
|
|
|
|
obj_desc->bank_field.bank_obj =
|
|
|
|
acpi_ns_get_attached_object(info->register_node);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* An additional reference for the attached objects */
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ut_add_reference(obj_desc->bank_field.region_obj);
|
|
|
|
acpi_ut_add_reference(obj_desc->bank_field.bank_obj);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"Bank Field: bit_off %X, Off %X, Gran %X, Region %p, bank_reg %p\n",
|
|
|
|
obj_desc->bank_field.start_field_bit_offset,
|
|
|
|
obj_desc->bank_field.base_byte_offset,
|
|
|
|
obj_desc->field.access_byte_width,
|
|
|
|
obj_desc->bank_field.region_obj,
|
|
|
|
obj_desc->bank_field.bank_obj));
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_TYPE_LOCAL_INDEX_FIELD:
|
|
|
|
|
2006-01-28 05:43:00 +08:00
|
|
|
/* Get the Index and Data registers */
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
obj_desc->index_field.index_obj =
|
|
|
|
acpi_ns_get_attached_object(info->register_node);
|
|
|
|
obj_desc->index_field.data_obj =
|
|
|
|
acpi_ns_get_attached_object(info->data_register_node);
|
|
|
|
|
|
|
|
if (!obj_desc->index_field.data_obj
|
|
|
|
|| !obj_desc->index_field.index_obj) {
|
2006-01-28 05:43:00 +08:00
|
|
|
ACPI_ERROR((AE_INFO,
|
|
|
|
"Null Index Object during field prep"));
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ut_delete_object_desc(obj_desc);
|
|
|
|
return_ACPI_STATUS(AE_AML_INTERNAL);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* An additional reference for the attached objects */
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ut_add_reference(obj_desc->index_field.data_obj);
|
|
|
|
acpi_ut_add_reference(obj_desc->index_field.index_obj);
|
|
|
|
|
2006-01-28 05:43:00 +08:00
|
|
|
/*
|
|
|
|
* The value written to the Index register is the byte offset of the
|
|
|
|
* target field
|
|
|
|
* Note: may change code to: ACPI_DIV_8 (Info->field_bit_position)
|
|
|
|
*/
|
|
|
|
obj_desc->index_field.value = (u32)
|
|
|
|
(info->field_bit_position /
|
|
|
|
ACPI_MUL_8(obj_desc->field.access_byte_width));
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"index_field: bit_off %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n",
|
|
|
|
obj_desc->index_field.start_field_bit_offset,
|
|
|
|
obj_desc->index_field.base_byte_offset,
|
|
|
|
obj_desc->index_field.value,
|
|
|
|
obj_desc->field.access_byte_width,
|
|
|
|
obj_desc->index_field.index_obj,
|
|
|
|
obj_desc->index_field.data_obj));
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/* No other types should get here */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Store the constructed descriptor (obj_desc) into the parent Node,
|
|
|
|
* preserving the current type of that named_obj.
|
|
|
|
*/
|
2005-08-05 12:44:28 +08:00
|
|
|
status = acpi_ns_attach_object(info->field_node, obj_desc,
|
|
|
|
acpi_ns_get_type(info->field_node));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
|
|
|
|
"Set named_obj %p [%4.4s], obj_desc %p\n",
|
|
|
|
info->field_node,
|
|
|
|
acpi_ut_get_node_name(info->field_node), obj_desc));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Remove local reference to the object */
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
acpi_ut_remove_reference(obj_desc);
|
|
|
|
return_ACPI_STATUS(status);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|