自学教程：C++ ACPI_DIV_8函数代码示例

static acpi_statusacpi_hw_validate_io_request(acpi_io_address address, u32 bit_width){	u32 i;	u32 byte_width;	acpi_io_address last_address;	const struct acpi_port_info *port_info;	ACPI_FUNCTION_TRACE(hw_validate_io_request);	/* Supported widths are 8/16/32 */	if ((bit_width != 8) && (bit_width != 16) && (bit_width != 32)) {		ACPI_ERROR((AE_INFO,			    "Bad BitWidth parameter: %8.8X", bit_width));		return AE_BAD_PARAMETER;	}	port_info = acpi_protected_ports;	byte_width = ACPI_DIV_8(bit_width);	last_address = address + byte_width - 1;	ACPI_DEBUG_PRINT((ACPI_DB_IO, "Address %p LastAddress %p Length %X",			  ACPI_CAST_PTR(void, address), ACPI_CAST_PTR(void,								      last_address),			  byte_width));	/* Maximum 16-bit address in I/O space */	if (last_address > ACPI_UINT16_MAX) {		ACPI_ERROR((AE_INFO,			    "Illegal I/O port address/length above 64K: %p/0x%X",			    ACPI_CAST_PTR(void, address), byte_width));		return_ACPI_STATUS(AE_LIMIT);	}

static ACPI_NAMESPACE_NODE *AcpiDmGetResourceNode (    ACPI_NAMESPACE_NODE     *BufferNode,    UINT32                  BitIndex){    ACPI_NAMESPACE_NODE     *Node;    UINT32                  ByteIndex = ACPI_DIV_8 (BitIndex);    /*     * Child list contains an entry for each resource descriptor. Find     * the descriptor that corresponds to the Index.     *     * If there are no children, this is not a resource template     */    Node = BufferNode->Child;    while (Node)    {        /*         * Check if the Index falls within this resource.         *         * Value contains the resource offset, Object contains the resource         * length (both in bytes)         */        if ((ByteIndex >= Node->Value) &&            (ByteIndex < (Node->Value + Node->Length)))        {            return (Node);        }        Node = Node->Peer;    }    return (NULL);}

acpi_statusacpi_ex_data_table_space_handler (	u32                             function,	acpi_physical_address           address,	u32                             bit_width,	acpi_integer                    *value,	void                            *handler_context,	void                            *region_context){	acpi_status                     status = AE_OK;	u32                             byte_width = ACPI_DIV_8 (bit_width);	u32                             i;	char                            *logical_addr_ptr;	ACPI_FUNCTION_TRACE ("ex_data_table_space_handler");	logical_addr_ptr = ACPI_PHYSADDR_TO_PTR (address);   /* Perform the memory read or write */	switch (function) {	case ACPI_READ:		for (i = 0; i < byte_width; i++) {			((char *) value) [i] = logical_addr_ptr[i];		}		break;	case ACPI_WRITE:	default:		return_ACPI_STATUS (AE_SUPPORT);	}	return_ACPI_STATUS (status);}

acpi_statusacpi_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){	u32 access_bit_width;	u32 byte_alignment;	u32 nearest_byte_address;	ACPI_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.	 */	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.	 */	access_bit_width = acpi_ex_decode_field_access(obj_desc, field_flags,						       &byte_alignment);	if (!access_bit_width) {		return_ACPI_STATUS(AE_AML_OPERAND_VALUE);	}	/* Setup width (access granularity) fields */	obj_desc->common_field.access_byte_width = (u8)	    ACPI_DIV_8(access_bit_width);	/* 1,  2,  4,  8 */	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 =	    ACPI_ROUND_BITS_DOWN_TO_BYTES(field_bit_position);	obj_desc->common_field.base_byte_offset = (u32)	    ACPI_ROUND_DOWN(nearest_byte_address, byte_alignment);	/*	 * 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)	    (field_bit_position -	     ACPI_MUL_8(obj_desc->common_field.base_byte_offset));	return_ACPI_STATUS(AE_OK);}

static u32acpi_ex_generate_access(u32 field_bit_offset,			u32 field_bit_length, u32 region_length){	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);	/*                                                                  */	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;	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,			  "Bit length %u, Bit offset %u/n",			  field_bit_length, field_bit_offset));	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,			  "Byte Length %u, Byte Offset %u, End Offset %u/n",			  field_byte_length, field_byte_offset,			  field_byte_end_offset));	/*                                                                                                                                                                                                   */	for (access_byte_width = 1; access_byte_width <= 8;	     access_byte_width <<= 1) {		/*                                                                                                                                                                                                                                                                                                  */		if (ACPI_ROUND_UP(field_byte_end_offset, access_byte_width) <=		    region_length) {			field_start_offset =			    ACPI_ROUND_DOWN(field_byte_offset,					    access_byte_width) /			    access_byte_width;			field_end_offset =			    ACPI_ROUND_UP((field_byte_length +					   field_byte_offset),					  access_byte_width) /			    access_byte_width;			accesses = field_end_offset - field_start_offset;			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,					  "AccessWidth %u end is within region/n",					  access_byte_width));			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,					  "Field Start %u, Field End %u -- requires %u accesses/n",					  field_start_offset, field_end_offset,					  accesses));			/*                          */			if (accesses <= 1) {				ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,						  "Entire field can be accessed with one operation of size %u/n",						  access_byte_width));				return_VALUE(access_byte_width);			}			/*                                                                                                                     */			if (accesses < minimum_accesses) {				minimum_accesses = accesses;				minimum_access_width = access_byte_width;			}		} else {			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,					  "AccessWidth %u end is NOT within region/n",					  access_byte_width));			if (access_byte_width == 1) {				ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,						  "Field goes beyond end-of-region!/n"));				/*                                         */				return_VALUE(0);			}//.........这里部分代码省略.........

