1 /******************************************************************************
2  *
3  * Module Name: ahaslops - Table of all known ASL operators
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2019, Intel Corp.
12  * All rights reserved.
13  *
14  * 2. License
15  *
16  * 2.1. This is your license from Intel Corp. under its intellectual property
17  * rights. You may have additional license terms from the party that provided
18  * you this software, covering your right to use that party's intellectual
19  * property rights.
20  *
21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22  * copy of the source code appearing in this file ("Covered Code") an
23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24  * base code distributed originally by Intel ("Original Intel Code") to copy,
25  * make derivatives, distribute, use and display any portion of the Covered
26  * Code in any form, with the right to sublicense such rights; and
27  *
28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29  * license (with the right to sublicense), under only those claims of Intel
30  * patents that are infringed by the Original Intel Code, to make, use, sell,
31  * offer to sell, and import the Covered Code and derivative works thereof
32  * solely to the minimum extent necessary to exercise the above copyright
33  * license, and in no event shall the patent license extend to any additions
34  * to or modifications of the Original Intel Code. No other license or right
35  * is granted directly or by implication, estoppel or otherwise;
36  *
37  * The above copyright and patent license is granted only if the following
38  * conditions are met:
39  *
40  * 3. Conditions
41  *
42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43  * Redistribution of source code of any substantial portion of the Covered
44  * Code or modification with rights to further distribute source must include
45  * the above Copyright Notice, the above License, this list of Conditions,
46  * and the following Disclaimer and Export Compliance provision. In addition,
47  * Licensee must cause all Covered Code to which Licensee contributes to
48  * contain a file documenting the changes Licensee made to create that Covered
49  * Code and the date of any change. Licensee must include in that file the
50  * documentation of any changes made by any predecessor Licensee. Licensee
51  * must include a prominent statement that the modification is derived,
52  * directly or indirectly, from Original Intel Code.
53  *
54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55  * Redistribution of source code of any substantial portion of the Covered
56  * Code or modification without rights to further distribute source must
57  * include the following Disclaimer and Export Compliance provision in the
58  * documentation and/or other materials provided with distribution. In
59  * addition, Licensee may not authorize further sublicense of source of any
60  * portion of the Covered Code, and must include terms to the effect that the
61  * license from Licensee to its licensee is limited to the intellectual
62  * property embodied in the software Licensee provides to its licensee, and
63  * not to intellectual property embodied in modifications its licensee may
64  * make.
65  *
66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
67  * substantial portion of the Covered Code or modification must reproduce the
68  * above Copyright Notice, and the following Disclaimer and Export Compliance
69  * provision in the documentation and/or other materials provided with the
70  * distribution.
71  *
72  * 3.4. Intel retains all right, title, and interest in and to the Original
73  * Intel Code.
74  *
75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76  * Intel shall be used in advertising or otherwise to promote the sale, use or
77  * other dealings in products derived from or relating to the Covered Code
78  * without prior written authorization from Intel.
79  *
80  * 4. Disclaimer and Export Compliance
81  *
82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88  * PARTICULAR PURPOSE.
89  *
90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97  * LIMITED REMEDY.
98  *
99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
100  * software or system incorporating such software without first obtaining any
101  * required license or other approval from the U. S. Department of Commerce or
102  * any other agency or department of the United States Government. In the
103  * event Licensee exports any such software from the United States or
104  * re-exports any such software from a foreign destination, Licensee shall
105  * ensure that the distribution and export/re-export of the software is in
106  * compliance with all laws, regulations, orders, or other restrictions of the
107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108  * any of its subsidiaries will export/re-export any technical data, process,
109  * software, or service, directly or indirectly, to any country for which the
110  * United States government or any agency thereof requires an export license,
111  * other governmental approval, or letter of assurance, without first obtaining
112  * such license, approval or letter.
113  *
114  *****************************************************************************
115  *
116  * Alternatively, you may choose to be licensed under the terms of the
117  * following license:
118  *
119  * Redistribution and use in source and binary forms, with or without
120  * modification, are permitted provided that the following conditions
121  * are met:
122  * 1. Redistributions of source code must retain the above copyright
123  *    notice, this list of conditions, and the following disclaimer,
124  *    without modification.
125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126  *    substantially similar to the "NO WARRANTY" disclaimer below
127  *    ("Disclaimer") and any redistribution must be conditioned upon
128  *    including a substantially similar Disclaimer requirement for further
129  *    binary redistribution.
130  * 3. Neither the names of the above-listed copyright holders nor the names
131  *    of any contributors may be used to endorse or promote products derived
132  *    from this software without specific prior written permission.
133  *
134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145  *
146  * Alternatively, you may choose to be licensed under the terms of the
147  * GNU General Public License ("GPL") version 2 as published by the Free
148  * Software Foundation.
149  *
150  *****************************************************************************/
151 
152 #include "acpihelp.h"
153 
154 /*
155  * ASL operators with syntax (directly from ACPI specification).
156  * Note: All tokens require a space separator.
157  * Long lines are automatically split during output.
158  */
159 const AH_ASL_OPERATOR       Gbl_AslOperatorInfo[] =
160 {
161     {"AccessAs",                "(AccessType, AccessAttribKeyword | "
162                                 "ExtendedAttribKeyword (AccessLength))",
163                                 "ChangeFieldUnitAccess"},
164     {"Acquire",                 "(SyncObject, TimeoutValue) => Boolean",
165                                 "Acquire a mutex"},
166     {"Add",                     "(Addend1, Addend2, Result) => Integer",
167                                 "Integer Add"},
168     {"Alias",                   "(SourceObject, AliasObject)",
169                                 "Define a name alias"},
170     {"And",                     "(Source1, Source2, Result) => Integer",
171                                 "Integer Bitwise And"},
172     {"Arg",                     "Arg0 - Arg6",
173                                 "Method argument data objects"},
174     {"BankField",               "(RegionName, BankName, BankValue, "
175                                 "AccessTypeKeyword, LockRuleKeyword, "
176                                 "UpdateRuleKeyword) {FieldUnitList}",
177                                 "Declare fields in a banked configuration object"},
178     {"Break",                   "No parameters",
179                                 "Continue following the innermost enclosing While"},
180     {"BreakPoint",              "No parameters",
181                                 "Used for debugging, stops execution in the debugger"},
182     {"Buffer",                  "(BufferSize) {String or ByteList} => Buffer",
183                                 "Declare Buffer object"},
184     {"Case",                    "(Value) {TermList}",
185                                 "Expression for conditional execution"},
186     {"Concatenate",             "(Source1, Source2, Result) => ComputationalData",
187                                 "Concatenate two strings, integers or buffers"},
188     {"ConcatenateResTemplate",  "(Source1, Source2, Result) => Buffer",
189                                 "Concatenate two resource templates"},
190     {"CondRefOf",               "(Source, Result) => Boolean",
191                                 "Conditional reference to an object"},
192     {"Connection",              "(ResourceMacro)",
193                                 "Associate connection with FieldUnits within a Field object"},
194     {"Continue",                "No parameters",
195                                 "Continue innermost enclosing While loop"},
196     {"CopyObject",              "(Source, Destination) => DataRefObject",
197                                 "Copy and existing object"},
198     {"CreateBitField",          "(SourceBuffer, BitIndex, BitFieldName)",
199                                 "Declare a bit field object of a buffer object"},
200     {"CreateByteField",         "(SourceBuffer, ByteIndex, ByteFieldName)",
201                                 "Declare a byte field object of a buffer object"},
202     {"CreateDWordField",        "(SourceBuffer, ByteIndex, DWordFieldName)",
203                                 "Declare a DWord field object of a buffer object"},
204     {"CreateField",             "(SourceBuffer, BitIndex, NumBits, FieldName)",
205                                 "Declare an arbitrary length bit field of a buffer object"},
206     {"CreateQWordField",        "(SourceBuffer, ByteIndex, QWordFieldName)",
207                                 "Declare a QWord field object of a buffer object"},
208     {"CreateWordField",         "(SourceBuffer, ByteIndex, WordFieldName)",
209                                 "Declare a Word field object of a buffer object"},
210     {"DataTableRegion",         "(RegionName, SignatureString, OemIDString, OemTableIDString)",
211                                 "Declare a Data Table Region"},
212     {"Debug",                   "No parameters",
213                                 "Debugger output"},
214     {"Decrement",               "(Minuend) => Integer",
215                                 "Decrement an Integer"},
216     {"Default",                 "{TermList}",
217                                 "Default execution path in Switch()"},
218     {"DefinitionBlock",         "(AmlFileName, TableSignature, ComplianceRevision, "
219                                 "OemId, TableId, OemRevision) {TermList}",
220                                 "Declare a Definition Block"},
221     {"DerefOf",                 "(Source) => Object",
222                                 "Dereference an object reference"},
223     {"Device",                  "(DeviceName) {TermList}",
224                                 "Declare a bus/device object"},
225     {"Divide",                  "(Dividend, Divisor, Remainder, Result) => Integer",
226                                 "Integer Divide"},
227     {"Dma",                     "(DmaTypeKeyword, BusMasterKeyword, XferTypeKeyword, "
228                                 "DescriptorName) {DmaChannelList} => Buffer",
229                                 "DMA Resource Descriptor macro"},
230     {"DWordIo",                 "(ResourceTypeKeyword, MinKeyword, MaxKeyword, "
231                                 "DecodeKeyword, RangeTypeKeyword, AddressGranularity, "
232                                 "AddressMinimum, AddressMaximum, AddressTranslation, "
233                                 "RangeLength, ResourceSourceIndex, "
234                                 "ResourceSource, DescriptorName, TypeKeyword, TranslationKeyword)",
235                                 "DWord I/O Resource Descriptor macro"},
236     {"DWordMemory",             "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
237                                 "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, "
238                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
239                                 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName, AddressKeyword, "
240                                 "TypeKeyword)",
241                                 "DWord Memory Resource Descriptor macro"},
242     {"DWordSpace",              "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
243                                 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
244                                 "AddressGranularity, AddressMinimum, AddressMaximum, "
245                                 "AddressTranslation, RangeLength, "
246                                 "ResourceSourceIndex, ResourceSource, DescriptorName)",
247                                 "DWord Space Resource Descriptor macro"},
248     {"EisaId",                  "(EisaIdString) => DWordConst",
249                                 "EISA ID String to Integer conversion macro"},
250     {"Else",                    "{TermList}",
251                                 "Alternate conditional execution"},
252     {"ElseIf",                  "(Predicate)",
253                                 "Conditional execution"},
254     {"EndDependentFn",          "() => Buffer",
255                                 "End Dependent Function Resource Descriptor macro"},
256     {"Event",                   "(EventName)",
257                                 "Declare an event synchronization object"},
258     {"ExtendedIo",              "(ResourceTypeKeyword, MinKeyword, MaxKeyword, "
259                                 "DecodeKeyword, RangeTypeKeyword, AddressGranularity, "
260                                 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
261                                 "TypeSpecificAttributes, DescriptorName, TypeKeyword, TranslationKeyword)",
262                                 "Extended I/O Resource Descriptor macro"},
263     {"ExtendedMemory",          "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
264                                 "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, "
265                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
266                                 "RangeLength, TypeSpecificAttributes, DescriptorName, "
267                                 "AddressKeyword, TypeKeyword)",
268                                 "Extended Memory Resource Descriptor macro"},
269     {"ExtendedSpace",           "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
270                                 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
271                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
272                                 "RangeLength, TypeSpecificAttributes, DescriptorName)",
273                                 "Extended Space Resource Descriptor macro"},
274     {"External",                "(ObjectName, ObjectTypeKeyword, ReturnType, ParameterTypes)",
275                                 "Declare external objects"},
276     {"Fatal",                   "(Type, Code, Arg)",
277                                 "Fatal error check"},
278     {"Field",                   "(RegionName, AccessTypeKeyword, LockRuleKeyword, "
279                                 "UpdateRuleKeyword) {FieldUnitList}",
280                                 "Declare fields of an operation region object"},
281     {"FindSetLeftBit",          "(Source, Result) => Integer",
282                                 "Index of first least significant bit set"},
283     {"FindSetRightBit",         "(Source, Result) => Integer",
284                                 "Index of first most significant bit set"},
285     {"FixedDma",                "(DmaRequestLine, Channel, TransferWidthKeyword, DescriptorName) => Buffer",
286                                 "Fixed DMA Resource Descriptor macro"},
287     {"FixedIo",                 "(AddressBase, RangeLength, DescriptorName) => Buffer",
288                                 "Fixed I/O Resource Descriptor macro"},
289     {"FromBcd",                 "(BcdValue, Result) => Integer",
290                                 "Convert from BCD to numeric"},
291     {"Function",                "(FunctionName, ReturnType, ParameterTypes) {TermList}",
292                                 "Declare control method"},
293     {"GpioInt",                 "(InterruptTypeKeyword, InterruptLevelKeyword, "
294                                 "ShareTypeKeyword, PinConfigKeyword, "
295                                 "DebounceTimeout, ResourceSource, "
296                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
297                                 "RawDataBuffer() {VendorData}) {Pin}",
298                                 "GPIO Interrupt Connection Resource Descriptor Macro"},
299     {"GpioIo",                  "(ShareTypeKeyword, PinConfigKeyword, DebounceTimeout, DriveStrength, "
300                                 "IoRestrictionKeyword, ResourceSource, "
301                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
302                                 "RawDataBuffer() {VendorData}) {PinList}",
303                                 "GPIO I/O Connection Resource Descriptor Macro"},
304     {"I2cSerialBusV2",           "(SlaveAddress, SlaveModeKeyword, ConnectionSpeed, "
305                                 "AddressingModeKeyword, ResourceSource, "
306                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, Shared, "
307                                 "RawDataBuffer() {VendorData})",
308                                 "I2C Serial Bus Connection Resource Descriptor Macro"},
309     {"If",                      "(Predicate) {TermList}",
310                                 "Conditional execution"},
311     {"Include",                 "(FilePathName)",
312                                 "Include another ASL file"},
313     {"Increment",               "(Addend) => Integer",
314                                 "Increment a Integer"},
315     {"Index",                   "(Source, Index, Destination) => ObjectReference",
316                                 "Indexed Reference to member object"},
317     {"IndexField",              "(IndexName, DataName, AccessTypeKeyword, LockRuleKeyword, "
318                                 "UpdateRuleKeyword) {FieldUnitList}",
319                                 "Declare Index/Data Fields"},
320     {"Interrupt",               "(ResourceTypeKeyword, InterruptTypeKeyword, InterruptLevelKeyword, "
321                                 "ShareTypeKeyword, ResourceSourceIndex, "
322                                 "ResourceSource, DescriptorName) {InterruptList} => Buffer",
323                                 "Interrupt Resource Descriptor macro"},
324     {"Io",                      "(IoDecodeKeyword, AddressMin, AddressMax, AddressAlignment, "
325                                 "RangeLength, DescriptorName) => Buffer",
326                                 "I/O Resource Descriptor macro"},
327     {"Irq",                     "(InterruptTypeKeyword, InterruptLevelKeyword, ShareTypeKeyword, "
328                                 "DescriptorName) {InterruptList} => Buffer",
329                                 "Interrupt Resource Descriptor macro"},
330     {"IrqNoFlags",              "(DescriptorName) {InterruptList} => Buffer",
331                                 "Short Interrupt Resource Descriptor macro"},
332     {"LAnd",                    "(Source1, Source2) => Boolean",
333                                 "Logical And"},
334     {"LEqual",                  "(Source1, Source2) => Boolean",
335                                 "Logical Equal"},
336     {"LGreater",                "(Source1, Source2) => Boolean",
337                                 "Logical Greater"},
338     {"LGreaterEqual",           "(Source1, Source2) => Boolean",
339                                 "Logical Not less"},
340     {"LLess",                   "(Source1, Source2) => Boolean",
341                                 "Logical Less"},
342     {"LLessEqual",              "(Source1, Source2) => Boolean",
343                                 "Logical Not greater"},
344     {"LNot",                    "(Source) => Boolean",
345                                 "Logical Not"},
346     {"LNotEqual",               "(Source1, Source2) => Boolean",
347                                 "Logical Not equal"},
348     {"Load",                    "(Object, DDBHandle)",
349                                 "Load differentiating definition block"},
350     {"LoadTable",               "(SignatureString, OemIdString, OemTableIdString, RootPathString, "
351                                 "ParameterPathString, ParameterData) => DDBHandle",
352                                 "Load Table from RSDT/XSDT"},
353     {"Local",                   "Local0 - Local7",
354                                 "Method local data objects"},
355     {"LOr",                     "(Source1, Source2) => Boolean",
356                                 "Logical Or"},
357     {"Match",                   "(SearchPackage, MatchOpKeyword, MatchObject1, MatchOpKeyword, "
358                                 "MatchObject2, StartIndex) => Ones | Integer",
359                                 "Search for match in package array"},
360     {"Memory24",                "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, "
361                                 "RangeLength, DescriptorName)",
362                                 "Memory Resource Descriptor macro"},
363     {"Memory32",                "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, "
364                                 "RangeLength, DescriptorName)",
365                                 "Memory Resource Descriptor macro"},
366     {"Memory32Fixed",           "(ReadWriteKeyword, AddressBase, RangeLength, DescriptorName)",
367                                 "Memory Resource Descriptor macro"},
368     {"Method",                  "(MethodName, NumArgs, SerializeRuleKeyword, "
369                                 "SyncLevel, ReturnType, ParameterTypes) "
370                                 "{TermList}",
371                                 "Declare a control method"},
372     {"Mid",                     "(Source, Index, Length, Result) => Buffer or String",
373                                 "Return a portion of buffer or string"},
374     {"Mod",                     "(Dividend, Divisor, Result) => Integer",
375                                 "Integer Modulo"},
376     {"Multiply",                "(Multiplicand, Multiplier, Result) => Integer",
377                                 "Integer Multiply"},
378     {"Mutex",                   "(MutexName, SyncLevel)",
379                                 "Declare a mutex synchronization object"},
380     {"Name",                    "(ObjectName, Object)",
381                                 "Declare a Named object"},
382     {"NAnd",                    "(Source1, Source2, Result) => Integer",
383                                 "Integer Bitwise Nand"},
384     {"NoOp",                    "No parameters",
385                                 "No operation"},
386     {"NOr",                     "(Source1, Source2, Result) => Integer",
387                                 "Integer Bitwise Nor"},
388     {"Not",                     "(Source, Result) => Integer",
389                                 "Integer Bitwise Not"},
390     {"Notify",                  "(Object, NotificationValue)",
391                                 "Notify Object of event"},
392     {"ObjectType",              "(Object) => Integer",
393                                 "Type of object"},
394     {"Offset",                  "(ByteOffset)",
395                                 "Change Current Field Unit Offset"},
396     {"One",                     "=> Integer",
397                                 "Constant One Object (1)"},
398     {"Ones",                    "=> Integer",
399                                 "Constant Ones Object (0xFFFFFFFF or 0xFFFFFFFFFFFFFFFF)"},
400     {"OperationRegion",         "(RegionName, RegionSpaceKeyword, Offset, Length)",
401                                 "Declare an operational region"},
402     {"Or",                      "(Source1, Source2, Result) => Integer",
403                                 "Integer Bitwise Or"},
404     {"Package",                 "(NumElements) {PackageList} => Package",
405                                 "Declare a package object"},
406     {"PowerResource",           "(ResourceName, SystemLevel, ResourceOrder) {TermList}",
407                                 "Declare a power resource object"},
408     {"Processor",               "(ProcessorName, ProcessorID, PBlockAddress, PblockLength) {TermList}",
409                                 "Declare a processor package"},
410     {"QWordIo",                 "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
411                                 "RangeTypeKeyword, AddressGranularity, "
412                                 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
413                                 "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, "
414                                 "TranslationKeyword)",
415                                 "QWord I/O Resource Descriptor macro"},
416     {"QWordMemory",             "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, MaxKeyword, "
417                                 "MemTypeKeyword, ReadWriteKeyword, "
418                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
419                                 "RangeLength, ResourceSourceIndex, ResourceSource, "
420                                 "DescriptorName, AddressKeyword, "
421                                 "TypeKeyword)",
422                                 "QWord Memory Resource Descriptor macro"},
423     {"QWordSpace",              "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
424                                 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
425                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
426                                 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)",
427                                 "Qword Space Resource Descriptor macro"},
428     {"RawDataBuffer",           "(BufferSize) {ByteList} => RawDataBuffer",
429                                 "Create a raw data buffer (does not use Buffer AML opcode)"},
430     {"RefOf",                   "(Object) => ObjectReference",
431                                 "Create Reference to an object"},
432     {"Register",                "(AddressSpaceKeyword, RegisterBitWidth, "
433                                 "RegisterBitOffset, RegisterAddress, "
434                                 "AccessSize, DescriptorName)",
435                                 "Generic register Resource Descriptor macro"},
436     {"Release",                 "(SyncObject)",
437                                 "Release a synchronization object"},
438     {"Reset",                   "(SyncObject)",
439                                 "Reset a synchronization object"},
440     {"ResourceTemplate",        "() {ResourceMacroList} => Buffer",
441                                 "Resource to buffer conversion macro"},
442     {"Return",                  "None | () | (ReturnArg)",
443                                 "Return from method execution"},
444     {"Revision",                "=> Integer",
445                                 "Constant revision object"},
446     {"Scope",                   "(Location) {TermList}",
447                                 "Open named scope "},
448     {"ShiftLeft",               "(Source, ShiftCount, Result) => Integer",
449                                 "Integer shift value left"},
450     {"ShiftRight",              "(Source, ShiftCount, Result) => Integer",
451                                 "Integer shift value right"},
452     {"Signal",                  "(SyncObject)",
453                                 "Signal a synchronization object"},
454     {"SizeOf",                  "(ObjectName) => Integer",
455                                 "Get the size of a buffer}, string}, or package"},
456     {"Sleep",                   "(Milliseconds)",
457                                 "Sleep n milliseconds (yields the processor)"},
458     {"SpiSerialBusV2",          "(DeviceSelection, PolarityKeyword, WireModeKeyword, "
459                                 "DataBitLength, SlaveModeKeyword, "
460                                 "ConnectionSpeed, ClockPolarityKeyword, ClockPhaseKeyword, "
461                                 "ResourceSource, ResourceSourceIndex, "
462                                 "ResourceTypeKeyword, DescriptorName, Shared, RawDataBuffer() {VendorData})",
463                                 "SPI Serial Bus Connection Resource Descriptor Macro"},
464     {"Stall",                   "(Microseconds)",
465                                 "Delay n microseconds (does not yield the processor)"},
466     {"StartDependentFn",        "(CompatibilityPriority, PerformancePriority) {ResourceList}",
467                                 "Start Dependent Function Resource Descriptor macro"},
468     {"StartDependentFnNoPri",   "() {ResourceList}",
469                                 "Start Dependent Function Resource Descriptor macro"},
470     {"Store",                   "(Source, Destination) => DataRefObject",
471                                 "Store object"},
472     {"Subtract",                "(Minuend, Subtrahend, Result) => Integer",
473                                 "Integer Subtract"},
474     {"Switch",                  "(Expression) {CaseTermList}",
475                                 "Select code to execute based on expression value"},
476     {"ThermalZone",             "(ThermalZoneName) {TermList}",
477                                 "Declare a thermal zone package"},
478     {"Timer",                   "=> Integer",
479                                 "Get 64-bit timer value"},
480     {"ToBcd",                   "(Value, Result) => Integer",
481                                 "Convert Integer to BCD"},
482     {"ToBuffer",                "(Data, Result) => Buffer",
483                                 "Convert data type to buffer"},
484     {"ToDecimalString",         "(Data, Result) => String",
485                                 "Convert data type to decimal string"},
486     {"ToHexString",             "(Data, Result) => String",
487                                 "Convert data type to hexadecimal string"},
488     {"ToInteger",               "(Data, Result) => Integer",
489                                 "Convert data type to integer"},
490     {"ToString",                "(Source, Length, Result) => String",
491                                 "Copy ASCII string from buffer"},
492     {"ToUuid",                  "(AsciiString) => Buffer",
493                                 "Convert Ascii string to UUID"},
494     {"UartSerialBusV2",         "(ConnectionSpeed, ByteLengthKeyword, StopBitsKeyword, "
495                                 "LinesInUse, EndianKeyword, ParityKeyword, "
496                                 "FlowControlKeyword, ReceiveBufferSize, TransmitBufferSize, ResourceSource, "
497                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, Shared, "
498                                 "RawDataBuffer() {VendorData})",
499                                 "UART Serial Bus Connection Resource Descriptor Macro"},
500     {"Unicode",                 "(String) => Buffer",
501                                 "String to Unicode conversion macro"},
502     {"Unload",                  "(Handle)",
503                                 "Unload definition block"},
504     {"VendorLong",              "(DescriptorName) {VendorByteList}",
505                                 "Vendor Resource Descriptor"},
506     {"VendorShort",             "(DescriptorName) {VendorByteList}",
507                                 "Vendor Resource Descriptor"},
508     {"Wait",                    "(SyncObject, TimeoutValue) => Boolean",
509                                 "Wait on an Event"},
510     {"While",                   "(Predicate) {TermList}",
511                                 "Conditional loop"},
512     {"WordBusNumber",           "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
513                                 "AddressGranularity, AddressMinimum, "
514                                 "AddressMaximum, AddressTranslation, RangeLength, ResourceSourceIndex, "
515                                 "ResourceSource, DescriptorName)",
516                                 "Word Bus number Resource Descriptor macro"},
517     {"WordIo",                  "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
518                                 "RangeTypeKeyword, AddressGranularity, "
519                                 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
520                                 "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, "
521                                 "TranslationKeyword)",
522                                 "Word I/O Resource Descriptor macro"},
523     {"WordSpace",               "(ResourceType, ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
524                                 "MaxKeyword, TypeSpecificFlags, "
525                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
526                                 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)",
527                                 "Word Space Resource Descriptor macro"},
528     {"Xor",                     "(Source1, Source2, Result) => Integer",
529                                 "Integer Bitwise Xor"},
530     {"Zero",                    "=> Integer",
531                                 "Constant Zero object (0)"},
532     {NULL, NULL, NULL}
533 };
534