ReactOS 0.4.15-dev-8348-gc1b9bb5
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 - 2022, 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 MERCHANTABILITY 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
57static UINT32
59 ACPI_OPERAND_OBJECT *ObjDesc,
60 UINT8 FieldFlags,
61 UINT32 *ReturnByteAlignment);
62
63
64#ifdef ACPI_UNDER_DEVELOPMENT
65
66static UINT32
67AcpiExGenerateAccess (
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
95static UINT32
96AcpiExGenerateAccess (
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
242static 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
547 "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n",
548 ObjDesc->Field.StartFieldBitOffset,
549 ObjDesc->Field.BaseByteOffset,
550 ObjDesc->Field.AccessByteWidth,
551 ObjDesc->Field.RegionObj));
552 break;
553
555
556 ObjDesc->BankField.Value = Info->BankValue;
557 ObjDesc->BankField.RegionObj =
558 AcpiNsGetAttachedObject (Info->RegionNode);
559 ObjDesc->BankField.BankObj =
560 AcpiNsGetAttachedObject (Info->RegisterNode);
561
562 /* An additional reference for the attached objects */
563
566
568 "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n",
569 ObjDesc->BankField.StartFieldBitOffset,
570 ObjDesc->BankField.BaseByteOffset,
571 ObjDesc->Field.AccessByteWidth,
572 ObjDesc->BankField.RegionObj,
573 ObjDesc->BankField.BankObj));
574
575 /*
576 * Remember location in AML stream of the field unit
577 * opcode and operands -- since the BankValue
578 * operands must be evaluated.
579 */
580 SecondDesc = ObjDesc->Common.NextObject;
582 Info->DataRegisterNode)->Named.Data;
584 Info->DataRegisterNode)->Named.Length;
585
586 break;
587
589
590 /* Get the Index and Data registers */
591
592 ObjDesc->IndexField.IndexObj =
593 AcpiNsGetAttachedObject (Info->RegisterNode);
594 ObjDesc->IndexField.DataObj =
595 AcpiNsGetAttachedObject (Info->DataRegisterNode);
596
597 if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)
598 {
599 ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));
600 AcpiUtDeleteObjectDesc (ObjDesc);
602 }
603
604 /* An additional reference for the attached objects */
605
608
609 /*
610 * April 2006: Changed to match MS behavior
611 *
612 * The value written to the Index register is the byte offset of the
613 * target field in units of the granularity of the IndexField
614 *
615 * Previously, the value was calculated as an index in terms of the
616 * width of the Data register, as below:
617 *
618 * ObjDesc->IndexField.Value = (UINT32)
619 * (Info->FieldBitPosition / ACPI_MUL_8 (
620 * ObjDesc->Field.AccessByteWidth));
621 *
622 * February 2006: Tried value as a byte offset:
623 * ObjDesc->IndexField.Value = (UINT32)
624 * ACPI_DIV_8 (Info->FieldBitPosition);
625 */
626 ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (
627 ACPI_DIV_8 (Info->FieldBitPosition),
628 ObjDesc->IndexField.AccessByteWidth);
629
631 "IndexField: BitOff %X, Off %X, Value %X, "
632 "Gran %X, Index %p, Data %p\n",
633 ObjDesc->IndexField.StartFieldBitOffset,
634 ObjDesc->IndexField.BaseByteOffset,
635 ObjDesc->IndexField.Value,
636 ObjDesc->Field.AccessByteWidth,
637 ObjDesc->IndexField.IndexObj,
638 ObjDesc->IndexField.DataObj));
639 break;
640
641 default:
642
643 /* No other types should get here */
644
645 break;
646 }
647
648 /*
649 * Store the constructed descriptor (ObjDesc) into the parent Node,
650 * preserving the current type of that NamedObj.
651 */
653 Info->FieldNode, ObjDesc, AcpiNsGetType (Info->FieldNode));
654
656 "Set NamedObj %p [%4.4s], ObjDesc %p\n",
657 Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));
658
659 /* Remove local reference to the object */
660
661 AcpiUtRemoveReference (ObjDesc);
663}
unsigned short UINT16
unsigned char UINT8
unsigned int UINT32
Type
Definition: Type.h:7
#define AE_AML_NO_OPERAND
Definition: acexcep.h:181
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define AE_AML_INTERNAL
Definition: acexcep.h:194
#define AE_AML_OPERAND_VALUE
Definition: acexcep.h:183
#define AE_NO_MEMORY
Definition: acexcep.h:112
#define AE_AML_OPERAND_TYPE
Definition: acexcep.h:182
#define AE_OK
Definition: acexcep.h:97
#define ACPI_ROUND_DOWN(value, boundary)
Definition: acmacros.h:239
#define ACPI_MUL_8(a)
Definition: acmacros.h:215
#define ACPI_DIV_8(a)
Definition: acmacros.h:214
#define ACPI_ROUND_UP(value, boundary)
Definition: acmacros.h:242
#define ACPI_ROUND_BITS_DOWN_TO_BYTES(a)
Definition: acmacros.h:257
#define ACPI_ROUND_BITS_UP_TO_BYTES(a)
Definition: acmacros.h:256
ACPI_OPERAND_OBJECT * AcpiNsGetAttachedObject(ACPI_NAMESPACE_NODE *Node)
Definition: nsobject.c:308
ACPI_OBJECT_TYPE AcpiNsGetType(ACPI_NAMESPACE_NODE *Node)
Definition: nsutils.c:120
ACPI_STATUS AcpiNsAttachObject(ACPI_NAMESPACE_NODE *Node, ACPI_OPERAND_OBJECT *Object, ACPI_OBJECT_TYPE Type)
Definition: nsobject.c:76
#define AOPOBJ_DATA_VALID
Definition: acobject.h:96
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
#define return_VALUE(s)
Definition: acoutput.h:499
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
#define ACPI_DB_BFIELD
Definition: acoutput.h:168
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
#define AE_INFO
Definition: acoutput.h:230
#define return_UINT32(s)
Definition: acoutput.h:501
#define ACPI_ADR_SPACE_EC
Definition: actypes.h:864
#define ACPI_TYPE_BUFFER_FIELD
Definition: actypes.h:701
#define ACPI_TYPE_LOCAL_BANK_FIELD
Definition: actypes.h:717
#define ACPI_TYPE_REGION
Definition: actypes.h:697
#define ACPI_TYPE_LOCAL_REGION_FIELD
Definition: actypes.h:716
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_CAST_PTR(t, p)
Definition: actypes.h:544
#define ACPI_TYPE_LOCAL_INDEX_FIELD
Definition: actypes.h:718
#define AcpiUtCreateInternalObject(t)
Definition: acutils.h:681
const char * AcpiUtGetTypeName(ACPI_OBJECT_TYPE Type)
Definition: utdecode.c:250
const char * AcpiUtGetNodeName(void *Object)
Definition: utdecode.c:306
void AcpiUtRemoveReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:790
void AcpiUtDeleteObjectDesc(ACPI_OPERAND_OBJECT *Object)
Definition: utobject.c:473
void AcpiUtAddReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:752
#define AML_FIELD_ACCESS_TYPE_MASK
Definition: amlcode.h:442
@ AML_FIELD_ACCESS_BYTE
Definition: amlcode.h:452
@ AML_FIELD_ACCESS_ANY
Definition: amlcode.h:451
@ AML_FIELD_ACCESS_WORD
Definition: amlcode.h:453
@ AML_FIELD_ACCESS_DWORD
Definition: amlcode.h:454
@ AML_FIELD_ACCESS_BUFFER
Definition: amlcode.h:456
@ AML_FIELD_ACCESS_QWORD
Definition: amlcode.h:455
#define NULL
Definition: types.h:112
ACPI_STATUS AcpiDsGetBufferArguments(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: dsargs.c:294
static UINT32 AcpiExDecodeFieldAccess(ACPI_OPERAND_OBJECT *ObjDesc, UINT8 FieldFlags, UINT32 *ReturnByteAlignment)
Definition: exprep.c:243
ACPI_STATUS AcpiExPrepFieldValue(ACPI_CREATE_FIELD_INFO *Info)
Definition: exprep.c:438
ACPI_STATUS AcpiExPrepCommonFieldObject(ACPI_OPERAND_OBJECT *ObjDesc, UINT8 FieldFlags, UINT8 FieldAttribute, UINT32 FieldBitPosition, UINT32 FieldBitLength)
Definition: exprep.c:347
Status
Definition: gdiplustypes.h:25
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object * RegionObj
Definition: acobject.h:358
union acpi_operand_object * BankObj
Definition: acobject.h:359
UINT32 AmlLength
Definition: acobject.h:485
UINT8 * AmlStart
Definition: acobject.h:484
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object * IndexObj
Definition: acobject.h:373
union acpi_operand_object * DataObj
Definition: acobject.h:374
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO UINT16 ResourceLength
Definition: acobject.h:345
union acpi_operand_object * RegionObj
Definition: acobject.h:346
ACPI_OBJECT_COMMON_HEADER UINT8 SpaceId
Definition: acobject.h:202
ACPI_OBJECT_REGION_FIELD Field
Definition: acobject.h:534
ACPI_OBJECT_BANK_FIELD BankField
Definition: acobject.h:536
ACPI_OBJECT_REGION Region
Definition: acobject.h:527
ACPI_OBJECT_EXTRA Extra
Definition: acobject.h:541
ACPI_OBJECT_INDEX_FIELD IndexField
Definition: acobject.h:537
ACPI_OBJECT_COMMON Common
Definition: acobject.h:519
ACPI_OBJECT_FIELD_COMMON CommonField
Definition: acobject.h:533
ACPI_OBJECT_BUFFER Buffer
Definition: acobject.h:522
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690