//.........这里部分代码省略.........		ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,				  "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %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));		/*                                                                                                                                         */		second_desc = obj_desc->common.next_object;		second_desc->extra.aml_start =		    ACPI_CAST_PTR(union acpi_parse_object,				  info->data_register_node)->named.data;		second_desc->extra.aml_length =		    ACPI_CAST_PTR(union acpi_parse_object,				  info->data_register_node)->named.length;		break;	case ACPI_TYPE_LOCAL_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);		if (!obj_desc->index_field.data_obj		    || !obj_desc->index_field.index_obj) {			ACPI_ERROR((AE_INFO,				    "Null Index Object during field prep"));			acpi_ut_delete_object_desc(obj_desc);			return_ACPI_STATUS(AE_AML_INTERNAL);		}		/*                                                  */		acpi_ut_add_reference(obj_desc->index_field.data_obj);		acpi_ut_add_reference(obj_desc->index_field.index_obj);		/*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */		obj_desc->index_field.value =		    (u32) ACPI_ROUND_DOWN(ACPI_DIV_8(info->field_bit_position),					  obj_desc->index_field.					  access_byte_width);		ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,				  "IndexField: BitOff %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));		break;	default:		/*                                */		break;	}	/*                                                                                                                         */	status = acpi_ns_attach_object(info->field_node, obj_desc,				       acpi_ns_get_type(info->field_node));	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,			  "Set NamedObj %p [%4.4s], ObjDesc %p/n",			  info->field_node,			  acpi_ut_get_node_name(info->field_node), obj_desc));	/*                                      */	acpi_ut_remove_reference(obj_desc);	return_ACPI_STATUS(status);}

//.........这里部分代码省略.........        /* An additional reference for the attached objects */        AcpiUtAddReference (ObjDesc->BankField.RegionObj);        AcpiUtAddReference (ObjDesc->BankField.BankObj);        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,            "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p/n",            ObjDesc->BankField.StartFieldBitOffset,            ObjDesc->BankField.BaseByteOffset,            ObjDesc->Field.AccessByteWidth,            ObjDesc->BankField.RegionObj,            ObjDesc->BankField.BankObj));        /*         * Remember location in AML stream of the field unit         * opcode and operands -- since the BankValue         * operands must be evaluated.         */        SecondDesc = ObjDesc->Common.NextObject;        SecondDesc->Extra.AmlStart = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,            Info->DataRegisterNode)->Named.Data;        SecondDesc->Extra.AmlLength = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,            Info->DataRegisterNode)->Named.Length;        break;    case ACPI_TYPE_LOCAL_INDEX_FIELD:        /* Get the Index and Data registers */        ObjDesc->IndexField.IndexObj =            AcpiNsGetAttachedObject (Info->RegisterNode);        ObjDesc->IndexField.DataObj =            AcpiNsGetAttachedObject (Info->DataRegisterNode);        if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)        {            ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));            AcpiUtDeleteObjectDesc (ObjDesc);            return_ACPI_STATUS (AE_AML_INTERNAL);        }        /* An additional reference for the attached objects */        AcpiUtAddReference (ObjDesc->IndexField.DataObj);        AcpiUtAddReference (ObjDesc->IndexField.IndexObj);        /*         * April 2006: Changed to match MS behavior         *         * The value written to the Index register is the byte offset of the         * target field in units of the granularity of the IndexField         *         * Previously, the value was calculated as an index in terms of the         * width of the Data register, as below:         *         *      ObjDesc->IndexField.Value = (UINT32)         *          (Info->FieldBitPosition / ACPI_MUL_8 (         *              ObjDesc->Field.AccessByteWidth));         *         * February 2006: Tried value as a byte offset:         *      ObjDesc->IndexField.Value = (UINT32)         *          ACPI_DIV_8 (Info->FieldBitPosition);         */        ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (            ACPI_DIV_8 (Info->FieldBitPosition),            ObjDesc->IndexField.AccessByteWidth);        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,            "IndexField: BitOff %X, Off %X, Value %X, Gran %X, Index %p, Data %p/n",            ObjDesc->IndexField.StartFieldBitOffset,            ObjDesc->IndexField.BaseByteOffset,            ObjDesc->IndexField.Value,            ObjDesc->Field.AccessByteWidth,            ObjDesc->IndexField.IndexObj,            ObjDesc->IndexField.DataObj));        break;    default:        /* No other types should get here */        break;    }    /*     * Store the constructed descriptor (ObjDesc) into the parent Node,     * preserving the current type of that NamedObj.     */    Status = AcpiNsAttachObject (Info->FieldNode, ObjDesc,                AcpiNsGetType (Info->FieldNode));    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Set NamedObj %p [%4.4s], ObjDesc %p/n",        Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));    /* Remove local reference to the object */    AcpiUtRemoveReference (ObjDesc);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiExPrepCommonFieldObject (    ACPI_OPERAND_OBJECT     *ObjDesc,    UINT8                   FieldFlags,    UINT8                   FieldAttribute,    UINT32                  FieldBitPosition,    UINT32                  FieldBitLength){    UINT32                  AccessBitWidth;    UINT32                  ByteAlignment;    UINT32                  NearestByteAddress;    ACPI_FUNCTION_TRACE (ExPrepCommonFieldObject);    /*     * Note: the structure being initialized is the     * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common     * area are initialized by this procedure.     */    ObjDesc->CommonField.FieldFlags = FieldFlags;    ObjDesc->CommonField.Attribute  = FieldAttribute;    ObjDesc->CommonField.BitLength  = FieldBitLength;    /*     * 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 ByteAlignment (address granularity) of the access.     *     * For AnyAcc, the AccessBitWidth 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 AnyAcc, the ByteAlignment is always one     * byte.     *     * For all Buffer Fields, the ByteAlignment is always one byte.     *     * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is     * the same (equivalent) as the ByteAlignment.     */    AccessBitWidth = AcpiExDecodeFieldAccess (ObjDesc, FieldFlags,                        &ByteAlignment);    if (!AccessBitWidth)    {        return_ACPI_STATUS (AE_AML_OPERAND_VALUE);    }    /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */    ObjDesc->CommonField.AccessByteWidth = (UINT8)        ACPI_DIV_8 (AccessBitWidth);    /*     * BaseByteOffset 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: ByteAlignment is always either equal to the AccessBitWidth or 8     * (Byte access), and it defines the addressing granularity of the parent     * region or buffer.     */    NearestByteAddress =        ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition);    ObjDesc->CommonField.BaseByteOffset = (UINT32)        ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment);    /*     * StartFieldBitOffset is the offset of the first bit of the field within     * a field datum.     */    ObjDesc->CommonField.StartFieldBitOffset = (UINT8)        (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset));    return_ACPI_STATUS (AE_OK);}

