Viewing file:  exprep.c (11.86 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/******************************************************************************
*
* Module Name: exprep - ACPI AML (p-code) execution - field prep utilities
* $Revision: 99 $
*
*****************************************************************************/
/*
* Copyright (C) 2000, 2001 R. Byron Moore
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "acpi.h"
#include "acinterp.h"
#include "amlcode.h"
#include "acnamesp.h"
#include "acparser.h"
#define _COMPONENT ACPI_EXECUTER
MODULE_NAME ("exprep")
/*******************************************************************************
*
* FUNCTION: Acpi_ex_decode_field_access_type
*
* PARAMETERS: Access - Encoded field access bits
* Length - Field length.
*
* RETURN: Field granularity (8, 16, 32 or 64)
*
* DESCRIPTION: Decode the Access_type bits of a field definition.
*
******************************************************************************/
static u32
acpi_ex_decode_field_access_type (
u32 access,
u16 length,
u32 *alignment)
{
PROC_NAME ("Ex_decode_field_access_type");
switch (access) {
case ACCESS_ANY_ACC:
*alignment = 8;
/* Use the length to set the access type */
if (length <= 8) {
return (8);
}
else if (length <= 16) {
return (16);
}
else if (length <= 32) {
return (32);
}
else if (length <= 64) {
return (64);
}
/* Default is 8 (byte) */
return (8);
break;
case ACCESS_BYTE_ACC:
*alignment = 8;
return (8);
break;
case ACCESS_WORD_ACC:
*alignment = 16;
return (16);
break;
case ACCESS_DWORD_ACC:
*alignment = 32;
return (32);
break;
case ACCESS_QWORD_ACC: /* ACPI 2.0 */
*alignment = 64;
return (64);
break;
default:
/* Invalid field access type */
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Unknown field access type %x\n",
access));
return (0);
}
}
/*******************************************************************************
*
* 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
* 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.
*
******************************************************************************/
acpi_status
acpi_ex_prep_common_field_object (
acpi_operand_object *obj_desc,
u8 field_flags,
u32 field_bit_position,
u32 field_bit_length)
{
u32 access_bit_width;
u32 alignment;
u32 nearest_byte_address;
FUNCTION_TRACE ("Ex_prep_common_field_object");
/*
* Note: the structure being initialized is the
* ACPI_COMMON_FIELD_INFO; No structure fields outside of the common area
* are initialized by this procedure.
*/
/* Demultiplex the Field_flags byte */
obj_desc->common_field.lock_rule = (u8) ((field_flags & LOCK_RULE_MASK)
>> LOCK_RULE_SHIFT);
obj_desc->common_field.update_rule = (u8) ((field_flags & UPDATE_RULE_MASK)
>> UPDATE_RULE_SHIFT);
/* Other misc fields */
obj_desc->common_field.bit_length = (u16) 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 alignment of the access. For Any_acc, the width used is the
* largest necessary/possible in an attempt to access the whole field in one
* I/O operation. However, for Any_acc, the alignment is 8. For all other
* access types (Byte, Word, Dword, Qword), the width is the same as the
* alignment.
*/
access_bit_width = acpi_ex_decode_field_access_type (
((field_flags & ACCESS_TYPE_MASK) >> ACCESS_TYPE_SHIFT),
obj_desc->field.bit_length, &alignment);
if (!access_bit_width) {
return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
}
/* Setup width (access granularity) fields */
obj_desc->common_field.access_bit_width = (u8) access_bit_width; /* 8, 16, 32, 64 */
obj_desc->common_field.access_byte_width = (u8) DIV_8 (access_bit_width); /* 1, 2, 4, 8 */
if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
/*
* Buffer_field access can be on any byte boundary, so the
* alignment is always 8 (regardless of any alignment implied by the
* field access type.)
*/
alignment = 8;
}
/*
* 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.)
*/
nearest_byte_address = ROUND_BITS_DOWN_TO_BYTES (field_bit_position);
obj_desc->common_field.base_byte_offset = ROUND_DOWN (nearest_byte_address,
DIV_8 (alignment));
/*
* Start_field_bit_offset is the offset of the first bit of the field within a field datum.
* This is calculated as the number of bits from the Base_byte_offset. In other words,
* the start of the field is relative to a byte address, regardless of the access type
* of the field.
*/
obj_desc->common_field.start_field_bit_offset = (u8) (MOD_8 (field_bit_position));
/*
* Datum_valid_bits is the number of valid field bits in the first field datum.
*/
obj_desc->common_field.datum_valid_bits = (u8) (access_bit_width -
obj_desc->common_field.start_field_bit_offset);
/*
* Valid bits -- the number of bits that compose a partial datum,
* 1) At the end of the field within the region (arbitrary starting bit offset)
* 2) At the end of a buffer used to contain the field (starting offset always zero)
*/
obj_desc->common_field.end_field_valid_bits = (u8) ((obj_desc->common_field.start_field_bit_offset +
field_bit_length) % access_bit_width);
obj_desc->common_field.end_buffer_valid_bits = (u8) (field_bit_length % access_bit_width); /* Start_buffer_bit_offset always = 0 */
/*
* Does the entire field fit within a single field access element
* (datum)? (without crossing a datum boundary)
*/
if ((obj_desc->common_field.start_field_bit_offset + obj_desc->common_field.bit_length) <=
(u16) obj_desc->common_field.access_bit_width) {
obj_desc->common_field.access_flags |= AFIELD_SINGLE_DATUM;
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: Acpi_ex_prep_field_value
*
* PARAMETERS: Node - Owning Node
* Region_node - Region in which field is being defined
* Field_flags - Access, Lock_rule, and Update_rule.
* Field_bit_position - Field start position
* Field_bit_length - Field length in number of bits
*
* RETURN: Status
*
* DESCRIPTION: Construct an acpi_operand_object of type Def_field and
* connect it to the parent Node.
*
******************************************************************************/
acpi_status
acpi_ex_prep_field_value (
ACPI_CREATE_FIELD_INFO *info)
{
acpi_operand_object *obj_desc;
u32 type;
acpi_status status;
FUNCTION_TRACE ("Ex_prep_field_value");
/* Parameter validation */
if (info->field_type != INTERNAL_TYPE_INDEX_FIELD) {
if (!info->region_node) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Region_node\n"));
return_ACPI_STATUS (AE_AML_NO_OPERAND);
}
type = acpi_ns_get_type (info->region_node);
if (type != ACPI_TYPE_REGION) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Needed Region, found type %X %s\n",
type, acpi_ut_get_type_name (type)));
return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
}
}
/* Allocate a new region object */
obj_desc = acpi_ut_create_internal_object (info->field_type);
if (!obj_desc) {
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Initialize areas of the object that are common to all fields */
status = acpi_ex_prep_common_field_object (obj_desc, info->field_flags,
info->field_bit_position, info->field_bit_length);
if (ACPI_FAILURE (status)) {
acpi_ut_delete_object_desc (obj_desc);
return_ACPI_STATUS (status);
}
/* Initialize areas of the object that are specific to the field type */
switch (info->field_type) {
case INTERNAL_TYPE_REGION_FIELD:
obj_desc->field.region_obj = acpi_ns_get_attached_object (info->region_node);
/* An additional reference for the container */
acpi_ut_add_reference (obj_desc->field.region_obj);
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Region_field: Bitoff=%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_bit_width, obj_desc->field.region_obj));
break;
case INTERNAL_TYPE_BANK_FIELD:
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_register_obj = acpi_ns_get_attached_object (info->register_node);
/* An additional reference for the attached objects */
acpi_ut_add_reference (obj_desc->bank_field.region_obj);
acpi_ut_add_reference (obj_desc->bank_field.bank_register_obj);
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "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_bit_width, obj_desc->bank_field.region_obj,
obj_desc->bank_field.bank_register_obj));
break;
case INTERNAL_TYPE_INDEX_FIELD:
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);
obj_desc->index_field.value = (u32) (info->field_bit_position /
obj_desc->field.access_bit_width);
if (!obj_desc->index_field.data_obj || !obj_desc->index_field.index_obj) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Index Object\n"));
return_ACPI_STATUS (AE_AML_INTERNAL);
}
/* An additional reference for the attached objects */
acpi_ut_add_reference (obj_desc->index_field.data_obj);
acpi_ut_add_reference (obj_desc->index_field.index_obj);
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Index_field: bitoff=%X off=%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->field.access_bit_width, obj_desc->index_field.index_obj,
obj_desc->index_field.data_obj));
break;
}
/*
* Store the constructed descriptor (Obj_desc) into the parent Node,
* preserving the current type of that Named_obj.
*/
status = acpi_ns_attach_object (info->field_node, obj_desc,
(u8) acpi_ns_get_type (info->field_node));
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "set Named_obj %p (%4.4s) val = %p\n",
info->field_node, (char*)&(info->field_node->name), obj_desc));
/* Remove local reference to the object */
acpi_ut_remove_reference (obj_desc);
return_ACPI_STATUS (status);
}
|