ReactOS  0.4.15-dev-1070-ge1a01de
exprep.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: exprep - ACPI AML field prep utilities
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2020, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  * notice, this list of conditions, and the following disclaimer,
16  * without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  * substantially similar to the "NO WARRANTY" disclaimer below
19  * ("Disclaimer") and any redistribution must be conditioned upon
20  * including a substantially similar Disclaimer requirement for further
21  * binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  * of any contributors may be used to endorse or promote products derived
24  * from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #include "acpi.h"
45 #include "accommon.h"
46 #include "acinterp.h"
47 #include "amlcode.h"
48 #include "acnamesp.h"
49 #include "acdispat.h"
50 
51 
52 #define _COMPONENT ACPI_EXECUTER
53  ACPI_MODULE_NAME ("exprep")
54 
55 /* Local prototypes */
56 
57 static UINT32
59  ACPI_OPERAND_OBJECT *ObjDesc,
60  UINT8 FieldFlags,
61  UINT32 *ReturnByteAlignment);
62 
63 
64 #ifdef ACPI_UNDER_DEVELOPMENT
65 
66 static UINT32
67 AcpiExGenerateAccess (
68  UINT32 FieldBitOffset,
69  UINT32 FieldBitLength,
70  UINT32 RegionLength);
71 
72 
73 /*******************************************************************************
74  *
75  * FUNCTION: AcpiExGenerateAccess
76  *
77  * PARAMETERS: FieldBitOffset - Start of field within parent region/buffer
78  * FieldBitLength - Length of field in bits
79  * RegionLength - Length of parent in bytes
80  *
81  * RETURN: Field granularity (8, 16, 32 or 64) and
82  * ByteAlignment (1, 2, 3, or 4)
83  *
84  * DESCRIPTION: Generate an optimal access width for fields defined with the
85  * AnyAcc keyword.
86  *
87  * NOTE: Need to have the RegionLength in order to check for boundary
88  * conditions (end-of-region). However, the RegionLength is a deferred
89  * operation. Therefore, to complete this implementation, the generation
90  * of this access width must be deferred until the region length has
91  * been evaluated.
92  *
93  ******************************************************************************/
94 
95 static UINT32
96 AcpiExGenerateAccess (
97  UINT32 FieldBitOffset,
98  UINT32 FieldBitLength,
99  UINT32 RegionLength)
100 {
101  UINT32 FieldByteLength;
102  UINT32 FieldByteOffset;
103  UINT32 FieldByteEndOffset;
104  UINT32 AccessByteWidth;
105  UINT32 FieldStartOffset;
106  UINT32 FieldEndOffset;
107  UINT32 MinimumAccessWidth = 0xFFFFFFFF;
108  UINT32 MinimumAccesses = 0xFFFFFFFF;
109  UINT32 Accesses;
110 
111 
112  ACPI_FUNCTION_TRACE (ExGenerateAccess);
113 
114 
115  /* Round Field start offset and length to "minimal" byte boundaries */
116 
117  FieldByteOffset = ACPI_DIV_8 (
118  ACPI_ROUND_DOWN (FieldBitOffset, 8));
119 
120  FieldByteEndOffset = ACPI_DIV_8 (
121  ACPI_ROUND_UP (FieldBitLength + FieldBitOffset, 8));
122 
123  FieldByteLength = FieldByteEndOffset - FieldByteOffset;
124 
126  "Bit length %u, Bit offset %u\n",
127  FieldBitLength, FieldBitOffset));
128 
130  "Byte Length %u, Byte Offset %u, End Offset %u\n",
131  FieldByteLength, FieldByteOffset, FieldByteEndOffset));
132 
133  /*
134  * Iterative search for the maximum access width that is both aligned
135  * and does not go beyond the end of the region
136  *
137  * Start at ByteAcc and work upwards to QwordAcc max. (1,2,4,8 bytes)
138  */
139  for (AccessByteWidth = 1; AccessByteWidth <= 8; AccessByteWidth <<= 1)
140  {
141  /*
142  * 1) Round end offset up to next access boundary and make sure that
143  * this does not go beyond the end of the parent region.
144  * 2) When the Access width is greater than the FieldByteLength, we
145  * are done. (This does not optimize for the perfectly aligned
146  * case yet).
147  */
148  if (ACPI_ROUND_UP (FieldByteEndOffset, AccessByteWidth) <=
149  RegionLength)
150  {
151  FieldStartOffset =
152  ACPI_ROUND_DOWN (FieldByteOffset, AccessByteWidth) /
153  AccessByteWidth;
154 
155  FieldEndOffset =
156  ACPI_ROUND_UP ((FieldByteLength + FieldByteOffset),
157  AccessByteWidth) / AccessByteWidth;
158 
159  Accesses = FieldEndOffset - FieldStartOffset;
160 
162  "AccessWidth %u end is within region\n", AccessByteWidth));
163 
165  "Field Start %u, Field End %u -- requires %u accesses\n",
166  FieldStartOffset, FieldEndOffset, Accesses));
167 
168  /* Single access is optimal */
169 
170  if (Accesses <= 1)
171  {
173  "Entire field can be accessed "
174  "with one operation of size %u\n",
175  AccessByteWidth));
176  return_VALUE (AccessByteWidth);
177  }
178 
179  /*
180  * Fits in the region, but requires more than one read/write.
181  * try the next wider access on next iteration
182  */
183  if (Accesses < MinimumAccesses)
184  {
185  MinimumAccesses = Accesses;
186  MinimumAccessWidth = AccessByteWidth;
187  }
188  }
189  else
190  {
192  "AccessWidth %u end is NOT within region\n",
193  AccessByteWidth));
194  if (AccessByteWidth == 1)
195  {
197  "Field goes beyond end-of-region!\n"));
198 
199  /* Field does not fit in the region at all */
200 
201  return_VALUE (0);
202  }
203 
204  /*
205  * This width goes beyond the end-of-region, back off to
206  * previous access
207  */
209  "Backing off to previous optimal access width of %u\n",
210  MinimumAccessWidth));
211  return_VALUE (MinimumAccessWidth);
212  }
213  }
214 
215  /*
216  * Could not read/write field with one operation,
217  * just use max access width
218  */
220  "Cannot access field in one operation, using width 8\n"));
221 
222  return_VALUE (8);
223 }
224 #endif /* ACPI_UNDER_DEVELOPMENT */
225 
226 
227 /*******************************************************************************
228  *
229  * FUNCTION: AcpiExDecodeFieldAccess
230  *
231  * PARAMETERS: ObjDesc - Field object
232  * FieldFlags - Encoded fieldflags (contains access bits)
233  * ReturnByteAlignment - Where the byte alignment is returned
234  *
235  * RETURN: Field granularity (8, 16, 32 or 64) and
236  * ByteAlignment (1, 2, 3, or 4)
237  *
238  * DESCRIPTION: Decode the AccessType bits of a field definition.
239  *
240  ******************************************************************************/
241 
242 static UINT32
244  ACPI_OPERAND_OBJECT *ObjDesc,
245  UINT8 FieldFlags,
246  UINT32 *ReturnByteAlignment)
247 {
248  UINT32 Access;
249  UINT32 ByteAlignment;
250  UINT32 BitLength;
251 
252 
253  ACPI_FUNCTION_TRACE (ExDecodeFieldAccess);
254 
255 
256  Access = (FieldFlags & AML_FIELD_ACCESS_TYPE_MASK);
257 
258  switch (Access)
259  {
261 
262 #ifdef ACPI_UNDER_DEVELOPMENT
263  ByteAlignment =
264  AcpiExGenerateAccess (ObjDesc->CommonField.StartFieldBitOffset,
265  ObjDesc->CommonField.BitLength,
266  0xFFFFFFFF /* Temp until we pass RegionLength as parameter */);
267  BitLength = ByteAlignment * 8;
268 #endif
269 
270  ByteAlignment = 1;
271  BitLength = 8;
272  break;
273 
275  case AML_FIELD_ACCESS_BUFFER: /* ACPI 2.0 (SMBus Buffer) */
276 
277  ByteAlignment = 1;
278  BitLength = 8;
279  break;
280 
282 
283  ByteAlignment = 2;
284  BitLength = 16;
285  break;
286 
288 
289  ByteAlignment = 4;
290  BitLength = 32;
291  break;
292 
293  case AML_FIELD_ACCESS_QWORD: /* ACPI 2.0 */
294 
295  ByteAlignment = 8;
296  BitLength = 64;
297  break;
298 
299  default:
300 
301  /* Invalid field access type */
302 
304  "Unknown field access type 0x%X",
305  Access));
306 
307  return_UINT32 (0);
308  }
309 
310  if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
311  {
312  /*
313  * BufferField access can be on any byte boundary, so the
314  * ByteAlignment is always 1 byte -- regardless of any ByteAlignment
315  * implied by the field access type.
316  */
317  ByteAlignment = 1;
318  }
319 
320  *ReturnByteAlignment = ByteAlignment;
321  return_UINT32 (BitLength);
322 }
323 
324 
325 /*******************************************************************************
326  *
327  * FUNCTION: AcpiExPrepCommonFieldObject
328  *
329  * PARAMETERS: ObjDesc - The field object
330  * FieldFlags - Access, LockRule, and UpdateRule.
331  * The format of a FieldFlag is described
332  * in the ACPI specification
333  * FieldAttribute - Special attributes (not used)
334  * FieldBitPosition - Field start position
335  * FieldBitLength - Field length in number of bits
336  *
337  * RETURN: Status
338  *
339  * DESCRIPTION: Initialize the areas of the field object that are common
340  * to the various types of fields. Note: This is very "sensitive"
341  * code because we are solving the general case for field
342  * alignment.
343  *
344  ******************************************************************************/
345 
348  ACPI_OPERAND_OBJECT *ObjDesc,
349  UINT8 FieldFlags,
350  UINT8 FieldAttribute,
351  UINT32 FieldBitPosition,
352  UINT32 FieldBitLength)
353 {
354  UINT32 AccessBitWidth;
355  UINT32 ByteAlignment;
356  UINT32 NearestByteAddress;
357 
358 
359  ACPI_FUNCTION_TRACE (ExPrepCommonFieldObject);
360 
361 
362  /*
363  * Note: the structure being initialized is the
364  * ACPI_COMMON_FIELD_INFO; No structure fields outside of the common
365  * area are initialized by this procedure.
366  */
367  ObjDesc->CommonField.FieldFlags = FieldFlags;
368  ObjDesc->CommonField.Attribute = FieldAttribute;
369  ObjDesc->CommonField.BitLength = FieldBitLength;
370 
371  /*
372  * Decode the access type so we can compute offsets. The access type gives
373  * two pieces of information - the width of each field access and the
374  * necessary ByteAlignment (address granularity) of the access.
375  *
376  * For AnyAcc, the AccessBitWidth is the largest width that is both
377  * necessary and possible in an attempt to access the whole field in one
378  * I/O operation. However, for AnyAcc, the ByteAlignment is always one
379  * byte.
380  *
381  * For all Buffer Fields, the ByteAlignment is always one byte.
382  *
383  * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
384  * the same (equivalent) as the ByteAlignment.
385  */
386  AccessBitWidth = AcpiExDecodeFieldAccess (
387  ObjDesc, FieldFlags, &ByteAlignment);
388  if (!AccessBitWidth)
389  {
391  }
392 
393  /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */
394 
395  ObjDesc->CommonField.AccessByteWidth = (UINT8)
396  ACPI_DIV_8 (AccessBitWidth);
397 
398  /*
399  * BaseByteOffset is the address of the start of the field within the
400  * region. It is the byte address of the first *datum* (field-width data
401  * unit) of the field. (i.e., the first datum that contains at least the
402  * first *bit* of the field.)
403  *
404  * Note: ByteAlignment is always either equal to the AccessBitWidth or 8
405  * (Byte access), and it defines the addressing granularity of the parent
406  * region or buffer.
407  */
408  NearestByteAddress =
409  ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition);
410  ObjDesc->CommonField.BaseByteOffset = (UINT32)
411  ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment);
412 
413  /*
414  * StartFieldBitOffset is the offset of the first bit of the field within
415  * a field datum.
416  */
417  ObjDesc->CommonField.StartFieldBitOffset = (UINT8)
418  (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset));
419 
421 }
422 
423 
424 /*******************************************************************************
425  *
426  * FUNCTION: AcpiExPrepFieldValue
427  *
428  * PARAMETERS: Info - Contains all field creation info
429  *
430  * RETURN: Status
431  *
432  * DESCRIPTION: Construct an object of type ACPI_OPERAND_OBJECT with a
433  * subtype of DefField and connect it to the parent Node.
434  *
435  ******************************************************************************/
436 
440 {
441  ACPI_OPERAND_OBJECT *ObjDesc;
442  ACPI_OPERAND_OBJECT *SecondDesc = NULL;
444  UINT32 AccessByteWidth;
445  UINT32 Type;
446 
447 
448  ACPI_FUNCTION_TRACE (ExPrepFieldValue);
449 
450 
451  /* Parameter validation */
452 
453  if (Info->FieldType != ACPI_TYPE_LOCAL_INDEX_FIELD)
454  {
455  if (!Info->RegionNode)
456  {
457  ACPI_ERROR ((AE_INFO, "Null RegionNode"));
459  }
460 
461  Type = AcpiNsGetType (Info->RegionNode);
462  if (Type != ACPI_TYPE_REGION)
463  {
464  ACPI_ERROR ((AE_INFO, "Needed Region, found type 0x%X (%s)",
466 
468  }
469  }
470 
471  /* Allocate a new field object */
472 
473  ObjDesc = AcpiUtCreateInternalObject (Info->FieldType);
474  if (!ObjDesc)
475  {
477  }
478 
479  /* Initialize areas of the object that are common to all fields */
480 
481  ObjDesc->CommonField.Node = Info->FieldNode;
483  Info->FieldFlags, Info->Attribute,
484  Info->FieldBitPosition, Info->FieldBitLength);
485  if (ACPI_FAILURE (Status))
486  {
487  AcpiUtDeleteObjectDesc (ObjDesc);
489  }
490 
491  /* Initialize areas of the object that are specific to the field type */
492 
493  switch (Info->FieldType)
494  {
496 
497  ObjDesc->Field.RegionObj = AcpiNsGetAttachedObject (Info->RegionNode);
498 
499  /* Fields specific to GenericSerialBus fields */
500 
501  ObjDesc->Field.AccessLength = Info->AccessLength;
502 
503  if (Info->ConnectionNode)
504  {
505  SecondDesc = Info->ConnectionNode->Object;
506  if (!(SecondDesc->Common.Flags & AOPOBJ_DATA_VALID))
507  {
508  Status = AcpiDsGetBufferArguments (SecondDesc);
509  if (ACPI_FAILURE (Status))
510  {
511  AcpiUtDeleteObjectDesc (ObjDesc);
513  }
514  }
515 
516  ObjDesc->Field.ResourceBuffer =
517  SecondDesc->Buffer.Pointer;
518  ObjDesc->Field.ResourceLength =
519  (UINT16) SecondDesc->Buffer.Length;
520  }
521  else if (Info->ResourceBuffer)
522  {
523  ObjDesc->Field.ResourceBuffer = Info->ResourceBuffer;
524  ObjDesc->Field.ResourceLength = Info->ResourceLength;
525  }
526 
527  ObjDesc->Field.PinNumberIndex = Info->PinNumberIndex;
528 
529  /* Allow full data read from EC address space */
530 
531  if ((ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_EC) &&
532  (ObjDesc->CommonField.BitLength > 8))
533  {
534  AccessByteWidth = ACPI_ROUND_BITS_UP_TO_BYTES (
535  ObjDesc->CommonField.BitLength);
536 
537  /* Maximum byte width supported is 255 */
538 
539  if (AccessByteWidth < 256)
540  {
541  ObjDesc->CommonField.AccessByteWidth =
542  (UINT8) AccessByteWidth;
543  }
544  }
545 
546  /* An additional reference for the container */
547 
549 
551  "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n",
552  ObjDesc->Field.StartFieldBitOffset,
553  ObjDesc->Field.BaseByteOffset,
554  ObjDesc->Field.AccessByteWidth,
555  ObjDesc->Field.RegionObj));
556  break;
557 
559 
560  ObjDesc->BankField.Value = Info->BankValue;
561  ObjDesc->BankField.RegionObj =
562  AcpiNsGetAttachedObject (Info->RegionNode);
563  ObjDesc->BankField.BankObj =
564  AcpiNsGetAttachedObject (Info->RegisterNode);
565 
566  /* An additional reference for the attached objects */
567 
570 
572  "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n",
573  ObjDesc->BankField.StartFieldBitOffset,
574  ObjDesc->BankField.BaseByteOffset,
575  ObjDesc->Field.AccessByteWidth,
576  ObjDesc->BankField.RegionObj,
577  ObjDesc->BankField.BankObj));
578 
579  /*
580  * Remember location in AML stream of the field unit
581  * opcode and operands -- since the BankValue
582  * operands must be evaluated.
583  */
584  SecondDesc = ObjDesc->Common.NextObject;
586  Info->DataRegisterNode)->Named.Data;
588  Info->DataRegisterNode)->Named.Length;
589 
590  break;
591 
593 
594  /* Get the Index and Data registers */
595 
596  ObjDesc->IndexField.IndexObj =
597  AcpiNsGetAttachedObject (Info->RegisterNode);
598  ObjDesc->IndexField.DataObj =
599  AcpiNsGetAttachedObject (Info->DataRegisterNode);
600 
601  if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)
602  {
603  ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));
604  AcpiUtDeleteObjectDesc (ObjDesc);
606  }
607 
608  /* An additional reference for the attached objects */
609 
612 
613  /*
614  * April 2006: Changed to match MS behavior
615  *
616  * The value written to the Index register is the byte offset of the
617  * target field in units of the granularity of the IndexField
618  *
619  * Previously, the value was calculated as an index in terms of the
620  * width of the Data register, as below:
621  *
622  * ObjDesc->IndexField.Value = (UINT32)
623  * (Info->FieldBitPosition / ACPI_MUL_8 (
624  * ObjDesc->Field.AccessByteWidth));
625  *
626  * February 2006: Tried value as a byte offset:
627  * ObjDesc->IndexField.Value = (UINT32)
628  * ACPI_DIV_8 (Info->FieldBitPosition);
629  */
630  ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (
631  ACPI_DIV_8 (Info->FieldBitPosition),
632  ObjDesc->IndexField.AccessByteWidth);
633 
635  "IndexField: BitOff %X, Off %X, Value %X, "
636  "Gran %X, Index %p, Data %p\n",
637  ObjDesc->IndexField.StartFieldBitOffset,
638  ObjDesc->IndexField.BaseByteOffset,
639  ObjDesc->IndexField.Value,
640  ObjDesc->Field.AccessByteWidth,
641  ObjDesc->IndexField.IndexObj,
642  ObjDesc->IndexField.DataObj));
643  break;
644 
645  default:
646 
647  /* No other types should get here */
648 
649  break;
650  }
651 
652  /*
653  * Store the constructed descriptor (ObjDesc) into the parent Node,
654  * preserving the current type of that NamedObj.
655  */
657  Info->FieldNode, ObjDesc, AcpiNsGetType (Info->FieldNode));
658 
660  "Set NamedObj %p [%4.4s], ObjDesc %p\n",
661  Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));
662 
663  /* Remove local reference to the object */
664 
665  AcpiUtRemoveReference (ObjDesc);
667 }
#define ACPI_DB_BFIELD
Definition: acoutput.h:168
void AcpiUtAddReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:747
Type
Definition: Type.h:6
#define AE_NO_MEMORY
Definition: acexcep.h:112
#define return_VALUE(s)
Definition: acoutput.h:499
static UINT32 AcpiExDecodeFieldAccess(ACPI_OPERAND_OBJECT *ObjDesc, UINT8 FieldFlags, UINT32 *ReturnByteAlignment)
Definition: exprep.c:243
#define return_UINT32(s)
Definition: acoutput.h:501
#define AE_AML_OPERAND_VALUE
Definition: acexcep.h:183
ACPI_OBJECT_FIELD_COMMON CommonField
Definition: acobject.h:531
#define AE_AML_INTERNAL
Definition: acexcep.h:194
#define ACPI_MUL_8(a)
Definition: acmacros.h:215
#define AE_AML_NO_OPERAND
Definition: acexcep.h:181
void AcpiUtDeleteObjectDesc(ACPI_OPERAND_OBJECT *Object)
Definition: utobject.c:473
UINT8 * AmlStart
Definition: acobject.h:482
UINT32 ACPI_STATUS
Definition: actypes.h:460
union acpi_operand_object * BankObj
Definition: acobject.h:358
ACPI_STATUS AcpiDsGetBufferArguments(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: dsargs.c:294
ACPI_OBJECT_COMMON_HEADER UINT8 SpaceId
Definition: acobject.h:202
struct TraceInfo Info
#define AE_AML_OPERAND_TYPE
Definition: acexcep.h:182
#define ACPI_TYPE_LOCAL_INDEX_FIELD
Definition: actypes.h:710
ACPI_OBJECT_TYPE AcpiNsGetType(ACPI_NAMESPACE_NODE *Node)
Definition: nsutils.c:120
ACPI_STATUS AcpiExPrepCommonFieldObject(ACPI_OPERAND_OBJECT *ObjDesc, UINT8 FieldFlags, UINT8 FieldAttribute, UINT32 FieldBitPosition, UINT32 FieldBitLength)
Definition: exprep.c:347
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
ACPI_OBJECT_BANK_FIELD BankField
Definition: acobject.h:534
ACPI_OBJECT_EXTRA Extra
Definition: acobject.h:539
unsigned int UINT32
#define ACPI_ROUND_DOWN(value, boundary)
Definition: acmacros.h:239
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
smooth NULL
Definition: ftsmooth.c:416
#define AE_INFO
Definition: acoutput.h:230
ACPI_STATUS AcpiExPrepFieldValue(ACPI_CREATE_FIELD_INFO *Info)
Definition: exprep.c:438
ACPI_OBJECT_REGION Region
Definition: acobject.h:525
union acpi_operand_object * DataObj
Definition: acobject.h:373
ACPI_OBJECT_BUFFER Buffer
Definition: acobject.h:520
#define ACPI_ADR_SPACE_EC
Definition: actypes.h:855
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object * RegionObj
Definition: acobject.h:357
#define ACPI_ROUND_UP(value, boundary)
Definition: acmacros.h:242
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
ACPI_OPERAND_OBJECT * AcpiNsGetAttachedObject(ACPI_NAMESPACE_NODE *Node)
Definition: nsobject.c:308
ACPI_OBJECT_INDEX_FIELD IndexField
Definition: acobject.h:535
#define ACPI_TYPE_LOCAL_REGION_FIELD
Definition: actypes.h:708
Status
Definition: gdiplustypes.h:24
#define ACPI_DIV_8(a)
Definition: acmacros.h:214
union acpi_operand_object * RegionObj
Definition: acobject.h:345
ACPI_STATUS AcpiNsAttachObject(ACPI_NAMESPACE_NODE *Node, ACPI_OPERAND_OBJECT *Object, ACPI_OBJECT_TYPE Type)
Definition: nsobject.c:76
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
#define ACPI_TYPE_BUFFER_FIELD
Definition: actypes.h:693
ACPI_OBJECT_COMMON Common
Definition: acobject.h:517
void AcpiUtRemoveReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:785
unsigned short UINT16
const char * AcpiUtGetTypeName(ACPI_OBJECT_TYPE Type)
Definition: utdecode.c:250
#define ACPI_ROUND_BITS_DOWN_TO_BYTES(a)
Definition: acmacros.h:257
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object * IndexObj
Definition: acobject.h:372
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO UINT16 ResourceLength
Definition: acobject.h:344
const char * AcpiUtGetNodeName(void *Object)
Definition: utdecode.c:306
#define AOPOBJ_DATA_VALID
Definition: acobject.h:96
ACPI_OBJECT_REGION_FIELD Field
Definition: acobject.h:532
#define ACPI_TYPE_REGION
Definition: actypes.h:689
#define ACPI_TYPE_LOCAL_BANK_FIELD
Definition: actypes.h:709
#define ACPI_ROUND_BITS_UP_TO_BYTES(a)
Definition: acmacros.h:256
#define AcpiUtCreateInternalObject(t)
Definition: acutils.h:655
#define ACPI_CAST_PTR(t, p)
Definition: actypes.h:544
unsigned char UINT8
#define AE_OK
Definition: acexcep.h:97
UINT32 AmlLength
Definition: acobject.h:483
#define AML_FIELD_ACCESS_TYPE_MASK
Definition: amlcode.h:442