//.........这里部分代码省略.........        if (FieldBitLength)        {            if (TagBitLength < FieldBitLength)            {                Message = ASL_MSG_TAG_SMALLER;            }            else if (TagBitLength > FieldBitLength)            {                Message = ASL_MSG_TAG_LARGER;            }            if (Message)            {                sprintf (AslGbl_MsgBuffer,                    "Size mismatch, Tag: %u bit%s, Field: %u bit%s",                    TagBitLength, (TagBitLength > 1) ? "s" : "",                    FieldBitLength, (FieldBitLength > 1) ? "s" : "");                AslError (ASL_WARNING, Message, Op, AslGbl_MsgBuffer);            }        }        /* Convert the BitOffset to a ByteOffset for certain opcodes */        switch (Op->Asl.Parent->Asl.AmlOpcode)        {        case AML_CREATE_BYTE_FIELD_OP:        case AML_CREATE_WORD_FIELD_OP:        case AML_CREATE_DWORD_FIELD_OP:        case AML_CREATE_QWORD_FIELD_OP:        case AML_INDEX_OP:            Offset = ACPI_DIV_8 (Offset);            break;        default:            break;        }        /* Now convert this node to an integer whose value is the field offset */        Op->Asl.AmlLength = 0;        Op->Asl.ParseOpcode = PARSEOP_INTEGER;        Op->Asl.Value.Integer = (UINT64) Offset;        Op->Asl.CompileFlags |= OP_IS_RESOURCE_FIELD;        OpcGenerateAmlOpcode (Op);    }    /* 3) Check for a method invocation */    else if ((((Op->Asl.ParseOpcode == PARSEOP_NAMESTRING) || (Op->Asl.ParseOpcode == PARSEOP_NAMESEG)) &&                (Node->Type == ACPI_TYPE_METHOD) &&                (Op->Asl.Parent) &&                (Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_METHOD))   ||                (Op->Asl.ParseOpcode == PARSEOP_METHODCALL))    {        /*         * A reference to a method within one of these opcodes is not an         * invocation of the method, it is simply a reference to the method.         *         * September 2016: Removed DeRefOf from this list         */

