|
||||
Warning, cross-references for /kernel/drivers/acpica/exprep.c need to be fixed.
0001 0002 /****************************************************************************** 0003 * 0004 * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities 0005 * 0006 *****************************************************************************/ 0007 0008 /****************************************************************************** 0009 * 0010 * 1. Copyright Notice 0011 * 0012 * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp. 0013 * All rights reserved. 0014 * 0015 * 2. License 0016 * 0017 * 2.1. This is your license from Intel Corp. under its intellectual property 0018 * rights. You may have additional license terms from the party that provided 0019 * you this software, covering your right to use that party's intellectual 0020 * property rights. 0021 * 0022 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 0023 * copy of the source code appearing in this file ("Covered Code") an 0024 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 0025 * base code distributed originally by Intel ("Original Intel Code") to copy, 0026 * make derivatives, distribute, use and display any portion of the Covered 0027 * Code in any form, with the right to sublicense such rights; and 0028 * 0029 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 0030 * license (with the right to sublicense), under only those claims of Intel 0031 * patents that are infringed by the Original Intel Code, to make, use, sell, 0032 * offer to sell, and import the Covered Code and derivative works thereof 0033 * solely to the minimum extent necessary to exercise the above copyright 0034 * license, and in no event shall the patent license extend to any additions 0035 * to or modifications of the Original Intel Code. No other license or right 0036 * is granted directly or by implication, estoppel or otherwise; 0037 * 0038 * The above copyright and patent license is granted only if the following 0039 * conditions are met: 0040 * 0041 * 3. Conditions 0042 * 0043 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 0044 * Redistribution of source code of any substantial portion of the Covered 0045 * Code or modification with rights to further distribute source must include 0046 * the above Copyright Notice, the above License, this list of Conditions, 0047 * and the following Disclaimer and Export Compliance provision. In addition, 0048 * Licensee must cause all Covered Code to which Licensee contributes to 0049 * contain a file documenting the changes Licensee made to create that Covered 0050 * Code and the date of any change. Licensee must include in that file the 0051 * documentation of any changes made by any predecessor Licensee. Licensee 0052 * must include a prominent statement that the modification is derived, 0053 * directly or indirectly, from Original Intel Code. 0054 * 0055 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 0056 * Redistribution of source code of any substantial portion of the Covered 0057 * Code or modification without rights to further distribute source must 0058 * include the following Disclaimer and Export Compliance provision in the 0059 * documentation and/or other materials provided with distribution. In 0060 * addition, Licensee may not authorize further sublicense of source of any 0061 * portion of the Covered Code, and must include terms to the effect that the 0062 * license from Licensee to its licensee is limited to the intellectual 0063 * property embodied in the software Licensee provides to its licensee, and 0064 * not to intellectual property embodied in modifications its licensee may 0065 * make. 0066 * 0067 * 3.3. Redistribution of Executable. Redistribution in executable form of any 0068 * substantial portion of the Covered Code or modification must reproduce the 0069 * above Copyright Notice, and the following Disclaimer and Export Compliance 0070 * provision in the documentation and/or other materials provided with the 0071 * distribution. 0072 * 0073 * 3.4. Intel retains all right, title, and interest in and to the Original 0074 * Intel Code. 0075 * 0076 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 0077 * Intel shall be used in advertising or otherwise to promote the sale, use or 0078 * other dealings in products derived from or relating to the Covered Code 0079 * without prior written authorization from Intel. 0080 * 0081 * 4. Disclaimer and Export Compliance 0082 * 0083 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 0084 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 0085 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 0086 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 0087 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 0088 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 0089 * PARTICULAR PURPOSE. 0090 * 0091 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 0092 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 0093 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 0094 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 0095 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 0096 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 0097 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 0098 * LIMITED REMEDY. 0099 * 0100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 0101 * software or system incorporating such software without first obtaining any 0102 * required license or other approval from the U. S. Department of Commerce or 0103 * any other agency or department of the United States Government. In the 0104 * event Licensee exports any such software from the United States or 0105 * re-exports any such software from a foreign destination, Licensee shall 0106 * ensure that the distribution and export/re-export of the software is in 0107 * compliance with all laws, regulations, orders, or other restrictions of the 0108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 0109 * any of its subsidiaries will export/re-export any technical data, process, 0110 * software, or service, directly or indirectly, to any country for which the 0111 * United States government or any agency thereof requires an export license, 0112 * other governmental approval, or letter of assurance, without first obtaining 0113 * such license, approval or letter. 0114 * 0115 *****************************************************************************/ 0116 0117 #define __EXPREP_C__ 0118 0119 #include "acpi.h" 0120 #include "accommon.h" 0121 #include "acinterp.h" 0122 #include "amlcode.h" 0123 #include "acnamesp.h" 0124 0125 0126 #define _COMPONENT ACPI_EXECUTER 0127 ACPI_MODULE_NAME ("exprep") 0128 0129 /* Local prototypes */ 0130 0131 static UINT32 0132 AcpiExDecodeFieldAccess ( 0133 ACPI_OPERAND_OBJECT *ObjDesc, 0134 UINT8 FieldFlags, 0135 UINT32 *ReturnByteAlignment); 0136 0137 0138 #ifdef ACPI_UNDER_DEVELOPMENT 0139 0140 static UINT32 0141 AcpiExGenerateAccess ( 0142 UINT32 FieldBitOffset, 0143 UINT32 FieldBitLength, 0144 UINT32 RegionLength); 0145 0146 /******************************************************************************* 0147 * 0148 * FUNCTION: AcpiExGenerateAccess 0149 * 0150 * PARAMETERS: FieldBitOffset - Start of field within parent region/buffer 0151 * FieldBitLength - Length of field in bits 0152 * RegionLength - Length of parent in bytes 0153 * 0154 * RETURN: Field granularity (8, 16, 32 or 64) and 0155 * ByteAlignment (1, 2, 3, or 4) 0156 * 0157 * DESCRIPTION: Generate an optimal access width for fields defined with the 0158 * AnyAcc keyword. 0159 * 0160 * NOTE: Need to have the RegionLength in order to check for boundary 0161 * conditions (end-of-region). However, the RegionLength is a deferred 0162 * operation. Therefore, to complete this implementation, the generation 0163 * of this access width must be deferred until the region length has 0164 * been evaluated. 0165 * 0166 ******************************************************************************/ 0167 0168 static UINT32 0169 AcpiExGenerateAccess ( 0170 UINT32 FieldBitOffset, 0171 UINT32 FieldBitLength, 0172 UINT32 RegionLength) 0173 { 0174 UINT32 FieldByteLength; 0175 UINT32 FieldByteOffset; 0176 UINT32 FieldByteEndOffset; 0177 UINT32 AccessByteWidth; 0178 UINT32 FieldStartOffset; 0179 UINT32 FieldEndOffset; 0180 UINT32 MinimumAccessWidth = 0xFFFFFFFF; 0181 UINT32 MinimumAccesses = 0xFFFFFFFF; 0182 UINT32 Accesses; 0183 0184 0185 ACPI_FUNCTION_TRACE (ExGenerateAccess); 0186 0187 0188 /* Round Field start offset and length to "minimal" byte boundaries */ 0189 0190 FieldByteOffset = ACPI_DIV_8 (ACPI_ROUND_DOWN (FieldBitOffset, 8)); 0191 FieldByteEndOffset = ACPI_DIV_8 (ACPI_ROUND_UP (FieldBitLength + 0192 FieldBitOffset, 8)); 0193 FieldByteLength = FieldByteEndOffset - FieldByteOffset; 0194 0195 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0196 "Bit length %d, Bit offset %d\n", 0197 FieldBitLength, FieldBitOffset)); 0198 0199 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0200 "Byte Length %d, Byte Offset %d, End Offset %d\n", 0201 FieldByteLength, FieldByteOffset, FieldByteEndOffset)); 0202 0203 /* 0204 * Iterative search for the maximum access width that is both aligned 0205 * and does not go beyond the end of the region 0206 * 0207 * Start at ByteAcc and work upwards to QwordAcc max. (1,2,4,8 bytes) 0208 */ 0209 for (AccessByteWidth = 1; AccessByteWidth <= 8; AccessByteWidth <<= 1) 0210 { 0211 /* 0212 * 1) Round end offset up to next access boundary and make sure that 0213 * this does not go beyond the end of the parent region. 0214 * 2) When the Access width is greater than the FieldByteLength, we 0215 * are done. (This does not optimize for the perfectly aligned 0216 * case yet). 0217 */ 0218 if (ACPI_ROUND_UP (FieldByteEndOffset, AccessByteWidth) <= RegionLength) 0219 { 0220 FieldStartOffset = 0221 ACPI_ROUND_DOWN (FieldByteOffset, AccessByteWidth) / 0222 AccessByteWidth; 0223 0224 FieldEndOffset = 0225 ACPI_ROUND_UP ((FieldByteLength + FieldByteOffset), 0226 AccessByteWidth) / AccessByteWidth; 0227 0228 Accesses = FieldEndOffset - FieldStartOffset; 0229 0230 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0231 "AccessWidth %d end is within region\n", AccessByteWidth)); 0232 0233 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0234 "Field Start %d, Field End %d -- requires %d accesses\n", 0235 FieldStartOffset, FieldEndOffset, Accesses)); 0236 0237 /* Single access is optimal */ 0238 0239 if (Accesses <= 1) 0240 { 0241 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0242 "Entire field can be accessed with one operation of size %d\n", 0243 AccessByteWidth)); 0244 return_VALUE (AccessByteWidth); 0245 } 0246 0247 /* 0248 * Fits in the region, but requires more than one read/write. 0249 * try the next wider access on next iteration 0250 */ 0251 if (Accesses < MinimumAccesses) 0252 { 0253 MinimumAccesses = Accesses; 0254 MinimumAccessWidth = AccessByteWidth; 0255 } 0256 } 0257 else 0258 { 0259 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0260 "AccessWidth %d end is NOT within region\n", AccessByteWidth)); 0261 if (AccessByteWidth == 1) 0262 { 0263 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0264 "Field goes beyond end-of-region!\n")); 0265 0266 /* Field does not fit in the region at all */ 0267 0268 return_VALUE (0); 0269 } 0270 0271 /* 0272 * This width goes beyond the end-of-region, back off to 0273 * previous access 0274 */ 0275 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0276 "Backing off to previous optimal access width of %d\n", 0277 MinimumAccessWidth)); 0278 return_VALUE (MinimumAccessWidth); 0279 } 0280 } 0281 0282 /* 0283 * Could not read/write field with one operation, 0284 * just use max access width 0285 */ 0286 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0287 "Cannot access field in one operation, using width 8\n")); 0288 return_VALUE (8); 0289 } 0290 #endif /* ACPI_UNDER_DEVELOPMENT */ 0291 0292 0293 /******************************************************************************* 0294 * 0295 * FUNCTION: AcpiExDecodeFieldAccess 0296 * 0297 * PARAMETERS: ObjDesc - Field object 0298 * FieldFlags - Encoded fieldflags (contains access bits) 0299 * ReturnByteAlignment - Where the byte alignment is returned 0300 * 0301 * RETURN: Field granularity (8, 16, 32 or 64) and 0302 * ByteAlignment (1, 2, 3, or 4) 0303 * 0304 * DESCRIPTION: Decode the AccessType bits of a field definition. 0305 * 0306 ******************************************************************************/ 0307 0308 static UINT32 0309 AcpiExDecodeFieldAccess ( 0310 ACPI_OPERAND_OBJECT *ObjDesc, 0311 UINT8 FieldFlags, 0312 UINT32 *ReturnByteAlignment) 0313 { 0314 UINT32 Access; 0315 UINT32 ByteAlignment; 0316 UINT32 BitLength; 0317 0318 0319 ACPI_FUNCTION_TRACE (ExDecodeFieldAccess); 0320 0321 0322 Access = (FieldFlags & AML_FIELD_ACCESS_TYPE_MASK); 0323 0324 switch (Access) 0325 { 0326 case AML_FIELD_ACCESS_ANY: 0327 0328 #ifdef ACPI_UNDER_DEVELOPMENT 0329 ByteAlignment = 0330 AcpiExGenerateAccess (ObjDesc->CommonField.StartFieldBitOffset, 0331 ObjDesc->CommonField.BitLength, 0332 0xFFFFFFFF /* Temp until we pass RegionLength as parameter */); 0333 BitLength = ByteAlignment * 8; 0334 #endif 0335 0336 ByteAlignment = 1; 0337 BitLength = 8; 0338 break; 0339 0340 case AML_FIELD_ACCESS_BYTE: 0341 case AML_FIELD_ACCESS_BUFFER: /* ACPI 2.0 (SMBus Buffer) */ 0342 ByteAlignment = 1; 0343 BitLength = 8; 0344 break; 0345 0346 case AML_FIELD_ACCESS_WORD: 0347 ByteAlignment = 2; 0348 BitLength = 16; 0349 break; 0350 0351 case AML_FIELD_ACCESS_DWORD: 0352 ByteAlignment = 4; 0353 BitLength = 32; 0354 break; 0355 0356 case AML_FIELD_ACCESS_QWORD: /* ACPI 2.0 */ 0357 ByteAlignment = 8; 0358 BitLength = 64; 0359 break; 0360 0361 default: 0362 /* Invalid field access type */ 0363 0364 ACPI_ERROR ((AE_INFO, 0365 "Unknown field access type %X", 0366 Access)); 0367 return_UINT32 (0); 0368 } 0369 0370 if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD) 0371 { 0372 /* 0373 * BufferField access can be on any byte boundary, so the 0374 * ByteAlignment is always 1 byte -- regardless of any ByteAlignment 0375 * implied by the field access type. 0376 */ 0377 ByteAlignment = 1; 0378 } 0379 0380 *ReturnByteAlignment = ByteAlignment; 0381 return_UINT32 (BitLength); 0382 } 0383 0384 0385 /******************************************************************************* 0386 * 0387 * FUNCTION: AcpiExPrepCommonFieldObject 0388 * 0389 * PARAMETERS: ObjDesc - The field object 0390 * FieldFlags - Access, LockRule, and UpdateRule. 0391 * The format of a FieldFlag is described 0392 * in the ACPI specification 0393 * FieldAttribute - Special attributes (not used) 0394 * FieldBitPosition - Field start position 0395 * FieldBitLength - Field length in number of bits 0396 * 0397 * RETURN: Status 0398 * 0399 * DESCRIPTION: Initialize the areas of the field object that are common 0400 * to the various types of fields. Note: This is very "sensitive" 0401 * code because we are solving the general case for field 0402 * alignment. 0403 * 0404 ******************************************************************************/ 0405 0406 ACPI_STATUS 0407 AcpiExPrepCommonFieldObject ( 0408 ACPI_OPERAND_OBJECT *ObjDesc, 0409 UINT8 FieldFlags, 0410 UINT8 FieldAttribute, 0411 UINT32 FieldBitPosition, 0412 UINT32 FieldBitLength) 0413 { 0414 UINT32 AccessBitWidth; 0415 UINT32 ByteAlignment; 0416 UINT32 NearestByteAddress; 0417 0418 0419 ACPI_FUNCTION_TRACE (ExPrepCommonFieldObject); 0420 0421 0422 /* 0423 * Note: the structure being initialized is the 0424 * ACPI_COMMON_FIELD_INFO; No structure fields outside of the common 0425 * area are initialized by this procedure. 0426 */ 0427 ObjDesc->CommonField.FieldFlags = FieldFlags; 0428 ObjDesc->CommonField.Attribute = FieldAttribute; 0429 ObjDesc->CommonField.BitLength = FieldBitLength; 0430 0431 /* 0432 * Decode the access type so we can compute offsets. The access type gives 0433 * two pieces of information - the width of each field access and the 0434 * necessary ByteAlignment (address granularity) of the access. 0435 * 0436 * For AnyAcc, the AccessBitWidth is the largest width that is both 0437 * necessary and possible in an attempt to access the whole field in one 0438 * I/O operation. However, for AnyAcc, the ByteAlignment is always one 0439 * byte. 0440 * 0441 * For all Buffer Fields, the ByteAlignment is always one byte. 0442 * 0443 * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is 0444 * the same (equivalent) as the ByteAlignment. 0445 */ 0446 AccessBitWidth = AcpiExDecodeFieldAccess (ObjDesc, FieldFlags, 0447 &ByteAlignment); 0448 if (!AccessBitWidth) 0449 { 0450 return_ACPI_STATUS (AE_AML_OPERAND_VALUE); 0451 } 0452 0453 /* Setup width (access granularity) fields */ 0454 0455 ObjDesc->CommonField.AccessByteWidth = (UINT8) 0456 ACPI_DIV_8 (AccessBitWidth); /* 1, 2, 4, 8 */ 0457 0458 ObjDesc->CommonField.AccessBitWidth = (UINT8) AccessBitWidth; 0459 0460 /* 0461 * BaseByteOffset is the address of the start of the field within the 0462 * region. It is the byte address of the first *datum* (field-width data 0463 * unit) of the field. (i.e., the first datum that contains at least the 0464 * first *bit* of the field.) 0465 * 0466 * Note: ByteAlignment is always either equal to the AccessBitWidth or 8 0467 * (Byte access), and it defines the addressing granularity of the parent 0468 * region or buffer. 0469 */ 0470 NearestByteAddress = 0471 ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition); 0472 ObjDesc->CommonField.BaseByteOffset = (UINT32) 0473 ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment); 0474 0475 /* 0476 * StartFieldBitOffset is the offset of the first bit of the field within 0477 * a field datum. 0478 */ 0479 ObjDesc->CommonField.StartFieldBitOffset = (UINT8) 0480 (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset)); 0481 0482 /* 0483 * Does the entire field fit within a single field access element? (datum) 0484 * (i.e., without crossing a datum boundary) 0485 */ 0486 if ((ObjDesc->CommonField.StartFieldBitOffset + FieldBitLength) <= 0487 (UINT16) AccessBitWidth) 0488 { 0489 ObjDesc->Common.Flags |= AOPOBJ_SINGLE_DATUM; 0490 } 0491 0492 return_ACPI_STATUS (AE_OK); 0493 } 0494 0495 0496 /******************************************************************************* 0497 * 0498 * FUNCTION: AcpiExPrepFieldValue 0499 * 0500 * PARAMETERS: Info - Contains all field creation info 0501 * 0502 * RETURN: Status 0503 * 0504 * DESCRIPTION: Construct an ACPI_OPERAND_OBJECT of type DefField and 0505 * connect it to the parent Node. 0506 * 0507 ******************************************************************************/ 0508 0509 ACPI_STATUS 0510 AcpiExPrepFieldValue ( 0511 ACPI_CREATE_FIELD_INFO *Info) 0512 { 0513 ACPI_OPERAND_OBJECT *ObjDesc; 0514 ACPI_OPERAND_OBJECT *SecondDesc = NULL; 0515 UINT32 Type; 0516 ACPI_STATUS Status; 0517 0518 0519 ACPI_FUNCTION_TRACE (ExPrepFieldValue); 0520 0521 0522 /* Parameter validation */ 0523 0524 if (Info->FieldType != ACPI_TYPE_LOCAL_INDEX_FIELD) 0525 { 0526 if (!Info->RegionNode) 0527 { 0528 ACPI_ERROR ((AE_INFO, "Null RegionNode")); 0529 return_ACPI_STATUS (AE_AML_NO_OPERAND); 0530 } 0531 0532 Type = AcpiNsGetType (Info->RegionNode); 0533 if (Type != ACPI_TYPE_REGION) 0534 { 0535 ACPI_ERROR ((AE_INFO, 0536 "Needed Region, found type %X (%s)", 0537 Type, AcpiUtGetTypeName (Type))); 0538 0539 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 0540 } 0541 } 0542 0543 /* Allocate a new field object */ 0544 0545 ObjDesc = AcpiUtCreateInternalObject (Info->FieldType); 0546 if (!ObjDesc) 0547 { 0548 return_ACPI_STATUS (AE_NO_MEMORY); 0549 } 0550 0551 /* Initialize areas of the object that are common to all fields */ 0552 0553 ObjDesc->CommonField.Node = Info->FieldNode; 0554 Status = AcpiExPrepCommonFieldObject (ObjDesc, Info->FieldFlags, 0555 Info->Attribute, Info->FieldBitPosition, Info->FieldBitLength); 0556 if (ACPI_FAILURE (Status)) 0557 { 0558 AcpiUtDeleteObjectDesc (ObjDesc); 0559 return_ACPI_STATUS (Status); 0560 } 0561 0562 /* Initialize areas of the object that are specific to the field type */ 0563 0564 switch (Info->FieldType) 0565 { 0566 case ACPI_TYPE_LOCAL_REGION_FIELD: 0567 0568 ObjDesc->Field.RegionObj = AcpiNsGetAttachedObject (Info->RegionNode); 0569 0570 /* An additional reference for the container */ 0571 0572 AcpiUtAddReference (ObjDesc->Field.RegionObj); 0573 0574 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0575 "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n", 0576 ObjDesc->Field.StartFieldBitOffset, ObjDesc->Field.BaseByteOffset, 0577 ObjDesc->Field.AccessByteWidth, ObjDesc->Field.RegionObj)); 0578 break; 0579 0580 0581 case ACPI_TYPE_LOCAL_BANK_FIELD: 0582 0583 ObjDesc->BankField.Value = Info->BankValue; 0584 ObjDesc->BankField.RegionObj = AcpiNsGetAttachedObject ( 0585 Info->RegionNode); 0586 ObjDesc->BankField.BankObj = AcpiNsGetAttachedObject ( 0587 Info->RegisterNode); 0588 0589 /* An additional reference for the attached objects */ 0590 0591 AcpiUtAddReference (ObjDesc->BankField.RegionObj); 0592 AcpiUtAddReference (ObjDesc->BankField.BankObj); 0593 0594 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0595 "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n", 0596 ObjDesc->BankField.StartFieldBitOffset, 0597 ObjDesc->BankField.BaseByteOffset, 0598 ObjDesc->Field.AccessByteWidth, 0599 ObjDesc->BankField.RegionObj, 0600 ObjDesc->BankField.BankObj)); 0601 0602 /* 0603 * Remember location in AML stream of the field unit 0604 * opcode and operands -- since the BankValue 0605 * operands must be evaluated. 0606 */ 0607 SecondDesc = ObjDesc->Common.NextObject; 0608 SecondDesc->Extra.AmlStart = ACPI_CAST_PTR (ACPI_PARSE_OBJECT, Info->DataRegisterNode)->Named.Data; 0609 SecondDesc->Extra.AmlLength = ACPI_CAST_PTR (ACPI_PARSE_OBJECT, Info->DataRegisterNode)->Named.Length; 0610 0611 break; 0612 0613 0614 case ACPI_TYPE_LOCAL_INDEX_FIELD: 0615 0616 /* Get the Index and Data registers */ 0617 0618 ObjDesc->IndexField.IndexObj = AcpiNsGetAttachedObject ( 0619 Info->RegisterNode); 0620 ObjDesc->IndexField.DataObj = AcpiNsGetAttachedObject ( 0621 Info->DataRegisterNode); 0622 0623 if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj) 0624 { 0625 ACPI_ERROR ((AE_INFO, "Null Index Object during field prep")); 0626 AcpiUtDeleteObjectDesc (ObjDesc); 0627 return_ACPI_STATUS (AE_AML_INTERNAL); 0628 } 0629 0630 /* An additional reference for the attached objects */ 0631 0632 AcpiUtAddReference (ObjDesc->IndexField.DataObj); 0633 AcpiUtAddReference (ObjDesc->IndexField.IndexObj); 0634 0635 /* 0636 * April 2006: Changed to match MS behavior 0637 * 0638 * The value written to the Index register is the byte offset of the 0639 * target field in units of the granularity of the IndexField 0640 * 0641 * Previously, the value was calculated as an index in terms of the 0642 * width of the Data register, as below: 0643 * 0644 * ObjDesc->IndexField.Value = (UINT32) 0645 * (Info->FieldBitPosition / ACPI_MUL_8 ( 0646 * ObjDesc->Field.AccessByteWidth)); 0647 * 0648 * February 2006: Tried value as a byte offset: 0649 * ObjDesc->IndexField.Value = (UINT32) 0650 * ACPI_DIV_8 (Info->FieldBitPosition); 0651 */ 0652 ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN ( 0653 ACPI_DIV_8 (Info->FieldBitPosition), 0654 ObjDesc->IndexField.AccessByteWidth); 0655 0656 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, 0657 "IndexField: BitOff %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n", 0658 ObjDesc->IndexField.StartFieldBitOffset, 0659 ObjDesc->IndexField.BaseByteOffset, 0660 ObjDesc->IndexField.Value, 0661 ObjDesc->Field.AccessByteWidth, 0662 ObjDesc->IndexField.IndexObj, 0663 ObjDesc->IndexField.DataObj)); 0664 break; 0665 0666 default: 0667 /* No other types should get here */ 0668 break; 0669 } 0670 0671 /* 0672 * Store the constructed descriptor (ObjDesc) into the parent Node, 0673 * preserving the current type of that NamedObj. 0674 */ 0675 Status = AcpiNsAttachObject (Info->FieldNode, ObjDesc, 0676 AcpiNsGetType (Info->FieldNode)); 0677 0678 ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Set NamedObj %p [%4.4s], ObjDesc %p\n", 0679 Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc)); 0680 0681 /* Remove local reference to the object */ 0682 0683 AcpiUtRemoveReference (ObjDesc); 0684 return_ACPI_STATUS (Status); 0685 } 0686
[ Source navigation ] | [ Diff markup ] | [ Identifier search ] | [ general search ] |
This page was automatically generated by the 1.2.0 LXR engine. |