acpi_status acpi_hw_write(u32 value, struct acpi_generic_address *reg){	u64 address;	u8 access_width;	u32 bit_width;	u8 bit_offset;	u64 value64;	u32 new_value32, old_value32;	u8 index;	acpi_status status;	ACPI_FUNCTION_NAME(hw_write);	/* Validate contents of the GAS register */	status = acpi_hw_validate_register(reg, 32, &address);	if (ACPI_FAILURE(status)) {		return (status);	}	/* Convert access_width into number of bits based */	access_width = acpi_hw_get_access_bit_width(reg, 32);	bit_width = reg->bit_offset + reg->bit_width;	bit_offset = reg->bit_offset;	/*	 * Two address spaces supported: Memory or IO. PCI_Config is	 * not supported here because the GAS structure is insufficient	 */	index = 0;	while (bit_width) {		/*		 * Use offset style bit reads because "Index * AccessWidth" is		 * ensured to be less than 32-bits by acpi_hw_validate_register().		 */		new_value32 = ACPI_GET_BITS(&value, index * access_width,					    ACPI_MASK_BITS_ABOVE_32					    (access_width));		if (bit_offset >= access_width) {			bit_offset -= access_width;		} else {			/*			 * Use offset style bit masks because access_width is ensured			 * to be less than 32-bits by acpi_hw_validate_register() and			 * bit_offset/bit_width is less than access_width here.			 */			if (bit_offset) {				new_value32 &= ACPI_MASK_BITS_BELOW(bit_offset);			}			if (bit_width < access_width) {				new_value32 &= ACPI_MASK_BITS_ABOVE(bit_width);			}			if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {				if (bit_offset || bit_width < access_width) {					/*					 * Read old values in order not to modify the bits that					 * are beyond the register bit_width/bit_offset setting.					 */					status =					    acpi_os_read_memory((acpi_physical_address)								address +								index *								ACPI_DIV_8								(access_width),								&value64,								access_width);					old_value32 = (u32)value64;					/*					 * Use offset style bit masks because access_width is					 * ensured to be less than 32-bits by					 * acpi_hw_validate_register() and bit_offset/bit_width is					 * less than access_width here.					 */					if (bit_offset) {						old_value32 &=						    ACPI_MASK_BITS_ABOVE						    (bit_offset);						bit_offset = 0;					}					if (bit_width < access_width) {						old_value32 &=						    ACPI_MASK_BITS_BELOW						    (bit_width);					}					new_value32 |= old_value32;				}				value64 = (u64)new_value32;				status =				    acpi_os_write_memory((acpi_physical_address)							 address +							 index *							 ACPI_DIV_8							 (access_width),							 value64, access_width);//.........这里部分代码省略.........

acpi_status acpi_hw_write(u64 value, struct acpi_generic_address *reg){	u64 address;	u8 access_width;	u32 bit_width;	u8 bit_offset;	u64 value64;	u8 index;	acpi_status status;	ACPI_FUNCTION_NAME(hw_write);	/* Validate contents of the GAS register */	status = acpi_hw_validate_register(reg, 64, &address);	if (ACPI_FAILURE(status)) {		return (status);	}	/* Convert access_width into number of bits based */	access_width = acpi_hw_get_access_bit_width(address, reg, 64);	bit_width = reg->bit_offset + reg->bit_width;	bit_offset = reg->bit_offset;	/*	 * Two address spaces supported: Memory or IO. PCI_Config is	 * not supported here because the GAS structure is insufficient	 */	index = 0;	while (bit_width) {		/*		 * Use offset style bit reads because "Index * AccessWidth" is		 * ensured to be less than 64-bits by acpi_hw_validate_register().		 */		value64 = ACPI_GET_BITS(&value, index * access_width,					ACPI_MASK_BITS_ABOVE_64(access_width));		if (bit_offset >= access_width) {			bit_offset -= access_width;		} else {			if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {				status =				    acpi_os_write_memory((acpi_physical_address)							 address +							 index *							 ACPI_DIV_8							 (access_width),							 value64, access_width);			} else {	/* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */				status = acpi_hw_write_port((acpi_io_address)							    address +							    index *							    ACPI_DIV_8							    (access_width),							    (u32)value64,							    access_width);			}		}		/*		 * Index * access_width is ensured to be less than 32-bits by		 * acpi_hw_validate_register().		 */		bit_width -=		    bit_width > access_width ? access_width : bit_width;		index++;	}	ACPI_DEBUG_PRINT((ACPI_DB_IO,			  "Wrote: %8.8X%8.8X width %2d   to %8.8X%8.8X (%s)/n",			  ACPI_FORMAT_UINT64(value), access_width,			  ACPI_FORMAT_UINT64(address),			  acpi_ut_get_region_name(reg->space_id)));	return (status);}

static ACPI_STATUSAcpiHwValidateIoRequest (    ACPI_IO_ADDRESS         Address,    UINT32                  BitWidth){    UINT32                  i;    UINT32                  ByteWidth;    ACPI_IO_ADDRESS         LastAddress;    const ACPI_PORT_INFO    *PortInfo;    ACPI_FUNCTION_TRACE (HwValidateIoRequest);    /* Supported widths are 8/16/32 */    if ((BitWidth != 8) &&        (BitWidth != 16) &&        (BitWidth != 32))    {        ACPI_ERROR ((AE_INFO,            "Bad BitWidth parameter: %8.8X", BitWidth));        return (AE_BAD_PARAMETER);    }    PortInfo = AcpiProtectedPorts;    ByteWidth = ACPI_DIV_8 (BitWidth);    LastAddress = Address + ByteWidth - 1;    ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Address %8.8X%8.8X LastAddress %8.8X%8.8X Length %X",        ACPI_FORMAT_UINT64 (Address), ACPI_FORMAT_UINT64 (LastAddress),        ByteWidth));    /* Maximum 16-bit address in I/O space */    if (LastAddress > ACPI_UINT16_MAX)    {        ACPI_ERROR ((AE_INFO,            "Illegal I/O port address/length above 64K: %8.8X%8.8X/0x%X",            ACPI_FORMAT_UINT64 (Address), ByteWidth));        return_ACPI_STATUS (AE_LIMIT);    }    /* Exit if requested address is not within the protected port table */    if (Address > AcpiProtectedPorts[ACPI_PORT_INFO_ENTRIES - 1].End)    {        return_ACPI_STATUS (AE_OK);    }    /* Check request against the list of protected I/O ports */    for (i = 0; i < ACPI_PORT_INFO_ENTRIES; i++, PortInfo++)    {        /*         * Check if the requested address range will write to a reserved         * port. Four cases to consider:         *         * 1) Address range is contained completely in the port address range         * 2) Address range overlaps port range at the port range start         * 3) Address range overlaps port range at the port range end         * 4) Address range completely encompasses the port range         */        if ((Address <= PortInfo->End) && (LastAddress >= PortInfo->Start))        {            /* Port illegality may depend on the _OSI calls made by the BIOS */            if (AcpiGbl_OsiData >= PortInfo->OsiDependency)            {                ACPI_DEBUG_PRINT ((ACPI_DB_IO,                    "Denied AML access to port 0x%8.8X%8.8X/%X (%s 0x%.4X-0x%.4X)",                    ACPI_FORMAT_UINT64 (Address), ByteWidth, PortInfo->Name,                    PortInfo->Start, PortInfo->End));                return_ACPI_STATUS (AE_AML_ILLEGAL_ADDRESS);            }        }        /* Finished if address range ends before the end of this port */        if (LastAddress <= PortInfo->End)        {            break;        }    }    return_ACPI_STATUS (AE_OK);}

ACPI_STATUSAcpiHwWrite (    UINT32                  Value,    ACPI_GENERIC_ADDRESS    *Reg){    UINT64                  Address;    UINT8                   AccessWidth;    UINT32                  BitWidth;    UINT8                   BitOffset;    UINT64                  Value64;    UINT32                  NewValue32, OldValue32;    UINT8                   Index;    ACPI_STATUS             Status;    ACPI_FUNCTION_NAME (HwWrite);    /* Validate contents of the GAS register */    Status = AcpiHwValidateRegister (Reg, 32, &Address);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Convert AccessWidth into number of bits based */    AccessWidth = Reg->AccessWidth ? Reg->AccessWidth : 1;    AccessWidth = 1 << (AccessWidth + 2);    BitWidth = ACPI_ROUND_UP (Reg->BitOffset + Reg->BitWidth, AccessWidth);    BitOffset = Reg->BitOffset;    /*     * Two address spaces supported: Memory or IO. PCI_Config is     * not supported here because the GAS structure is insufficient     */    Index = 0;    while (BitWidth)    {        NewValue32 = ACPI_GET_BITS (&Value, (Index * AccessWidth),            ((1 << AccessWidth) - 1));        if (BitOffset > AccessWidth)        {            BitOffset -= AccessWidth;        }        else        {            if (BitOffset)            {                NewValue32 &= ACPI_MASK_BITS_BELOW (BitOffset);            }            if (BitWidth < AccessWidth)            {                NewValue32 &= ACPI_MASK_BITS_ABOVE (BitWidth);            }            if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)            {                if (BitOffset || BitWidth < AccessWidth)                {                    /*                     * Read old values in order not to modify the bits that                     * are beyond the register BitWidth/BitOffset setting.                     */                    Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)                        Address + Index * ACPI_DIV_8 (AccessWidth),                        &Value64, AccessWidth);                    OldValue32 = (UINT32) Value64;                    if (BitOffset)                    {                        OldValue32 &= ACPI_MASK_BITS_ABOVE (BitOffset + 1);                        BitOffset = 0;                    }                    if (BitWidth < AccessWidth)                    {                        OldValue32 &= ACPI_MASK_BITS_BELOW (BitWidth - 1);                    }                    NewValue32 |= OldValue32;                }                Value64 = (UINT64) NewValue32;                Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)                    Address + Index * ACPI_DIV_8 (AccessWidth),                    Value64, AccessWidth);            }            else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */            {                if (BitOffset || BitWidth < AccessWidth)                {                    /*                     * Read old values in order not to modify the bits that                     * are beyond the register BitWidth/BitOffset setting.                     */                    Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)//.........这里部分代码省略.........

ACPI_STATUSAcpiHwRead (    UINT32                  *Value,    ACPI_GENERIC_ADDRESS    *Reg){    UINT64                  Address;    UINT8                   AccessWidth;    UINT32                  BitWidth;    UINT8                   BitOffset;    UINT64                  Value64;    UINT32                  Value32;    UINT8                   Index;    ACPI_STATUS             Status;    ACPI_FUNCTION_NAME (HwRead);    /* Validate contents of the GAS register */    Status = AcpiHwValidateRegister (Reg, 32, &Address);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /*     * Initialize entire 32-bit return value to zero, convert AccessWidth     * into number of bits based     */    *Value = 0;    AccessWidth = Reg->AccessWidth ? Reg->AccessWidth : 1;    AccessWidth = 1 << (AccessWidth + 2);    BitWidth = ACPI_ROUND_UP (Reg->BitOffset + Reg->BitWidth, AccessWidth);    BitOffset = Reg->BitOffset;    /*     * Two address spaces supported: Memory or IO. PCI_Config is     * not supported here because the GAS structure is insufficient     */    Index = 0;    while (BitWidth)    {        if (BitOffset > AccessWidth)        {            Value32 = 0;            BitOffset -= AccessWidth;        }        else        {            if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)            {                Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)                    Address + Index * ACPI_DIV_8 (AccessWidth),                    &Value64, AccessWidth);                Value32 = (UINT32) Value64;            }            else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */            {                Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)                    Address + Index * ACPI_DIV_8 (AccessWidth),                    &Value32, AccessWidth);            }            if (BitOffset)            {                Value32 &= ACPI_MASK_BITS_BELOW (BitOffset);                BitOffset = 0;            }            if (BitWidth < AccessWidth)            {                Value32 &= ACPI_MASK_BITS_ABOVE (BitWidth);            }        }        ACPI_SET_BITS (Value, Index * AccessWidth,            ((1 << AccessWidth) - 1), Value32);        BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;        Index++;    }    ACPI_DEBUG_PRINT ((ACPI_DB_IO,        "Read:  %8.8X width %2d from %8.8X%8.8X (%s)/n",        *Value, AccessWidth, ACPI_FORMAT_UINT64 (Address),        AcpiUtGetRegionName (Reg->SpaceId)));    return (Status);}

//.........这里部分代码省略.........		ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,				  "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %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));		/*		 * Remember location in AML stream of the field unit		 * opcode and operands -- since the bank_value		 * operands must be evaluated.		 */		second_desc = obj_desc->common.next_object;		second_desc->extra.aml_start =		    ACPI_CAST_PTR(union acpi_parse_object,				  info->data_register_node)->named.data;		second_desc->extra.aml_length =		    ACPI_CAST_PTR(union acpi_parse_object,				  info->data_register_node)->named.length;		break;	case ACPI_TYPE_LOCAL_INDEX_FIELD:		/* Get the Index and Data registers */		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) {			ACPI_ERROR((AE_INFO,				    "Null Index Object during field prep"));			acpi_ut_delete_object_desc(obj_desc);			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);		/*		 * April 2006: Changed to match MS behavior		 *		 * The value written to the Index register is the byte offset of the		 * target field in units of the granularity of the index_field		 *		 * Previously, the value was calculated as an index in terms of the		 * width of the Data register, as below:		 *		 *      obj_desc->index_field.Value = (u32)		 *          (Info->field_bit_position / ACPI_MUL_8 (		 *              obj_desc->Field.access_byte_width));		 *		 * February 2006: Tried value as a byte offset:		 *      obj_desc->index_field.Value = (u32)		 *          ACPI_DIV_8 (Info->field_bit_position);		 */		obj_desc->index_field.value =		    (u32) ACPI_ROUND_DOWN(ACPI_DIV_8(info->field_bit_position),					  obj_desc->index_field.					  access_byte_width);		ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,				  "IndexField: BitOff %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));		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.	 */	status = acpi_ns_attach_object(info->field_node, obj_desc,				       acpi_ns_get_type(info->field_node));	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,			  "Set NamedObj %p [%4.4s], ObjDesc %p/n",			  info->field_node,			  acpi_ut_get_node_name(info->field_node), obj_desc));	/* Remove local reference to the object */	acpi_ut_remove_reference(obj_desc);	return_ACPI_STATUS(status);}

acpi_status acpi_hw_read(u32 *value, struct acpi_generic_address *reg){	u64 address;	u8 access_width;	u32 bit_width;	u8 bit_offset;	u64 value64;	u32 value32;	u8 index;	acpi_status status;	ACPI_FUNCTION_NAME(hw_read);	/* Validate contents of the GAS register */	status = acpi_hw_validate_register(reg, 32, &address);	if (ACPI_FAILURE(status)) {		return (status);	}	/*	 * Initialize entire 32-bit return value to zero, convert access_width	 * into number of bits based	 */	*value = 0;	access_width = acpi_hw_get_access_bit_width(reg, 32);	bit_width = reg->bit_offset + reg->bit_width;	bit_offset = reg->bit_offset;	/*	 * Two address spaces supported: Memory or IO. PCI_Config is	 * not supported here because the GAS structure is insufficient	 */	index = 0;	while (bit_width) {		if (bit_offset >= access_width) {			value32 = 0;			bit_offset -= access_width;		} else {			if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {				status =				    acpi_os_read_memory((acpi_physical_address)							address +							index *							ACPI_DIV_8							(access_width),							&value64, access_width);				value32 = (u32)value64;			} else {	/* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */				status = acpi_hw_read_port((acpi_io_address)							   address +							   index *							   ACPI_DIV_8							   (access_width),							   &value32,							   access_width);			}			/*			 * Use offset style bit masks because:			 * bit_offset < access_width/bit_width < access_width, and			 * access_width is ensured to be less than 32-bits by			 * acpi_hw_validate_register().			 */			if (bit_offset) {				value32 &= ACPI_MASK_BITS_BELOW(bit_offset);				bit_offset = 0;			}			if (bit_width < access_width) {				value32 &= ACPI_MASK_BITS_ABOVE(bit_width);			}		}		/*		 * Use offset style bit writes because "Index * AccessWidth" is		 * ensured to be less than 32-bits by acpi_hw_validate_register().		 */		ACPI_SET_BITS(value, index * access_width,			      ACPI_MASK_BITS_ABOVE_32(access_width), value32);		bit_width -=		    bit_width > access_width ? access_width : bit_width;		index++;	}	ACPI_DEBUG_PRINT((ACPI_DB_IO,			  "Read:  %8.8X width %2d from %8.8X%8.8X (%s)/n",			  *value, access_width, ACPI_FORMAT_UINT64(address),			  acpi_ut_get_region_name(reg->space_id)));	return (status);}

static u32acpi_ex_generate_access(u32 field_bit_offset,			u32 field_bit_length, u32 region_length){	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);	/* Round Field start offset and length to "minimal" byte boundaries */	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;	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,			  "Bit length %u, Bit offset %u/n",			  field_bit_length, field_bit_offset));	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,			  "Byte Length %u, Byte Offset %u, End Offset %u/n",			  field_byte_length, field_byte_offset,			  field_byte_end_offset));	/*	 * 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)	 */	for (access_byte_width = 1; access_byte_width <= 8;	     access_byte_width <<= 1) {		/*		 * 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).		 */		if (ACPI_ROUND_UP(field_byte_end_offset, access_byte_width) <=		    region_length) {			field_start_offset =			    ACPI_ROUND_DOWN(field_byte_offset,					    access_byte_width) /			    access_byte_width;			field_end_offset =			    ACPI_ROUND_UP((field_byte_length +					   field_byte_offset),					  access_byte_width) /			    access_byte_width;			accesses = field_end_offset - field_start_offset;			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,					  "AccessWidth %u end is within region/n",					  access_byte_width));			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,					  "Field Start %u, Field End %u -- requires %u accesses/n",					  field_start_offset, field_end_offset,					  accesses));			/* Single access is optimal */			if (accesses <= 1) {				ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,						  "Entire field can be accessed with one operation of size %u/n",						  access_byte_width));				return_VALUE(access_byte_width);			}			/*			 * Fits in the region, but requires more than one read/write.			 * try the next wider access on next iteration			 */			if (accesses < minimum_accesses) {				minimum_accesses = accesses;				minimum_access_width = access_byte_width;			}		} else {			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,					  "AccessWidth %u end is NOT within region/n",					  access_byte_width));			if (access_byte_width == 1) {				ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,						  "Field goes beyond end-of-region!/n"));				/* Field does not fit in the region at all */				return_VALUE(0);			}//.........这里部分代码省略.........

static UINT32AcpiExGenerateAccess (    UINT32                  FieldBitOffset,    UINT32                  FieldBitLength,    UINT32                  RegionLength){    UINT32                  FieldByteLength;    UINT32                  FieldByteOffset;    UINT32                  FieldByteEndOffset;    UINT32                  AccessByteWidth;    UINT32                  FieldStartOffset;    UINT32                  FieldEndOffset;    UINT32                  MinimumAccessWidth = 0xFFFFFFFF;    UINT32                  MinimumAccesses = 0xFFFFFFFF;    UINT32                  Accesses;    ACPI_FUNCTION_TRACE (ExGenerateAccess);    /* Round Field start offset and length to "minimal" byte boundaries */    FieldByteOffset    = ACPI_DIV_8 (ACPI_ROUND_DOWN (FieldBitOffset, 8));    FieldByteEndOffset = ACPI_DIV_8 (ACPI_ROUND_UP   (FieldBitLength +                                                      FieldBitOffset, 8));    FieldByteLength    = FieldByteEndOffset - FieldByteOffset;    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,        "Bit length %u, Bit offset %u/n",        FieldBitLength, FieldBitOffset));    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,        "Byte Length %u, Byte Offset %u, End Offset %u/n",        FieldByteLength, FieldByteOffset, FieldByteEndOffset));    /*     * Iterative search for the maximum access width that is both aligned     * and does not go beyond the end of the region     *     * Start at ByteAcc and work upwards to QwordAcc max. (1,2,4,8 bytes)     */    for (AccessByteWidth = 1; AccessByteWidth <= 8; AccessByteWidth <<= 1)    {        /*         * 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 FieldByteLength, we         *    are done. (This does not optimize for the perfectly aligned         *    case yet).         */        if (ACPI_ROUND_UP (FieldByteEndOffset, AccessByteWidth) <= RegionLength)        {            FieldStartOffset =                ACPI_ROUND_DOWN (FieldByteOffset, AccessByteWidth) /                AccessByteWidth;            FieldEndOffset =                ACPI_ROUND_UP ((FieldByteLength + FieldByteOffset),                    AccessByteWidth) / AccessByteWidth;            Accesses = FieldEndOffset - FieldStartOffset;            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,                "AccessWidth %u end is within region/n", AccessByteWidth));            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,                "Field Start %u, Field End %u -- requires %u accesses/n",                FieldStartOffset, FieldEndOffset, Accesses));            /* Single access is optimal */            if (Accesses <= 1)            {                ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,                    "Entire field can be accessed with one operation of size %u/n",                    AccessByteWidth));                return_VALUE (AccessByteWidth);            }            /*             * Fits in the region, but requires more than one read/write.             * try the next wider access on next iteration             */            if (Accesses < MinimumAccesses)            {                MinimumAccesses    = Accesses;                MinimumAccessWidth = AccessByteWidth;            }        }        else        {            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,                "AccessWidth %u end is NOT within region/n", AccessByteWidth));            if (AccessByteWidth == 1)            {                ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,                    "Field goes beyond end-of-region!/n"));                /* Field does not fit in the region at all *///.........这里部分代码省略.........

static acpi_statusacpi_hw_validate_io_request(acpi_io_address address, u32 bit_width){	u32 i;	u32 byte_width;	acpi_io_address last_address;	const struct acpi_port_info *port_info;	ACPI_FUNCTION_TRACE(hw_validate_io_request);	/* Supported widths are 8/16/32 */	if ((bit_width != 8) && (bit_width != 16) && (bit_width != 32)) {		ACPI_ERROR((AE_INFO,			    "Bad BitWidth parameter: %8.8X", bit_width));		return (AE_BAD_PARAMETER);	}	port_info = acpi_protected_ports;	byte_width = ACPI_DIV_8(bit_width);	last_address = address + byte_width - 1;	ACPI_DEBUG_PRINT((ACPI_DB_IO,			  "Address %8.8X%8.8X LastAddress %8.8X%8.8X Length %X",			  ACPI_FORMAT_UINT64(address),			  ACPI_FORMAT_UINT64(last_address), byte_width));	/* Maximum 16-bit address in I/O space */	if (last_address > ACPI_UINT16_MAX) {		ACPI_ERROR((AE_INFO,			    "Illegal I/O port address/length above 64K: %8.8X%8.8X/0x%X",			    ACPI_FORMAT_UINT64(address), byte_width));		return_ACPI_STATUS(AE_LIMIT);	}	/* Exit if requested address is not within the protected port table */	if (address > acpi_protected_ports[ACPI_PORT_INFO_ENTRIES - 1].end) {		return_ACPI_STATUS(AE_OK);	}	/* Check request against the list of protected I/O ports */	for (i = 0; i < ACPI_PORT_INFO_ENTRIES; i++, port_info++) {		/*		 * Check if the requested address range will write to a reserved		 * port. Four cases to consider:		 *		 * 1) Address range is contained completely in the port address range		 * 2) Address range overlaps port range at the port range start		 * 3) Address range overlaps port range at the port range end		 * 4) Address range completely encompasses the port range		 */		if ((address <= port_info->end)		    && (last_address >= port_info->start)) {			/* Port illegality may depend on the _OSI calls made by the BIOS */			if (acpi_gbl_osi_data >= port_info->osi_dependency) {				ACPI_DEBUG_PRINT((ACPI_DB_IO,						  "Denied AML access to port 0x%8.8X%8.8X/%X (%s 0x%.4X-0x%.4X)",						  ACPI_FORMAT_UINT64(address),						  byte_width, port_info->name,						  port_info->start,						  port_info->end));				return_ACPI_STATUS(AE_AML_ILLEGAL_ADDRESS);			}		}		/* Finished if address range ends before the end of this port */		if (last_address <= port_info->end) {			break;		}	}	return_ACPI_STATUS(AE_OK);}

ACPI_STATUSAcpiHwWrite (    UINT64                  Value,    ACPI_GENERIC_ADDRESS    *Reg){    UINT64                  Address;    UINT8                   AccessWidth;    UINT32                  BitWidth;    UINT8                   BitOffset;    UINT64                  Value64;    UINT8                   Index;    ACPI_STATUS             Status;    ACPI_FUNCTION_NAME (HwWrite);    /* Validate contents of the GAS register */    Status = AcpiHwValidateRegister (Reg, 64, &Address);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Convert AccessWidth into number of bits based */    AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);    BitWidth = Reg->BitOffset + Reg->BitWidth;    BitOffset = Reg->BitOffset;    /*     * Two address spaces supported: Memory or IO. PCI_Config is     * not supported here because the GAS structure is insufficient     */    Index = 0;    while (BitWidth)    {        /*         * Use offset style bit reads because "Index * AccessWidth" is         * ensured to be less than 64-bits by AcpiHwValidateRegister().         */        Value64 = ACPI_GET_BITS (&Value, Index * AccessWidth,            ACPI_MASK_BITS_ABOVE_64 (AccessWidth));        if (BitOffset >= AccessWidth)        {            BitOffset -= AccessWidth;        }        else        {            if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)            {                Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)                    Address + Index * ACPI_DIV_8 (AccessWidth),                    Value64, AccessWidth);            }            else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */            {                Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)                    Address + Index * ACPI_DIV_8 (AccessWidth),                    (UINT32) Value64, AccessWidth);            }        }        /*         * Index * AccessWidth is ensured to be less than 32-bits by         * AcpiHwValidateRegister().         */        BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;        Index++;    }    ACPI_DEBUG_PRINT ((ACPI_DB_IO,        "Wrote: %8.8X%8.8X width %2d   to %8.8X%8.8X (%s)/n",        ACPI_FORMAT_UINT64 (Value), AccessWidth,        ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));    return (Status);}