aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
authorJung-uk Kim <jkim@FreeBSD.org>2010-04-28 21:50:57 +0000
committerJung-uk Kim <jkim@FreeBSD.org>2010-04-28 21:50:57 +0000
commit5b663f0c698a9ecf7e562f7f7f730d056e499b5f (patch)
tree8e0094680041ac8d48075e0787478ffeb5d61682 /tests
parent9a8b5e6355e39ba0602a7f9484dca40f429fe6b0 (diff)
downloadsrc-5b663f0c698a9ecf7e562f7f7f730d056e499b5f.tar.gz
src-5b663f0c698a9ecf7e562f7f7f730d056e499b5f.zip
Import ACPICA 20100428.vendor/acpica/20100428
Notes
Notes: svn path=/vendor-sys/acpica/dist/; revision=207340 svn path=/vendor-sys/acpica/20100428/; revision=207341; tag=vendor/acpica/20100428
Diffstat (limited to 'tests')
-rw-r--r--tests/misc/badcode.asl295
-rw-r--r--tests/misc/grammar.asl10266
2 files changed, 10561 insertions, 0 deletions
diff --git a/tests/misc/badcode.asl b/tests/misc/badcode.asl
new file mode 100644
index 000000000000..36ca0d582f27
--- /dev/null
+++ b/tests/misc/badcode.asl
@@ -0,0 +1,295 @@
+/*
+ * badcode.asl
+ *
+ * This file contains examples of the extended error checking and
+ * typechecking capabilities of the iASL compiler. Other ASL compilers
+ * may ignore these errors completely. Note - this is not an exhaustive
+ * list of errors detected by iASL, it shows many of the errors that
+ * are not detected by other ASL compilers.
+ *
+ * To compile, use:
+ * iasl badcode.asl
+ */
+DefinitionBlock ("badcode.aml", "DSDT", 1, "Intel", "Example", 0x00000001)
+{
+ Name (INT1, 0)
+ Name (BUF1, Buffer() {0,1,2,3})
+ Event (EVT1)
+
+ // Invalid SyncLevel in Mutex declaration
+
+ Mutex (MTX1, 32)
+
+ // Integer beyond the table integer size (32 bits)
+
+ Name (BIG, 0x1234567887654321)
+
+ // CPackage length does not match initializer list length
+
+ Name (PKG1, Package(5) {0,1})
+
+ // Inadvertent use of single backslash in a string
+
+ Name (PATH, Buffer() {"\_SB_.PCI2._CRS"})
+
+ // Invalid hex escape sequence
+
+ Name (ESC1, "abcdefg\x00hijklmn")
+
+ // Field access beyond region bounds
+
+ OperationRegion (OPR1, SystemMemory, 0x2000, 6)
+ Field (OPR1, DWordAcc, NoLock, Preserve)
+ {
+ Offset (4),
+ FLD1, 8
+ }
+
+ // Some address spaces support only ByteAcc or BufferAcc
+
+ OperationRegion (OPR2, EmbeddedControl, 0x4000, 8)
+ Field (OPR2, DWordAcc, NoLock, Preserve)
+ {
+ FLD2, 8
+ }
+ OperationRegion (OPR3, SMBus, 0x8000, 16)
+ Field (OPR3, WordAcc, NoLock, Preserve)
+ {
+ FLD3, 8
+ }
+
+ // Invalid SyncLevel in method declaration
+
+ Method (MTH1, 0, NotSerialized, 32)
+ {
+ // Invalid arguments and uninitialized locals
+
+ Store (Arg3, Local0)
+ Store (Local1, Local2)
+
+ // Parameter typechecking (MTX1 is invalid type)
+
+ Subtract (MTX1, 4, Local3)
+
+ // Various invalid parameters
+
+ CreateField (BUF1, 0, Subtract (4, 4), FLD1)
+
+ // Unchecked mutex and event timeouts
+
+ Acquire (MTX1, 100)
+ Wait (EVT1, 1)
+
+ // Result from operation is not used - statement has no effect
+
+ Add (INT1, 8)
+
+ // Unreachable code
+
+ Return (0)
+ Store (5, INT1)
+ }
+
+ Method (MTH2)
+ {
+ // Switch with no Case statements
+
+ Switch (ToInteger (INT1))
+ {
+ Default
+ {
+ }
+ }
+
+ if (LEqual (INT1, 0))
+ {
+ Return (INT1)
+ }
+
+ // Fallthrough exit path does not return a value
+ }
+
+ Method (MTH3)
+ {
+ // Method MTH2 above does not always return a value
+
+ Store (MTH2 (), Local0)
+ }
+
+ // Invalid _HID value
+
+ Name (_HID, "*PNP0C0A")
+
+ // Predefined Name typechecking
+
+ Name (_PRW, 4)
+ Name (_FDI, Buffer () {0})
+
+ // Predefined Name argument count validation
+ // and return value validation
+
+ Method (_OSC, 5)
+ {
+ }
+
+ // Predefined Names that must be implemented as control methods
+
+ Name (_L01, 1)
+ Name (_E02, 2)
+ Name (_Q03, 3)
+ Name (_ON, 0)
+ Name (_INI, 1)
+ Name (_PTP, 2)
+
+ /*
+ * Resource Descriptor error checking
+ */
+ Name (RSC1, ResourceTemplate ()
+ {
+ // Illegal nested StartDependent macros
+
+ StartDependentFn (0, 0)
+ {
+ StartDependentFn (0, 0)
+ {
+ }
+ }
+
+ // Missing EndDependentFn macro
+ })
+
+ Name (RSC2, ResourceTemplate ()
+ {
+ // AddressMin is larger than AddressMax
+ IO (Decode16,
+ 0x07D0, // Range Minimum
+ 0x03E8, // Range Maximum
+ 0x01, // Alignment
+ 0x20, // Length
+ )
+
+ // Length larger than Min/Max window size
+ Memory32 (ReadOnly,
+ 0x00001000, // Range Minimum
+ 0x00002000, // Range Maximum
+ 0x00000004, // Alignment
+ 0x00002000, // Length
+ )
+
+ // Min and Max not multiples of alignment value
+ Memory32 (ReadOnly,
+ 0x00001001, // Range Minimum
+ 0x00002002, // Range Maximum
+ 0x00000004, // Alignment
+ 0x00000200, // Length
+ )
+
+ // 10-bit ISA I/O address has a max of 0x3FF
+ FixedIO (
+ 0xFFFF, // Address
+ 0x20, // Length
+ )
+
+ // Invalid AccessSize parameter
+ Register (SystemIO,
+ 0x08, // Bit Width
+ 0x00, // Bit Offset
+ 0x0000000000000100, // Address
+ 0x05 // Access Size
+ )
+
+ // Invalid ResourceType (0xB0)
+ QWordSpace (0xB0, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+ 0x0000, // Granularity
+ 0xA000, // Range Minimum
+ 0xBFFF, // Range Maximum
+ 0x0000, // Translation Offset
+ 0x2000, // Length
+ ,, )
+
+ // AddressMin is larger than AddressMax
+ WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+ 0x0000, // Granularity
+ 0x0200, // Range Minimum
+ 0x0100, // Range Maximum
+ 0x0000, // Translation Offset
+ 0x0100, // Length
+ ,, , TypeStatic)
+
+ // Length larger than Min/Max window size
+ DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+ 0x00000000, // Granularity
+ 0x000C8000, // Range Minimum
+ 0x000C9000, // Range Maximum
+ 0x00000000, // Translation Offset
+ 0x00001002, // Length
+ ,, )
+
+ // Granularity must be (power-of-two -1)
+ DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxNotFixed, NonCacheable, ReadWrite,
+ 0x00000010,
+ 0x40000000,
+ 0xFED9FFFF,
+ 0x00000000,
+ 0xBECA0000)
+
+ // Address Min (with zero length) not on granularity boundary
+ QWordIO (ResourceProducer, MinFixed, MaxNotFixed, PosDecode, EntireRange,
+ 0x0000000000000003, // Granularity
+ 0x0000000000000B02, // Range Minimum
+ 0x0000000000000C00, // Range Maximum
+ 0x0000000000000000, // Translation Offset
+ 0x0000000000000000, // Length
+ ,, , TypeStatic)
+
+ // Address Max (with zero length) not on (granularity boundary -1)
+ QWordMemory (ResourceProducer, PosDecode, MinNotFixed, MaxFixed, Cacheable, ReadWrite,
+ 0x0000000000000001, // Granularity
+ 0x0000000000100000, // Range Minimum
+ 0x00000000002FFFFE, // Range Maximum
+ 0x0000000000000000, // Translation Offset
+ 0x0000000000000000, // Length
+ ,, , AddressRangeMemory, TypeStatic)
+
+ // Invalid combination: zero length, both Min and Max are fixed
+ DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+ 0x00000000, // Granularity
+ 0x000C8000, // Range Minimum
+ 0x000C8FFF, // Range Maximum
+ 0x00000000, // Translation Offset
+ 0x00000000, // Length
+ ,, )
+
+ // Invalid combination: non-zero length, Min Fixed, Max not fixed
+ DWordIO (ResourceProducer, MinFixed, MaxNotFixed, PosDecode, EntireRange,
+ 0x00000001, // Granularity
+ 0x000C8000, // Range Minimum
+ 0x000C8FFF, // Range Maximum
+ 0x00000000, // Translation Offset
+ 0x00000100, // Length
+ ,, )
+
+ // Invalid combination: non-zero length, Min not Fixed, Max fixed
+ DWordIO (ResourceProducer, MinNotFixed, MaxFixed, PosDecode, EntireRange,
+ 0x00000001, // Granularity
+ 0x000C8000, // Range Minimum
+ 0x000C8FFF, // Range Maximum
+ 0x00000000, // Translation Offset
+ 0x00000200, // Length
+ ,, )
+
+ // Granularity must be zero if non-zero length, min/max fixed
+ DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+ 0x0000000F, // Granularity
+ 0x000C8000, // Range Minimum
+ 0x000C8FFF, // Range Maximum
+ 0x00000000, // Translation Offset
+ 0x00001000, // Length
+ ,, )
+
+ // Missing StartDependentFn macro
+
+ EndDependentFn ()
+ })
+}
+
diff --git a/tests/misc/grammar.asl b/tests/misc/grammar.asl
new file mode 100644
index 000000000000..8a13fd1a20cf
--- /dev/null
+++ b/tests/misc/grammar.asl
@@ -0,0 +1,10266 @@
+/*
+ * Some or all of this work - Copyright (c) 2006 - 2010, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+//
+//
+// Grammar.asl - Minimally excercises most ASL constructs
+//
+// NOTE -- use: iasl -f -of grammar.asl to compile
+//
+// This 1) Ignores errors (checks compiler error handling)
+// 2) Disables constant folding
+//
+//
+
+/*******************************************************************************
+Compilation should look like this:
+
+C:\acpica\tests\misc>iasl -f -of grammar.asl
+
+Intel ACPI Component Architecture
+ASL Optimizing Compiler version 20090422 [Apr 22 2009]
+Copyright (C) 2000 - 2009 Intel Corporation
+Supports ACPI Specification Revision 3.0a
+
+grammar.asl 187: Name (_NPK, Package (8)
+Warning 1098 - ^ Unknown reserved name (_NPK)
+
+grammar.asl 510: NAME (ESC1, "abcdefg\x00hijklmn")
+Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
+
+grammar.asl 511: NAME (ESC2, "abcdefg\000hijklmn")
+Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
+
+grammar.asl 601: Method (RCIV, 1)
+Warning 1087 - ^ Not all control paths return a value (RCIV)
+
+grammar.asl 608: RCIV (Subtract (Arg0, 1))
+Remark 5073 - ^ Recursive method call (RCIV)
+
+grammar.asl 937: Method (_ERR, 2)
+Warning 1077 - ^ Reserved method has too few arguments (_ERR requires 3)
+
+grammar.asl 1377: Store (0x1234567887654321, QWD2)
+Warning 1032 - ^ 64-bit integer in 32-bit table, truncating
+
+grammar.asl 1379: if (LNotEqual (Local0, 0x1234567887654321))
+Warning 1032 - 64-bit integer in 32-bit table, truncating ^
+
+grammar.asl 1459: SizeOf (BUFO)
+Warning 1105 - ^ Result is not used, operator has no effect
+
+grammar.asl 1485: Acquire (MTX2, 1)
+Warning 1104 - ^ Possible operator timeout is ignored
+
+grammar.asl 1633: Add (Local0, Local1)
+Warning 1105 - ^ Result is not used, operator has no effect
+
+grammar.asl 1804: Method (COND)
+Warning 1087 - ^ Not all control paths return a value (COND)
+
+grammar.asl 6010: Name (_HID, "*PNP0A06")
+Error 4001 - ^ String must be entirely alphanumeric (*PNP0A06)
+
+grammar.asl 6461: Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})
+Warning 1038 - Invalid or unknown escape sequence ^
+
+grammar.asl 6800: And (Local0, 1, Local0) // Local0 &= 1
+Error 4050 - ^ Method local variable is not initialized (Local0)
+
+grammar.asl 6886: Name (_HID, "*PNP0C0A") // Control Method Battey ID
+Error 4001 - ^ String must be entirely alphanumeric (*PNP0C0A)
+
+ASL Input: grammar.asl - 10254 lines, 322162 bytes, 4810 keywords
+AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes
+
+Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations
+
+***************************************************************************************************/
+
+DefinitionBlock (
+ "grammar.aml", //Output filename
+ "DSDT", //Signature
+ 0x01, //DSDT Revision ---> 32-bit table
+ "Intel", //OEMID
+ "GRMTEST", //TABLE ID
+ 0x20090511 //OEM Revision
+ )
+{
+
+ External (\ABCD, UnknownObj)
+
+
+ /* Device with _STA and _INI */
+
+ Device (A1)
+ {
+ Method (_STA)
+ {
+ Return (0x0F)
+ }
+
+ Method (_INI)
+ {
+ Return
+ }
+ }
+
+ /* Device with no _STA, has _INI */
+
+ Device (A2)
+ {
+ Method (_INI)
+ {
+ Return
+ }
+ }
+
+ /* Device with _STA, no _INI */
+
+ Device (A3)
+ {
+ Method (_STA)
+ {
+ Return (0x0F)
+ }
+ }
+
+ /* Device with _STA and _INI, but not present */
+
+ Device (A4)
+ {
+ Method (_STA)
+ {
+ Return (Zero)
+ }
+
+ Method (_INI)
+ {
+ Return
+ }
+ }
+
+
+ /* Resource descriptors */
+
+ Device (IRES)
+ {
+ Name (PRT0, ResourceTemplate ()
+ {
+ IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15}
+
+ StartDependentFn (1,1)
+ {
+ IRQNoFlags () {0,1,2}
+ }
+ EndDependentFn ()
+ })
+
+ Method (_CRS, 0, NotSerialized)
+ {
+ Store ("_CRS:", Debug)
+ Store (PRT0, Debug)
+ Return (PRT0)
+ }
+
+ Method (_SRS, 1, Serialized)
+ {
+ Store ("_SRS:", Debug)
+ Store (Arg0, Debug)
+ Return (Zero)
+ }
+ }
+
+ Name (_NPK, Package ()
+ {
+ 0x1111,
+ 0x2222,
+ 0x3333,
+ 0x4444
+ })
+
+
+ Device (RES)
+ {
+ Name (_PRT, Package (0x04)
+ {
+ Package (0x04)
+ {
+ 0x0002FFFF,
+ Zero,
+ Zero,
+ Zero
+ },
+
+ Package (0x04)
+ {
+ 0x0002FFFF,
+ One,
+ Zero,
+ Zero
+ },
+
+ Package (0x04)
+ {
+ 0x000AFFFF,
+ Zero,
+ Zero,
+ Zero
+ },
+
+ Package (0x04)
+ {
+ 0x000BFFFF,
+ Zero,
+ Zero,
+ Zero
+ }
+ })
+
+ Method (_CRS, 0, NotSerialized)
+ {
+ Name (PRT0, ResourceTemplate ()
+ {
+ WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
+ 0x0000, // Address Space Granularity
+ 0xFFF2, // Address Range Minimum
+ 0xFFF3, // Address Range Maximum
+ 0x0032, // Address Translation Offset
+ 0x0002,,,)
+ WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
+ 0x0000, // Address Space Granularity
+ 0x0000, // Address Range Minimum
+ 0x00FF, // Address Range Maximum
+ 0x0000, // Address Translation Offset
+ 0x0100,,,)
+ WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+ 0x0000, // Address Space Granularity
+ 0xA000, // Address Range Minimum
+ 0xBFFF, // Address Range Maximum
+ 0x0000, // Address Translation Offset
+ 0x2000,,,)
+ IO (Decode16, 0x0CF8, 0x0CFF, 0x01, 0x08)
+ WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+ 0x0000, // Address Space Granularity
+ 0x0000, // Address Range Minimum
+ 0x0CF7, // Address Range Maximum
+ 0x0000, // Address Translation Offset
+ 0x0CF8,,,
+ , TypeStatic)
+ WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+ 0x0000, // Address Space Granularity
+ 0x0D00, // Address Range Minimum
+ 0xFFFF, // Address Range Maximum
+ 0x0000, // Address Translation Offset
+ 0xF300,,,
+ , TypeStatic)
+ DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+ 0x00000000, // Address Space Granularity
+ 0x00000000, // Address Range Minimum
+ 0x00000CF7, // Address Range Maximum
+ 0x00000000, // Address Translation Offset
+ 0x00000CF8,,,
+ , TypeStatic)
+ DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+ 0x00000000, // Address Space Granularity
+ 0x000C8000, // Address Range Minimum
+ 0x000EFFFF, // Address Range Maximum
+ 0x00000000, // Address Translation Offset
+ 0x00028000,,,
+ , AddressRangeMemory, TypeStatic)
+ DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+ 0x00000000, // Address Space Granularity
+ 0x000C8000, // Address Range Minimum
+ 0x000EFFFF, // Address Range Maximum
+ 0x00000000, // Address Translation Offset
+ 0x00028000,,,)
+ QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+ 0x0000000000000000, // Address Space Granularity
+ 0x0000000000000000, // Address Range Minimum
+ 0x0000000000000CF7, // Address Range Maximum
+ 0x0000000000000000, // Address Translation Offset
+ 0x0000000000000CF8, 0x44, "This is a ResouceSource string",
+ , TypeStatic)
+ QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+ 0x0000000000000000, // Address Space Granularity
+ 0x0000000000000000, // Address Range Minimum
+ 0x0000000000000CF7, // Address Range Maximum
+ 0x0000000000000000, // Address Translation Offset
+ 0x0000000000000CF8,,,
+ , TypeStatic)
+ QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+ 0x0000000000000000, // Address Space Granularity
+ 0x0000000000100000, // Address Range Minimum
+ 0x00000000FFDFFFFF, // Address Range Maximum
+ 0x0000000000000000, // Address Translation Offset
+ 0x00000000FFD00000,,,
+ , AddressRangeMemory, TypeStatic)
+ QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
+ 0x0000000000000000, // Address Space Granularity
+ 0x0000000000000000, // Address Range Minimum
+ 0x0000000000000CF7, // Address Range Maximum
+ 0x0000000000000000, // Address Translation Offset
+ 0x0000000000000CF8,,,)
+ ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+ 0x0000000000000000, // Address Space Granularity
+ 0x0000000000000000, // Address Range Minimum
+ 0x0000000000000CF7, // Address Range Maximum
+ 0x0000000000000000, // Address Translation Offset
+ 0x0000000000000CF8, // Address Length
+ 0x0000000000000000, // Type Specific Attributes
+ , TypeStatic)
+ ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+ 0x0000000000000000, // Address Space Granularity
+ 0x0000000000100000, // Address Range Minimum
+ 0x00000000FFDFFFFF, // Address Range Maximum
+ 0x0000000000000000, // Address Translation Offset
+ 0x00000000FFD00000, // Address Length
+ 0x0000000000000000, // Type Specific Attributes
+ , AddressRangeMemory, TypeStatic)
+ ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,
+ 0x0000000000000000, // Address Space Granularity
+ 0x0000000000100000, // Address Range Minimum
+ 0x00000000FFDFFFFF, // Address Range Maximum
+ 0x0000000000000000, // Address Translation Offset
+ 0x00000000FFD00000, // Address Length
+ 0x0000000000000000) // Type Specific Attributes
+ IO (Decode16, 0x0010, 0x0020, 0x01, 0x10)
+ IO (Decode16, 0x0090, 0x00A0, 0x01, 0x10)
+ FixedIO (0x0061, 0x01)
+ IRQNoFlags () {2}
+ DMA (Compatibility, BusMaster, Transfer8_16) {4}
+ DMA (Compatibility, BusMaster, Transfer8) {2,5,7}
+ Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)
+ Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000)
+ Memory32 (ReadOnly, 0x00020000, 0xFFFE0000, 0x00000004, 0x00000200)
+ Memory24 (ReadOnly, 0x1111, 0x2222, 0x0004, 0x0200)
+ Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0xE, "\\_SB_.TEST")
+ {
+ 0x00000E01,
+ }
+ Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx")
+ {
+ 0x00000601,
+ 0x00000003,
+ 0x00000002,
+ 0x00000001,
+ }
+ Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive)
+ {
+ 0xFFFF0000,
+ 0x00000003,
+ 0x00000002,
+ 0x00000001,
+ 0x00000005,
+ 0x00000007,
+ 0x00000009,
+ }
+ VendorShort () {0x01, 0x02, 0x03}
+ VendorLong ()
+ {
+ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+ 0x09
+ }
+ Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000)
+ Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2)
+ StartDependentFnNoPri ()
+ {
+ IRQNoFlags () {0,1,2}
+ IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15}
+ }
+ EndDependentFn ()
+ })
+ CreateWordField (PRT0, 0x08, BMIN)
+ CreateByteField (PRT0, R000._ASZ, RSIZ)
+ Store (0x03, BMIN)
+ Return (PRT0)
+ }
+
+ Method (_PRS, 0, NotSerialized)
+ {
+ Name (BUF0, ResourceTemplate ()
+ {
+ StartDependentFn (0x01, 0x02)
+ {
+ IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08)
+ IRQNoFlags () {4}
+ }
+ StartDependentFn (0x02, 0x01)
+ {
+ IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08)
+ IRQNoFlags () {4}
+ }
+ StartDependentFn (0x00, 0x02)
+ {
+ IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08)
+ IRQNoFlags () {3}
+ }
+ StartDependentFn (0x00, 0x02)
+ {
+ IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08)
+ IRQNoFlags () {3}
+ }
+ StartDependentFn (0x02, 0x00)
+ {
+ IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08)
+ IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15}
+ }
+ EndDependentFn ()
+ })
+ Return (BUF0)
+ }
+
+ Method (_SRS, 1, Serialized)
+ {
+ Return (Zero)
+ }
+ }
+
+
+ Name(\_S0,Package(0x04){
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00
+ })
+ Name(\_S3,Package(0x04){
+ 0x05,
+ 0x05,
+ 0x00,
+ 0x00
+ })
+ Name(\_S4,Package(0x04){
+ 0x06,
+ 0x06,
+ 0x00,
+ 0x00
+ })
+ Name(\_S5,Package(0x04){
+ 0x07,
+ 0x07,
+ 0x00,
+ 0x00
+ })
+
+/* Examine this table header (DSDT) */
+
+/*
+ DataTableRegion (HDR, "DSDT", "", "")
+ Field (HDR, AnyAcc, NoLock, Preserve)
+ {
+ SIG, 32,
+ LENG, 32,
+ REV, 8,
+ SUM, 8,
+ OID, 48,
+ OTID, 64,
+ OREV, 32,
+ CID, 32,
+ CREV, 32
+ }
+
+ Method (SIZE)
+ {
+ If (LLess (REV, 2))
+ {
+ Store ("32-bit table", Debug)
+ }
+ else
+ {
+ Store ("64-bit table", Debug)
+ }
+ Return (0)
+ }
+
+*/
+ Name (SIZE, 0)
+
+ /* Custom operation region */
+
+ OperationRegion(MYOP,0x80,0xFD60,0x6)
+ Field(MYOP,ByteAcc,NoLock,Preserve)
+ {
+ MFLD,8
+ }
+
+ Method (TCOP)
+ {
+ Name (_STR, Unicode ("test"))
+ Store (4, MFLD)
+ Store (MFLD, Local0)
+ }
+
+ Name (ERRS, 0x0)
+
+ /* Warning should be issued for premature string termination */
+
+ NAME (ESC1, "abcdefg\x00hijklmn")
+ NAME (ESC2, "abcdefg\000hijklmn")
+ Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\432")
+
+
+ Name(CRSA,ResourceTemplate()
+ {
+ WORDBusNumber(ResourceProducer,MinFixed,MaxFixed,PosDecode,0x0000,0x0019,0x001D,0x0000,0x0005)
+ WORDIO(ResourceProducer,MinFixed,MaxFixed,PosDecode,NonISAOnlyRanges,0x0000,0xC000,0xCFFF,0x0000,0x1000)
+ DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
+
+ })
+ Name(CRSB,ResourceTemplate()
+ {
+ DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
+
+ })
+
+ Name(CRSC,ResourceTemplate()
+ {
+ VendorShort () {0x1, 0x2, 0x3}
+ })
+ Name(CRSD,ResourceTemplate()
+ {
+ VendorLong (VNDL) {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}
+ })
+
+ Name(CRSE,ResourceTemplate()
+ {
+ IRQNoFlags(){3,4,10,11}
+ IRQNoFlags(xxxt){3,4,10,11}
+ })
+ Name(CRSR, Buffer (Add (SizeOf(CRSA),SizeOf(CRSB))){})
+ Method(_CRS,0,NotSerialized)
+ {
+ Return(CRSR)
+ }
+
+
+ //
+ // Unnamed scope
+ //
+ Scope (\)
+ {
+ Name(Bxxx,0xFFFFFFFF)
+ }
+
+ Name (LANS, 0x0)
+
+ PowerResource(LANP,1,0)
+ {
+ Method(_STA){
+ If(LEqual(And(LANS,0x30),0x30)){
+ Return(One)
+ } Else {
+ Return(Zero)
+ }
+ }
+ Method(_ON){
+ If(LNot(_STA())){
+ Store (0x30, LANS)
+ }
+ }
+ Method(_OFF){
+ If(_STA()){
+ Store (0, LANS)
+ }
+ }
+ }
+
+
+ /* Can a method define another method? */
+
+ /**********************************
+ Method (TASK, 2, SERIALIZED)
+ {
+ Sleep (100)
+
+ Method (TAS2)
+ {
+ Sleep (100)
+ }
+
+ TAS2()
+ Return
+
+ }
+ ************************************/
+
+ /* A recursive method */
+
+ Method (RCIV, 1)
+ {
+ Store (Arg0, Debug)
+ If (Lequal (Arg0, 0))
+ {
+ Return ()
+ }
+ RCIV (Subtract (Arg0, 1))
+ }
+
+ Method (RTOP)
+ {
+ RCIV (100)
+ }
+
+
+ Scope(\_PR)
+ {
+ Processor(CPU0,0x0,0xFFFFFFFF,0x0) {}
+ }
+
+ Name(B1TP,0xFFFFFFFF)
+
+ Name(B2TP,0xFFFFFFFF)
+ Name(ADPS,0xFFFFFFFF)
+ Name(B1PS,0xFFFFFFFF)
+ Name(B1RS,0xFFFFFFFF)
+ Name(B1CS,0xFFFFFFFF)
+ Name(B2PS,0xFFFFFFFF)
+ Name(B2RS,0xFFFFFFFF)
+ Name(B2CS,0xFFFFFFFF)
+ Name(B1DC,3000)
+ Name(B2DC,2600)
+ Name(B1LF,3000)
+ Name(B2LF,2600)
+ Name(BPIF,0)
+ Name(PBLL,0)
+
+ Name(RBIF,Package()
+ {
+ 0x1,
+ 2200,
+ 2200,
+ 0x1,
+ 10800,
+ 0,
+ 0,
+ 1,
+ 1,
+ "CA54200-5003/5",
+ "1",
+ "LION",
+ "Fujitsu"
+ })
+
+ Method(SMWE, 4)
+ {
+ return(ONES)
+ }
+
+ Method(SMRE, 4)
+ {
+ return(ONES)
+ }
+
+/*
+ Method(RDBT,0,Serialized){
+ If(LNot(SMWE(0x09,0x15,1,1))){
+ Store(0x18,Local2)
+ }
+ }
+*/
+ Scope(_SB)
+ {
+
+ Name (SBUF, Buffer (128) {})
+
+ CreateBitField (SBUF, 3, BITY)
+ CreateByteField (SBUF, 1, BYTY)
+ CreateWordField (SBUF, 2, WRDZ)
+ CreateDwordField (SBUF, 4, DWDZ)
+ CreateQwordField (SBUF, 8, QWDZ)
+ CreateField (SBUF, 128, 12, FLDZ)
+ CreateField (SBUF, 148, 96, FLDY)
+ CreateField (SBUF, 148, 96, \_SB_.FLDW)
+
+ Method (_INI)
+ {
+ CreateField (\_SB_.SBUF, 148, 96, FLDV)
+ }
+
+
+ Device(PCI0)
+ {
+ Name(_HID,EISAID("PNP0A03"))
+ Name(_ADR,0x0)
+
+ Method(_CRS)
+ {
+ Name(PRT0, ResourceTemplate() {
+ WORDBusNumber( // Bus number resource(0)
+ ResourceConsumer, // bit 0 of general flags is 1
+ MinFixed, // Range is notfixed
+ MaxFixed, // Range is not fixed
+ SubDecode, // SubDecode
+ 0x0000, // Granularity
+ 0xfff1, // Min
+ 0xfff2, // Max
+ 0x0032, // Translation
+ 0x0002,,, // Range Length
+ BUS0
+ ) } )// PRT0
+
+ CreateWordField(PRT0, BUS0._MIN, BMIN) //Minimum bus number suported under this bridge.
+
+ Store(3, BMIN)
+ Return(PRT0)
+
+ } // _CRS
+
+ Method(_SRS)
+ {
+ Return ()
+ }
+
+ Device(EIO)
+ {
+ OperationRegion(FJIO,SystemIO,0xFD60,0x6)
+ Field(FJIO,ByteAcc,NoLock,Preserve)
+ {
+ GIDX,8,
+
+ GDTA,8,
+
+ PIDX,8,
+
+ PDTA,8,
+
+ SIDX,8,
+
+ SDTA,8
+ }
+ IndexField(GIDX,GDTA,ByteAcc,NoLock,Preserve)
+ {
+ Offset(0x2),
+ ,5,
+ VGAS,2,
+ Offset(0x4),
+ ,4,
+ DCKE,1,
+ Offset(0x5),
+ ,6,
+ ACPW,1,
+
+ Offset(0xA),
+ B1P,1,
+
+ B2P,1,
+
+ B1C,1,
+
+ B2C,1,
+
+ B1ER,1,
+
+ B2ER,1,
+
+ Offset(0xB),
+ B1CP,8,
+
+ B2CP,8,
+
+ BCP,8,
+
+ B1VH,8,
+
+ B1VL,8,
+
+ B2VH,8,
+
+ B2VL,8,
+
+ B1TM,8,
+
+ B2TM,8,
+
+ B1CH,8,
+
+ B1CL,8,
+
+ B2CH,8,
+
+ B2CL,8
+ }
+ }
+ }
+ }
+
+ Method(RDBT,3,Serialized){
+ Store(0x1FFF,Local1)
+ If( Arg0 ){
+ Store(0x2FFF,Local1)
+ }
+ Store(0x18,Local2)
+ If( Arg1 ){
+ Store(0x10,Local2)
+ }
+ If(LNot(SMRE(0x09,0x15,1,RefOf(Local0)))){
+ If(LNot(SMWE(0x08,0x14,1,Local1))){
+ If(LNot(SMRE(0x09,0x17,Local2,RefOf(Local3)))){
+ Store(Local1,Arg2)
+ }
+ }
+ Or(Local0,0xFFF,Local0)
+ SMWE(0x08,0x14,1,Local0)
+ }
+ }
+ Method(MKWD,2)
+ {
+ If(And(Arg1,0x80)) {
+ Or(0xFFFF0000,Arg0,Local0)
+ Or(Local0,ShiftLeft(Arg1,8),Local0)
+ Subtract(Zero,Local0,Local0)
+ } else {
+ Store(Arg0,Local0)
+ Or(Local0,ShiftLeft(Arg1,8),Local0)
+ }
+ Return(Local0)
+ }
+
+ Device(CMB1)
+ {
+ Name(_HID,EISAID("PNP0C0A"))
+ Name(_UID,0x1)
+ Alias(\_SB.PCI0.EIO.B1P,\_SB_.PCI0.XXXX)
+ Alias(\_SB.PCI0.EIO.B1P,B1P)
+ Alias(\_SB.PCI0.EIO.B1C,B1C)
+ Alias(\_SB.PCI0.EIO.B1CH,B1CH)
+ Alias(\_SB.PCI0.EIO.B1CL,B1CL)
+ Alias(\_SB.PCI0.EIO.B1VH,B1VH)
+ Alias(\_SB.PCI0.EIO.B1VL,B1VL)
+ Alias(\_SB.PCI0.EIO.B1CP,B1CP)
+
+ Method(_INI)
+ {
+ Store(B1P, B1PS)
+ Store(B1CP,B1RS)
+ Store(B1C, B1CS)
+ }
+
+ Method(_BIF){
+ RDBT(Zero,Zero,RefOf(B1DC))
+ RDBT(Zero,One,RefOf(B1LF))
+ Store(B1DC,Index(RBIF,1))
+ Store(B1LF,Index(RBIF,2))
+ Store("CA54200-5003/5",Index(RBIF,9))
+ Store("1",Index(RBIF,10))
+ Return(RBIF)
+ }
+
+ Method(_BST) {
+
+ _INI()
+
+ Store(Zero,Local0)
+
+ if (LAnd(B1P,LNot(B1C))){
+ Or(Local0,1,Local0)
+ }
+
+ if (LAnd(B1P,B1C)) {
+ Or(Local0,2,Local0)
+ }
+
+ if (LLessEqual(B1CP,1)) {
+ Or(Local0,4,Local0)
+ }
+
+ Store(MKWD(B1CL,B1CH),Local1)
+
+ Store(Divide(Add(Multiply(B1CP,B1LF),99),100),Local2)
+
+ Store(MKWD(B1VL,B1VH),Local3)
+
+ Name(STAT,Package(4){})
+ Store(Local0,Index(STAT,0))
+ Store(Local1,Index(STAT,1))
+ Store(Local2,Index(STAT,2))
+ Store(Local3,Index(STAT,3))
+
+ If(LNot(BPIF)){
+// \_SB.PCI0.EIO.EC0.IECT()
+// \_SB.PCI0.EIO.EC0.SECT()
+ Store(One,BPIF)
+ }
+ return(STAT)
+ }
+
+ }
+
+ Device (DEV1)
+ {
+ }
+
+ Scope(\_TZ)
+ {
+ ThermalZone(TZ1)
+ {
+ Name(_PSL,Package()
+ {
+ \_PR.CPU0
+ })
+ }
+ }
+
+ Method (TZ2, 0, SERIALIZED)
+ {
+ Name(_PSL,Package()
+ {
+ \_PR.CPU0
+ })
+
+ Return (_PSL)
+ }
+
+ ThermalZone (THM1)
+ {
+ }
+
+ Method (NOTI)
+ {
+ Notify (\DEV1, 0)
+ Notify (\THM1, 0)
+ Notify (\_PR.CPU0, 0)
+ }
+
+ Method (_ERR, 2)
+ {
+ Increment (ERRS)
+ Store ("Run-time exception:", Debug)
+ Store (Arg0, Debug)
+ Store (Arg1, Debug)
+
+ Return (0) // Map error to AE_OK
+ }
+
+ Method (DIV0)
+ {
+ Store (1, Local0)
+ Store (0, Local1)
+ Divide (Local0, Local1, Local3)
+
+ Store ("DIV0 - noabort", Debug)
+ }
+
+ Method (ERR_, 1)
+ {
+ if (LEqual (Arg0, 0))
+ {
+ Store ("+*+*+*+* MTHD_ERROR: Results not equal!", Debug)
+ }
+ if (LEqual (Arg0, 1))
+ {
+ Store ("+*+*+*+* MTHD_ERROR: Numeric result is incorrect!", Debug)
+ }
+ if (LEqual (Arg0, 2))
+ {
+ Store ("+*+*+*+* MTHD_ERROR: Operand was clobbered!", Debug)
+ }
+
+ Notify (DEV1, Arg0)
+ Increment (ERRS)
+ }
+
+ Method (R226, 2)
+ {
+ }
+ Method (R225, 2)
+ {
+ R226 (Arg0, Arg1)
+ }
+ Method (R224, 2)
+ {
+ R225 (Arg1, Arg0)
+ }
+ Method (R223, 2)
+ {
+ R224 (Arg0, Arg1)
+ }
+ Method (R222, 2)
+ {
+ R223 (Arg1, Arg0)
+ }
+ Method (R111)
+ {
+ Store (0x01010101, Local0)
+ R222 (0xABAB, Local0)
+ Store (Local0, Local1)
+ }
+
+ Method (MAIN)
+ {
+
+// SIZE()
+ Store (NUM1(), Local0)
+ \CMB1._BST()
+ RDBT(1,2,3)
+ OBJ1(1)
+ OBJ2(2)
+ CHEK()
+ RETZ()
+ BITZ()
+ LOGS()
+ REFS()
+ COND()
+ TZ2()
+
+ //
+ // iPCO tests added
+ //
+ Store (\IFEL.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\NOSV.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\IDXF.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\_SB_.NSTL.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\RTBF.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\_SB_.RTLV.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\_SB_.RETP.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\WHLR.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\ANDO.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\BRKP.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\ADSU.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\INDC.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\LOPS.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\FDSO.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\MLDV.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\NBIT.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\SHFT.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\XORD.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\CRBF.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\IDX4.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\EVNT.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\SZLV.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\_SB_.BYTF.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\DWDF.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\DVAX.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\IDX6.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\IDX5.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\_SB_.IDX0.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\_SB_.IDX3.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\IDX7.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\MTCH.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\WHLB.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\_SB_.IDX2.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\SIZO.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ Store (\_SB_.SMIS.TEST(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ ERR_ (1)
+ Return(Local0)
+ }
+
+ if (LGreater (ERRS, 0))
+ {
+ Store ("****** There were errors during the execution of the test ******", Debug)
+ }
+
+ //
+ // Last Test
+ //
+
+ Return(0) // Success
+ }
+
+
+ Method (OBJ1, 1, SERIALIZED)
+ {
+
+ Store (3, Local0)
+ Name(BUFR, Buffer (Local0) {})
+ Name(BUF1, Buffer (4) {1,2,3,4})
+ Name(BUF2, Buffer (4) {})
+
+ Store (BUF1, BUF2)
+ Mutex (MTX1, 4)
+
+ Alias (MTX1, MTX2)
+ }
+
+
+ Mutex (MTXT, 0)
+ Mutex (MTXX, 0)
+
+ /*
+ * Field Creation
+ */
+
+ Method (FLDS)
+ {
+ Store ("++++++++ Creating BufferFields", Debug)
+ Name (BUF2, Buffer (128) {})
+
+ CreateBitField (BUF2, 3, BIT2)
+ CreateByteField (BUF2, 1, BYT2)
+ CreateWordField (BUF2, 2, WRD2)
+ CreateDwordField (BUF2, 4, DWD2)
+ CreateQwordField (BUF2, 8, QWD2)
+ CreateField (BUF2, 128, 12, FLD2)
+ CreateField (BUF2, 148, 96, FLD3)
+
+ Store (0x1, BIT2)
+ Store (BIT2, Local0)
+ if (LNotEqual (Local0, 0x1))
+ {
+ ERR_ (1)
+ }
+ else
+ {
+ Store (DerefOf (Index (BUF2, 0)), Local0)
+ if (LNotEqual (Local0, 0x08))
+ {
+ ERR_ (1)
+ }
+ else
+ {
+ Store ("++++++++ Bit BufferField I/O PASS", Debug)
+ }
+ }
+
+ Store (0x1A, BYT2)
+ Store (BYT2, Local0)
+ if (LNotEqual (Local0, 0x1A))
+ {
+ ERR_ (1)
+ }
+ else
+ {
+ Store ("++++++++ Byte BufferField I/O PASS", Debug)
+ }
+
+ Store (0x1234, WRD2)
+ Store (WRD2, Local0)
+ if (LNotEqual (Local0, 0x1234))
+ {
+ ERR_ (1)
+ }
+ else
+ {
+ Store ("++++++++ Word BufferField I/O PASS", Debug)
+ }
+
+ Store (0x123, FLD2)
+ Store (FLD2, Local0)
+ if (LNotEqual (Local0, 0x123))
+ {
+ ERR_ (1)
+ }
+ else
+ {
+ Store ("++++++++ 12-bit BufferField I/O PASS", Debug)
+ }
+
+ Store (0x12345678, DWD2)
+ Store (DWD2, Local0)
+ if (LNotEqual (Local0, 0x12345678))
+ {
+ ERR_ (1)
+ }
+ else
+ {
+ Store ("++++++++ Dword BufferField I/O PASS", Debug)
+ }
+
+ Store (0x1234567887654321, QWD2)
+ Store (QWD2, Local0)
+ if (LNotEqual (Local0, 0x1234567887654321))
+ {
+ ERR_ (1)
+ }
+ else
+ {
+ Store ("++++++++ Qword BufferField I/O PASS", Debug)
+ }
+ }
+
+
+ /* Field execution */
+
+ Method (FLDX)
+ {
+ Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
+ { // Field: SMEM overlay using 32-bit field elements
+ SMD0, 32, // 32-bits
+ SMD1, 32, // 32-bits
+ SMD2, 32, // 32-bits
+ SMD3, 32 // 32-bits
+ } // Field: SMEM overlay using 32-bit field elements
+ Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
+ { // Field: SMEM overlay using greater than 32-bit field elements
+ SME0, 69, // larger than an integer (32 or 64)
+ SME1, 97 // larger than an integer
+ } // Field: SMEM overlay using greater than 32-bit field elements
+ }
+
+
+ Method (MTX_, )
+ {
+ /* Test "Force release" of mutex on method exit */
+
+ Acquire (MTXT, 0xFFFF)
+ Acquire (MTXX, 0xFFFF)
+
+ Store ("++++++++ Acquiring Mutex MTX2", Debug)
+ Acquire (_GL_, 0xFFFF)
+
+
+ Store ("++++++++ Releasing Mutex MTX2", Debug)
+ Release (_GL_)
+ }
+
+
+ Method (OBJ2, 1)
+ {
+ Store ("++++++++ Creating Buffer BUFO", Debug)
+ Name (BUFO, Buffer (32) {})
+
+ Store ("++++++++ Creating OpRegion OPR2", Debug)
+ OperationRegion (OPR2, SystemMemory, Arg0, 256)
+
+ Store ("++++++++ Creating Field(s) in OpRegion OPR2", Debug)
+ Field (OPR2, ByteAcc, NoLock, Preserve)
+ {
+ IDX2, 8,
+ DAT2, 8,
+ BNK2, 4
+ }
+
+ Store ("++++++++ Creating BankField BNK2 in OpRegion OPR2", Debug)
+ //
+ // mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1
+ //
+ BankField (OPR2, BNK2, 0, ByteAcc, NoLock, Preserve)
+ {
+ FET0, 4,
+ FET1, 3
+ }
+
+ Store ("++++++++ Creating IndexField", Debug)
+ IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve)
+ {
+ FET2, 4,
+ FET3, 3
+ }
+
+ Store ("++++++++ SizeOf (BUFO)", Debug)
+ SizeOf (BUFO)
+
+ Store ("++++++++ Store (SizeOf (BUFO), Local0)", Debug)
+ Store (SizeOf (BUFO), Local0)
+
+ Store ("++++++++ Concatenate (\"abd\", \"def\", Local0)", Debug)
+ Concatenate ("abd", "def", Local0)
+ Store (Local0, Debug)
+
+ Store ("++++++++ Concatenate (\"abd\", 0x7B, Local0)", Debug)
+ Concatenate ("abd", 0x7B, Local0)
+ Store (Local0, Debug)
+
+ Store ("++++++++ Creating Event EVT2", Debug)
+ Event (EVT2)
+
+ Store ("++++++++ Creating Mutex MTX2", Debug)
+ Mutex (MTX2, 0)
+
+ Store ("++++++++ Creating Alias MTXA to MTX2", Debug)
+ Alias (MTX2, MTXA)
+
+ Store ("++++++++ Acquiring Mutex MTX2", Debug)
+ Acquire (MTX2, 0xFFFF)
+
+ Store ("++++++++ Acquiring Mutex MTX2 (2nd acquire)", Debug)
+ Acquire (MTX2, 1)
+
+ Store ("++++++++ Releasing Mutex MTX2", Debug)
+ Release (MTX2)
+
+ // Type 1 opcodes
+
+ Store ("++++++++ Signalling Event EVT2", Debug)
+ Signal (EVT2)
+
+ Store ("++++++++ Resetting Event EVT2", Debug)
+ Reset (EVT2)
+
+ Store ("++++++++ Signalling Event EVT2", Debug)
+ Signal (EVT2)
+
+ Store ("++++++++ Waiting Event EVT2", Debug)
+ Wait (EVT2, 0xFFFF)
+
+ Store ("++++++++ Sleep", Debug)
+ Sleep (100)
+
+ Store ("++++++++ Stall", Debug)
+ Stall (254)
+
+ Store ("++++++++ NoOperation", Debug)
+ Noop
+
+ // Type 2 Opcodes
+
+ Store ("++++++++ Return from Method OBJ2", Debug)
+ return (4)
+ }
+
+
+ Method (NUM1, 0)
+ {
+ /* ADD */
+
+ Store ("++++++++ Add (0x12345678, 0x11111111, Local0)", Debug)
+ Add (0x12345678, 0x11111111, Local0)
+
+ Store ("++++++++ Store (Add (0x12345678, 0x11111111), Local1)", Debug)
+ Store (Add (0x12345678, 0x11111111), Local1)
+
+ Store ("++++++++ Checking result from ADD", Debug)
+ if (LNotEqual (Local0, Local1))
+ {
+ ERR_ (0)
+ }
+
+
+ /* SUBTRACT */
+
+ Store ("++++++++ Subtract (0x87654321, 0x11111111, Local4)", Debug)
+ Subtract (0x87654321, 0x11111111, Local4)
+
+ Store ("++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)", Debug)
+ Store (Subtract (0x87654321, 0x11111111), Local5)
+
+ Store ("++++++++ Checking result from SUBTRACT", Debug)
+ if (LNotEqual (Local4, Local5))
+ {
+ ERR_ (0)
+ }
+
+
+ /* MULTIPLY */
+
+ Store ("++++++++ Multiply (33, 10, Local6)", Debug)
+ Multiply (33, 10, Local6)
+
+ Store ("++++++++ Store (Multiply (33, 10), Local7)", Debug)
+ Store (Multiply (33, 10), Local7)
+
+
+ Store ("++++++++ Checking result from MULTIPLY", Debug)
+ if (LNotEqual (Local6, Local7))
+ {
+ ERR_ (0)
+ }
+
+
+ /* DIVIDE */
+
+ Store ("++++++++ Divide (100, 9, Local1, Local2)", Debug)
+ Divide (100, 9, Local1, Local2)
+
+ Store ("++++++++ Store (Divide (100, 9), Local3)", Debug)
+ Store (Divide (100, 9), Local3)
+
+ Store ("++++++++ Checking (quotient) result from DIVIDE", Debug)
+ if (LNotEqual (Local2, Local3))
+ {
+ ERR_ (0)
+ }
+
+
+ /* INCREMENT */
+
+ Store ("++++++++ Increment (Local0)", Debug)
+ Store (1, Local0)
+ Store (2, Local1)
+ Increment (Local0)
+
+ Store ("++++++++ Checking result from INCREMENT", Debug)
+ if (LNotEqual (Local0, Local1))
+ {
+ ERR_ (0)
+ }
+
+
+ /* DECREMENT */
+
+ Store ("++++++++ Decrement (Local0)", Debug)
+ Store (2, Local0)
+ Store (1, Local1)
+ Decrement (Local0)
+
+ Store ("++++++++ Checking result from DECREMENT", Debug)
+ if (LNotEqual (Local0, Local1))
+ {
+ ERR_ (0)
+ }
+
+
+ /* TOBCD */
+ /* FROMBCD */
+
+ Store ("++++++++ ToBCD (0x1234, Local5)", Debug)
+ ToBCD (0x1234, Local5)
+
+ Store ("++++++++ FromBCD (Local5, Local6)", Debug)
+ FromBCD (Local5, Local6)
+
+ Store ("++++++++ Return (Local6)", Debug)
+ Return (Local6)
+ }
+
+
+ Method (CHEK)
+ {
+
+ Store (3, Local0)
+ Store (3, Debug)
+ Store (Local0, Debug)
+ Store (7, Local1)
+
+ Add (Local0, Local1)
+ if (LNotEqual (Local0, 3))
+ {
+ ERR_ (2)
+ }
+ if (LNotEqual (Local1, 7))
+ {
+ ERR_ (2)
+ }
+
+
+ Add (Local0, Local1, Local2)
+ if (LNotEqual (Local0, 3))
+ {
+ ERR_ (2)
+ }
+ if (LNotEqual (Local1, 7))
+ {
+ ERR_ (2)
+ }
+ }
+
+
+ Method (RET1)
+ {
+ Store (3, Local0)
+ Return (Local0)
+ }
+
+ Method (RET2)
+ {
+ Return (RET1())
+ }
+
+ Method (RETZ)
+ {
+ RET2 ()
+ }
+
+
+ Method (BITZ)
+ {
+ Store ("++++++++ FindSetLeftBit (0x00100100, Local0)", Debug)
+ FindSetLeftBit (0x00100100, Local0)
+ if (LNotEqual (Local0, 21))
+ {
+ ERR_ (1)
+ }
+
+ Store ("++++++++ FindSetRightBit (0x00100100, Local1)", Debug)
+ FindSetRightBit (0x00100100, Local1)
+ if (LNotEqual (Local1, 9))
+ {
+ ERR_ (1)
+ }
+
+ Store ("++++++++ And (0xF0F0F0F0, 0x11111111, Local2)", Debug)
+ And (0xF0F0F0F0, 0x11111111, Local2)
+ if (LNotEqual (Local2, 0x10101010))
+ {
+ ERR_ (1)
+ }
+
+ Store ("++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)", Debug)
+ NAnd (0xF0F0F0F0, 0x11111111, Local3)
+ if (LNotEqual (Local3, 0xEFEFEFEF))
+ {
+ ERR_ (1)
+ }
+
+ Store ("++++++++ Or (0x11111111, 0x22222222, Local4)", Debug)
+ Or (0x11111111, 0x22222222, Local4)
+ if (LNotEqual (Local4, 0x33333333))
+ {
+ ERR_ (1)
+ }
+
+ Store ("++++++++ NOr (0x11111111, 0x22222222, Local5)", Debug)
+ NOr (0x11111111, 0x22222222, Local5)
+ if (LNotEqual (Local5, 0xCCCCCCCC))
+ {
+ ERR_ (1)
+ }
+
+ Store ("++++++++ XOr (0x11113333, 0x22222222, Local6)", Debug)
+ XOr (0x11113333, 0x22222222, Local6)
+ if (LNotEqual (Local6, 0x33331111))
+ {
+ ERR_ (1)
+ }
+
+ Store ("++++++++ ShiftLeft (0x11112222, 2, Local7)", Debug)
+ ShiftLeft (0x11112222, 2, Local7)
+ if (LNotEqual (Local7, 0x44448888))
+ {
+ ERR_ (1)
+ }
+
+ Store ("++++++++ ShiftRight (Local7, 2, Local7)", Debug)
+ ShiftRight (Local7, 2, Local7)
+ if (LNotEqual (Local7, 0x11112222))
+ {
+ ERR_ (1)
+ }
+
+
+ Store ("++++++++ Not (Local0, Local1)", Debug)
+ Store (0x22224444, Local0)
+ Not (Local0, Local1)
+ if (LNotEqual (Local0, 0x22224444))
+ {
+ ERR_ (2)
+ }
+
+ if (LNotEqual (Local1, 0xDDDDBBBB))
+ {
+ ERR_ (1)
+ }
+
+ Return (Local7)
+ }
+
+
+ Method (LOGS)
+ {
+
+ Store ("++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)", Debug)
+ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)
+
+ Store ("++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)", Debug)
+ Store (LEqual (0xFFFFFFFF, 0x11111111), Local1)
+
+ Store ("++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)", Debug)
+ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)
+
+ Store ("++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)", Debug)
+ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)
+
+ Store ("++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)", Debug)
+ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)
+
+ Store ("++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)", Debug)
+ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)
+
+ Store ("++++++++ Store (LNot (0x31313131), Local6)", Debug)
+ Store (0x00001111, Local6)
+ Store (LNot (Local6), Local7)
+ if (LNotEqual (Local6, 0x00001111))
+ {
+ ERR_ (2)
+ }
+
+ if (LNotEqual (Local7, 0x0))
+ {
+ ERR_ (1)
+ }
+
+
+ Store ("++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)", Debug)
+ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)
+
+ Store ("++++++++ Lor (0x0, 0x1)", Debug)
+ if (Lor (0x0, 0x1))
+ {
+ Store ("+_+_+_+_+ Lor (0x0, 0x1) returned TRUE", Debug)
+ }
+
+ return (Local7)
+ }
+
+
+ Method (COND)
+ {
+ Store ("++++++++ Store (0x4, Local0)", Debug)
+ Store (0x4, Local0)
+
+ Store ("++++++++ While (Local0)", Debug)
+ While (Local0)
+ {
+ Store ("++++++++ Decrement (Local0)", Debug)
+ Decrement (Local0)
+ }
+
+
+ Store ("++++++++ Store (0x3, Local6)", Debug)
+ Store (0x3, Local6)
+
+ Store ("++++++++ While (Subtract (Local6, 1))", Debug)
+ While (Subtract (Local6, 1))
+ {
+ Store ("++++++++ Decrement (Local6)", Debug)
+ Decrement (Local6)
+ }
+
+
+ Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
+ If (LGreater (0x2, 0x1))
+ {
+ Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
+ If (LEqual (0x11111111, 0x22222222))
+ {
+ Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
+ }
+
+ else
+ {
+ Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
+ If (LNot (0x0))
+ {
+ Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
+ If (LAnd (0xEEEEEEEE, 0x2))
+ {
+ Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
+ If (LLess (0x44444444, 0x3))
+ {
+ Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
+ }
+
+ else
+ {
+ Store ("++++++++ Exiting from nested IF/ELSE statements", Debug)
+ }
+ }
+ }
+ }
+ }
+
+
+ Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
+ If (LGreater (0x2, 0x1))
+ {
+ Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
+ If (LEqual (0x11111111, 0x22222222))
+ {
+ Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
+ }
+
+ else
+ {
+ Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
+ If (LNot (0x0))
+ {
+ Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
+ If (LAnd (0xEEEEEEEE, 0x2))
+ {
+ Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
+ If (LLess (0x44444444, 0x3))
+ {
+ Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
+ }
+
+ else
+ {
+ Store ("++++++++ Returning from nested IF/ELSE statements", Debug)
+ Return (Local6)
+ }
+ }
+ }
+ }
+ }
+
+ }
+
+
+ Method (REFS)
+ {
+ Name (BBUF, Buffer() {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7})
+
+ Name (NEST, Package ()
+ {
+ Package ()
+ {
+ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06
+ },
+ Package ()
+ {
+ 0x11, 0x12, 0x12, 0x14, 0x15, 0x16
+ }
+ })
+
+ /* Parser thinks this is a method invocation!! */
+
+ Store (RefOf (MAIN), Local5)
+
+ // For this to work, ABCD must NOT exist.
+
+ Store (CondRefOf (ABCD, Local0), Local1)
+ if (LNotEqual (Local1, 0))
+ {
+ ERR_ (2)
+ }
+
+ Store (CondRefOf (BBUF, Local0), Local1)
+ if (LNotEqual (Local1, Ones))
+ {
+ ERR_ (2)
+ }
+
+ Store (DeRefOf (Index (BBUF, 3)), Local6)
+ if (LNotEqual (Local6, 0xB3))
+ {
+ ERR_ (2)
+ }
+
+ Store (DeRefOf (Index (DeRefOf (Index (NEST, 1)), 3)), Local0)
+ if (LNotEqual (Local0, 0x14))
+ {
+ ERR_ (2)
+ }
+
+
+ Store (0x11223344, Local0)
+ Store (RefOf (Local0), Local1)
+
+ Store (DerefOf (Local1), Local2)
+ If (LNotEqual (Local2, 0x11223344))
+ {
+ ERR_ (2)
+ }
+
+
+ /* Parser thinks this is a method invocation!! */
+
+ // RefOf (MAIN)
+
+
+ // RefOf (R___)
+ // RefOf (BBUF)
+
+ // Store (RefOf (Local0), Local1)
+
+ // CondRefOf (BBUF, Local2)
+ // CondRefOf (R___, Local3)
+
+ // Store (DerefOf (Local1), Local4)
+
+ // Return (Local4)
+ }
+
+
+ Method (INDX, 0)
+ {
+ Name(STAT,Package(4){})
+ Store(0x44443333,Index(STAT,0))
+ }
+
+//=================================================================
+//=================================================================
+//===================== iPCO TESTS ================================
+//=================================================================
+//=================================================================
+//
+//
+// test IfElseOp.asl
+//
+// test for IfOp and ElseOp, including validation of object stack cleanup
+//
+ Device (IFEL)
+ {
+ Name (DWRD, 1)
+ Name (RSLT, 0)
+
+ // IFNR control method executes IfOp branch with NO nested Return
+ // and no Else branch
+ Method (IFNR)
+ {
+ Store (DWRD, RSLT)
+ If (LEqual (DWRD, 1))
+ {
+ Store (0, RSLT)
+ }
+ } // IFNR
+
+ // NINR control method does not execute If branch and has no Else branch
+ Method (NINR)
+ {
+ Store (0, RSLT)
+ If (LNotEqual (DWRD, 1))
+ {
+ Store (DWRD, RSLT)
+ }
+ } // NINR
+
+ // IENR control method executes IfOp branch with NO nested Return
+ Method (IENR)
+ {
+ If (LEqual (DWRD, 1))
+ {
+ Store (0, RSLT)
+ }
+ Else
+ {
+ Store (DWRD, RSLT)
+ }
+ } // IENR
+
+ // ELNR control method executes ElseOp branch with NO nested Return
+ Method (ELNR)
+ {
+ If (LNotEqual (DWRD, 1))
+ {
+ Store (DWRD, RSLT)
+ }
+ Else
+ {
+ Store (0, RSLT)
+ }
+ } // ELNR
+
+ // IFRT control method executes IfOp branch with nested Return with
+ // no Else branch
+ Method (IFRT)
+
+ {
+ If (LEqual (DWRD, 1))
+ {
+ Return (0)
+ }
+ Return (DWRD)
+ } // IFRT
+
+ // IERT control method executes IfOp branch with nested Return with
+ // Else branch
+ Method (IERT)
+ {
+ If (LEqual (DWRD, 1))
+ {
+ Return (0)
+ }
+ Else
+ {
+ Return (DWRD)
+ }
+ } // IERT
+
+ // ELRT control method executes ElseOp branch with nested Return
+ Method (ELRT)
+ {
+ If (LNotEqual (DWRD, 1))
+ {
+ Return (DWRD)
+ }
+ Else
+ {
+ Return (0)
+ }
+ } // ELRT
+
+ Method (TEST)
+ {
+ Store ("++++++++ IfElseOp Test", Debug)
+
+ // IfOp with NO return value
+ IFNR()
+ If (LNotEqual (RSLT, 0))
+ {
+ Return (RSLT)
+ }
+
+ // IfOp with NO return value
+ NINR()
+ If (LNotEqual (RSLT, 0))
+ {
+ Return (RSLT)
+ }
+
+ // IfOp with NO return value
+ IENR()
+ If (LNotEqual (RSLT, 0))
+ {
+ Return (RSLT)
+ }
+
+ // ElseOp with NO return value
+ ELNR()
+ If (LNotEqual (RSLT, 0))
+ {
+ Return (RSLT)
+ }
+
+ // IfOp with return value
+ Store (IFRT, RSLT)
+ If (LNotEqual (RSLT, 0))
+ {
+ Return (RSLT)
+ }
+
+ // IfOp with return value
+ Store (IERT, RSLT)
+ If (LNotEqual (RSLT, 0))
+ {
+ Return (RSLT)
+ }
+
+ // ElseOp with return value
+ Store (ELRT, RSLT)
+ If (LNotEqual (RSLT, 0))
+ {
+ Return (RSLT)
+ }
+
+ Return (0)
+ } // TEST
+ } // IFEL
+
+//
+// test NoSave.asl
+//
+//
+// Internal test cases to validate IfOp (Operator (,,)) where Operator
+// target is ZeroOp to throw away the results.
+// Includes internal test cases for logical operators with no destination
+// operands.
+//
+ Device (NOSV)
+ {
+ Method (TEST)
+ {
+ Store ("++++++++ NoSave Test", Debug)
+
+ Name (WRD, 0x1234)
+
+ //
+ // Begin test of nested operators without saving results
+ //
+
+ // Test If (And ()) with no save of And result
+ If (And (3, 1, ))
+ {
+ Store (1, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (1) // fail
+ }
+
+ // Test If (And ()) with no save of And result
+ If (And (4, 1, ))
+ {
+ Return (2) // fail
+ }
+ else
+ {
+ Store (2, WRD) // pass -- just do something
+ }
+
+
+ // Test If (NAnd ()) with no save of NAnd result
+ If (NAnd (3, 1, ))
+ {
+ Store (3, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (3) // fail
+ }
+
+ // Test If (NAnd ()) with no save of NAnd result
+ If (NAnd (0xFFFFFFFF, 0xFFFFFFFF, ))
+ {
+ Return (4) // fail
+ }
+ else
+ {
+ Store (4, WRD) // pass -- just do something
+ }
+
+
+ // Test If (NOr ()) with no save of NOr result
+ If (NOr (0, 1, ))
+ {
+ Store (5, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (5) // fail
+ }
+
+ // Test If (NOr ()) with no save of NOr result
+ If (NOr (0xFFFFFFFE, 1, ))
+ {
+ Return (6) // fail
+ }
+ else
+ {
+ Store (6, WRD) // pass -- just do something
+ }
+
+
+ // Test If (Not ()) with no save of Not result
+ If (Not (1, ))
+ {
+ Store (7, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (7) // fail
+ }
+
+ // Test If (Not ()) with no save of Not result
+ If (Not (0xFFFFFFFF, ))
+ {
+ Return (8) // fail
+ }
+ else
+ {
+ Store (8, WRD) // pass -- just do something
+ }
+
+
+ // Test If (Or ()) with no save of Or result
+ If (Or (3, 1, ))
+ {
+ Store (9, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (9) // fail
+ }
+
+ // Test If (Or ()) with no save of Or result
+ If (Or (0, 0, ))
+ {
+ Return (10) // fail
+ }
+ else
+ {
+ Store (10, WRD) // pass -- just do something
+ }
+
+
+ // Test If (XOr ()) with no save of XOr result
+ If (XOr (3, 1, ))
+ {
+ Store (11, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (11) // fail
+ }
+
+ // Test If (XOr ()) with no save of XOr result
+ If (XOr (3, 3, ))
+ {
+ Return (12) // fail
+ }
+ else
+ {
+ Store (12, WRD) // pass -- just do something
+ }
+
+
+ //
+ // Begin test of logical operators with no destination operands
+ //
+
+ // Test If (LAnd ()) with no save of LAnd result
+ If (LAnd (3, 3))
+ {
+ Store (21, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (21) // fail
+ }
+
+ // Test If (LAnd ()) with no save of LAnd result
+ If (LAnd (3, 0))
+ {
+ Return (22) // fail
+ }
+ else
+ {
+ Store (22, WRD) // pass -- just do something
+ }
+
+ // Test If (LAnd ()) with no save of LAnd result
+ If (LAnd (0, 3))
+ {
+ Return (23) // fail
+ }
+ else
+ {
+ Store (23, WRD) // pass -- just do something
+ }
+
+ // Test If (LAnd ()) with no save of LAnd result
+ If (LAnd (0, 0))
+ {
+ Return (24) // fail
+ }
+ else
+ {
+ Store (24, WRD) // pass -- just do something
+ }
+
+
+ // Test If (LEqual ()) with no save of LEqual result
+ If (LEqual (3, 3))
+ {
+ Store (31, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (31) // fail
+ }
+
+ // Test If (LEqual ()) with no save of LEqual result
+ If (LEqual (1, 3))
+ {
+ Return (32) // fail
+ }
+ else
+ {
+ Store (32, WRD) // pass -- just do something
+ }
+
+
+ // Test If (LGreater ()) with no save of LGreater result
+ If (LGreater (3, 1))
+ {
+ Store (41, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (41) // fail
+ }
+
+ // Test If (LGreater ()) with no save of LGreater result
+ If (LGreater (4, 4))
+ {
+ Return (42) // fail
+ }
+ else
+ {
+ Store (42, WRD) // pass -- just do something
+ }
+
+ // Test If (LGreater ()) with no save of LGreater result
+ If (LGreater (1, 4))
+ {
+ Return (43) // fail
+ }
+ else
+ {
+ Store (43, WRD) // pass -- just do something
+ }
+
+ // Test If (LGreaterEqual ()) with no save of LGreaterEqual result
+ If (LGreaterEqual (3, 1))
+ {
+ Store (44, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (44) // fail
+ }
+
+ // Test If (LGreaterEqual ()) with no save of LGreaterEqual result
+ If (LGreaterEqual (3, 3))
+ {
+ Store (45, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (45) // fail
+ }
+
+ // Test If (LGreaterEqual ()) with no save of LGreaterEqual result
+ If (LGreaterEqual (3, 4))
+ {
+ Return (46) // fail
+ }
+ else
+ {
+ Store (46, WRD) // pass -- just do something
+ }
+
+
+ // Test If (LLess ()) with no save of LLess result
+ If (LLess (1, 3))
+ {
+ Store (51, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (51) // fail
+ }
+
+ // Test If (LLess ()) with no save of LLess result
+ If (LLess (2, 2))
+ {
+ Return (52) // fail
+ }
+ else
+ {
+ Store (52, WRD) // pass -- just do something
+ }
+
+ // Test If (LLess ()) with no save of LLess result
+ If (LLess (4, 2))
+ {
+ Return (53) // fail
+ }
+ else
+ {
+ Store (53, WRD) // pass -- just do something
+ }
+
+
+ // Test If (LLessEqual ()) with no save of LLessEqual result
+ If (LLessEqual (1, 3))
+ {
+ Store (54, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (54) // fail
+ }
+
+ // Test If (LLessEqual ()) with no save of LLessEqual result
+ If (LLessEqual (2, 2))
+ {
+ Store (55, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (55) // fail
+ }
+
+ // Test If (LLessEqual ()) with no save of LLessEqual result
+ If (LLessEqual (4, 2))
+ {
+ Return (56) // fail
+ }
+ else
+ {
+ Store (56, WRD) // pass -- just do something
+ }
+
+
+ // Test If (LNot ()) with no save of LNot result
+ If (LNot (0))
+ {
+ Store (61, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (61) // fail
+ }
+
+ // Test If (LNot ()) with no save of LNot result
+ If (LNot (1))
+ {
+ Return (62) // fail
+ }
+ else
+ {
+ Store (62, WRD) // pass -- just do something
+ }
+
+
+ // Test If (LNotEqual ()) with no save of LNotEqual result
+ If (LNotEqual (3, 3))
+ {
+ Return (63) // fail
+ }
+ else
+ {
+ Store (63, WRD) // pass -- just do something
+ }
+
+ // Test If (LNotEqual ()) with no save of LNotEqual result
+ If (LNotEqual (1, 3))
+ {
+ Store (64, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (64) // fail
+ }
+
+
+ // Test If (LOr ()) with no save of LOr result
+ If (LOr (3, 1))
+ {
+ Store (71, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (71) // fail
+ }
+
+ // Test If (LOr ()) with no save of LOr result
+ If (LOr (0, 1))
+ {
+ Store (72, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (72) // fail
+ }
+
+ // Test If (LOr ()) with no save of LOr result
+ If (LOr (3, 0))
+ {
+ Store (73, WRD) // pass -- just do something
+ }
+ else
+ {
+ Return (73) // fail
+ }
+
+ // Test If (LOr ()) with no save of LOr result
+ If (LOr (0, 0))
+ {
+ Return (74) // fail
+ }
+ else
+ {
+ Store (74, WRD) // pass -- just do something
+ }
+
+ Return (0)
+ } // TEST
+ } // NOSV
+
+
+//
+// test IndxFld.asl
+//
+// IndexFld test
+// This is just a subset of the many RegionOp/Index Field test cases.
+// Tests index field element AccessAs macro.
+//
+ Device (IDXF)
+ { // Test device name
+
+ OperationRegion (SIO, SystemIO, 0x100, 2)
+ Field (SIO, ByteAcc, NoLock, Preserve)
+ {
+ INDX, 8,
+ DATA, 8
+ }
+ IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
+ {
+ AccessAs (ByteAcc, 0),
+ IFE0, 8,
+ IFE1, 8,
+ IFE2, 8,
+ IFE3, 8,
+ IFE4, 8,
+ IFE5, 8,
+ IFE6, 8,
+ IFE7, 8,
+ IFE8, 8,
+ IFE9, 8,
+ }
+
+ Method (TEST)
+ {
+ Store ("++++++++ IndxFld Test", Debug)
+
+ Store (IFE0, Local0)
+ Store (IFE1, Local1)
+ Store (IFE2, Local2)
+
+ Return (0)
+ } // TEST
+ } // IDXF
+
+//
+// test NestdLor.asl
+//
+ Scope (\_SB) // System Bus
+ { // _SB system bus
+
+ Name (ZER0, 0)
+ Name (ZER1, 0)
+ Name (ZER2, 0)
+ Name (ONE0, 1)
+
+ Device (NSTL)
+ {
+ Method (TEST)
+ {
+ Store ("++++++++ NestdLor Test", Debug)
+
+ If (Lor (ZER0, Lor (ZER1, Lor (ZER2, ONE0))))
+ { // Indicate Pass
+ Store (0x00, Local0)
+ }
+
+ Else
+ { // Indicate Fail
+ Store (0x01, Local0)
+ }
+
+ Return (Local0)
+ } // End Method TEST
+ } // Device NSTL
+ } // _SB system bus
+
+//
+// test RetBuf.asl
+//
+// Test ReturnOp(Buffer)
+// This is required to support Control Method Batteries on
+// Dell Latitude Laptops (e.g., CP1-A)
+//
+ Device (RTBF)
+ {
+ Method (SUBR, 1)
+ {
+ Return (Arg0)
+ }
+
+ Method (RBUF)
+ { // RBUF: Return Buffer from local variable
+ Name (ABUF, Buffer() {"ARBITRARY_BUFFER"})
+
+ // store local buffer ABUF into Local0
+ Store (ABUF, Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Buffer
+ If (LNotEqual (Local1, 3)) // Buffer type is 3
+ {
+ Return (1) // failure
+ }
+
+ // store value returned by control method SUBR into Local0
+ Store (SUBR (ABUF), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Buffer
+ If (LNotEqual (Local1, 3)) // Buffer type is 3
+ {
+ Return (2) // failure
+ }
+
+ // allocate buffer using Local1 as buffer size (run-time evaluation)
+ Store (5, Local1)
+ Name (BUFR, Buffer(Local1) {})
+
+ // store value returned by control method SUBR into Local0
+ Store (SUBR (BUFR), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Buffer
+ If (LNotEqual (Local1, 3)) // Buffer type is 3
+ {
+ Return (3) // failure
+ }
+
+ // store BUFR Buffer into Local0
+ Store (BUFR, Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Buffer
+ If (LNotEqual (Local1, 3)) // Buffer type is 3
+ {
+ Return (4) // failure
+ }
+
+
+ // return Local0 Buffer
+ Return (Local0)
+ } // RBUF
+
+ Method (TEST)
+ {
+ Store ("++++++++ RetBuf Test", Debug)
+
+ // store RBUF Buffer return value into Local0
+ Store (RBUF, Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Buffer
+ If (LNotEqual (Local1, 3)) // Buffer type is 3
+ {
+ Return (10) // failure
+ }
+ Else
+ {
+ Return (0) // success
+ }
+ } // TEST
+ } // RTBF
+
+//
+// test RetLVal.asl
+//
+// Test ReturnOp(Lvalue)
+// This is required to support _PSR on IBM ThinkPad 560D and
+// _DCK on Toshiba Tecra 8000.
+//
+
+ Device (GPE2)
+ {
+ Method (_L03)
+ {
+ Store ("Method GPE2._L03 invoked", Debug)
+ Return ()
+ }
+
+ Method (_E05)
+ {
+ Store ("Method GPE2._E05 invoked", Debug)
+ Return ()
+ }
+ }
+
+ Device (PRW2)
+ {
+ Name (_PRW, Package(2) {Package(2){\GPE2, 0x05}, 3})
+ }
+
+
+ Scope (\_GPE)
+ {
+ Name (ACST, 0xFF)
+
+ Method (_L08)
+ {
+ Store ("Method _GPE._L08 invoked", Debug)
+ Return ()
+ }
+
+ Method (_E09)
+ {
+ Store ("Method _GPE._E09 invoked", Debug)
+ Return ()
+ }
+
+ Method (_E11)
+ {
+ Store ("Method _GPE._E11 invoked", Debug)
+ Notify (\PRW1, 2)
+ }
+
+ Method (_L22)
+ {
+ Store ("Method _GPE._L22 invoked", Debug)
+ Return ()
+ }
+
+ Method (_L33)
+ {
+ Store ("Method _GPE._L33 invoked", Debug)
+ Return ()
+ }
+
+ Method (_E64)
+ {
+ Store ("Method _GPE._E64 invoked", Debug)
+ Return ()
+ }
+
+ } // _GPE
+
+ Device (PRW1)
+ {
+ Name (_PRW, Package(2) {0x11, 3})
+ }
+
+ Device (PWRB)
+ {
+ Name (_HID, EISAID("PNP0C0C"))
+ Name (_PRW, Package(2) {0x33, 3})
+ }
+
+
+ Scope (\_SB) // System Bus
+ { // _SB system bus
+
+ Device (ACAD)
+ { // ACAD: AC adapter device
+ Name (_HID, "ACPI0003") // AC adapter device
+
+ Name (_PCL, Package () {\_SB})
+
+ OperationRegion (AREG, SystemIO, 0x0372, 2)
+ Field (AREG, ByteAcc, NoLock, Preserve)
+ {
+ AIDX, 8,
+ ADAT, 8
+ }
+ IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve)
+ {
+ , 1, // skips
+ ACIN, 1,
+ , 2, // skips
+ CHAG, 1,
+ , 3, // skips
+ , 7, // skips
+ ABAT, 1,
+ } // IndexField
+
+ Method (_PSR)
+ {
+ Store (\_GPE.ACST, Local0)
+ Store (ACIN, Local1)
+ If (LNotEqual (\_GPE.ACST, Local1))
+ {
+ Store (Local1, \_GPE.ACST)
+ // This Notify is commented because it causes a
+ // method error when running on a system without the
+ // specific device.
+ // Notify (\_SB_.ACAD, 0)
+ }
+ Return (Local0)
+ } // _PSR
+
+ Method (_STA)
+ {
+ Return (0x0F)
+ }
+
+ Method (_INI)
+ {
+ Store (ACIN, \_GPE.ACST)
+ }
+ } // ACAD: AC adapter device
+
+ // test implicit return from control method
+ Method (DIS_, 1)
+ {
+ Store (Arg0, Local0)
+ }
+
+ Device (RTLV)
+ {
+ // test implicit return inside nested if with explicit return of Lvalue
+ Method (_DCK, 1)
+ // Arg0: 1 == dock, 0 == undock
+ {
+ If (Arg0)
+ { // dock
+ Store (0x87, Local0)
+
+ If (Local0)
+ {
+ DIS_ (0x23)
+ Return (1)
+ }
+
+ Return (0)
+ } // dock
+ Else
+ { // undock
+ Store (Arg0, Local0)
+
+ If (Local0)
+ {
+ DIS_ (0x23)
+ Return (1)
+ }
+
+ Return (0)
+ } // undock
+ } // _DCK control method
+
+ Method (TEST)
+ {
+ Store ("++++++++ RetLVal Test", Debug)
+
+ // store _PSR return value into Local0
+ Store (\_SB_.ACAD._PSR, Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number/Integer type is 1
+ {
+ Return (1) // failure
+ }
+
+ // test implicit return inside nested if with explicit return of Lvalue
+ Store (_DCK (1), Local2)
+
+ // save Local2 object type value into Local3
+ Store (ObjectType (Local2), Local3)
+
+ // validate Local2 is a Number
+ If (LNotEqual (Local3, 1)) // Number/Integer type is 1
+ {
+ Return (2) // failure
+ }
+
+ If (LNotEqual (Local2, 1))
+ {
+ Return (3) // failure
+ }
+
+ Return (0) // success
+ } // TEST
+ } // RTLV
+ } // _SB system bus
+
+//
+// test RetPkg.asl
+//
+// Test ReturnOp(Package)
+// This is required to support _PRT on Dell Optiplex Workstations (e.g. GX1)
+//
+
+ Scope (\_SB) // System Bus
+ { // _SB system bus
+ Device(LNKA)
+ {
+ Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
+ Name (_UID, 1)
+ }
+ Device(LNKB)
+ {
+ Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
+ Name (_UID, 2)
+ }
+ Device(LNKC)
+ {
+ Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
+ Name (_UID, 3)
+ }
+ Device(LNKD)
+ {
+ Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
+ Name (_UID, 4)
+ }
+
+ Device (PCI1)
+ { // PCI1: Root PCI Bus
+ Name (_HID, "PNP0A03") // Need _HID for root device (String format)
+ Name (_ADR,0x00000000)
+ Name (_CRS,0)
+
+ Name (_PRT, Package ()
+ {
+ Package () {0x0004ffff, 0, LNKA, 0}, // Slot 1, INTA
+ Package () {0x0004ffff, 1, LNKB, 0}, // Slot 1, INTB
+ Package () {0x0004ffff, 2, LNKC, 0}, // Slot 1, INTC
+ Package () {0x0004ffff, 3, LNKD, 0}, // Slot 1, INTD
+ Package () {0x0005ffff, 0, \_SB_.LNKB, 0}, // Slot 2, INTA
+ Package () {0x0005ffff, 1, \_SB_.LNKC, 0}, // Slot 2, INTB
+ Package () {0x0005ffff, 2, \_SB_.LNKD, 0}, // Slot 2, INTC
+ Package () {0x0006ffff, 3, \_SB_.LNKA, 0}, // Slot 2, INTD
+ Package () {0x0006ffff, 0, LNKC, 0}, // Slot 3, INTA
+ Package () {0x0006ffff, 1, LNKD, 0}, // Slot 3, INTB
+ Package () {0x0006ffff, 2, LNKA, 0}, // Slot 3, INTC
+ Package () {0x0006ffff, 3, LNKB, 0}, // Slot 3, INTD
+ })
+
+ Device (PX40)
+ { // Map f0 space, Start PX40
+ Name (_ADR,0x00070000) // Address+function.
+ }
+ } // PCI0: Root PCI Bus
+
+ Device (RETP)
+ {
+ Method (RPKG)
+ { // RPKG: Return Package from local variable
+
+ // store _PRT package into Local0
+ Store (\_SB_.PCI1._PRT, Local0)
+
+ // return Local0 Package
+ Return (Local0)
+ } // RPKG
+
+ Method (TEST)
+ {
+ Store ("++++++++ RetPkg Test", Debug)
+
+ // store RPKG package return value into Local0
+ Store (RPKG, Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Package
+ If (LNotEqual (Local1, 4)) // Package type is 4
+ { Return (1) } // failure
+ Else
+ { Return (0) } // success
+ } // TEST
+ } // RETP
+ } // _SB_
+
+//
+// test WhileRet.asl
+//
+// WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp.
+//
+ Device (WHLR)
+ {
+ Name (LCNT, 0)
+ Method (WIR)
+ { // WIR: control method that returns inside of IfOp inside of WhileOp
+ While (LLess (LCNT, 4))
+ {
+ If (LEqual (LCNT, 2))
+ {
+ Return (0)
+ }
+
+ Increment (LCNT)
+ }
+
+ Return (LCNT)
+ } // WIR: control method that returns inside of IfOp inside of WhileOp
+
+ Method (TEST)
+ {
+ Store ("++++++++ WhileRet Test", Debug)
+
+ Store (WIR, Local0)
+
+ Return (Local0)
+ } // TEST
+ } // WHLR
+
+//
+// test AndOrOp.asl
+//
+//This code tests the bitwise AndOp and OrOp Operator terms
+//
+//Syntax of Andop term
+//And - Bitwise And
+//AndTerm := And(
+// Source1, //TermArg=>Integer
+// Source2, //TermArg=>Integer
+// Result //Nothing | SuperName
+//) => Integer
+//Source1 and Source2 are evaluated as integer data types,
+// a bit-wise AND is performed, and the result is optionally
+//stored into Result.
+//
+//
+//Syntax of OrOp
+//Or - Bit-wise Or
+//OrTerm := Or(
+// Source1, //TermArg=>Integer
+// Source2 //TermArg=>Integer
+// Result //Nothing | SuperName
+//) => Integer
+//Source1 and Source2 are evaluated as integer data types,
+// a bit-wide OR is performed, and the result is optionally
+//stored in Result
+//
+ Device (ANDO)
+ {
+ OperationRegion (TMEM, SystemMemory, 0xC4, 0x02)
+ Field (TMEM, ByteAcc, NoLock, Preserve)
+ {
+ , 3,
+ TOUD, 13
+ }
+
+ //Create System Memory Operation Region and field overlays
+ OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ {
+ SMDW, 32, // 32-bit DWORD
+ SMWD, 16, // 16-bit WORD
+ SMBY, 8, // 8-bit BYTE
+ }// Field(RAM)
+
+
+ //And with Byte Data
+ Name (BYT1, 0xff)
+ Name (BYT2, 0xff)
+ Name (BRSL, 0x00)
+
+ //And with Word Data
+ Name (WRD1, 0xffff)
+ Name (WRD2, 0xffff)
+ Name (WRSL, 0x0000)
+
+ //And with DWord Data
+ Name (DWD1, 0xffffffff)
+ Name (DWD2, 0xffffffff)
+ Name (DRSL, 0x00000000)
+
+ Method (ANDP)
+ {
+ //Check with 1 And 1 on byte data
+ And(BYT1, BYT2, BRSL)
+ if(LNotEqual(BRSL,0xff))
+ {Return(1)}
+
+ //Check with 1 And 1 on Word data
+ And(WRD1, WRD2, WRSL)
+ if(LNotEqual(WRSL,0xffff))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 1 And 1 Dword
+ And(DWD1, DWD2, DRSL)
+ if(LNotEqual(DRSL,0xffffffff))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 0 And 0 on byte data
+ Store(0x00,BYT1)
+ Store(0x00,BYT2)
+ Store(0x00,BRSL)
+ And(BYT1, BYT2, BRSL)
+ if(LNotEqual(BRSL,0x00))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 0 And 0 on Word data
+ Store (0x0000,WRD1)
+ Store (0x0000,WRD2)
+ Store (0x0000,WRSL)
+ And(WRD1, WRD2, WRSL)
+ if(LNotEqual(WRSL,0x0000))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 0 And 0 Dword
+ Store (0x00000000,DWD1)
+ Store (0x00000000,DWD2)
+ Store (0x00000000,DRSL)
+ And(DWD1, DWD2, DRSL)
+ if(LNotEqual(DRSL,0x00000000))
+ {
+ Return (1) // failure
+ }
+
+
+ //Check with 1 And 0 on byte data
+ Store(0x55,BYT1)
+ Store(0xAA,BYT2)
+ Store(0x00,BRSL)
+ And(BYT1, BYT2, BRSL)
+ if(LNotEqual(BRSL,0x00))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 1 And 0 on Word data
+ Store (0x5555,WRD1)
+ Store (0xAAAA,WRD2)
+ Store (0x0000,WRSL)
+ And(WRD1, WRD2, WRSL)
+ if(LNotEqual(WRSL,0x0000))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 1 And 0 on Dword
+ Store (0x55555555,DWD1)
+ Store (0xAAAAAAAA,DWD2)
+ Store (0x00000000,DRSL)
+ And(DWD1, DWD2, DRSL)
+ if(LNotEqual(DRSL,0x00000000))
+ {
+ Return (1) // failure
+ }
+
+ Store (0x1FFF, TOUD)
+ Store (TOUD, Local0)
+ if(LNotEqual(Local0,0x1FFF))
+ {
+ Return (1) // failure
+ }
+
+ //TBD- Do We need to check for system memory data also for each test case ??
+
+ Return(0)
+
+ }//ANDP
+
+ Method (OROP)
+ {
+
+ //Check with 1 Ored with 1 on byte data
+ Store(0xff,BYT1)
+ Store(0xff,BYT2)
+ Store(0x00,BRSL)
+ Or(BYT1, BYT2, BRSL)
+ if(LNotEqual(BRSL,0xff))
+ {
+ Return (1) // failure
+ }
+
+
+ //Check with 1 Ored with 1 on Word data
+ Store(0xffff,WRD1)
+ Store(0xffff,WRD2)
+ Store(0x0000,WRSL)
+ Or(WRD1, WRD2, WRSL)
+ if(LNotEqual(WRSL,0xffff))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 1 Ored with 1 on Dword data
+ Store(0xffffffff,DWD1)
+ Store(0xffffffff,DWD2)
+ Store(0x00000000,DRSL)
+ Or(DWD1, DWD2, DRSL)
+ if(LNotEqual(DRSL,0xffffffff))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 0 Ored with 0 on byte data
+ Store(0x00,BYT1)
+ Store(0x00,BYT2)
+ Store(0x00,BRSL)
+ Or(BYT1, BYT2, BRSL)
+ if(LNotEqual(BRSL,0x00))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 0 Ored with 0 on Word data
+ Store (0x0000,WRD1)
+ Store (0x0000,WRD2)
+ Store (0x0000,WRSL)
+ Or(WRD1, WRD2, WRSL)
+ if(LNotEqual(WRSL,0x0000))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 0 Ored with 0 Dword data
+ Store (0x00000000,DWD1)
+ Store (0x00000000,DWD2)
+ Store (0x00000000,DRSL)
+ Or(DWD1, DWD2, DRSL)
+ if(LNotEqual(DRSL,0x00000000))
+ {
+ Return (1) // failure
+ }
+
+
+ //Check with 1 Ored with 0 on byte data
+ Store(0x55,BYT1)
+ Store(0xAA,BYT2)
+ Store(0x00,BRSL)
+ Or(BYT1, BYT2, BRSL)
+ if(LNotEqual(BRSL,0xff))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 1 Ored with 0 on Word data
+ Store (0x5555,WRD1)
+ Store (0xAAAA,WRD2)
+ Store (0x0000,WRSL)
+ Or(WRD1, WRD2, WRSL)
+ if(LNotEqual(WRSL,0xffff))
+ {
+ Return (1) // failure
+ }
+
+ //Check with 1 Ored with 0 on Dword data
+ Store (0x55555555,DWD1)
+ Store (0xAAAAAAAA,DWD2)
+ Store (0x00000000,DRSL)
+ Or(DWD1, DWD2, DRSL)
+ if(LNotEqual(DRSL,0xffffffff))
+ {
+ Return (1) // failure
+ }
+
+ //TBD - Do We need to check for system memory data also for each test case ??
+
+ Return(0)
+
+ }//OROP
+
+ Method(TEST)
+ {
+ Store ("++++++++ AndOrOp Test", Debug)
+
+ Name(RSLT,1)
+ //Call Andop method
+ Store(ANDP,RSLT)
+ if(LEqual(RSLT,1))
+ {
+ Return (RSLT)
+ }
+
+ //Call OrOp Method
+ Store(OROP,RSLT)
+ if(LEqual(RSLT,1))
+ {
+ Return(RSLT)
+ }
+
+ //
+ // Return original conditions to allow iterative execution
+ //
+ Store(0xff,BYT1)
+ Store(0xff,BYT2)
+ Store(0x00,BRSL)
+ Store (0xffff,WRD1)
+ Store (0xffff,WRD2)
+ Store (0x0000,WRSL)
+ Store (0xffffffff,DWD1)
+ Store (0xffffffff,DWD2)
+ Store (0x00000000,DRSL)
+
+ Return(0)
+ } //TEST
+ } //ANDO
+
+//
+// test BreakPnt.asl
+//
+// This code tests the BreakPoint opcode term. The syntax of BreakPoint Term is
+// BreakPointTerm := BreakPoint
+// Used for debugging, the Breakpoint opcode stops the execution and enters the AML debugger.
+// In the non-debug version of the interpreter, BreakPoint is equivalent to Noop.
+//
+ Device (BRKP)
+ {
+ Name(CNT0,0)
+
+ Method (BK1)
+ {
+ BreakPoint
+ Return(0)
+ }
+
+ Method (TEST)
+ {
+ Store ("++++++++ BreakPnt Test", Debug)
+
+ Store(0,CNT0)
+
+ //Check BreakPoint statement
+ While(LLess(CNT0,10))
+ {
+ Increment(CNT0)
+ }
+
+ //Check the BreakPoint statement
+ If(LEqual(CNT0,10))
+ {
+ // BreakPoint
+ Return(0)
+ }
+
+ //failed
+ Return(1)
+ }
+ }
+
+//
+// test AddSubOp.asl
+//
+ Device (ADSU)
+ {
+ // create System Memory Operation Region and field overlays
+ OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ {
+ SMDW, 32, // 32-bit DWORD
+ SMWD, 16, // 16-bit WORD
+ SMBY, 8, // 8-bit BYTE
+ } // Field(RAM)
+
+ Method (TEST)
+ {
+ Store ("++++++++ AddSubOp Test", Debug)
+
+ Name (DWRD, 0x12345678)
+ Name (WRD, 0x1234)
+ Name (BYT, 0x12)
+
+ // Test AddOp with DWORD data
+ Store (0x12345678, DWRD)
+ Add (DWRD, 7, DWRD)
+ If (LNotEqual (DWRD, 0x1234567F))
+ { Return (DWRD) }
+
+ // Test AddOp with WORD data
+ Add (WRD, 5, WRD)
+ If (LNotEqual (WRD, 0x1239))
+ { Return (WRD) }
+
+ // Test AddOp with BYTE data
+ Add (BYT, 3, BYT)
+ If (LNotEqual (BYT, 0x15))
+ { Return (BYT) }
+
+ // Test SubtractOp with DWORD data
+ Subtract (DWRD, 7, DWRD)
+ If (LNotEqual (DWRD, 0x12345678))
+ { Return (DWRD) }
+
+ // Test SubtractOp with WORD data
+ Subtract (WRD, 3, WRD)
+ If (LNotEqual (WRD, 0x1236))
+ { Return (WRD) }
+
+ // Test SubtractOp with BYTE data
+ Subtract (BYT, 3, BYT)
+ If (LNotEqual (BYT, 0x12))
+ { Return (BYT) }
+
+
+ // test AddOp with DWORD SystemMemory OpRegion
+ Store (0x01234567, SMDW)
+ Add (SMDW, 8, SMDW)
+ If (LNotEqual (SMDW, 0x0123456F))
+ { Return (SMDW) }
+
+ // test SubtractOp with DWORD SystemMemory OpRegion
+ Subtract (SMDW, 7, SMDW)
+ If (LNotEqual (SMDW, 0x01234568))
+ { Return (SMDW) }
+
+
+ // test AddOp with WORD SystemMemory OpRegion
+ Store (0x0123, SMWD)
+ Add (SMWD, 6, SMWD)
+ If (LNotEqual (SMWD, 0x0129))
+ { Return (SMWD) }
+
+ // test SubtractOp with WORD SystemMemory OpRegion
+ Subtract (SMWD, 5, SMWD)
+ If (LNotEqual (SMWD, 0x0124))
+ { Return (SMWD) }
+
+
+ // test AddOp with BYTE SystemMemory OpRegion
+ Store (0x01, SMBY)
+ Add (SMBY, 4, SMBY)
+ If (LNotEqual (SMBY, 0x05))
+ { Return (SMBY) }
+
+ // test SubtractOp with BYTE SystemMemory OpRegion
+ Subtract (SMBY, 3, SMBY)
+ If (LNotEqual (SMBY, 0x02))
+ { Return (SMBY) }
+
+ Return (0)
+ } // TEST
+ } // ADSU
+
+//
+// test IncDecOp.asl
+//
+ Device (INDC)
+ {
+ // create System Memory Operation Region and field overlays
+ OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ {
+ SMDW, 32, // 32-bit DWORD
+ SMWD, 16, // 16-bit WORD
+ SMBY, 8, // 8-bit BYTE
+ } // Field(RAM)
+
+ Method (TEST)
+ {
+ Store ("++++++++ IncDecOp Test", Debug)
+
+ Name (DWRD, 0x12345678)
+ Name (WRD, 0x1234)
+ Name (BYT, 0x12)
+
+ // Test IncrementOp with DWORD data
+ Store (0x12345678, DWRD)
+ Increment (DWRD)
+ If (LNotEqual (DWRD, 0x12345679))
+ { Return (DWRD) }
+
+ // Test IncrementOp with WORD data
+ Increment (WRD)
+ If (LNotEqual (WRD, 0x1235))
+ { Return (WRD) }
+
+ // Test IncrementOp with BYTE data
+ Increment (BYT)
+ If (LNotEqual (BYT, 0x13))
+ { Return (BYT) }
+
+ // Test DecrementOp with DWORD data
+ Decrement (DWRD)
+ If (LNotEqual (DWRD, 0x12345678))
+ { Return (DWRD) }
+
+ // Test DecrementOp with WORD data
+ Decrement (WRD)
+ If (LNotEqual (WRD, 0x1234))
+ { Return (WRD) }
+
+ // Test DecrementOp with BYTE data
+ Decrement (BYT)
+ If (LNotEqual (BYT, 0x12))
+ { Return (BYT) }
+
+
+ // test IncrementOp with DWORD SystemMemory OpRegion
+ Store (0x01234567, SMDW)
+ Increment (SMDW)
+ If (LNotEqual (SMDW, 0x01234568))
+ { Return (SMDW) }
+
+ // test DecrementOp with DWORD SystemMemory OpRegion
+ Decrement (SMDW)
+ If (LNotEqual (SMDW, 0x01234567))
+ { Return (SMDW) }
+
+
+ // test IncrementOp with WORD SystemMemory OpRegion
+ Store (0x0123, SMWD)
+ Increment (SMWD)
+ If (LNotEqual (SMWD, 0x0124))
+ { Return (SMWD) }
+
+ // test DecrementOp with WORD SystemMemory OpRegion
+ Decrement (SMWD)
+ If (LNotEqual (SMWD, 0x0123))
+ { Return (SMWD) }
+
+
+ // test IncrementOp with BYTE SystemMemory OpRegion
+ Store (0x01, SMBY)
+ Increment (SMBY)
+ If (LNotEqual (SMBY, 0x02))
+ { Return (SMBY) }
+
+ // test DecrementOp with BYTE SystemMemory OpRegion
+ Decrement (SMBY)
+ If (LNotEqual (SMBY, 0x01))
+ { Return (SMBY) }
+
+ Return (0)
+ } // TEST
+ } // INDC
+
+//
+// test LOps.asl
+//
+//This source tests all the logical operators. Logical operators in ASL are as follows.
+//LAnd, LEqual, LGreater, LLess, LNot, LNotEqual, LOr.
+// Success will return 0 and failure will return a non zero number. Check the source code for
+// non zero number to find where the test failed
+
+ Device (LOPS)
+ {
+ //Create System Memory Operation Region and field overlays
+ OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ {
+ SMDW, 32, // 32-bit DWORD
+ SMWD, 16, // 16-bit WORD
+ SMBY, 8, // 8-bit BYTE
+ }// Field(RAM)
+
+ //And with Byte Data
+ Name (BYT1, 0xff)
+ Name (BYT2, 0xff)
+ Name (BRSL, 0x00)
+
+ //And with Word Data
+ Name (WRD1, 0xffff)
+ Name (WRD2, 0xffff)
+ Name (WRSL, 0x0000)
+
+ //And with DWord Data
+ Name (DWD1, 0xffffffff)
+ Name (DWD2, 0xffffffff)
+ Name (DRSL, 0x00000000)
+
+ Name(RSLT,1)
+
+ Method (ANDL,2) // Test Logical And
+ {
+ //test with the arguments passed
+ if(LEqual(Arg0,Arg1))
+ { Store(LAnd(Arg0,Arg1),RSLT)
+ if(LNotEqual(Ones,RSLT))
+ {Return(11)}
+ }
+
+ //test with he locals
+ Store(Arg0,Local0)
+ Store(Arg1,Local1)
+
+ if(LEqual(Local0,Local1))
+ {
+ Store(LAnd(Local0,Local1),RSLT)
+ if(LNotEqual(Ones,RSLT))
+ {Return(12)}
+ }
+
+ //test with BYTE data
+ if(LEqual(BYT1,BYT2))
+ { Store(LAnd(BYT1,BYT2),BRSL)
+ if(LNotEqual(Ones,BRSL))
+ {Return(13)}
+ }
+
+ //test with WORD data
+ if(LEqual(WRD1,WRD2))
+ { Store(LAnd(WRD1,WRD2),WRSL)
+ if(LNotEqual(Ones,WRSL))
+ {Return(14)}
+ }
+
+ //test with DWORD data
+ if(LEqual(DWD1,DWD2))
+ { Store(LAnd(DWD1,DWD2),DRSL)
+ if(LNotEqual(Ones,DRSL))
+ {Return(15)}
+ }
+
+ //Test for system memory data for each test case.
+
+ Store(0xff,BYT1)
+ Store(0xff,SMBY)
+ Store(0x00,BRSL)
+
+ //test with BYTE system memory data
+ if(LEqual(BYT1,SMBY))
+ { Store(LAnd(BYT1,SMBY),BRSL)
+ if(LNotEqual(Ones,BRSL))
+ {Return(16)}
+ }
+
+ Store (0xffff,WRD1)
+ Store(0xffff,SMWD)
+ Store(0x0000,WRSL)
+ //test with WORD system memory data
+ if(LEqual(WRD1,SMWD))
+ { Store(LAnd(WRD1,SMWD),WRSL)
+ if(LNotEqual(Ones,WRSL))
+ {Return(17)}
+ }
+
+ Store(0x000000,DRSL)
+ Store (0xffffff,DWD1)
+ Store(0xffffff,SMDW)
+
+ //test with DWORD system memory data
+ if(LEqual(DWD1,SMDW))
+ { Store(LAnd(DWD1,SMDW),DRSL)
+ if(LNotEqual(Ones,DRSL))
+ {Return(18)}
+ }
+
+ Return(0)
+
+ }//ANDL
+
+ //Test the LOr Operator
+
+ Method (ORL_,2)
+ {//ORL_
+
+ //test with the arguments passed
+ if(LEqual(Arg0,Arg1))
+ {
+ Store(LOr(Arg0,Arg1),RSLT)
+ if(LNotEqual(Ones,RSLT))
+ {
+ Return(21)
+ }
+ }
+
+ //test with he locals
+ Store(Arg0,Local0)
+ Store(Arg1,Local1)
+
+ if(LEqual(Local0,Local1))
+ {
+ Store(LOr(Local0,Local1),RSLT)
+ if(LNotEqual(Ones,RSLT))
+ {Return(22)}
+ }
+
+ //Check with 1 LOred with 0 on byte data
+ Store(0xff,BYT1)
+ Store(0x00,BYT2)
+ Store(0x00,BRSL)
+
+ if(LNotEqual(BYT1, BYT2))
+ {
+ Store(LOr(BYT1, BYT2), BRSL)
+ if(LNotEqual(Ones,BRSL))
+ {Return(23)}
+ }
+
+ //Check with 1 LOred with 0 on WORD data
+ Store(0xffff,WRD1)
+ Store(0x0000,WRD2)
+ Store(0x0000,WRSL)
+
+ if(LNotEqual(WRD1, WRD2))
+ {
+ Store(LOr(WRD1, WRD2), WRSL)
+ if(LNotEqual(Ones,WRSL))
+ {Return(24)}
+ }
+
+ //Check with 1 LOred with 0 on DWORD data
+ Store(0xffffffff,DWD1)
+ Store(0x00000000,DWD2)
+ Store(0x00000000,DRSL)
+
+ if(LNotEqual(DWD1, DWD2))
+ {
+ Store(LOr(DWD1, DWD2), DRSL)
+ if(LNotEqual(Ones,DRSL))
+ {Return(25)}
+ }
+
+ Store(0x00,BYT1)
+ Store(0xff,SMBY)
+ Store(0x00,BRSL)
+
+ //test with BYTE system memory data
+ if(LEqual(BYT1,SMBY))
+ { Store(LOr(BYT1,SMBY),BRSL)
+ if(LNotEqual(Ones,BRSL))
+ {Return(26)}
+ }
+
+ Store (0x0000,WRD1)
+ Store(0xffff,SMWD)
+ Store(0x0000,WRSL)
+
+ //test with WORD system memory data
+ if(LEqual(WRD1,SMWD))
+ { Store(LOr(WRD1,SMWD),WRSL)
+ if(LNotEqual(Ones,WRSL))
+ {Return(27)}
+ }
+
+
+ Store(0x00000000,DWD1)
+ Store(0xffffffff,SMDW)
+ Store(0x00000000,DRSL)
+
+ //test with DWORD system memory data
+ if(LEqual(DWD1,SMDW))
+ { Store(LAnd(DWD1,SMDW),DRSL)
+ if(LNotEqual(Ones,DRSL))
+ {Return(28)}
+ }
+ Return(0)
+
+ }//ORL_
+
+ //This method tests LGreater and LNot operator
+ Method(LSGR,2)
+ {//LSGR
+
+ //Test on arguements passed
+
+ //in test data, Arg1 > Arg0
+ if(LEqual(Ones,LNot(LGreater(Arg1,Arg0))))
+ {Return(31)}
+
+ //test LLessEqual
+ if(LEqual(Ones,LNot(LGreaterEqual(Arg1,Arg0))))
+ {Return(32)}
+
+ if(LEqual(Ones,LLess(Arg1,Arg0)))
+ {Return(33)}
+
+ //test LLessEqual
+ if(LEqual(Ones,LLessEqual(Arg1,Arg0)))
+ {Return(34)}
+
+ Store(Arg0,Local0)
+ Store(Arg1,Local1)
+
+ //test with the locals
+ if(LNot(LGreater(Local1,Local0)))
+ {Return(35)}
+
+ //test on Byte data
+ Store(0x12,BYT1)
+ Store(0x21,BYT2)
+
+ if(LNot(LGreater(BYT2,BYT1)))
+ {Return(36)}
+
+ if(LNot(LLess(BYT1,BYT2)))
+ {Return(37)}
+
+ //test LGreaterEqual with byte data
+ if(LNot(LGreaterEqual(BYT2,BYT1)))
+ {Return(38)}
+
+ //test LLessEqual byte data
+ if(LNot(LLessEqual(BYT1,BYT2)))
+ {Return(39)}
+
+
+ //test on Word data
+ Store(0x1212,WRD1)
+ Store(0x2121,WRD2)
+
+ if(LNot(LGreater(WRD2,WRD1)))
+ {Return(310)}
+
+ if(LNot(LLess(WRD1,WRD2)))
+ {Return(311)}
+
+ //Test LGreaterEqual with Word Data
+ if(LNot(LGreaterEqual(WRD2,WRD1)))
+ {Return(312)}
+
+
+ //Test LLessEqual with Word Data
+ if(LNot(LLessEqual(WRD1,WRD2)))
+ {Return(313)}
+
+ //test on DWord data
+ Store(0x12121212,DWD1)
+ Store(0x21212121,DWD2)
+
+ if(LNot(LGreater(DWD2,DWD1)))
+ {Return(314)}
+
+ if(LNot(LLess(DWD1,DWD2)))
+ {Return(315)}
+
+
+ //Test LGreaterEqual with Dword
+ if(LNot(LGreaterEqual(DWD2,DWD1)))
+ {Return(316)}
+
+ //Test LLessEqual DWord
+ if(LNot(LLessEqual(DWD1,DWD2)))
+ {Return(317)}
+
+ Return(0)
+ }//LSGR
+
+ //The test method
+ Method(TEST)
+ {
+ Store ("++++++++ LOps Test", Debug)
+
+ Store(0,RSLT)
+ //Call LAndOp method
+ Store(ANDL(2,2),RSLT)
+ if(LNotEqual(RSLT,0))
+ {Return(RSLT)}
+
+ //Call LOrOp Method
+ Store(ORL_(5,5),RSLT)
+ if(LNotEqual(RSLT,0))
+ {Return(RSLT)}
+
+ //Call LSGR Method
+ Store(LSGR(5,7),RSLT)
+ if(LNotEqual(RSLT,0))
+ {Return(RSLT)}
+
+ Return(0)
+ }//TEST
+ }//LOPS
+
+//
+// test FdSetOps.asl
+//
+// FindSetLeftBit - Find Set Left Bit
+// FindSetLeftBitTerm := FindSetLeftBit
+// ( Source, //TermArg=>Integer
+// Result //Nothing | SuperName
+// ) => Integer
+// Source is evaluated as integer data type, and the one-based bit location of
+// the first MSb (most significant set bit) is optionally stored into Result.
+// The result of 0 means no bit was set, 1 means the left-most bit set is the
+// first bit, 2 means the left-most bit set is the second bit, and so on.
+// FindSetRightBit - Find Set Right Bit
+
+// FindSetRightBitTerm := FindSetRightBit
+// ( Source, //TermArg=>Integer
+// Result //Nothing | SuperName
+// ) => Integer
+// Source is evaluated as integer data type, and the one-based bit location of
+// the most LSb (least significant set bit) is optionally stored in Result.
+// The result of 0 means no bit was set, 32 means the first bit set is the
+// 32nd bit, 31 means the first bit set is the 31st bit, and so on.
+
+// If the Control method is success Zero is returned. Otherwise a non-zero
+// number is returned.
+//
+ Device (FDSO)
+ { // FDSO
+
+ // Create System Memory Operation Region and field overlays
+ OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ {
+ SMDW, 32, // 32-bit DWORD
+ SMWD, 16, // 16-bit WORD
+ SMBY, 8, // 8-bit BYTE
+ } // Field(RAM)
+
+ // Byte Data
+ Name (BYT1, 1)
+ Name (BRSL, 0x00)
+
+ // Word Data
+ Name (WRD1, 0x100)
+ Name (WRSL, 0x0000)
+
+ // DWord Data
+ Name (DWD1, 0x10000)
+ Name (DRSL, 0x00000000)
+ Name (RSLT, 1)
+ Name (CNTR, 1)
+
+ Method (SHFT,2)
+ // Arg0 is the actual data and Arg1 is the bit position
+ { // SHFT
+ Store (Arg0, Local0)
+ Store (Arg1, Local1)
+
+ FindSetLeftBit (Arg0, BRSL)
+ If (LNotEqual (BRSL, Arg1))
+ { Return (0x11) }
+ If (LNotEqual (Arg0, Local0))
+ { Return (0x12) }
+
+ FindSetLeftBit (Local0, BRSL)
+ If (LNotEqual (BRSL, Local1))
+ { Return (0x13) }
+ If (LNotEqual (Arg0, Local0))
+ { Return (0x14) }
+
+ // test the byte value for SetLeftBit
+ Store (7, BYT1)
+ FindSetLeftBit (BYT1, BRSL)
+ If (LNotEqual (BRSL, 3))
+ { Return (0x15) }
+ If (LNotEqual (BYT1, 7))
+ { Return (0x16) }
+
+ Store (1, BYT1)
+ Store (1, CNTR)
+ While (LLessEqual (CNTR, 8))
+ { // FindSetLeftBit check loop for byte data
+ FindSetLeftBit (BYT1, BRSL)
+ If (LNotEqual (BRSL, CNTR))
+ { Return (0x17) }
+
+ // Shift the bits to check the same
+ ShiftLeft (BYT1, 1, BYT1)
+ Increment (CNTR)
+ } // FindSetLeftBit check loop for byte data
+
+
+ // Check BYTE value for SetRightBit
+ Store (7, BYT1)
+ FindSetRightBit (BYT1, BRSL)
+ If (LNotEqual (BRSL, 1))
+ { Return (0x21) }
+ If (LNotEqual (BYT1, 7))
+ { Return (0x22) }
+
+ Store (1, CNTR)
+ Store (0xFF, BYT1)
+ While (LLessEqual (CNTR, 8))
+ { // FindSetRightBit check loop for byte data
+ FindSetRightBit (BYT1, BRSL)
+ If (LNotEqual (BRSL, CNTR))
+ { Return (0x23) }
+
+ ShiftLeft (BYT1, 1, BYT1)
+ Increment (CNTR)
+ } // FindSetRightBit check loop for byte data
+
+
+ // Test Word value for SetLeftBit
+ Store (9, CNTR)
+ Store (0x100, WRD1)
+ While (LLessEqual (CNTR, 16))
+ {
+ // FindSetLeftBit check loop for Word data
+ FindSetLeftBit (WRD1, WRSL)
+ If (LNotEqual (WRSL, CNTR))
+ { Return (0x31) }
+
+ // Shift the bits to check the same
+ ShiftLeft (WRD1, 1, WRD1)
+ Increment (CNTR)
+ } // FindSetLeftBit check loop for Word data
+
+ // Check Word value for SetRightBit
+ Store (9, CNTR)
+ Store (0xFF00, WRD1)
+ While (LLessEqual (CNTR, 16))
+ {
+ // FindSetRightBit check loop for Word data
+ FindSetRightBit (WRD1, WRSL)
+ If (LNotEqual (WRSL, CNTR))
+ { Return (0x32) }
+
+ ShiftLeft (WRD1, 1, WRD1)
+ Increment (CNTR)
+ } // FindSetRightBit check loop for Word data
+
+ // Test the DWord value for SetLeftBit
+ Store (17, CNTR)
+ Store (0x10000, DWD1)
+ While (LLessEqual (CNTR, 32))
+ {
+ // FindSetLeftBit check loop for Dword
+ FindSetLeftBit (DWD1, DRSL)
+ If (LNotEqual (DRSL, CNTR))
+ { Return (0x41) }
+
+ // Shift the bits to check the same
+ ShiftLeft (DWD1, 1, DWD1)
+ Increment (CNTR)
+ } // FindSetLeftBit check loop for Dword
+
+ // Check DWord value for SetRightBit
+ Store (17, CNTR)
+ Store (0xFFFF0000, DWD1)
+ While (LLessEqual (CNTR, 32))
+ { // FindSetRightBit Check loop for DWORD
+ FindSetRightBit (DWD1, DRSL)
+ If (LNotEqual (DRSL, CNTR))
+ { Return (0x42) }
+
+ ShiftLeft (DWD1, 1, DWD1)
+ Increment (CNTR)
+ } // FindSetRightBit Check loop for DWORD
+
+ Return (0)
+ } // SHFT
+
+ // Test method called from amlexec
+ Method (TEST)
+ { // TEST
+
+ Store ("++++++++ FdSetOps Test", Debug)
+
+ Store (SHFT (0x80, 8), RSLT)
+ If (LNotEqual (RSLT, 0))
+ { Return (RSLT) }
+
+ Return (0) // pass
+ } // TEST
+ } // Device FDSO
+
+//
+// test MulDivOp.asl
+//
+ Device (MLDV)
+ {
+ // create System Memory Operation Region and field overlays
+ OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ {
+ SMDW, 32, // 32-bit DWORD
+ SMWD, 16, // 16-bit WORD
+ SMBY, 8, // 8-bit BYTE
+ } // Field(RAM)
+
+ Method (TEST)
+ {
+ Store ("++++++++ MulDivOp Test", Debug)
+
+ Name (RMDR, 0)
+ Name (DWRD, 0x12345678)
+ Name (WRD, 0x1234)
+ Name (BYT, 0x12)
+
+ // Test MultiplyOp with DWORD data
+ Store (0x12345678, DWRD)
+ Multiply (DWRD, 3, DWRD)
+ If (LNotEqual (DWRD, 0x369D0368))
+ { Return (DWRD) }
+
+ // Test MultiplyOp with WORD data
+ Multiply (WRD, 4, WRD)
+ If (LNotEqual (WRD, 0x48D0))
+ { Return (WRD) }
+
+ // Test MultiplyOp with BYTE data
+ Multiply (BYT, 5, BYT)
+ If (LNotEqual (BYT, 0x5A))
+ { Return (BYT) }
+
+ // Test DivideOp with DWORD data
+ Divide (DWRD, 3, DWRD, RMDR)
+ If (LNotEqual (DWRD, 0x12345678))
+ { Return (DWRD) }
+ If (LNotEqual (RMDR, 0))
+ { Return (RMDR) }
+
+ // Test DivideOp with WORD data
+ Divide (WRD, 4, WRD, RMDR)
+ If (LNotEqual (WRD, 0x1234))
+ { Return (WRD) }
+ If (LNotEqual (RMDR, 0))
+ { Return (RMDR) }
+
+ // Test DivideOp with BYTE data
+ Divide (BYT, 5, BYT, RMDR)
+ If (LNotEqual (BYT, 0x12))
+ { Return (BYT) }
+ If (LNotEqual (RMDR, 0))
+ { Return (RMDR) }
+
+
+ // test MultiplyOp with DWORD SystemMemory OpRegion
+ Store (0x01234567, SMDW)
+ Multiply (SMDW, 2, SMDW)
+ If (LNotEqual (SMDW, 0x02468ACE))
+ { Return (SMDW) }
+
+ // test DivideOp with DWORD SystemMemory OpRegion
+ Divide (SMDW, 3, SMDW, RMDR)
+ If (LNotEqual (SMDW, 0x00C22E44))
+ { Return (SMDW) }
+ If (LNotEqual (RMDR, 2))
+ { Return (RMDR) }
+
+
+ // test MultiplyOp with WORD SystemMemory OpRegion
+ Store (0x0123, SMWD)
+ Multiply (SMWD, 3, SMWD)
+ If (LNotEqual (SMWD, 0x369))
+ { Return (SMWD) }
+
+ // test DivideOp with WORD SystemMemory OpRegion
+ Divide (SMWD, 2, SMWD, RMDR)
+ If (LNotEqual (SMWD, 0x01B4))
+ { Return (SMWD) }
+ If (LNotEqual (RMDR, 1))
+ { Return (RMDR) }
+
+
+ // test MultiplyOp with BYTE SystemMemory OpRegion
+ Store (0x01, SMBY)
+ Multiply (SMBY, 7, SMBY)
+ If (LNotEqual (SMBY, 0x07))
+ { Return (SMBY) }
+
+ // test DivideOp with BYTE SystemMemory OpRegion
+ Divide (SMBY, 4, SMBY, RMDR)
+ If (LNotEqual (SMBY, 0x01))
+ { Return (SMBY) }
+ If (LNotEqual (RMDR, 3))
+ { Return (RMDR) }
+
+ Return (0)
+ } // TEST
+ } // MLDV
+
+//
+// test NBitOps.asl
+//
+//NAnd - Bit-wise NAnd
+//NAndTerm := NAnd(
+// Source1, //TermArg=>Integer
+// Source2 //TermArg=>Integer
+// Result //Nothing | SuperName
+//) => Integer
+//Source1 and Source2 are evaluated as integer data types, a bit-wise NAND is performed, and the result is optionally
+//stored in Result.
+
+//NOr - Bitwise NOr
+//NOrTerm := NOr(
+// Source1, //TermArg=>Integer
+// Source2 //TermArg=>Integer
+// Result //Nothing | SuperName
+//) => Integer
+//Source1 and Source2 are evaluated as integer data types, a bit-wise NOR is performed, and the result is optionally
+//stored in Result.
+// Not - Not
+//NotTerm := Not(
+// Source, //TermArg=>Integer
+// Result //Nothing | SuperName
+//) => Integer
+//Source1 is evaluated as an integer data type, a bit-wise NOT is performed, and the result is optionally stored in
+//Result.
+
+//If the Control method is success Zero is returned else a non-zero number is returned
+
+ Device (NBIT)
+ {//NBIT
+
+ //Create System Memory Operation Region and field overlays
+ OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ {
+ SMDW, 32, // 32-bit DWORD
+ SMWD, 16, // 16-bit WORD
+ SMBY, 8, // 8-bit BYTE
+ }// Field(RAM)
+
+
+ //And with Byte Data
+ Name (BYT1, 0xff)
+ Name (BYT2, 0xff)
+ Name (BRSL, 0x00)
+
+ //And with Word Data
+ Name (WRD1, 0xffff)
+ Name (WRD2, 0xffff)
+ Name (WRSL, 0x0000)
+
+ //And with DWord Data
+ Name (DWD1, 0xffffffff)
+ Name (DWD2, 0xffffffff)
+ Name (DRSL, 0x00000000)
+ Name(RSLT,1)
+
+
+ Name(ARSL,0x00)
+ Name(LRSL,0x00)
+
+ Method(NNDB,2)
+ {//NNDB
+
+ Store(0xffffffff,SMDW)
+ Store(0xffff,SMWD)
+ Store(0xff,SMBY)
+
+
+ NAnd(Arg0,Arg1,ARSL)
+ if(LNotEqual(ARSL,0xfffffffd))
+ {Return(11)}
+
+ Store(Arg0,local0)
+ Store(Arg1,Local1)
+
+ NAnd(Local0,Local1,LRSL)
+ if(LNotEqual(LRSL,0xfffffffd))
+ {Return(12)}
+
+
+ //Byte data
+ NAnd(BYT1,BYT2,BRSL)
+ if(LNotEqual(BRSL,0xffffff00))
+ {Return(13)}
+
+ //Word Data
+ NAnd(WRD1,WRD2,WRSL)
+ if(LNotEqual(WRSL,0xffff0000))
+ {Return(14)}
+
+ //DWord Data
+ NAnd(DWD1,DWD2,DRSL)
+ if(LNotEqual(DRSL,0x00000000))
+ {Return(15)}
+
+ //Byte data
+ NAnd(SMBY,0xff,BRSL)
+ if(LNotEqual(BRSL,0xffffff00))
+ {Return(16)}
+
+ //Word Data
+ NAnd(SMWD,0xffff,WRSL)
+ if(LNotEqual(WRSL,0xffff0000))
+ {Return(17)}
+
+ //DWord Data
+ NAnd(SMDW,0xffffffff,DRSL)
+ if(LNotEqual(DRSL,0x00000000))
+ {Return(18)}
+
+ Return(0)
+
+ }//NNDB
+
+ Method(NNOR,2)
+ {//NNOR
+
+ NOr(Arg0,Arg1,ARSL)
+ if(LNotEqual(ARSL,0xfffffffd))
+ {Return(21)}
+
+ Store(Arg0,local0)
+ Store(Arg1,Local1)
+
+ NOr(Local0,Local1,LRSL)
+ if(LNotEqual(LRSL,0xfffffffd))
+ {Return(22)}
+
+
+ //Byte data
+ NOr(BYT1,BYT2,BRSL)
+ if(LNotEqual(BRSL,0xffffff00))
+ {Return(23)}
+
+ //Word Data
+ NOr(WRD1,WRD2,WRSL)
+ if(LNotEqual(WRSL,0xffff0000))
+ {Return(24)}
+
+ //DWord Data
+ NOr(DWD1,DWD2,DRSL)
+ if(LNotEqual(DRSL,0x00000000))
+ {Return(25)}
+
+ //System Memory Byte data
+ NOr(SMBY,0xff,BRSL)
+ if(LNotEqual(BRSL,0xffffff00))
+ {Return(26)}
+
+ //System Memory Word Data
+ NOr(SMWD,0xffff,WRSL)
+ if(LNotEqual(WRSL,0xffff0000))
+ {Return(27)}
+
+ //System Memory DWord Data
+ NOr(SMDW,0xffffffff,DRSL)
+ if(LNotEqual(DRSL,0x00000000))
+ {Return(28)}
+
+ Return(0)
+
+ }//NNOR
+
+ Method(NNOT,2)
+ {//NNOT
+
+ Or(Arg0,Arg1,ARSL)
+ Not(ARSL,ARSL)
+ if(LNotEqual(ARSL,0xfffffffd))
+ {Return(31)}
+
+ Store(Arg0,local0)
+ Store(Arg1,Local1)
+
+ Or(Local0,Local1,LRSL)
+ Not(LRSL,LRSL)
+ if(LNotEqual(LRSL,0xfffffffd))
+ {Return(32)}
+
+
+ //Byte data
+ Or(BYT1,BYT2,BRSL)
+ Not(BRSL,BRSL)
+ if(LNotEqual(BRSL,0xffffff00))
+ {Return(33)}
+
+ //Word Data
+ Or(WRD1,WRD2,WRSL)
+ Not(WRSL,WRSL)
+ if(LNotEqual(WRSL,0xffff0000))
+ {Return(34)}
+
+ //DWord Data
+ Or(DWD1,DWD2,DRSL)
+ Not(DRSL,DRSL)
+ if(LNotEqual(DRSL,0x00000000))
+ {Return(35)}
+
+ //System Memory Byte data
+ Or(SMBY,0xff,BRSL)
+ Not(BRSL,BRSL)
+ if(LNotEqual(BRSL,0xffffff00))
+ {Return(36)}
+
+ //System Memory Word Data
+ Or(SMWD,0xffff,WRSL)
+ Not(WRSL,WRSL)
+ if(LNotEqual(WRSL,0xffff0000))
+ {Return(37)}
+
+ //System Memory DWord Data
+ Or(SMDW,0xffffffff,DRSL)
+ Not(DRSL,DRSL)
+ if(LNotEqual(DRSL,0x00000000))
+ {Return(38)}
+
+ Return(0)
+ }//NNOT
+
+
+ Method(TEST)
+ {
+
+ Store ("++++++++ NBitOps Test", Debug)
+
+ Store(NNDB(2,2),RSLT)
+ if(LNotEqual(RSLT,0))
+ {Return(RSLT)}
+
+ Store(NNOR(2,2),RSLT)
+ if(LNotEqual(RSLT,0))
+ {Return(RSLT)}
+
+ Store(NNOT(2,2),RSLT)
+ if(LNotEqual(RSLT,0))
+ {Return(RSLT)}
+
+
+ Return(0)
+ }
+
+ }//Device NBIT
+
+//
+// test ShftOp.asl
+//
+//ShiftRightTerm := ShiftRight(
+// Source, //TermArg=>Integer
+// ShiftCount //TermArg=>Integer
+// Result //Nothing | SuperName
+//) => Integer
+//Source and ShiftCount are evaluated as integer data types. Source is shifted right with the most significant bit
+//zeroed ShiftCount times. The result is optionally stored into Result.
+
+//ShiftLeft(
+// Source, //TermArg=>Integer
+// ShiftCount //TermArg=>Integer
+// Result //Nothing | SuperName
+//) => Integer
+//Source and ShiftCount are evaluated as integer data types. Source is shifted left with the least significant
+//bit zeroed ShiftCount times. The result is optionally stored into Result.
+
+//If the Control method is success Zero is returned else a non-zero number is returned
+ Device (SHFT)
+ {//SHFT
+
+ //Create System Memory Operation Region and field overlays
+ OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ {
+ SMDW, 32, // 32-bit DWORD
+ SMWD, 16, // 16-bit WORD
+ SMBY, 8, // 8-bit BYTE
+ }// Field(RAM)
+
+
+ Name(SHFC,0x00)
+
+ //And with Byte Data
+ Name (BYT1, 0xff)
+ Name (BRSL, 0x00)
+
+ //And with Word Data
+ Name (WRD1, 0xffff)
+ Name (WRSL, 0x0000)
+
+ //And with DWord Data
+ Name (DWD1, 0xffffffff)
+ Name (DRSL, 0x00000000)
+
+ Name(RSLT,1)
+
+ Name(ARSL,0x00)
+ Name(LRSL,0x00)
+
+ Method(SLFT,2)
+ {//SLFT
+
+ Store(0xffffffff,SMDW)
+ Store(0xffff,SMWD)
+ Store(0xff,SMBY)
+
+
+ //Arg0-> 2 & Arg1->2
+ ShiftLeft(Arg0,Arg1,ARSL)
+ if(LNotEqual(ARSL,8))
+ {Return(11)}
+
+ Store(Arg0,local0)
+ Store(Arg1,Local1)
+
+ //Local0->8 and Local1->2
+ ShiftLeft(Local0,Local1,LRSL)
+ if(LNotEqual(LRSL,8))
+ {Return(12)}
+
+ Store(2,SHFC)
+ //Byte data
+ ShiftLeft(BYT1,SHFC,BRSL)
+ if(LNotEqual(BRSL,0x3FC))
+ {Return(13)}
+
+ Store(4,SHFC)
+ //Word Data
+ ShiftLeft(WRD1,SHFC,WRSL)
+ if(LNotEqual(WRSL,0xFFFF0))
+ {Return(14)}
+
+ Store(8,SHFC)
+ //DWord Data
+ ShiftLeft(DWD1,SHFC,DRSL)
+ if(LNotEqual(DRSL,0xFFFFFF00))
+ {Return(15)}
+
+
+ //System Memory Byte data
+ Store(4,SHFC)
+ ShiftLeft(SMBY,SHFC,BRSL)
+ if(LNotEqual(BRSL,0xFF0))
+ {Return(16)}
+
+ //Word Data
+ Store(4,SHFC)
+ ShiftLeft(SMWD,SHFC,WRSL)
+ if(LNotEqual(WRSL,0xffff0))
+ {Return(17)}
+
+ //DWord Data
+ Store(8,SHFC)
+ ShiftLeft(SMDW,SHFC,DRSL)
+ if(LNotEqual(DRSL,0xFFFFFF00))
+ {Return(18)}
+
+ Return(0)
+
+ }//SLFT
+
+ Method(SRGT,2)
+ {//SRGT
+ //And with Byte Data
+ Store (0xff,BYT1)
+ Store (0x00,BRSL)
+
+ //And with Word Data
+ Store (0xffff,WRD1)
+ Store (0x0000,WRSL)
+
+ //And with DWord Data
+ Store(0xffffffff,DWD1)
+ Store (0x00000000,DRSL)
+
+ //Reinitialize the result objects
+ Store(0x00,ARSL)
+ Store(0x00,LRSL)
+
+ Store(0xffffffff,SMDW)
+ Store(0xffff,SMWD)
+ Store(0xff,SMBY)
+
+ //Arg0-> 2 & Arg1->2
+ ShiftRight(Arg0,Arg1,ARSL)
+ if(LNotEqual(ARSL,0))
+ {Return(21)}
+
+ Store(Arg0,local0)
+ Store(Arg1,Local1)
+
+ //Local0->8 and Local1->2
+ ShiftRight(Local0,Local1,LRSL)
+ if(LNotEqual(LRSL,0))
+ {Return(22)}
+
+ Store(2,SHFC)
+ //Byte data
+ ShiftRight(BYT1,SHFC,BRSL)
+ if(LNotEqual(BRSL,0x3F))
+ {Return(23)}
+
+ Store(4,SHFC)
+ //Word Data
+ ShiftRight(WRD1,SHFC,WRSL)
+ if(LNotEqual(WRSL,0xFFF))
+ {Return(24)}
+
+ Store(8,SHFC)
+ //DWord Data
+ ShiftRight(DWD1,SHFC,DRSL)
+ if(LNotEqual(DRSL,0xFFFFFF))
+ {Return(25)}
+
+ //System Memory Byte data
+ Store(4,SHFC)
+ ShiftRight(SMBY,SHFC,BRSL)
+ if(LNotEqual(BRSL,0xF))
+ {Return(26)}
+
+ //Word Data
+ Store(4,SHFC)
+ ShiftRight(SMWD,SHFC,WRSL)
+ if(LNotEqual(WRSL,0xFFF))
+ {Return(27)}
+
+ //DWord Data
+ Store(8,SHFC)
+ ShiftRight(SMDW,SHFC,DRSL)
+ if(LNotEqual(DRSL,0xFFFFFF))
+ {Return(28)}
+
+ Return(0)
+ }//SRGT
+
+ //Test method called from amlexec
+ Method(TEST)
+ {
+ Store ("++++++++ ShftOp Test", Debug)
+
+ Store(SLFT(2,2),RSLT)
+ if(LNotEqual(RSLT,0))
+ {Return(RSLT)}
+ Store(SRGT(2,2),RSLT)
+ if(LNotEqual(RSLT,0))
+ {Return(RSLT)}
+ Return(0)
+ }
+
+ }//Device SHFT
+
+//
+// test Xor.asl and slightly modified
+//
+//This code tests the XOR opcode term
+//Syntax of XOR term
+// XOr(
+// Source1 //TermArg=>BufferTerm
+// Source2 //TermArg=>Integer
+// Result //NameString
+// )
+//"Source1" and "Source2" are evaluated as integers, a bit-wise XOR is performed, and the result is optionally stored in
+// Result
+ Device (XORD)
+ {
+ //This Method tests XOr operator for all the data types i.e. BYTE, WORD and DWORD
+ Method (TEST)
+ {
+ Store ("++++++++ Xor Test", Debug)
+
+ //Overlay in system memory
+ OperationRegion (RAM, SystemMemory, 0x800000, 256)
+ Field (RAM, ByteAcc, NoLock, Preserve)
+ {
+ RES1, 1, //Offset
+ BYT1, 8, //First BYTE
+ BYT2, 8, //Second BYTE
+ RBYT, 8, //Result Byte
+ RES2, 1, //Offset
+ WRD1, 16, //First WORD field
+ WRD2, 16, //Second WORD field
+ RWRD, 16, //RSLT WORD field
+ RES3, 1, //Offset
+ DWD1, 32, //First Dword
+ DWD2, 32, //Second Dword
+ RDWD, 32, //Result Dword
+ RES4, 1, //Offset
+ }
+
+ // Store bits in the single bit fields for checking
+ // at the end
+ Store(1, RES1)
+ Store(1, RES2)
+ Store(1, RES3)
+ Store(1, RES4)
+
+ // Check the stored single bits
+ if(LNotEqual(RES1, 1))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RES2, 1))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RES3, 1))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RES4, 1))
+ {
+ Return(1)
+ }
+
+ //************************************************
+ // (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition
+ Store(0x00,BYT1)
+ Store(0x00,BYT2)
+ XOr(BYT1,BYT2,Local0)
+ Store (Local0, RBYT)
+ if(LNotEqual(RBYT,0))
+ { Return(1)}
+
+ // (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition
+ Store(0xff,BYT1)
+ Store(0xff,BYT2)
+ XOr(BYT1,BYT2,Local0)
+ Store (Local0, RBYT)
+ if(LNotEqual(RBYT,0))
+ { Return(1)}
+
+ // (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition
+ Store(0x55,BYT1)
+ Store(0xAA,BYT2)
+ XOr(BYT1,BYT2,Local0)
+ Store (Local0, RBYT)
+ if(LNotEqual(RBYT,0xFF))
+ { Return(1)}
+
+ //(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition
+ Store(0xAA,BYT1)
+ Store(0x55,BYT2)
+ XOr(BYT1,BYT2,Local0)
+ Store (Local0, RBYT)
+ if(LNotEqual(RBYT,0xFF))
+ { Return(1)}
+
+ Store(0x12,BYT1)
+ Store(0xED,BYT2)
+
+ XOr(BYT1,BYT2,Local0)
+ Store (Local0, RBYT)
+ if(LNotEqual(RBYT,0xFF))
+ {
+ Return(1)
+ }
+
+ // Store known values for checking later
+ Store(0x12, BYT1)
+ if(LNotEqual(BYT1, 0x12))
+ {
+ Return(1)
+ }
+
+ Store(0xFE, BYT2)
+ if(LNotEqual(BYT2, 0xFE))
+ {
+ Return(1)
+ }
+
+ Store(0xAB, RBYT)
+ if(LNotEqual(RBYT, 0xAB))
+ {
+ Return(1)
+ }
+
+ //***********************************************
+ // (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition
+ Store(0x0000,WRD1)
+ Store(0x0000,WRD2)
+ XOr(WRD1,WRD2,RWRD)
+ if(LNotEqual(RWRD,0))
+ { Return(1)}
+
+ // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition
+ Store(0xffff,WRD1)
+ Store(0xffff,WRD2)
+ XOr(WRD1,WRD2,RWRD)
+ if(LNotEqual(RWRD,0))
+ { Return(1)}
+
+ // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition
+ Store(0x5555,WRD1)
+ Store(0xAAAA,WRD2)
+ XOr(WRD1,WRD2,RWRD)
+ if(LNotEqual(RWRD,0xFFFF))
+ { Return(1)}
+
+ //(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition
+ Store(0xAAAA,WRD1)
+ Store(0x5555,WRD2)
+ XOr(WRD1,WRD2,RWRD)
+ if(LNotEqual(RWRD,0xFFFF))
+ { Return(1)}
+
+ Store(0x1234,WRD1)
+ Store(0xEDCB,WRD2)
+ XOr(WRD1,WRD2,RWRD)
+ if(LNotEqual(RWRD,0xFFFF))
+ { Return(1)}
+
+ // Store known values for checking later
+ Store(0x1234, WRD1)
+ if(LNotEqual(WRD1, 0x1234))
+ {
+ Return(1)
+ }
+
+ Store(0xFEDC, WRD2)
+ if(LNotEqual(WRD2, 0xFEDC))
+ {
+ Return(1)
+ }
+
+ Store(0x87AB, RWRD)
+ if(LNotEqual(RWRD, 0x87AB))
+ {
+ Return(1)
+ }
+
+
+ //**************************************************
+ // (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition
+ Store(0x00000000,DWD1)
+ Store(0x00000000,DWD2)
+ XOr(DWD1,DWD2,RDWD)
+ if(LNotEqual(RDWD,0))
+ { Return(1)}
+
+ // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition
+ Store(0xffffffff,DWD1)
+ Store(0xffffffff,DWD2)
+ XOr(DWD1,DWD2,RDWD)
+ if(LNotEqual(RDWD,0))
+ { Return(1)}
+
+ // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
+ Store(0x55555555,DWD1)
+ Store(0xAAAAAAAA,DWD2)
+ XOr(DWD1,DWD2,RDWD)
+ if(LNotEqual(RDWD,0xFFFFFFFF))
+ { Return(1)}
+
+ //(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition
+ Store(0xAAAAAAAA,DWD1)
+ Store(0x55555555,DWD2)
+ XOr(DWD1,DWD2,RDWD)
+ if(LNotEqual(RDWD,0xFFFFFFFF))
+ { Return(1)}
+
+ // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
+ Store(0x12345678,DWD1)
+ Store(0xEDCBA987,DWD2)
+ XOr(DWD1,DWD2,RDWD)
+ if(LNotEqual(RDWD,0xFFFFFFFF))
+ { Return(1)}
+
+ Store(0x12345678,DWD1)
+ if(LNotEqual(DWD1,0x12345678))
+ {
+ Return(1)
+ }
+
+ Store(0xFEDCBA98,DWD2)
+ if(LNotEqual(DWD2,0xFEDCBA98))
+ {
+ Return(1)
+ }
+
+ Store(0x91827364,RDWD)
+ if(LNotEqual(RDWD,0x91827364))
+ {
+ Return(1)
+ }
+
+ //****************************************************
+ // Check the stored single bits
+ if(LNotEqual(RES1, 1))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RES2, 1))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RES3, 1))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RES4, 1))
+ {
+ Return(1)
+ }
+
+ // Change all of the single bit fields to zero
+ Store(0, RES1)
+ Store(0, RES2)
+ Store(0, RES3)
+ Store(0, RES4)
+
+ // Now, check all of the fields
+
+ // Byte
+ if(LNotEqual(BYT1, 0x12))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(BYT2, 0xFE))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RBYT, 0xAB))
+ {
+ Return(1)
+ }
+
+ // Word
+ if(LNotEqual(WRD1, 0x1234))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(WRD2, 0xFEDC))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RWRD, 0x87AB))
+ {
+ Return(1)
+ }
+
+ // Dword
+ if(LNotEqual(DWD1, 0x12345678))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(DWD2, 0xFEDCBA98))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RDWD, 0x91827364))
+ {
+ Return(1)
+ }
+
+ // Bits
+ if(LNotEqual(RES1, 0))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RES2, 0))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RES3, 0))
+ {
+ Return(1)
+ }
+
+ if(LNotEqual(RES4, 0))
+ {
+ Return(1)
+ }
+
+
+ Return(0)
+ } // TEST
+ } // XORD
+
+//
+// test CrBytFld.asl
+//
+// CrBytFld test
+// Test for CreateByteField.
+// Tests creating byte field overlay of buffer stored in Local0.
+// Tests need to be added for Arg0 and Name buffers.
+//
+ Device (CRBF)
+ { // Test device name
+ Method (TEST)
+ {
+ Store ("++++++++ CrBytFld Test", Debug)
+
+ // Local0 is unitialized buffer with 4 elements
+ Store (Buffer (4) {}, Local0)
+
+ // create Byte Field named BF0 based on Local0 element 0
+ CreateByteField (Local0, 0, BF0)
+
+ // validate CreateByteField did not alter Local0
+ Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
+ If (LNotEqual (Local1, 3)) // Buffer object type value is 3
+ { Return (2) }
+
+ // store something into BF0
+ Store (1, BF0)
+
+ // validate Store did not alter Local0 object type
+ Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
+ If (LNotEqual (Local1, 3)) // Buffer object type value is 3
+ { Return (3) }
+
+ // verify that the Store into BF0 was successful
+ If (LNotEqual (BF0, 1))
+ { Return (4) }
+
+
+ // create Byte Field named BF1 based on Local0 element 1
+ CreateByteField (Local0, 1, BF1)
+
+ // validate CreateByteField did not alter Local0
+ Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
+ If (LNotEqual (Local1, 3)) // Buffer object type value is 3
+ { Return (10) }
+
+ // store something into BF1
+ Store (5, BF1)
+
+ // validate Store did not alter Local0 object type
+ Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
+ If (LNotEqual (Local1, 3)) // Buffer object type value is 3
+ { Return (11) }
+
+ // verify that the Store into BF1 was successful
+ If (LNotEqual (BF1, 5))
+ { Return (12) }
+
+ // verify that the Store into BF1 did not alter BF0
+ If (LNotEqual (BF0, 1))
+ { Return (13) }
+
+
+ // store something into BF0
+ Store (0xFFFF, BF0)
+
+ // verify that the Store into BF0 was successful
+ If (LNotEqual (BF0, 0xFF))
+ { Return (20) }
+
+ // verify that the Store into BF0 did not alter BF1
+ If (LNotEqual (BF1, 5))
+ { Return (21) }
+
+
+ Return (0)
+ } // TEST
+ } // CRBF
+
+//
+// test IndexOp4.asl
+//
+// IndexOp4 test
+// This is just a subset of the many RegionOp/Index Field test cases.
+// Tests access of index fields smaller than 8 bits.
+//
+ Device (IDX4)
+ { // Test device name
+
+ // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion
+ // Tests OperationRegion memory access using misaligned BYTE,
+ // WORD, and DWORD field element accesses. Validation is performed
+ // using both misaligned field entries and aligned field entries.
+ //
+ // MADM returns 0 if all test cases pass or non-zero identifying
+ // the failing test case for debug purposes. This non-zero numbers
+ // are not guaranteed to be in perfect sequence (i.e., test case
+ // index), but are guaranteed to be unique so the failing test
+ // case can be uniquely identified.
+ //
+ Method (MADM, 1) // Misaligned Dynamic RAM SystemMemory OperationRegion
+ // Arg0 -- SystemMemory OperationRegion base address
+ { // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion
+ OperationRegion (RAM, SystemMemory, Arg0, 0x100)
+ Field (RAM, DwordAcc, NoLock, Preserve)
+ { // aligned field definition (for verification)
+ DWD0, 32, // aligned DWORD field
+ DWD1, 32 // aligned DWORD field
+ }
+ Field (RAM, ByteAcc, NoLock, Preserve)
+ { // bit access field definition
+ BIT0, 1, // single bit field entry
+ BIT1, 1, // single bit field entry
+ BIT2, 1, // single bit field entry
+ BIT3, 1, // single bit field entry
+ BIT4, 1, // single bit field entry
+ BIT5, 1, // single bit field entry
+ BIT6, 1, // single bit field entry
+ BIT7, 1, // single bit field entry
+ BIT8, 1, // single bit field entry
+ BIT9, 1, // single bit field entry
+ BITA, 1, // single bit field entry
+ BITB, 1, // single bit field entry
+ BITC, 1, // single bit field entry
+ BITD, 1, // single bit field entry
+ BITE, 1, // single bit field entry
+ BITF, 1, // single bit field entry
+ BI10, 1, // single bit field entry
+ BI11, 1, // single bit field entry
+ BI12, 1, // single bit field entry
+ BI13, 1, // single bit field entry
+ BI14, 1, // single bit field entry
+ BI15, 1, // single bit field entry
+ BI16, 1, // single bit field entry
+ BI17, 1, // single bit field entry
+ BI18, 1, // single bit field entry
+ BI19, 1, // single bit field entry
+ BI1A, 1, // single bit field entry
+ BI1B, 1, // single bit field entry
+ BI1C, 1, // single bit field entry
+ BI1D, 1, // single bit field entry
+ BI1E, 1, // single bit field entry
+ BI1F, 1 // single bit field entry
+ } // bit access field definition
+
+ Field (RAM, ByteAcc, NoLock, Preserve)
+ { // two-bit access field definition
+ B2_0, 2, // single bit field entry
+ B2_1, 2, // single bit field entry
+ B2_2, 2, // single bit field entry
+ B2_3, 2, // single bit field entry
+ B2_4, 2, // single bit field entry
+ B2_5, 2, // single bit field entry
+ B2_6, 2, // single bit field entry
+ B2_7, 2, // single bit field entry
+ B2_8, 2, // single bit field entry
+ B2_9, 2, // single bit field entry
+ B2_A, 2, // single bit field entry
+ B2_B, 2, // single bit field entry
+ B2_C, 2, // single bit field entry
+ B2_D, 2, // single bit field entry
+ B2_E, 2, // single bit field entry
+ B2_F, 2 // single bit field entry
+ } // bit access field definition
+
+ // initialize memory contents using aligned field entries
+ Store (0x5AA55AA5, DWD0)
+ Store (0x5AA55AA5, DWD1)
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BIT0)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT0, 0))
+ { Return (1) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55AA4))
+ { Return (2) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BIT1)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT1, 1))
+ { Return (3) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55AA6))
+ { Return (4) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BIT2)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT2, 0))
+ { Return (5) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55AA2))
+ { Return (6) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BIT3)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT3, 1))
+ { Return (7) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55AAA))
+ { Return (8) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BIT4)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT4, 1))
+ { Return (9) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55ABA))
+ { Return (10) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BIT5)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT5, 0))
+ { Return (11) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55A9A))
+ { Return (12) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BIT6)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT6, 1))
+ { Return (13) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55ADA))
+ { Return (14) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BIT7)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT7, 0))
+ { Return (15) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55A5A))
+ { Return (16) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BIT8)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT8, 1))
+ { Return (17) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55B5A))
+ { Return (18) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BIT9)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BIT9, 0))
+ { Return (19) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA5595A))
+ { Return (20) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BITA)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BITA, 1))
+ { Return (21) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA55D5A))
+ { Return (22) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BITB)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BITB, 0))
+ { Return (23) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA5555A))
+ { Return (24) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BITC)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BITC, 0))
+ { Return (25) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA5455A))
+ { Return (26) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BITD)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BITD, 1))
+ { Return (27) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA5655A))
+ { Return (28) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BITE)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BITE, 0))
+ { Return (29) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA5255A))
+ { Return (30) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BITF)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BITF, 1))
+ { Return (31) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA5A55A))
+ { Return (32) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BI10)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI10, 0))
+ { Return (33) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA4A55A))
+ { Return (34) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BI11)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI11, 1))
+ { Return (35) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA6A55A))
+ { Return (36) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BI12)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI12, 0))
+ { Return (37) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AA2A55A))
+ { Return (38) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BI13)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI13, 1))
+ { Return (39) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5AAAA55A))
+ { Return (40) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BI14)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI14, 1))
+ { Return (41) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5ABAA55A))
+ { Return (42) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BI15)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI15, 0))
+ { Return (43) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5A9AA55A))
+ { Return (44) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BI16)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI16, 1))
+ { Return (45) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5ADAA55A))
+ { Return (46) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BI17)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI17, 0))
+ { Return (47) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5A5AA55A))
+ { Return (48) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BI18)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI18, 1))
+ { Return (49) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5B5AA55A))
+ { Return (50) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BI19)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI19, 0))
+ { Return (51) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x595AA55A))
+ { Return (52) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BI1A)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI1A, 1))
+ { Return (53) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x5D5AA55A))
+ { Return (54) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BI1B)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI1B, 0))
+ { Return (55) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x555AA55A))
+ { Return (56) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BI1C)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI1C, 0))
+ { Return (57) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x455AA55A))
+ { Return (58) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BI1D)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI1D, 1))
+ { Return (59) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x655AA55A))
+ { Return (60) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, BI1E)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI1E, 0))
+ { Return (61) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x255AA55A))
+ { Return (62) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, BI1F)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (BI1F, 1))
+ { Return (63) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55AA55A))
+ { Return (64) }
+
+
+ // set memory contents to known values using misaligned field entries
+ Store (3, B2_0)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_0, 3))
+ { Return (65) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55AA55B))
+ { Return (66) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, B2_1)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_1, 1))
+ { Return (67) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55AA557))
+ { Return (68) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, B2_2)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_2, 0))
+ { Return (69) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55AA547))
+ { Return (70) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (3, B2_3)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_3, 3))
+ { Return (71) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55AA5C7))
+ { Return (72) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (3, B2_4)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_4, 3))
+ { Return (73) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55AA7C7))
+ { Return (74) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, B2_5)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_5, 0))
+ { Return (75) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55AA3C7))
+ { Return (76) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, B2_6)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_6, 1))
+ { Return (77) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55A93C7))
+ { Return (78) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, B2_7)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_7, 1))
+ { Return (79) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55A53C7))
+ { Return (80) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, B2_8)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_8, 0))
+ { Return (81) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55853C7))
+ { Return (82) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, B2_9)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_9, 1))
+ { Return (83) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA55453C7))
+ { Return (84) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (2, B2_A)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_A, 2))
+ { Return (85) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA56453C7))
+ { Return (86) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (2, B2_B)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_B, 2))
+ { Return (87) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA5A453C7))
+ { Return (88) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (3, B2_C)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_C, 3))
+ { Return (89) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xA7A453C7))
+ { Return (90) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (3, B2_D)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_D, 3))
+ { Return (91) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0xAFA453C7))
+ { Return (92) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (1, B2_E)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_E, 1))
+ { Return (93) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x9FA453C7))
+ { Return (94) }
+
+ // set memory contents to known values using misaligned field entries
+ Store (0, B2_F)
+ // verify memory contents using misaligned field entries
+ If (LNotEqual (B2_F, 0))
+ { Return (95) }
+ // verify memory contents using aligned field entries
+ If (LNotEqual (DWD0, 0x1FA453C7))
+ { Return (96) }
+
+
+ Return (0) // pass
+ } // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion
+
+ Method (TEST)
+ {
+ Store ("++++++++ IndexOp4 Test", Debug)
+
+ // MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments:
+ // Arg0 -- SystemMemory OperationRegion base address
+ Store (MADM (0x800000), Local0)
+ If (LNotEqual (Local0, 0)) // MADM returns zero if successful
+ { Return (Local0) } // failure: return MADM error code
+
+ Return (Local0)
+ } // TEST
+ } // IDX4
+
+//
+// test Event.asl
+//
+// EventOp, ResetOp, SignalOp, and WaitOp test cases.
+//
+ Device (EVNT)
+ {
+ Event (EVNT) // event synchronization object
+
+ Method (TEVN, 1)
+ // Arg0: time to Wait for event in milliseconds
+ { // TEVN control method to test ResetOp, SignalOp, and WaitOp
+ // reset EVNT to initialization (zero) state
+ Reset (EVNT)
+
+ // prime EVNT with two outstanding signals
+ Signal (EVNT)
+ Signal (EVNT)
+
+
+ // acquire existing signal
+ Store (Wait (EVNT, Arg0), Local0)
+
+ // validate Local0 is a Number
+ Store (ObjectType (Local0), Local1)
+ If (LNotEqual (Local1, 1)) // Number is type 1
+ { Return (0x21) } // Local1 indicates Local0 is not a Number
+
+ If (LNotEqual (Local0, 0)) // Number is type 1
+ { Return (0x22) } // timeout occurred without acquiring signal
+
+ Store ("Acquire 1st existing signal PASS", Debug)
+
+
+ // acquire existing signal
+ Store (Wait (EVNT, Arg0), Local0)
+
+ // validate Local0 is a Number
+ Store (ObjectType (Local0), Local1)
+ If (LNotEqual (Local1, 1)) // Number is type 1
+ { Return (0x31) } // Local1 indicates Local0 is not a Number
+
+ If (LNotEqual (Local0, 0)) // Number is type 1
+ { Return (0x32) } // timeout occurred without acquiring signal
+
+ Store ("Acquire 2nd existing signal PASS", Debug)
+
+
+ // ensure WaitOp timeout test cases do not hang
+ if (LEqual (Arg0, 0xFFFF))
+ { Store (0xFFFE, Arg0) }
+
+ // acquire non-existing signal
+ Store (Wait (EVNT, Arg0), Local0)
+
+ // validate Local0 is a Number
+ Store (ObjectType (Local0), Local1)
+ If (LNotEqual (Local1, 1)) // Number is type 1
+ { Return (0x41) } // Local1 indicates Local0 is not a Number
+
+ If (LEqual (Local0, 0)) // Number is type 1
+ { Return (0x42) } // non-existant signal was acquired
+
+ Store ("Acquire signal timeout PASS", Debug)
+
+
+ // prime EVNT with two outstanding signals
+ Signal (EVNT)
+ Signal (EVNT)
+
+ // reset EVNT to initialization (zero) state
+ Reset (EVNT)
+
+ // acquire non-existing signal
+ Store (Wait (EVNT, Arg0), Local0)
+
+ // validate Local0 is a Number
+ Store (ObjectType (Local0), Local1)
+ If (LNotEqual (Local1, 1)) // Number is type 1
+ { Return (0x51) } // Local1 indicates Local0 is not a Number
+
+ If (LEqual (Local0, 0)) // Number is type 1
+ { Return (0x52) } // non-existant signal was acquired
+
+ Store ("Reset signal PASS", Debug)
+
+
+ // acquire non-existing signal using Lvalue timeout
+ Store (Wait (EVNT, Zero), Local0)
+
+ // validate Local0 is a Number
+ Store (ObjectType (Local0), Local1)
+ If (LNotEqual (Local1, 1)) // Number is type 1
+ { Return (0x61) } // Local1 indicates Local0 is not a Number
+
+ If (LEqual (Local0, 0)) // Number is type 1
+ { Return (0x62) } // non-existant signal was acquired
+
+ Store ("Zero Lvalue PASS", Debug)
+
+
+ // acquire non-existing signal using Lvalue timeout
+ Store (Wait (EVNT, One), Local0)
+
+ // validate Local0 is a Number
+ Store (ObjectType (Local0), Local1)
+ If (LNotEqual (Local1, 1)) // Number is type 1
+ { Return (0x71) } // Local1 indicates Local0 is not a Number
+
+ If (LEqual (Local0, 0)) // Number is type 1
+ { Return (0x72) } // non-existant signal was acquired
+
+ Store ("One Lvalue PASS", Debug)
+
+ // Lvalue Event test cases
+ // ILLEGAL SOURCE OPERAND Store (EVNT, Local2)
+
+ // validate Local2 is an Event
+ Store (ObjectType (EVNT), Local1)
+ If (LNotEqual (Local1, 7)) // Event is type 7
+ { Return (0x81) } // Local1 indicates Local0 is not a Number
+
+ // reset EVNT to initialization (zero) state
+ Reset (EVNT)
+
+ // prime EVNT with two outstanding signals
+ Signal (EVNT)
+
+ // acquire existing signal
+ Store (Wait (EVNT, Arg0), Local0)
+
+ // validate Local0 is a Number
+ Store (ObjectType (Local0), Local1)
+ If (LNotEqual (Local1, 1)) // Number is type 1
+ { Return (0x82) } // Local1 indicates Local0 is not a Number
+
+ If (LNotEqual (Local0, 0)) // Number is type 1
+ { Return (0x83) } // timeout occurred without acquiring signal
+
+ Store ("Acquire Lvalue existing signal PASS", Debug)
+
+
+ // acquire non-existing signal
+ Store (Wait (EVNT, Arg0), Local0)
+
+ // validate Local0 is a Number
+ Store (ObjectType (Local0), Local1)
+ If (LNotEqual (Local1, 1)) // Number is type 1
+ { Return (0x84) } // Local1 indicates Local0 is not a Number
+
+ If (LEqual (Local0, 0)) // Number is type 1
+ { Return (0x85) } // non-existant signal was acquired
+
+ Store ("Acquire Lvalue signal timeout PASS", Debug)
+
+
+ Return (0) // success
+ } // TEVN control method to test ResetOp, SignalOp, and WaitOp
+
+ Method (TEST)
+ {
+ Store ("++++++++ Event Test", Debug)
+
+ Store (TEVN (100), Local0)
+
+ Return (Local0)
+ } // TEST
+ } // EVNT
+
+//
+// test SizeOfLv.asl
+//
+// Test for SizeOf (Lvalue)
+//
+// This next section will contain the packages that the SizeOfOp will be
+// exercised on. The first one, PKG0, is a regular package of 3 elements.
+// The 2nd one, PKG1, is a nested package with 3 packages inside it, each
+// with 3 elements. It is expected that SizeOf operator will return the
+// same value for these two packages since they both have 3 elements. The
+// final package, PKG2, has 4 elements and the SizeOf operator is expected
+// to return different results for this package.
+
+ Name (PKG0,
+ Package (3)
+ {0x0123, 0x4567, 0x89AB}
+ ) // PKG0
+
+ Name (PKG1,
+ Package (3)
+ {
+ Package (3) {0x0123, 0x4567, 0x89AB},
+ Package (3) {0xCDEF, 0xFEDC, 0xBA98},
+ Package (3) {0x7654, 0x3210, 0x1234}
+ }
+ ) // PKG1
+
+ Name (PKG2,
+ Package (4)
+ {0x0123, 0x4567, 0x89AB, 0x8888}
+ ) // PKG2
+
+ Name (PKG3,
+ Package (5)
+ {0x0123, 0x4567, 0x89AB, 0x8888, 0x7777}
+ ) // PKG3
+
+// End Packages **********************************************************
+
+// The following section will declare the data strings that will be used to
+// exercise the SizeOf operator. STR0 and STR1 are expected to be equal,
+// STR2 is expected to have a different SizeOf value than STR0 and STR1.
+
+ Name (STR0, "ACPI permits very flexible methods of expressing a system")
+
+ Name (STR1, "MIKE permits very flexible methods of expressing a system")
+
+ Name (STR2, "Needless to say, Mike and ACPI are frequently at odds")
+
+// This string is being made in case we want to do a SizeOf comparison
+// between strings and packages or buffers
+ Name (STR3, "12345")
+
+// End Strings **********************************************************
+
+// The following section will declare the buffers that will be used to exercise
+// the SizeOf operator.
+
+ Name (BUF0, Buffer (10) {})
+ Name (BUF1, Buffer (10) {})
+ Name (BUF2, Buffer (8) {})
+ Name (BUF3, Buffer (5) {})
+
+// End Buffers **********************************************************
+ Device (SZLV)
+ {
+
+ Method (CMPR, 2)
+ {
+ // CMPR is passed two arguments. If unequal, return 1 to indicate
+ // that, otherwise return 0 to indicate SizeOf each is equal.
+
+ Store (0x01, Local0)
+
+ if (LEqual (SizeOf(Arg0), SizeOf(Arg1)))
+ {
+ Store (0x00, Local0)
+ }
+
+ return (Local0)
+ } // CMPR
+
+
+ Method (TEST)
+ {
+
+ Store ("++++++++ SizeOfLv Test", Debug)
+
+ // TBD: SizeOf ("string")
+ // SizeOf (Buffer)
+ // SizeOf (Package)
+ // SizeOf (String)
+ // SizeOf (STR0) -- where Name (STR0,...) -- lot's of cases
+ // buffer, string, package,
+ // SizeOf (METH) -- where METH control method returns
+ // buffer, string, package,
+
+ // TBD: SLOC [SizeOf (Local0)] -- dup SARG
+
+ // Compare the elements that we expect to be the same. Exit out with an error
+ // code on the first failure.
+ if (LNotEqual (0x00, CMPR (STR0, STR1)))
+ {
+ Return (0x01)
+ }
+
+ if (LNotEqual (0x00, CMPR (STR3, BUF3)))
+ {
+ Return (0x02)
+ }
+
+ if (LNotEqual (0x00, CMPR (STR3, PKG3)))
+ {
+ Return (0x03)
+ }
+
+ // In the following section, this test will cover the SizeOf
+ // operator for Local values.
+ // In this case, both Local0 and Local1 should have the same Size
+ Store (STR0, Local0)
+ Store (STR1, Local1)
+
+ if (LNotEqual (SizeOf (Local0), SizeOf (Local1)))
+ {
+ Return (0x04)
+ }
+
+ // Now create a case where Local0 and Local1 are different
+ Store (STR2, Local1)
+
+ if (LEqual (SizeOf (Local0), SizeOf (Local1)))
+ {
+ Return (0x05)
+ }
+
+ // Finally, check for the return of SizeOf for a known Buffer. Just
+ // in case we magically pass above cases due to all Buffers being Zero
+ // bytes in size, or Infinity, etc.
+ if (LNotEqual (0x05, SizeOf (BUF3)))
+ {
+ Return (0x06)
+ }
+
+ Return (0)
+ } // TEST
+ } // SZLV
+
+
+//
+// test BytField.asl
+//
+// BytField test
+// This is just a subset of the many RegionOp/Index Field test cases.
+// Tests access of TBD.
+//
+ Scope (\_SB) // System Bus
+ { // _SB system bus
+ Device (BYTF)
+ { // Test device name
+ Method (TEST)
+ {
+ Store ("++++++++ BytField Test", Debug)
+
+ Return (\_TZ.C19B.RSLT)
+ } // TEST
+ } // BYTF
+
+ Device (C005)
+ { // Device C005
+ Device (C013)
+ { // Device C013
+ } // Device C013
+ } // Device C005
+
+ Method (C115)
+ { // C115 control method
+ Acquire (\_GL, 0xFFFF)
+ Store (\_SB.C005.C013.C058.C07E, Local0)
+ Release (\_GL)
+ And (Local0, 16, Local0)
+ Store (ShiftRight (Local0, 4, ), Local1)
+ If (LEqual (Local1, 0))
+ { Return (1) }
+ Else
+ { Return (0) }
+ } // C115 control method
+ } // _SB system bus
+
+ OperationRegion (C018, SystemIO, 0x5028, 4)
+ Field (C018, AnyAcc, NoLock, Preserve)
+ { // Field overlaying C018
+ C019, 32
+ } // Field overlaying C018
+
+ OperationRegion (C01A, SystemIO, 0x5030, 4)
+ Field (C01A, ByteAcc, NoLock, Preserve)
+ { // Field overlaying C01A
+ C01B, 8,
+ C01C, 8,
+ C01D, 8,
+ C01E, 8
+ } // Field overlaying C01A
+
+ Mutex (\C01F, 0)
+ Name (\C020, 0)
+ Name (\C021, 0)
+
+ Method (\C022, 0)
+ { // \C022 control method
+ Acquire (\C01F, 0xFFFF)
+ If (LEqual (\C021, 0))
+ {
+ Store (C019, Local0)
+ And (Local0, 0xFFFEFFFE, Local0)
+ Store (Local0, C019)
+ Increment (\C021)
+ }
+ Release (\C01F)
+ } // \C022 control method
+
+ Scope (\_SB.C005.C013)
+ { // Scope \_SB.C005.C013
+ Device (C058)
+ { // Device C058
+ Name (_HID, "*PNP0A06")
+
+ OperationRegion (C059, SystemIO, 0xE0, 2)
+ Field (C059, ByteAcc, NoLock, Preserve)
+ { // Field overlaying C059
+ C05A, 8,
+ C05B, 8
+ } // Field overlaying C059
+
+ OperationRegion (C05C, SystemIO, 0xE2, 2)
+ Field (C05C, ByteAcc, NoLock, Preserve)
+ { // Field overlaying C05C
+ C05D, 8,
+ C05E, 8
+ } // Field overlaying C05C
+ IndexField (C05D, C05E, ByteAcc, NoLock, Preserve)
+ { // IndexField overlaying C05D/C05E
+ , 0x410, // skip
+ C05F, 8,
+ C060, 8,
+ C061, 8,
+ C062, 8,
+ C063, 8,
+ C064, 8,
+ C065, 8,
+ C066, 8,
+ C067, 8,
+ C068, 8,
+ C069, 8,
+ C06A, 8,
+ C06B, 8,
+ C06C, 8,
+ C06D, 8,
+ C06E, 8,
+ , 0x70, // skip
+ C06F, 8,
+ C070, 8,
+ C071, 8,
+ C072, 8,
+ C073, 8,
+ C074, 8,
+ C075, 8,
+ C076, 8,
+ C077, 8,
+ C078, 8,
+ C079, 8,
+ C07A, 8,
+ C07B, 8,
+ C07C, 8,
+ C07D, 8,
+ C07E, 8
+ } // IndexField overlaying C05D/C05E
+
+ OperationRegion (C07F, SystemIO, 0xE4, 2)
+ Field (C07F, ByteAcc, NoLock, Preserve)
+ { // Field overlaying C07F
+ C080, 8,
+ C081, 8
+ } // Field overlaying C07F
+
+ OperationRegion (C082, SystemIO, 0xE0, 1)
+ Field (C082, ByteAcc, NoLock, Preserve)
+ { // Field overlaying C082
+ C083, 8
+ } // Field overlaying C082
+
+ OperationRegion (C084, SystemIO, 0xFF, 1)
+ Field (C084, ByteAcc, NoLock, Preserve)
+ { // Field overlaying C084
+ C085, 8
+ } // Field overlaying C084
+
+ OperationRegion (C086, SystemIO, 0xFD, 1)
+ Field (C086, ByteAcc, NoLock, Preserve)
+ { // Field overlaying C086
+ C087, 8
+ } // Field overlaying C086
+
+ Mutex (C088, 0)
+ Mutex (C089, 0)
+ Mutex (C08A, 0)
+ Mutex (C08B, 0)
+ Mutex (C08C, 0)
+ Mutex (C08D, 0)
+
+ Name (C08E, 0xFFFFFFFD)
+ Name (C08F, 0)
+
+ Method (C0AA, 4)
+ { // C0AA control method
+ Store (Buffer (4) {}, Local7)
+ CreateByteField (Local7, 0, C0AB)
+ CreateByteField (Local7, 1, C0AC)
+ CreateByteField (Local7, 2, C0AD)
+ CreateByteField (Local7, 3, C0AE)
+ Acquire (^C08B, 0xFFFF)
+ Acquire (\_GL, 0xFFFF)
+ \C022 ()
+ Store (1, \_SB.C005.C013.C058.C06B)
+ While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
+ { Stall (100) }
+ Store (Arg3, \_SB.C005.C013.C058.C06E)
+ Store (Arg2, \_SB.C005.C013.C058.C06D)
+ Store (Arg1, \_SB.C005.C013.C058.C06C)
+ Store (Arg0, \_SB.C005.C013.C058.C06B)
+ While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
+ { Stall (100) }
+ Store (\_SB.C005.C013.C058.C06E, C0AB)
+ Store (\_SB.C005.C013.C058.C06D, C0AC)
+ Store (\_SB.C005.C013.C058.C06C, C0AD)
+ Store (\_SB.C005.C013.C058.C06B, C0AE)
+ If (LNot (LEqual (Arg0, 23)))
+ {
+ Store (2, \_SB.C005.C013.C058.C06B)
+ Stall (100)
+ }
+ Release (\_GL)
+ Release (^C08B)
+ Return (Local7)
+ } // C0AA control method
+ } // Device C058
+ } // Scope \_SB.C005.C013
+
+ Scope (\_TZ)
+ { // \_TZ thermal zone scope
+ Name (C18B, Package (2)
+ {
+ Package (2)
+ {
+ Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
+ Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
+ },
+ Package (2)
+ {
+ Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
+ Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
+ }
+ }) // C18B
+
+ Name (C18C, Package (2)
+ {
+ Package (2)
+ {
+ Package (3) {0x64, 0x4B, 0x32},
+ Package (3) {0x64, 0x4B, 0x32}
+ }
+ }) // C81C
+
+ Name (C18D, 0)
+ Name (C18E, 0)
+ Name (C18F, 0)
+ Name (C190, 0)
+ Name (C191, 3)
+ Name (C192, 0)
+ Name (C193, 1)
+ Name (C194, 2)
+ Mutex (C195, 0)
+ Name (C196, 1)
+ Name (C197, 0x0B9C)
+ Name (C198, 0x0B9C)
+ Name (C199, 0xFFFFFFFD)
+ Name (C19A, 0)
+
+ Device (C19B)
+ { // Device C19B
+ Name (RSLT, 0) // default to zero
+
+ Method (XINI)
+ { // _INI control method (Uses Global Lock -- can't run under AcpiExec)
+ Store (\_SB.C115, C19A)
+ \_TZ.C19C._SCP (0)
+ Subtract (0x0EB2, 0x0AAC, Local1) // Local1 = AACh - EB2h
+ Divide (Local1, 10, Local0, Local2) // Local0 = Local1 / 10
+ // Local2 = Local1 % 10
+ \_SB.C005.C013.C058.C0AA (14, Local2, 0, 0)
+ Store
+ (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 0, )), C18D)
+ Store
+ (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 1, )), C18E)
+ Store
+ (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 2, )), C18F)
+
+ Store (1, RSLT) // set RSLT to 1 if _INI control method completes
+ } // _INI control method
+
+ // PowerResource (C19D) {...}
+ } // Device C19B
+
+ ThermalZone (C19C)
+ {
+ Method (_SCP, 1)
+ { // _SCP control method
+ Store (Arg0, Local0)
+ If (LEqual (Local0, 0))
+ {
+ Store (0, \_TZ.C192)
+ Store (1, \_TZ.C193)
+ Store (2, \_TZ.C194)
+ Store (3, \_TZ.C191)
+ }
+ Else
+ {
+ Store (0, \_TZ.C191)
+ Store (1, \_TZ.C192)
+ Store (2, \_TZ.C193)
+ Store (3, \_TZ.C194)
+ }
+ } // _SCP control method
+ } // ThermalZone C19C
+ } // \_TZ thermal zone scope
+
+
+//
+// test DwrdFld.asl
+//
+ Name (BUFR, buffer(10) {0,0,0,0,0,0,0,0,0,0} )
+
+ Device (DWDF)
+ {
+ Method (TEST)
+ {
+ Store ("++++++++ DwrdFld Test", Debug)
+
+ CreateByteField (BUFR, 0, BYTE)
+ Store (0xAA, BYTE)
+
+ CreateWordField (BUFR, 1, WORD)
+ Store (0xBBCC, WORD)
+
+ CreateDWordField (BUFR, 3, DWRD)
+ Store (0xDDEEFF00, DWRD)
+
+ CreateByteField (BUFR, 7, BYT2)
+ Store (0x11, BYT2)
+
+ CreateWordField (BUFR, 8, WRD2)
+ Store (0x2233, WRD2)
+
+ Return (0)
+
+ } // End Method TEST
+ } // Device DWDF
+
+ //
+ // test DivAddx.asl
+ //
+ Name (B1LO, 0xAA)
+ Name (B1HI, 0xBB)
+
+ Method (MKW_, 2)
+ { // This control method will take two bytes and make them into a WORD
+
+ Multiply (B1HI, 256, Local0) // Make high byte.....high
+ Or (Local0, B1LO, Local0) // OR in the low byte
+ Return (Local0) // Return the WORD
+
+ } // MKW_
+
+ Device (DVAX)
+ {
+ Method (TEST)
+ {
+
+ Store ("++++++++ DivAddx Test", Debug)
+
+ Store (25, B1LO)
+ Store (0, B1HI)
+
+ // We'll multiply 25 * 3 to get 75, add 99 to it then divide
+ // by 100. We expect to get 74 for the remainder and 1 for
+ // the quotient.
+ Divide(
+ Add (Multiply (3, MKW_ (B1LO, B1HI)), 0x63),
+ // Dividend,
+ 100, // Divisor
+ Local4, // Remainder
+ Local2) // Quotient
+
+ If (LAnd (LEqual (74, Local4), LEqual (1, Local2)))
+ { // Indicate Pass
+ Store (0x00, Local0)
+ }
+
+ Else
+ { // Indicate Fail
+ Store (0x01, Local0)
+ }
+
+ Return (Local0)
+ } // End Method TEST
+ } // Device DVAX
+
+//
+// test IndexFld.asl (IndexOp6.asl)
+//
+// IndexFld test
+// This is just a subset of the many RegionOp/Index Field test cases.
+// Tests index field element AccessAs macro.
+// Also tests name resolution of index field elements with same names
+// but different namespace scopes.
+//
+ Device (IDX6)
+ { // Test device name
+
+ OperationRegion (SIO, SystemIO, 0x100, 2)
+ Field (SIO, ByteAcc, NoLock, Preserve)
+ {
+ INDX, 8,
+ DATA, 8
+ }
+ IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
+ {
+ AccessAs (ByteAcc, 0),
+ IFE0, 8,
+ IFE1, 8,
+ IFE2, 8,
+ IFE3, 8,
+ IFE4, 8,
+ IFE5, 8,
+ IFE6, 8,
+ IFE7, 8,
+ IFE8, 8,
+ IFE9, 8,
+ }
+
+ Device (TST_)
+ { // TST_: provides a different namespace scope for IFE0 and IFE1
+ OperationRegion (SIO2, SystemIO, 0x100, 2)
+ Field (SIO2, ByteAcc, NoLock, Preserve)
+ {
+ IND2, 8,
+ DAT2, 8
+ }
+ IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes)
+ {
+ IFE0, 8, // duplicate IndexField name with different scope
+ IFE1, 8
+ }
+ } // TST_: provides a different namespace scope for IFE0 and IFE1
+
+ Method (TEST)
+ {
+ Store ("++++++++ IndexOp6 Test", Debug)
+
+ Store (IFE0, Local0)
+ Store (IFE1, Local1)
+ Store (IFE2, Local2)
+
+ // validate name resolution of IndexFields with different scopes
+ Store (\IDX6.IFE0, Local3)
+ Store (\IDX6.IFE1, Local4)
+ // verioading of namespace can resolve following names
+ Store (\IDX6.TST_.IFE0, Local5)
+ Store (\IDX6.TST_.IFE1, Local6)
+
+ Return (0)
+ } // TEST
+ } // IDX6
+
+//
+// test IndexOp5.asl
+//
+// IndexOp5 test
+// This is just a subset of the many RegionOp/Index Field test cases.
+// Tests copying string into buffer then performing IndexOp on result.
+//
+ Device (IDX5)
+ { // Test device name
+
+ Name (OSFL, 0) // 0 == Windows 98, 1 == Windows NT
+
+ // MCTH is a control method to compare two strings. It returns
+ // zero if the strings mismatch, or 1 if the strings match.
+ // This exercises the test case of copying a string into a buffer
+ // and performing an IndexOp on the resulting buffer.
+ Method (MCTH, 2) // Control Method to compare two strings
+ { // MCTH: Control Method to compare two strings
+ // Arg0: first string to compare
+ // Arg1: second string to compare
+ // Return: zero if strings mismatch, 1 if strings match
+
+ // check if first string's length is less than second string's length
+ If (LLess (SizeOf (Arg0), SizeOf (Arg1)))
+ { Return (0) }
+
+ // increment length to include NULL termination character
+ Add (SizeOf (Arg0), 1, Local0) // Local0 = strlen(Arg0) + 1
+
+ // create two buffers of size Local0 [strlen(Arg0)+1]
+ Name (BUF0, Buffer (Local0) {})
+ Name (BUF1, Buffer (Local0) {})
+
+ // copy strings into buffers
+ Store (Arg0, BUF0)
+ Store (Arg1, BUF1)
+
+ // validate BUF0 and BUF1 are still buffers
+ Store (ObjectType (BUF0), Local1)
+ If (LNotEqual (Local1, 3)) // Buffer is type 3
+ { Return (20) }
+ Store (ObjectType (BUF1), Local1)
+ If (LNotEqual (Local1, 3)) // Buffer is type 3
+ { Return (21) }
+
+ // Decrement because the Index base below is zero based
+ // while Local0 length is one based.
+ Decrement (Local0)
+
+ While (Local0)
+ { // loop through all BUF0 buffer elements
+ Decrement (Local0)
+
+ // check if BUF0[n] == BUF1[n]
+ If (LEqual (DerefOf (Index (BUF0, Local0, )),
+ DerefOf (Index (BUF1, Local0, ))))
+ { } // this is how the code was really implemented
+ Else
+ { Return (Zero) }
+ } // loop through all BUF0 buffer elements
+
+ Return (One) // strings / buffers match
+ } // MCTH: Control Method to compare two strings
+
+
+ Method (TEST)
+ {
+ Store ("++++++++ IndexOp5 Test", Debug)
+
+ If (MCTH (\_OS, "Microsoft Windows NT"))
+ { Store (1, OSFL) }
+
+ If (LNotEqual (OSFL, 1))
+ { Return (11) }
+
+ Return (0)
+ } // TEST
+ } // IDX5
+
+//
+// test IndexOp.asl
+//
+ Scope (\_SB) // System Bus
+ { // _SB system bus
+
+ Method (C097)
+ { Return (1) }
+
+ Device (PCI2)
+ { // Root PCI Bus
+ Name (_HID, EISAID("PNP0A03"))
+ Name (_ADR, 0x00000000)
+ Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})
+ Method (_STA) {Return (0x0F)}
+
+ Device (ISA)
+ { // ISA bridge
+ Name (_ADR, 0x00030000) // ISA bus ID
+
+ Device (EC0)
+ { // Embedded Controller
+ Name (_GPE, 0) // EC use GPE0
+ Name (_ADR, 0x0030000) // PCI address
+
+ Method (_STA,0) // EC Status
+ { Return(0xF) } // EC is functioning
+
+ Name (_CRS, ResourceTemplate()
+ {
+ IO (Decode16, 0x62, 0x62, 1, 1)
+ IO (Decode16, 0x66, 0x66, 1, 1)
+ }
+ )
+
+ // create EC's region and field
+ OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ {
+ // AC information
+ ADP, 1, // AC Adapter 1:On-line, 0:Off-line
+ AFLT, 1, // AC Adapter Fault 1:Fault 0:Normal
+ BAT0, 1, // BAT0 1:present, 0:not present
+ , 1, // reserved
+ , 28, // filler to force DWORD alignment
+
+ // CMBatt information
+ BPU0, 32, // Power Unit
+ BDC0, 32, // Designed Capacity
+ BFC0, 32, // Last Full Charge Capacity
+ BTC0, 32, // Battery Technology
+ BDV0, 32, // Design Voltage
+ BST0, 32, // Battery State
+ BPR0, 32, // Battery Present Rate
+ // (Designed Capacity)x(%)/{(h)x100}
+ BRC0, 32, // Battery Remaining Capacity
+ // (Designed Capacity)(%)^100
+ BPV0, 32, // Battery Present Voltage
+ BTP0, 32, // Trip Point
+ BCW0, 32, // Design capacity of Warning
+ BCL0, 32, // Design capacity of Low
+ BCG0, 32, // capacity granularity 1
+ BG20, 32, // capacity granularity 2
+ BMO0, 32, // Battery model number field
+ BIF0, 32, // OEM Information(00h)
+ BSN0, 32, // Battery Serial Number
+ BTY0, 32, // Battery Type (e.g., "Li-Ion")
+ BTY1, 32 // Battery Type (e.g., "Li-Ion")
+ } // Field
+ } // EC0: Embedded Controller
+ } // ISA bridge
+ } // PCI2 Root PCI Bus
+
+ Device (IDX0)
+ { // Test device name
+ Name (_HID, EISAID ("PNP0C0A")) // Control Method Battey ID
+ Name (_PCL, Package() {\_SB})
+ Method (_STA)
+ {
+ // _STA bits 0-3 indicate existence of battery slot
+ // _STA bit 4 indicates battery (not) present
+ If (\_SB.PCI2.ISA.EC0.BAT0)
+ { Return (0x1F) } // Battery present
+ else
+ { Return (0x0F) } // Battery not present
+ } // _STA
+
+ Method (_BIF)
+ {
+ Name (BUFR, Package(13) {})
+ Store (\_SB.PCI2.ISA.EC0.BPU0, Index (BUFR,0)) // Power Unit
+ Store (\_SB.PCI2.ISA.EC0.BDC0, Index (BUFR,1)) // Designed Capacity
+ Store (\_SB.PCI2.ISA.EC0.BFC0, Index (BUFR,2)) // Last Full Charge Capa.
+ Store (\_SB.PCI2.ISA.EC0.BTC0, Index (BUFR,3)) // Battery Technology
+ Store (\_SB.PCI2.ISA.EC0.BDV0, Index (BUFR,4)) // Designed Voltage
+ Store (\_SB.PCI2.ISA.EC0.BCW0, Index (BUFR,5)) // Designed warning level
+ Store (\_SB.PCI2.ISA.EC0.BCL0, Index (BUFR,6)) // Designed Low level
+ Store (\_SB.PCI2.ISA.EC0.BCG0, Index (BUFR,7)) // Capacity granularity 1
+ Store (\_SB.PCI2.ISA.EC0.BG20, Index (BUFR,8)) // Capacity granularity 2
+
+ Store ("", Index (BUFR,9)) // Model Number
+
+ Store ("", Index (BUFR,10)) // Serial Number
+
+ Store ("LiOn", Index (BUFR,11)) // Battery Type
+
+ Store ("Chicony", Index (BUFR,12)) // OEM Information
+
+ Return (BUFR)
+ } // _BIF
+
+ Method (_BST)
+ {
+ Name (BUFR, Package(4) {1, 0x100, 0x76543210, 0x180})
+ Return (BUFR)
+ } // _BST
+
+ Method (_BTP,1)
+ {
+ Store (arg0, \_SB.PCI2.ISA.EC0.BTP0) // Set Battery Trip point
+ }
+
+ Method (TEST)
+ {
+
+ Store ("++++++++ IndexOp Test", Debug)
+
+ // test storing into uninitialized package elements
+ Name (PBUF, Package(4) {}) // leave unitialized
+ Store (0x01234567, Index (PBUF,0))
+ Store (0x89ABCDEF, Index (PBUF,1))
+ Store (0xFEDCBA98, Index (PBUF,2))
+ Store (0x76543210, Index (PBUF,3))
+
+ // verify values stored into uninitialized package elements
+ If (LNotEqual (DerefOf (Index (PBUF,0)), 0x01234567))
+ { Return (0x10) }
+
+ If (LNotEqual (DerefOf (Index (PBUF,1)), 0x89ABCDEF))
+ { Return (0x11) }
+
+ If (LNotEqual (DerefOf (Index (PBUF,2)), 0xFEDCBA98))
+ { Return (0x12) }
+
+ If (LNotEqual (DerefOf (Index (PBUF,3)), 0x76543210))
+ { Return (0x13) }
+
+
+ // store _BIF package return value into Local0
+ Store (_BIF, Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Package
+ If (LNotEqual (Local1, 4)) // Package type is 4
+ { Return (0x21) } // failure
+
+
+ // test storing into buffer field elements
+ Name (BUFR, Buffer(16)
+ { // initial values
+ 00, 00, 00, 00, 00, 00, 00, 00,
+ 00, 00, 00, 00, 00, 00, 00, 00,
+ }
+ ) // BUFR
+ // test storing into buffer field elements
+ Store (0x01234567, Index (BUFR,0)) // should only store 0x67
+ Store (0x89ABCDEF, Index (BUFR,4)) // should only store 0xEF
+ Store (0xFEDCBA98, Index (BUFR,8)) // should only store 0x98
+ Store (0x76543210, Index (BUFR,12)) // should only store 0x10
+
+ // verify storing into buffer field elements
+ If (LNotEqual (DerefOf (Index (BUFR,0)), 0x67))
+ { Return (0x30) }
+
+ If (LNotEqual (DerefOf (Index (BUFR,1)), 0))
+ { Return (0x31) }
+
+ If (LNotEqual (DerefOf (Index (BUFR,4)), 0xEF))
+ { Return (0x34) }
+
+ If (LNotEqual (DerefOf (Index (BUFR,8)), 0x98))
+ { Return (0x38) }
+
+ If (LNotEqual (DerefOf (Index (BUFR,12)), 0x10))
+ { Return (0x3C) }
+
+
+ Return (0) // pass
+ } // TEST
+ } // IDX0
+ } // _SB system bus
+
+//
+// test BitIndex.asl
+//
+// BitIndex test
+// This is a test case for accessing fields defined as single bits in
+// memory. This is done by creating two index fields that overlay the
+// same DWORD in memory. One field accesses the DWORD as a DWORD, the
+// other accesses individual bits of the same DWORD field in memory.
+//
+ Scope (\_SB) // System Bus
+ { // _SB system bus
+ OperationRegion (RAM, SystemMemory, 0x800000, 0x100)
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ { // Any access
+ TREE, 3,
+ WRD0, 16,
+ WRD1, 16,
+ WRD2, 16,
+ WRD3, 16,
+ WRD4, 16,
+ DWRD, 32, // DWORD field
+ }
+ Field (RAM, AnyAcc, NoLock, Preserve)
+ { // Any access
+ THRE, 3,
+ WD00, 16,
+ WD01, 16,
+ WD02, 16,
+ WD03, 16,
+ WD04, 16,
+ BYT0, 8, // Start off with a BYTE
+ BIT0, 1, // single-bit field
+ BIT1, 1, // single-bit field
+ BIT2, 1, // single-bit field
+ BIT3, 1, // single-bit field
+ BIT4, 1, // single-bit field
+ BIT5, 1, // single-bit field
+ BIT6, 1, // single-bit field
+ BIT7, 1, // single-bit field
+ BIT8, 1, // single-bit field
+ BIT9, 1, // single-bit field
+ BITA, 1, // single-bit field
+ BITB, 1, // single-bit field
+ BITC, 1, // single-bit field
+ BITD, 1, // single-bit field
+ BITE, 1, // single-bit field
+ BITF, 1, // single-bit field
+ BYTZ, 8, // End with a BYTE for a total of 32 bits
+ }
+
+ Device (BITI)
+ { // Test device name
+
+ Method (MBIT) // Test single bit memory accesses
+ {
+
+ If (LNotEqual (DWRD, 0x00))
+ {
+ Store (0xFF00, Local0)
+ }
+ Else
+ {
+ // Prime Local0 with 0...assume passing condition
+ Store (0, Local0)
+
+ // set memory contents to known values using DWORD field
+ Store (0x5A5A5A5A, DWRD)
+
+ // Given the value programmed into DWRD, only the odd bits
+ // of the lower nibble should be set. BIT1, BIT3 should be set.
+ // BIT0 and BIT2 should be clear
+
+ If (BIT0)
+ {
+ Or (Local0, 0x01, Local0)
+ }
+
+ If (LNot (BIT1))
+ {
+ Or (Local0, 0x02, Local0)
+ }
+
+ If (BIT2)
+ {
+ Or (Local0, 0x04, Local0)
+ }
+
+ If (LNot (BIT3))
+ {
+ Or (Local0, 0x08, Local0)
+ }
+
+ // Now check the upper nibble. Only the "even" bits should
+ // be set. BIT4, BIT6. BIT5 and BIT7 should be clear.
+ If (LNot (BIT4))
+ {
+ Or (Local0, 0x10, Local0)
+ }
+
+ If (BIT5)
+ {
+ Or (Local0, 0x20, Local0)
+ }
+
+ If (LNot (BIT6))
+ {
+ Or (Local0, 0x40, Local0)
+ }
+
+ If (BIT7)
+ {
+ Or (Local0, 0x80, Local0)
+ }
+ } // End Else DWRD zeroed out
+
+ Return (Local0)
+ } // MBIT: Test single bit memory accesses
+
+ Method (TEST)
+ {
+
+ Store ("++++++++ BitIndex Test", Debug)
+
+ // Zero out DWRD
+ Store (0x00000000, DWRD)
+
+ // MBIT returns zero if successful
+ // This may be causing problems -- Return (MBIT)
+ Store (MBIT, Local0)
+
+ Return (Local0)
+ } // TEST
+ } // BITI
+ } // _SB system bus
+
+//
+// test IndexOp3.asl
+//
+// Additional IndexOp test cases to support ACPICMB (control method battery
+// test) on Compaq laptops. Test cases include storing a package into
+// an IndexOp target and validating that changing source and destination
+// package contents are independent of each other.
+//
+ Scope (\_SB) // System Bus
+ { // _SB system bus
+
+ Name (C174, 13)
+ Name (C175, 8)
+
+ Device (C158)
+ { // C158: AC Adapter device
+ Name (_HID, "ACPI0003") // AC Adapter device
+ Name (_PCL, Package (1) {\_SB})
+
+ Method (_PSR)
+ {
+ Acquire (\_GL, 0xFFFF)
+ Release (\_GL)
+ And (Local0, 1, Local0) // Local0 &= 1
+ Return (Local0)
+ } // _PSR
+ } // C158: AC Adapter device
+
+ Name (C176, Package (4) {"Primary", "MultiBay", "DockRight", "DockLeft"})
+
+ Name (C177, Package (4) {0x99F5, 0x99F5, 0x995F, 0x995F})
+
+ Name (C178, Package (4)
+ {
+ Package (4) {0, 0, 0x966B, 0x4190},
+ Package (4) {0, 0, 0x966B, 0x4190},
+ Package (4) {0, 0, 0x966B, 0x4190},
+ Package (4) {0, 0, 0x966B, 0x4190}
+ }) // C178
+
+ Name (C179, Package (4) {0, 0, 0x966B, 0x4190})
+
+ Name (C17A, Package (4)
+ {
+ Package (3) {0, 0, 0},
+ Package (3) {0, 0, 0},
+ Package (3) {0, 0, 0},
+ Package (3) {0, 0, 0}
+ }) // C17A
+
+ Method (C17B, 1)
+ { // C17B: _BIF implementation
+ Name (C17C, Package (13)
+ { // C17C: _BIF control method return package
+ 0, // Power Unit (0 ==> mWh and mW)
+ 0x99F5, // Design Capacity
+ 0x99F5, // Last Full Charge Capacity
+ 1, // Battery Technology (1 ==> rechargeable)
+ 0x3840, // Design Voltage
+ 0x1280, // Design Capacity of Warning
+ 0x0AC7, // Design Capacity of Low
+ 1, // Battery Capacity Granularity 1 (Low -- Warning)
+ 1, // Battery Capacity Granularity 2 (Warning -- Full)
+ "2891", // Model Number (ASCIIZ)
+ "(-Unknown-)", // Serial Number (ASCIIZ)
+ "LIon", // Battery Type (ASCIIZ)
+ 0 // OEM Information (ASCIIZ)
+ }) // C17C: _BIF control method return package
+
+ And (Arg0, 7, Local0) // Local0 = Arg0 & 7
+
+ ShiftRight (Local0, 1, Local4) // Local4 = Local0 >> 1
+
+ Store (C179, Index (C178, Local4, )) // C178->Local4 = C179
+
+ // verify source and destination packages can be altered independent
+ // of each other (i.e., changing one's contents does NOT change other's
+ // contents)
+ Store (0x1234, Index (C179, 2, )) // C179[2] = 0x1234
+ Store (DerefOf (Index (C179, 2, )), Local2) // Local2 = C179[2]
+ if (LNotEqual (Local2, 0x1234))
+ { Return (0x1234) }
+ // Local2 = C178[0,2]
+ Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 2, )), Local2)
+ if (LNotEqual (Local2, 0x966B))
+ { Return (0x1234) }
+
+ // Restore data to allow iterative execution
+ Store (0x966B, Index (C179, 2, )) // C179[2] = 0x966B
+
+ // C178[0,3] = 0x5678
+ Store (0x5678, Index (DerefOf (Index (C178, 0, )), 3, ))
+ // Local2 = C178[0,3]
+ Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 3, )), Local2)
+ if (LNotEqual (Local2, 0x5678))
+ { Return (0x5678) }
+
+ Store (DerefOf (Index (C179, 3, )), Local2) // Local2 = C179[3]
+ if (LNotEqual (Local2, 0x4190))
+ { Return (0x5678) }
+
+ // Restore data to allow iterative execution
+ Store (0x4190, Index (DerefOf (Index (C178, 0, )), 3, )) // C179[2] = 0x4190
+
+ Return (C17C)
+ } // C17B: _BIF implementation
+
+ Device (C154)
+ { // C154: Battery 0
+ Name (_HID, "*PNP0C0A") // Control Method Battey ID
+ Name (_UID, 0) // first instance
+
+ Method (_BIF)
+ { // _BIF
+ Return (C17B (48))
+ } // _BIF
+ } // C154: Battery 0
+
+ Device (IDX3)
+ {
+ Method (LCLB)
+ { // LCLB control method: test Index(Local#) where Local# is buffer
+ // Local0 is index counter
+ // Local1 is buffer
+ // Local2 receives BUFR[Local0] via Deref(Index(Local1...))
+ // Local3 is Local1 or Local2 object type
+ // Local4 is return error code
+
+ Name (BUFR, Buffer () {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+ // save PKG into Local1
+ Store (BUFR, Local1)
+
+ // save Local2 object type value into Local3
+ Store (ObjectType (Local1), Local3)
+
+ // validate Local1 is a Buffer
+ If (LNotEqual (Local3, 3)) // Buffer type is 3
+ { Return (0x9F) }
+
+
+ Store (0, Local0)
+ While (LLess (Local0, 5))
+ { // While (Local0 < 5)
+ // Local2 = Local1[Local0]
+ Store (DerefOf (Index (Local1, Local0, )), Local2)
+
+ // save Local2 object type value into Local3
+ Store (ObjectType (Local2), Local3)
+
+ // validate Local2 is a Number
+ If (LNotEqual (Local3, 1)) // Number type is 1
+ { Return (0x9E) }
+
+ // validate Local1[Local0] value == Local0
+ If (LNotEqual (Local0, Local2))
+ { // Local0 != Local2 == PKG[Local0]
+ // Local4 = 0x90 + loop index (Local0)
+ Add (0x90, Local0, Local4)
+
+ // return 0x90 + loop index
+ Return (Local4)
+ }
+
+ Increment (Local0)
+ } // While (Local0 < 5)
+
+ Store ("DerefOf(Index(LocalBuffer,,)) PASS", Debug)
+
+ Return (0) // Pass
+ } // LCLB control method: test Index(Local#) where Local# is buffer
+
+ Method (LCLP)
+ { // LCLP control method: test Index(Local#) where Local# is package
+ // Local0 is index counter
+ // Local1 is package
+ // Local2 receives PKG[Local0] via Deref(Index(Local1...))
+ // Local3 is Local1 or Local2 object type
+ // Local4 is return error code
+
+ Name (PKG, Package () {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+ // save PKG into Local1
+ Store (PKG, Local1)
+
+ // save Local2 object type value into Local3
+ Store (ObjectType (Local1), Local3)
+
+ // validate Local1 is a Package
+ If (LNotEqual (Local3, 4)) // Package type is 4
+ { Return (0x8F) }
+
+
+ Store (0, Local0)
+ While (LLess (Local0, 5))
+ { // While (Local0 < 5)
+ // Local2 = Local1[Local0]
+ Store (DerefOf (Index (Local1, Local0, )), Local2)
+
+ // save Local2 object type value into Local3
+ Store (ObjectType (Local2), Local3)
+
+ // validate Local2 is a Number
+ If (LNotEqual (Local3, 1)) // Number type is 1
+ { Return (0x8E) }
+
+ // validate Local1[Local0] value == Local0
+ If (LNotEqual (Local0, Local2))
+ { // Local0 != Local2 == PKG[Local0]
+ // Local4 = 0x80 + loop index (Local0)
+ Add (0x80, Local0, Local4)
+
+ // return 0x80 + loop index
+ Return (Local4)
+ }
+
+ Increment (Local0)
+ } // While (Local0 < 5)
+
+ Store ("DerefOf(Index(LocalPackage,,)) PASS", Debug)
+
+ Return (0) // Pass
+ } // LCLP control method: test Index(Local#) where Local# is package
+
+ Method (TEST)
+ {
+
+ Store ("++++++++ IndexOp3 Test", Debug)
+
+ // store _BIF package return value into Local0
+ Store (\_SB.C154._BIF, Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Package
+ If (LNotEqual (Local1, 4)) // Package type is 4
+ { // failure: did not return a Package (type 4)
+ // if Local0 is a Number, it contains an error code
+ If (LEqual (Local1, 1)) // Number type is 1
+ { Return (Local0) } // return Local0 error code
+ Else // Local0 is not a Number
+ { Return (1) } // return default error code
+ } // failure: did not return a Package (type 4)
+
+ // save LCLB control method return value into Local2
+ Store (LCLB, Local2)
+ If (LNotEqual (Local2, 0))
+ { Return (Local2) } // return failure code
+
+ // save LCLP control method return value into Local2
+ Store (LCLP, Local2)
+ If (LNotEqual (Local2, 0))
+ { Return (Local2) } // return failure code
+
+ Return (0) // Pass
+ } // TEST
+ } // IDX3: Test device name
+ } // _SB system bus
+
+//
+// MTL developed test to exercise Indexes into buffers
+//
+ Device(IDX7)
+ {
+
+ Name (PKG4, Package() {
+ 0x2,
+ "A short string",
+ Buffer() {0xA, 0xB, 0xC, 0xD},
+ 0x1234,
+ Package() {IDX7, 0x3}
+ })
+
+ //
+ // Generic Test method
+ //
+ // This test returns 0xE (14) - ObjectType = Buffer Field
+ Method(TST1)
+ {
+ Name (DEST, Buffer () // 62 characters plus NULL
+ {"Destination buffer that is longer than the short source buffer"})
+
+ // verify object type returned by Index(Buffer,Element,)
+ Store (Index (DEST, 2, ), Local1)
+ Store (ObjectType (Local1), Local2)
+ If (LEqual(Local2, 14))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0x1)
+ }
+
+ }
+
+ Method(TST2)
+ {
+ Name (BUF0, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
+ Store(0x55, Index(BUF0, 2))
+ Store(DerefOf(Index(BUF0, 2)), Local0)
+ If (LEqual(Local0, 0x55))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0x2)
+ }
+
+
+ }
+
+ Method(TST3)
+ {
+ Name (BUF1, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
+ Store(Index(BUF1, 1), Local0)
+ Store(DerefOf(Local0), Local1)
+ If (LEqual(Local1, 0x2))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0x3)
+ }
+
+ }
+
+ Method(TST4)
+ {
+ // Index (PKG4, 0) is a Number
+ Store (Index (PKG4, 0), Local0)
+ Store (ObjectType(Local0), Local1)
+ If (LEqual(Local1, 0x1))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0x4)
+ }
+
+ }
+
+ Method(TST5)
+ {
+ // Index (PKG4, 1) is a String
+ Store (Index (PKG4, 1), Local0)
+ Store (ObjectType(Local0), Local1)
+ If (LEqual(Local1, 0x2))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0x5)
+ }
+
+ }
+
+ Method(TST6)
+ {
+ // Index (PKG4, 2) is a Buffer
+ Store (Index (PKG4, 2), Local0)
+ Store (ObjectType(Local0), Local1)
+ If (LEqual(Local1, 0x3))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0x6)
+ }
+
+ }
+
+ Method(TST7)
+ {
+ // Index (PKG4, 3) is a Number
+ Store (Index (PKG4, 3), Local0)
+ Store (ObjectType(Local0), Local1)
+ If (LEqual(Local1, 0x1))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0x7)
+ }
+
+ }
+
+ Method(TST8)
+ {
+ // Index (PKG4, 4) is a Package
+ Store (Index (PKG4, 4), Local0)
+ Store (ObjectType(Local0), Local1)
+ If (LEqual(Local1, 0x4))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0x8)
+ }
+
+ }
+
+ Method(TST9)
+ {
+ // DerefOf (Index (PKG4, 0)) is a Number
+ Store (DerefOf (Index (PKG4, 0)), Local0)
+ If (LEqual(Local0, 0x2))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0x9)
+ }
+
+ }
+
+ Method(TSTA)
+ {
+ // DerefOf (Index (PKG4, 1)) is a String
+ Store (DerefOf (Index (PKG4, 1)), Local0)
+ Store (SizeOf(Local0), Local1)
+ If (LEqual(Local1, 0xE))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0xA)
+ }
+
+ }
+
+ Method(TSTB)
+ {
+ // DerefOf (Index (PKG4, 2)) is a Buffer
+ Store (DerefOf (Index (PKG4, 2)), Local0)
+ Store (SizeOf(Local0), Local1)
+ If (LEqual(Local1, 0x4))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0xB)
+ }
+
+ }
+
+ Method(TSTC)
+ {
+ // DerefOf (Index (PKG4, 3)) is a Number
+ Store (DerefOf (Index (PKG4, 3)), Local0)
+ If (LEqual(Local0, 0x1234))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0xC)
+ }
+
+ }
+
+ Method(TSTD)
+ {
+ // DerefOf (Index (PKG4, 4)) is a Package
+ Store (DerefOf (Index (PKG4, 4)), Local0)
+ Store (SizeOf(Local0), Local1)
+ If (LEqual(Local1, 0x2))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0xD)
+ }
+
+ }
+
+ Method(TSTE)
+ {
+ // DerefOf (Index (PKG4, 2)) is a Buffer
+ Store (DerefOf (Index (PKG4, 2)), Local0)
+ // DerefOf (Index (Local0, 1)) is a Number
+ Store (DerefOf (Index (Local0, 1)), Local1)
+ If (LEqual(Local1, 0xB))
+ {
+ Return(0)
+ }
+ Else
+ {
+ Return(0xE)
+ }
+
+ }
+
+ Method (TSTF)
+ {
+ Name (SRCB, Buffer (12) {}) // 12 characters
+ Store ("Short Buffer", SRCB)
+
+ Name (DEST, Buffer () // 62 characters plus NULL
+ {"Destination buffer that is longer than the short source buffer"})
+
+ // overwrite DEST contents, starting at buffer position 2
+ Store (SRCB, Index (DEST, 2))
+
+ //
+ // The DEST buffer element should be replaced with the last element of
+ // the SRCB element (i.e. 's'->'r')
+ Store (DerefOf (Index (DEST, 2)), Local0)
+
+ If (LNotEqual (Local0, 0x72)) // 'r'
+ {
+ // DEST element does not match the value from SRCB
+ Return(Or(Local0, 0x1000))
+ }
+
+ Return(0)
+ }
+
+ Method (TSTG)
+ {
+
+ Name (SRCB, Buffer (12) {}) // 12 characters
+ Store ("Short Buffer", SRCB)
+
+ Name (DEST, Buffer () // 62 characters plus NULL
+ {"Destination buffer that is longer than the short source buffer"})
+
+ // overwrite DEST contents, starting at buffer position 2
+ Store (SRCB, Index (DEST, 2))
+
+ //
+ // The next element of DEST should be unchanged
+ //
+ Store (DerefOf (Index (DEST, 3)), Local0)
+
+ If (LNotEqual (Local0, 0x74)) // 't'
+ {
+ // DEST has been changed
+ Return(Or(Local0, 0x2000))
+ }
+
+ //
+ // The next element of DEST should be unchanged
+ //
+ Store (DerefOf (Index (DEST, 4)), Local0)
+
+ If (LNotEqual (Local0, 0x69)) // 'i'
+ {
+ // DEST has been changed
+ Return(Or(Local0, 0x2100))
+ }
+
+ //
+ // The next element of DEST should be unchanged
+ //
+ Store (DerefOf (Index (DEST, 5)), Local0)
+
+ If (LNotEqual (Local0, 0x6E)) // 'n'
+ {
+ // DEST has been changed
+ Return(Or(Local0, 0x2200))
+ }
+
+ //
+ // The next element of DEST should be unchanged
+ //
+ Store (DerefOf (Index (DEST, 6)), Local0)
+
+ If (LNotEqual (Local0, 0x61)) // 'a'
+ {
+ // DEST has been changed
+ Return(Or(Local0, 0x2300))
+ }
+
+ //
+ // The next element of DEST should be unchanged
+ //
+ Store (DerefOf (Index (DEST, 7)), Local0)
+
+ If (LNotEqual (Local0, 0x74)) // 't'
+ {
+ // DEST has been changed
+ Return(Or(Local0, 0x2400))
+ }
+
+ //
+ // Verify DEST elements beyond end of SRCB buffer copy
+ // have not been changed
+ Store (DerefOf (Index (DEST, 14)), Local0)
+
+ If (LNotEqual (Local0, 0x66)) // 'f'
+ {
+ // DEST has been changed
+ Return(Or(Local0, 0x2400))
+ }
+
+ Return(0)
+ }
+
+ //
+ // This test shows that MS ACPI.SYS stores only the lower 8-bits of a 32-bit
+ // number into the index'ed buffer
+ //
+ Method (TSTH)
+ {
+ // Create a Destination Buffer
+ Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+ // Store a number > UINT8 into an index of the buffer
+ Store (0x12345678, Index(DBUF, 2))
+
+ // Check the results
+ Store (DerefOf (Index (DBUF, 2)), Local0)
+ If (LNotEqual (Local0, 0x78)) // 0x78
+ {
+ Return(Or(Local0, 0x3000))
+ }
+
+ Store (DerefOf (Index (DBUF, 3)), Local0)
+ If (LNotEqual (Local0, 0x64)) // 'd'
+ {
+ Return(Or(Local0, 0x3100))
+ }
+
+ Store (DerefOf (Index (DBUF, 4)), Local0)
+ If (LNotEqual (Local0, 0x65)) // 'e'
+ {
+ Return(Or(Local0, 0x3200))
+ }
+
+ Store (DerefOf (Index (DBUF, 5)), Local0)
+ If (LNotEqual (Local0, 0x66)) // 'f'
+ {
+ Return(Or(Local0, 0x3300))
+ }
+
+ Return(0)
+ }
+
+ Method (TSTI)
+ {
+ // Create a Destination Buffer
+ Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+ // Store a String into an index of the buffer
+ Store ("ABCDEFGH", Index(DBUF, 2))
+
+ // Check the results
+ Store (DerefOf (Index (DBUF, 2)), Local0)
+ If (LNotEqual (Local0, 0x48)) // 'H'
+ {
+ Return(Or(Local0, 0x4000))
+ }
+
+ Store (DerefOf (Index (DBUF, 3)), Local0)
+ If (LNotEqual (Local0, 0x64)) // 'd'
+ {
+ Return(Or(Local0, 0x4100))
+ }
+
+ Store (DerefOf (Index (DBUF, 4)), Local0)
+ If (LNotEqual (Local0, 0x65)) // 'e'
+ {
+ Return(Or(Local0, 0x4200))
+ }
+
+ Store (DerefOf (Index (DBUF, 5)), Local0)
+ If (LNotEqual (Local0, 0x66)) // 'f'
+ {
+ Return(Or(Local0, 0x4300))
+ }
+
+ Return(0)
+ }
+
+ Method(TSTJ)
+ {
+ // Create a Destination Buffer
+ Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+ // Store a number > UINT8 into an index of the buffer
+ Store (0x1234, Index(DBUF, 2))
+
+ // Check the results
+ Store (DerefOf (Index (DBUF, 2)), Local0)
+ If (LNotEqual (Local0, 0x34)) // 0x34
+ {
+ Return(Or(Local0, 0x3000))
+ }
+
+ Store (DerefOf (Index (DBUF, 3)), Local0)
+ If (LNotEqual (Local0, 0x64)) // 'd'
+ {
+ Return(Or(Local0, 0x3100))
+ }
+
+ Store (DerefOf (Index (DBUF, 4)), Local0)
+ If (LNotEqual (Local0, 0x65)) // 'e'
+ {
+ Return(Or(Local0, 0x3200))
+ }
+
+ Store (DerefOf (Index (DBUF, 5)), Local0)
+ If (LNotEqual (Local0, 0x66)) // 'f'
+ {
+ Return(Or(Local0, 0x3300))
+ }
+
+ Return(0)
+ }
+
+ Method(TSTK)
+ {
+ // Create a Destination Buffer
+ Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+ // Store a number > UINT8 into an index of the buffer
+ Store (0x123456, Index(DBUF, 2))
+
+ // Check the results
+ Store (DerefOf (Index (DBUF, 2)), Local0)
+ If (LNotEqual (Local0, 0x56)) // 0x56
+ {
+ Return(Or(Local0, 0x3000))
+ }
+
+ Store (DerefOf (Index (DBUF, 3)), Local0)
+ If (LNotEqual (Local0, 0x64)) // 'd'
+ {
+ Return(Or(Local0, 0x3100))
+ }
+
+ Store (DerefOf (Index (DBUF, 4)), Local0)
+ If (LNotEqual (Local0, 0x65)) // 'e'
+ {
+ Return(Or(Local0, 0x3200))
+ }
+
+ Store (DerefOf (Index (DBUF, 5)), Local0)
+ If (LNotEqual (Local0, 0x66)) // 'f'
+ {
+ Return(Or(Local0, 0x3300))
+ }
+
+ Return(0)
+ }
+
+ Method(TSTL)
+ {
+ // Create a Destination Buffer
+ Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
+
+ // Store a number > UINT8 into an index of the buffer
+ Store (0x12, Index(DBUF, 2))
+
+ // Check the results
+ Store (DerefOf (Index (DBUF, 2)), Local0)
+ If (LNotEqual (Local0, 0x12)) // 0x12
+ {
+ Return(Or(Local0, 0x3000))
+ }
+
+ Store (DerefOf (Index (DBUF, 3)), Local0)
+ If (LNotEqual (Local0, 0x64)) // 'd'
+ {
+ Return(Or(Local0, 0x3100))
+ }
+
+ Store (DerefOf (Index (DBUF, 4)), Local0)
+ If (LNotEqual (Local0, 0x65)) // 'e'
+ {
+ Return(Or(Local0, 0x3200))
+ }
+
+ Store (DerefOf (Index (DBUF, 5)), Local0)
+ If (LNotEqual (Local0, 0x66)) // 'f'
+ {
+ Return(Or(Local0, 0x3300))
+ }
+
+ Return(0)
+ }
+
+ Method(TEST)
+ {
+ Store ("++++++++ IndexOp7 Test", Debug)
+
+ Store(TST1(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TST2(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TST3(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TST4(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TST5(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TST6(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TST7(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TST8(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TST9(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TSTA(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TSTB(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TSTC(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TSTD(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TSTE(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ /* No longer ACPI compliant */
+ /*
+ Store(TSTF(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+ */
+
+ Store(TSTG(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TSTH(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ /* No longer ACPI compliant */
+ /*
+ Store(TSTI(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+ */
+ Store(TSTJ(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TSTK(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Store(TSTL(), Local0)
+ if (LGreater (Local0, 0))
+ {
+ Return(Local0)
+ }
+
+ Return(Local0)
+
+ }
+
+ } // Device(IDX7)
+
+//
+// test MatchOp.asl
+//
+// MatchOp test cases that utilize nested DerefOf(Index(...)) to validate
+// MatchOp, DerefOfOp, and IndexOp of nested packages.
+//
+ Device (MTCH)
+ {
+
+ Method (TEST)
+ {
+ Store ("++++++++ MatchOp Test", Debug)
+
+ Name (TIM0, Package ()
+ {
+ Package () {0x78, 0xB4, 0xF0, 0x0384},
+ Package () {0x23, 0x21, 0x10, 0},
+ Package () {0x0B, 9, 4, 0},
+ Package () {0x70, 0x49, 0x36, 0x27, 0x19},
+ Package () {0, 1, 2, 1, 2},
+ Package () {0, 0, 0, 1, 1},
+ Package () {4, 3, 2, 0},
+ Package () {2, 1, 0, 0}
+ }) // TIM0
+
+ Name (TMD0, Buffer (20) {0xFF, 0xFF, 0xFF, 0xFF })
+ CreateDWordField (TMD0, 0, PIO0) // 0xFFFFFFFF
+ CreateDWordField (TMD0, 4, DMA0)
+ CreateDWordField (TMD0, 8, PIO1)
+ CreateDWordField (TMD0, 12, DMA1)
+ CreateDWordField (TMD0, 16, CHNF)
+
+
+ // validate PIO0 value
+ Store (PIO0, Local3)
+
+ // save Local3 object type value into Local2
+ Store (ObjectType (Local3), Local2)
+
+ // validate Local3 is a Number
+ If (LNotEqual (Local2, 1)) // Number type is 1
+ { Return (2) } // failure
+
+ // validate Local3 Number value
+ If (LNotEqual (Local3, 0xFFFFFFFF)) // Number value 0xFFFFFFFF
+ { Return (3) } // failure
+
+ Store ("DWordField PASS", Debug)
+
+
+ Store (0, Local5)
+ Store (Match (DerefOf (Index (TIM0, 1, )), MLE, Local5, MTR, 0, 0), Local6)
+
+ // save Local6 object type value into Local2
+ Store (ObjectType (Local6), Local2)
+
+ // validate Local6 is a Number
+ If (LNotEqual (Local2, 1)) // Number type is 1
+ { Return (4) } // failure
+
+ Store ("Match(DerefOf(Index(TIM0,1)),... PASS", Debug)
+
+
+ // validate following produces a nested package to validate
+ // that MatchOp did not corrupt SearchPackage (TIM0)
+ Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+ // save Local4 object type value into Local2
+ Store (ObjectType (Local4), Local2)
+
+ // validate Local4 is a Package
+ If (LNotEqual (Local2, 4)) // Package type is 4
+ { Return (5) } // failure
+
+ Store ("DerefOf(Index(TIM0,1)),... PASS", Debug)
+
+
+ And (Match (DerefOf (Index (TIM0, 0, )), MGE, PIO0, MTR, 0, 0), 3, Local0)
+
+ // save Local0 object type value into Local2
+ Store (ObjectType (Local0), Local2)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local2, 1)) // Number type is 1
+ { Return (6) } // failure
+
+ // validate Local0 Number value
+ If (LNotEqual (Local0, 3)) // Number value 3
+ { Return (7) } // failure
+
+ Store ("And(Match(DerefOf(Index(TIM0,0)),... PASS", Debug)
+
+
+ // again, validate following produces a nested package
+ Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+ // save Local4 object type value into Local2
+ Store (ObjectType (Local4), Local2)
+
+ // validate Local4 is a Package
+ If (LNotEqual (Local2, 4)) // Package type is 4
+ { Return (8) } // failure
+
+ Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+ // again, validate following produces a nested package
+ Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+ // save Local4 object type value into Local2
+ Store (ObjectType (Local4), Local2)
+
+ // validate Local4 is a Package
+ If (LNotEqual (Local2, 4)) // Package type is 4
+ { Return (9) } // failure
+
+ Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+ // test nested DerefOf(Index) operators
+ Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
+
+ // save Local1 object type value into Local2
+ Store (ObjectType (Local1), Local2)
+
+ // validate Local1 is a Number
+ If (LNotEqual (Local2, 1)) // Number type is 1
+ { Return (10) } // failure
+
+ // zero indicates pass, non-zero is an error code
+ If (LNotEqual (Local1, 0))
+ { Return (11) } // failure
+
+ Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS", Debug)
+
+
+ // again, validate following produces a nested package
+ Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+ // save Local4 object type value into Local2
+ Store (ObjectType (Local4), Local2)
+
+ // validate Local4 is a Package
+ If (LNotEqual (Local2, 4)) // Package type is 4
+ { Return (12) } // failure
+
+ Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+ // retest nested DerefOf(Index) operators
+ Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
+
+ // save Local1 object type value into Local2
+ Store (ObjectType (Local1), Local2)
+
+ // validate Local1 is a Number
+ If (LNotEqual (Local2, 1)) // Number type is 1
+ { Return (13) } // failure
+
+ // zero indicates pass, non-zero is an error code
+ If (LNotEqual (Local1, 0))
+ { Return (14) } // failure
+
+ Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+ // again, validate following produces a nested package
+ Store (DerefOf (Index (TIM0, 1, )), Local4)
+
+ // save Local4 object type value into Local2
+ Store (ObjectType (Local4), Local2)
+
+ // validate Local4 is a Package
+ If (LNotEqual (Local2, 4)) // Package type is 4
+ { Return (15) } // failure
+
+ Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
+
+
+ Return (0) // pass
+ } // TEST
+ } // MTCH
+
+//
+// test WhileBrk.asl
+//
+// This code tests the Break term and While term
+//
+// Syntax of Break term
+// BreakTerm := Break
+// The break operation causes the current package execution to complete.
+//
+// Syntax of While Term
+// WhileTerm := While(
+// Predicate //TermArg=>Integer
+// ) {TermList}
+// Predicate is evaluated as an integer.
+// If the integer is non-zero, the list of terms in TermList is executed.
+// The operation repeats until the Predicate evaluates to zero.
+//
+// MTL NOTE: This test has been modified to reflect ACPI 2.0 break
+// NOTE: This test, when run under the MS ACPI.SYS grinds the system to
+// a halt.
+//
+ Device (WHLB)
+ {
+ Name (CNT0, 0)
+ Name (CNT1, 0)
+
+ Method (TEST)
+ {
+ // Check Break statement nested in If nested in While nested in
+ // While only exits inner-most While loop
+ Store (0, CNT0)
+
+ While (LLess (CNT0, 4))
+ {
+ Store (0, CNT1)
+ While (LLess (CNT1, 10))
+ {
+ if (LEqual (CNT1, 1))
+ {
+ Break // exit encompassing loop
+ }
+
+ Increment (CNT1)
+ }
+
+ If (LNotEqual (CNT1, 1))
+ {
+ // failure
+ Return (7)
+ }
+
+ Increment (CNT0)
+ }
+
+ // Verify Break only exited inner-most While loop
+
+ If (LNotEqual (CNT0, 4))
+ {
+ // failure
+ Return (8)
+ }
+
+ Store ("While/While/If/Break PASS", Debug)
+
+ Store ("++++++++ WhileBrk Test", Debug)
+
+ // Check Break statement nested in While
+ Store (0, CNT0)
+
+ While (LLess (CNT0, 10))
+ {
+ Break // exit encompassing package
+ Increment (CNT0)
+ }
+
+ If (LNotEqual (CNT0, 0)) // instruction after Break executed
+ {
+ Return (4)
+ }
+
+
+ Store (0, CNT0)
+
+ // Test While Term
+ While (LLess (CNT0, 10))
+ {
+ Increment (CNT0)
+ }
+
+ // Check if the while loop was executed until the condition is satisfied.
+ If (LNotEqual (CNT0, 10))
+ {
+ Return (1)
+ }
+
+
+ // While loop in a reverse order
+ While (LGreater (CNT0, 0))
+ {
+ Decrement (CNT0)
+ }
+
+ // Check if the while loop was executed until the condition is satisfied.
+ If (LNotEqual (CNT0, 0))
+ {
+ Return (2)
+ }
+
+
+ Store ("While/Break PASS", Debug)
+
+
+ // Check Break statement nested in If nested in While
+ Store (0, CNT0)
+
+ While (LLess (CNT0, 10))
+ {
+ if (LEqual (CNT0, 5))
+ {
+ Break // exit encompassing Package (If)
+
+ // if we execute the next instruction,
+ // Break did not exit the loop
+ Store (20, CNT0) // exit While loop with value larger
+ // than above
+ }
+
+ Increment (CNT0) // check if Break exited both If and While
+ } // While
+
+ If (LGreater (CNT0, 19))
+ { // instruction after Break inside IfOp executed
+ Return (5)
+ }
+
+ //
+ // Break will exit out of the while loop, therefore
+ // the CNT0 counter should still Increment until 5
+ //
+ If (LNotEqual (CNT0, 5))
+ { // instruction after Break inside WhileOp executed
+ Return (6)
+ }
+ Store ("While/If/Break PASS", Debug)
+
+
+ // All the conditions passed
+ Return (0)
+ } // TEST
+ } // WHLB
+
+
+//
+// test IndexOp2.asl
+//
+// Additional IndexOp test cases to support ACPICMB (control method battery
+// test) on Toshiba Portege 7020CT. Test cases include appropriate bit
+// shifting of Field elements and reading Field elements greater than 64 bits.
+//
+// MTL NOTE: This test has been modified slightly from the original test
+// to take into account ACPI specification limitations.
+//
+ Scope (\_SB) // System Bus
+ { // _SB system bus
+
+ Device (MEM)
+ { // MEM
+ Name (_HID, 0x010CD041)
+ Name (_STA, 0x0F)
+
+ OperationRegion (SMEM, SystemMemory, 0x800000, 0x100)
+ Field (SMEM, AnyAcc, NoLock, Preserve)
+ { // Field: SMEM overlay using 32-bit field elements
+ SMD0, 32, // 32-bits
+ SMD1, 32, // 32-bits
+ SMD2, 32, // 32-bits
+ SMD3, 32 // 32-bits
+ } // Field: SMEM overlay using 32-bit field elements
+ Field (SMEM, AnyAcc, NoLock, Preserve)
+ { // Field: SMEM overlay using greater than 32-bit field elements
+ SME0, 69, // larger than an integer (32 or 64)
+ SME1, 97 // larger than an integer
+ } // Field: SMEM overlay using greater than 32-bit field elements
+
+ OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000)
+ Field (SRAM, AnyAcc, NoLock, Preserve)
+ { // Field: SRAM overlay
+ , 0x34000, // skip
+ IEAX, 0x20,
+ IEBX, 0x20,
+ IECX, 0x20,
+ IEDX, 0x20,
+ IESI, 0x20,
+ IEDI, 0x20,
+ IEBP, 0x20,
+ , 0x20,
+ OEAX, 0x20,
+ OEBX, 0x20,
+ OECX, 0x20,
+ OEDX, 0x20,
+ OESI, 0x20,
+ OEDI, 0x20,
+ OEBP, 0x20,
+ , 0x618, // skip
+ ACST, 1,
+ BES1, 1,
+ BES2, 1,
+ , 5, // skip
+ BMN1, 0x68,
+ BSN1, 0x58,
+ BTP1, 0x48,
+ BPU1, 0x20,
+ BDC1, 0x20,
+ BLF1, 0x20,
+ BTC1, 0x20,
+ BDV1, 0x20,
+ BST1, 0x20,
+ BPR1, 0x20,
+ BRC1, 0x20,
+ BPV1, 0x20,
+ , 0x20,
+ BCW1, 0x20,
+ BCL1, 0x20,
+ BG11, 0x20,
+ BG21, 0x20,
+ BOI1, 0x20,
+ , 0x530, // skip
+ BMN2, 0x68,
+ BSN2, 0x58,
+ BTP2, 0x48,
+ BPU2, 0x20,
+ BDC2, 0x20,
+ BLF2, 0x20,
+ BTC2, 0x20,
+ BDV2, 0x20,
+ BST2, 0x20,
+ BPR2, 0x20,
+ BRC2, 0x20,
+ BPV2, 0x20,
+ , 0x20,
+ BCW2, 0x20,
+ BCL2, 0x20,
+ BG12, 0x20,
+ BG22, 0x20,
+ BOI2, 0x20,
+ , 0x518, // skip
+ AC01, 0x10,
+ AC11, 0x10,
+ PSV1, 0x10,
+ CRT1, 0x10,
+ TMP1, 0x10,
+ AST1, 0x10,
+ AC21, 0x10,
+ AC31, 0x10,
+ AC02, 0x10,
+ AC12, 0x10,
+ PSV2, 0x10,
+ CRT2, 0x10,
+ TMP2, 0x10,
+ AST2, 0x10,
+ AC22, 0x10,
+ AC32, 0x10,
+ AC03, 0x10,
+ AC13, 0x10,
+ PSV3, 0x10,
+ CRT3, 0x10,
+ TMP3, 0x10,
+ AST3, 0x10,
+ AC23, 0x10,
+ AC33, 0x10,
+ , 0x80, // skip
+ TMPF, 0x10,
+ , 0x570, // skip
+ FANH, 1,
+ FANL, 7,
+ TF11, 1,
+ TF21, 1,
+ TF31, 1,
+ , 1,
+ TF10, 1,
+ TF20, 1,
+ TF30, 1,
+ , 1,
+ TP11, 1,
+ TP21, 1,
+ TP31, 1,
+ , 0x6D, // 109
+ GP50, 1,
+ GP51, 1,
+ GP52, 1,
+ GP53, 1,
+ , 4,
+ GP60, 1,
+ GP61, 1,
+ GP62, 1,
+ GP63, 1,
+ GP64, 1,
+ GP65, 1,
+ GP66, 1,
+ , 1,
+ GP70, 1,
+ GP71, 1,
+ GP72, 1,
+ GP73, 1,
+ GP74, 1,
+ GP75, 1,
+ GP76, 1,
+ , 1,
+ WED0, 1,
+ WED1, 1,
+ WED2, 1,
+ WED3, 1,
+ WED4, 1,
+ , 3,
+ SBL0, 1,
+ SBL1, 1,
+ SBL2, 1,
+ SBL3, 1,
+ , 4,
+ LIDS, 1,
+ VALF, 1,
+ , 2,
+ DCKI, 1,
+ DCKF, 1,
+ BT1F, 1,
+ BT2F, 1,
+ , 0x7D0, // skip
+ HKCD, 8,
+ , 8,
+ DLID, 0x20,
+ DSRN, 0x20,
+ , 0x20,
+ BDID, 0x20,
+ DSPW, 1,
+ VGAF, 1,
+ VWE0, 1,
+ VWE1, 1,
+ PPSC, 1,
+ SPSC, 1,
+ EWLD, 1,
+ EWPS, 1,
+ , 0x1768, // skip
+ PRES, 0x8000
+ } // Field: SRAM overlay
+ } // MEM
+
+ Device (BAT1)
+ { // BAT1
+ Name (_HID, EISAID ("PNP0C0A")) // Control Method Battey ID
+ Name (_UID, 1)
+ Name (_PCL, Package (1) {\_SB})
+
+ Method (_STA)
+ { // _STA
+ If (\_SB.MEM.BES1)
+ { Return (0x1F) } // battery present
+ Else
+ { Return (0x0F) } // battery not present
+ } // _STA
+
+ Method (_BIF)
+ { // _BIF
+ Name (BUFR, Package (13) {})
+
+ Store (\_SB.MEM.BPU1, Index (BUFR, 0))
+ Store (\_SB.MEM.BDC1, Index (BUFR, 1))
+ Store (\_SB.MEM.BLF1, Index (BUFR, 2))
+ Store (\_SB.MEM.BTC1, Index (BUFR, 3))
+ Store (\_SB.MEM.BDV1, Index (BUFR, 4))
+ Store (\_SB.MEM.BCW1, Index (BUFR, 5))
+ Store (\_SB.MEM.BCL1, Index (BUFR, 6))
+ Store (\_SB.MEM.BG11, Index (BUFR, 7))
+ Store (\_SB.MEM.BG21, Index (BUFR, 8))
+ Store (\_SB.MEM.BMN1, Index (BUFR, 9))
+ Store (\_SB.MEM.BSN1, Index (BUFR, 10))
+ Store (\_SB.MEM.BTP1, Index (BUFR, 11))
+ Store (\_SB.MEM.BOI1, Index (BUFR, 12))
+
+ Return (BUFR)
+ } // _BIF
+ } // BAT1
+
+ Device (IDX2)
+ {
+ Method (B2IB)
+ { // B2IB: store from Buffer into Index'ed Buffer
+
+ Name (SRCB, Buffer () {"Short Buffer"}) // 12 characters plus NULL
+
+ Name (DEST, Buffer () // 62 characters plus NULL
+ {"Destination buffer that is longer than the short source buffer"})
+
+
+ // verify object type returned by Index(Buffer,Element,)
+
+ Store (Index (DEST, 2, ), Local1)
+ Store (ObjectType (Local1), Local2)
+
+ If (LNotEqual (Local2, 14)) // Buffer Field is type 14
+ {
+ // Local2 indicates Local1 is not a Buffer Field
+
+ Return (0x61)
+ }
+
+ // verify object type and value returned by DerefOf(Index(Buffer,Element,))
+ // should return Number containing element value
+
+ Store (DerefOf (Local1), Local3)
+ Store (ObjectType (Local3), Local4)
+
+ If (LNotEqual (Local4, 1)) // Number is type 1
+ {
+ // Local2 indicates Local1 is not a Number
+ Return (0x62)
+ }
+ Else
+ {
+ If (LNotEqual (Local3, 0x73)) // expect 's' element from DEST
+ {
+ Return (0x63)
+ }
+ }
+
+ Store ("DerefOf(Index(Buffer,,)) PASS", Debug)
+
+
+ //
+ // The following sections have been rewritten because storing into
+ // an Indexed buffer only changes one byte - the FIRST byte of the
+ // buffer is written to the source index. This is the ONLY byte
+ // written -- as per ACPI 2.0
+ //
+ // Overwrite DEST contents, at buffer position 2 [only]
+
+ Store (SRCB, Index (DEST, 2, ))
+
+ //
+ // Check that the next byte is not changed
+ //
+ Store (DerefOf (Index (DEST, 3, )), Local0)
+ If (LNotEqual (Local0, 0x74)) // 't'
+ {
+ // DEST element is not matching original value
+ If (LEqual (Local0, 0x68))
+ {
+ // DEST element was altered to 'h'
+ Return (0x68)
+ }
+ Else
+ {
+ // DEST element is an unknown value
+ Return (0x69)
+ }
+ }
+
+ //
+ // Check that the elements beyond the SRCB buffer copy
+ // have not been altered.
+ //
+ Store (DerefOf (Index (DEST, 14)), Local0)
+
+ //
+ // This should be an 'f'.
+ //
+ If (LNotEqual (Local0, 0x66))
+ {
+ // DEST element was zero'd by buffer copy
+ If (LEqual (Local0, 0))
+ {
+ // DEST element is zero
+ Return (0x6A)
+ }
+ Else
+ {
+ // DEST element is unknown value
+ Return (0x6B)
+ }
+ }
+
+ Store ("Store(SRCB,Index(Buffer,,)) PASS", Debug)
+
+ //
+ // verify altering SRCB does NOT alter DEST
+ //
+ Store (0x6A, Index (SRCB, 1)) // SRCB = "Sjort Buffer"
+
+ Store (DerefOf (Index (SRCB, 1)), Local0)
+
+ If (LNotEqual (Local0, 0x6A)) // 'j'
+ {
+ // SRCB element is unaltered
+ Return (0x71)
+ }
+
+ Store (DerefOf (Index (DEST, 3)), Local0) // DEST = "Destination buffer that...
+
+ If (LNotEqual (Local0, 0x74)) // 't'
+ {
+ // DEST element is altered
+ If (LEqual (Local0, 0x6A)) // 'j'
+ {
+ // SRCB change altered DEST element
+ Return (0x72)
+ }
+ Else
+ {
+ // DEST element is unknown value
+ Return (0x73)
+ }
+ }
+
+ // verify altering DEST does NOT alter SRCB
+
+ Store (0x6B, Index (DEST, 4, )) // DEST = "DeSkination buffer..."
+
+ Store (DerefOf (Index (DEST, 4, )), Local0)
+
+ If (LNotEqual (Local0, 0x6B)) // 'k'
+ {
+ // DEST element is unaltered
+ Return (0x74)
+ }
+
+ Store (DerefOf (Index (SRCB, 2, )), Local0)
+
+ If (LNotEqual (Local0, 0x6F)) // 'o'
+ { // SRC element is altered
+ If (LEqual (Local0, 0x6B)) // 'k'
+ {
+ // DEST change altered SRCB element
+ Return (0x75)
+ }
+ Else
+ {
+ // SRCB element is unknown value
+ Return (0x76)
+ }
+ }
+
+ Store ("SRCB and DEST independent PASS", Debug)
+
+
+ // verify string can be written to Index target/destination
+ // Only FIRST byte is written
+
+ Store ("New Buff", Index (DEST, 2, )) // DEST = "DeNkination buffer..."
+
+ Store (DerefOf (Index (DEST, 2, )), Local0)
+
+ If (LNotEqual (Local0, 0x4E)) // 'N'
+ {
+ // DEST element is unaltered
+ Return (0x81)
+ }
+
+ Store (DerefOf (Index (DEST, 6, )), Local0)
+
+ If (LNotEqual (Local0, 0x61)) // 'a'
+ {
+ // DEST element is unaltered
+ Return (0x82)
+ }
+
+ Store (DerefOf (Index (DEST, 10, )), Local0)
+
+ If (LNotEqual (Local0, 0x6E)) // 'n'
+ {
+ // DEST element is unaltered
+ Return (0x83)
+ }
+
+ Store ("Store(String,Index) PASS", Debug)
+
+
+ Return (0) // pass
+ } // B2IB: store from Buffer into Index'ed Buffer
+
+ Method (FB2P)
+ { // FB2P: store from Field Buffer into Index'ed Package
+ Name (DEST, Package (2) {})
+
+ // initialize memory using 32-bit field elements
+ Store (0x01234567, \_SB.MEM.SMD0)
+ Store (0x89ABCDEF, \_SB.MEM.SMD1)
+ Store (0xFEDCBA98, \_SB.MEM.SMD2)
+ Store (0x76543210, \_SB.MEM.SMD3)
+
+ // move greater than 64-bit buffers into DEST package
+ Store (\_SB.MEM.SME0, Index (DEST, 0))
+ Store (\_SB.MEM.SME1, Index (DEST, 1))
+
+ // validate DEST contents
+ Store (DerefOf (Index (DEST, 0, )), Local0)
+ Store (DerefOf (Index (DEST, 1, )), Local1)
+
+ // verify Local0 and Local1 are Buffers
+ Store (ObjectType (Local0), Local2)
+ if (LNotEqual (Local2, 3)) // Buffer type is 3
+ {
+ Return (0x11)
+ }
+
+ Store (ObjectType (Local1), Local3)
+ if (LNotEqual (Local3, 3)) // Buffer type is 3
+ {
+ Return (0x12)
+ }
+
+ // validate DEST buffer contents
+ Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 0)), Local4)
+ If (LNotEqual (Local4, 0x67))
+ {
+ Return (0x13)
+ }
+
+ Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 1)), Local4)
+ If (LNotEqual (Local4, 0x45))
+ {
+ Return (0x14)
+ }
+
+ Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 4)), Local4)
+ If (LNotEqual (Local4, 0xEF))
+ {
+ Return (0x15)
+ }
+
+ Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 5, )), Local4)
+ If (LNotEqual (Local4, 0xCD))
+ {
+ Return (0x16)
+ }
+
+ Store ("Store(Mem,PkgElement) PASS", Debug)
+
+
+ // validate changing source \_SB.MEM.SMD* does not impact DEST
+ Store (0x12345678, \_SB.MEM.SMD0)
+
+ Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 0, )), Local5)
+ If (LNotEqual (Local5, 0x67))
+ {
+ Return (0x21)
+ }
+
+ Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 1, )), Local5)
+ If (LNotEqual (Local5, 0x45))
+ {
+ Return (0x22)
+ }
+
+ // validate changing DEST does not impact source \_SB.MEM.SMD*
+ Store (0x30, Index (DerefOf (Index (DEST, 0)), 0))
+
+ Store (DerefOf(Index (DerefOf (Index (DEST, 0)), 0)), Local5)
+ If (LNotEqual (Local5, 0x30))
+ {
+ Return (0x23)
+ }
+
+ //
+ // This section was modified from the original iPCO code because
+ // it attempted to compare two buffers. This is not allowed until
+ // ACPI v2.0, so the test has been modified to just check the
+ // changed \_SB.MEM.SMD0
+ //
+ Store (\_SB.MEM.SMD0, Local5)
+
+ If(LNotEqual(Local5, 0x12345678))
+ {
+ Return (0x24)
+ }
+
+ Store ("Mem and Pkg independent PASS", Debug)
+
+
+ Return (0)
+ } // FB2P: store from Field Buffer into Index'ed Package
+
+ Method (TEST)
+ {
+ Store ("++++++++ IndexOp2 Test", Debug)
+
+ // store _BIF package return value into Local0
+
+ Store (\_SB.BAT1._BIF, Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Package
+ If (LNotEqual (Local1, 4)) // Package type is 4
+ {
+ // failure
+ Return (2)
+ }
+
+ // validate source and destination buffers are independent of each
+ // of each other (i.e., changing one's contents does not change
+ // other's contents) using B2IB (store from Buffer into Index'ed
+ // Buffer) and FB2P (store from Field Buffer into Index'ed Package)
+
+ // call B2IB (store from Buffer into Index'ed Buffer)
+ Store (B2IB, Local2) // Local2 is B2IB return value
+
+ // save Local2 object type value into Local3
+ Store (ObjectType (Local2), Local3)
+
+ // validate Local2 is a Number
+ If (LNotEqual (Local3, 1)) // Number type is 1
+ {
+ // failure
+ Return (4)
+ }
+
+ // zero indicates pass, non-zero is an error code
+ If (LNotEqual (Local2, 0))
+ {
+ // return B2IB error code
+ Return (Local2)
+ }
+
+ // call FB2P (store from Field Buffer into Index'ed Package)
+ Store (FB2P, Local2) // Local2 is FB2P return value
+
+ // save Local2 object type value into Local3
+ Store (ObjectType (Local2), Local3)
+
+ // validate Local2 is a Number
+ If (LNotEqual (Local3, 1)) // Number type is 1
+ {
+ // failure
+ Return (5)
+ }
+
+ // zero indicates pass, non-zero is an error code
+ If (LNotEqual (Local2, 0))
+ {
+ // return FB2P error code
+ Return (Local2)
+ }
+
+
+ Return (0)
+ } // TEST
+ } // IDX2: Test device name
+ } // _SB system bus
+
+//
+// test SizeOf.asl
+//
+// Test for SizeOf
+// test cases include following SizeOf arguments:
+// buffer, buffer field;
+// control method argument, control method local variable;
+// control method return values;
+// direct string, string;
+// package;
+// buffer, package, and string package elements
+//
+// MTL NOTE: This test has been modified to remove any SizeOf(Index(Buff,...
+// calls because it is not legal to perform a SizeOf operation on a Buffer Field.
+// This test has also been extended to test additional Package element sizes.
+//
+ Device (SIZO)
+ {
+ // SAR0 control method validates SizeOf(Arg)
+ // SAR0 should only be called by SARG
+ Method (SAR0, 2)
+ // Arg0 object to determine size of
+ // Arg1 expected Arg length
+ { // SAR0: SizeOf(Arg) test control method
+ // Local0 Arg0 length
+ // Local1 Local0 object type
+
+ // Store first string size (Arg0) into Local7
+ Store (SizeOf (Arg0), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ { Return (0x21) }
+
+ // If strings are not of equal size, return error code
+ If (LNotEqual (Local0, Arg1))
+ { Return (0x22) }
+
+ Return (0)
+ } // SAR0: SizeOf(Arg) test control method
+
+ Method (SARG)
+ { // SARG: SizeOf(Arg) test control method
+ Name (BUFR, Buffer (12) {}) // uninitialized Buffer
+ Name (BUF1, Buffer() {0x01, 0x02, 0x03, 0x04, 0x05})
+ Name (PKG0, Package (4) {}) // uninitialized Package
+ Name (STR0, "String")
+ Name (PKG1, Package (4)
+ {
+ BUFR,
+ "String2",
+ STR0,
+ PKG0
+ }) // PKG1
+
+ Name (PKG2, Package (4)
+ {
+ Buffer (15) {},
+ "String 1",
+ Package (2) {}
+ }) // PKG2
+
+ // Namespace entry buffer reference
+ Store (SAR0 (BUFR, 12), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x23)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=BUFR) PASS", Debug)
+
+
+ // Namespace entry package reference
+ Store (SAR0 (PKG0, 4), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x24)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=PKG0) PASS", Debug)
+
+
+ // Namespace entry string reference
+ Store (SAR0 (STR0, 6), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x25)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=STR0) PASS", Debug)
+
+
+ // direct string reference
+ Store (SAR0 ("String", 6), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x26)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=String) PASS", Debug)
+
+ Store (0x55, Index (BUF1, 2))
+
+ /****************************************************
+ //
+ // This section is commented because it is illegal to
+ // perform a SizeOf operation on a Buffer Field
+ //
+ // Namespace BufferField reference
+ Store (SAR0 (Index (BUFR, 2, ), 10), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ { Return (0x27) }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ { Return (Local0) }
+
+ Store ("SizeOf(Arg=BufferField) PASS", Debug)
+ ****************************************************/
+
+ // Namespace BufferPackageElement reference
+ //
+ Store (SAR0 (Index(PKG1, 0), 12), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x28)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=PackageBuffer NTE Reference Element) PASS", Debug)
+
+
+ // Namespace StringPackageElement reference
+ Store (SAR0 (Index (PKG1, 1, ), 7), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x29)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=Package String Element) PASS", Debug)
+
+
+ // Namespace StringPackageElement reference
+ Store (SAR0 (Index (PKG1, 2, ), 6), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x2A)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=Package String NTE Reference Element) PASS", Debug)
+
+
+ // Namespace PackagePackageElement reference
+ Store (SAR0 (Index (PKG1, 3, ), 4), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x2B)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=Package Package NTE Reference Element) PASS", Debug)
+
+ // Package Buffer Element
+ Store (SAR0 (Index (PKG2, 0), 15), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x2B)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=Package Buffer Element) PASS", Debug)
+
+ // Package String Element
+ Store (SAR0 (Index (PKG2, 1), 8), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x2B)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=Package String Element) PASS", Debug)
+
+ // Package Package Element
+ Store (SAR0 (Index (PKG2, 2), 2), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x2B)
+ }
+
+ If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
+ {
+ Return (Local0)
+ }
+
+ Store ("SizeOf(Arg=Package Package Element) PASS", Debug)
+
+ Store ("SizeOf(Arg) PASS", Debug)
+
+ Return (0)
+ } // SARG: SizeOf(Arg) test control method
+
+ Method (SBUF)
+ { // SBUF: SizeOf(Buffer) test control method
+ Name (BUFR, Buffer (12) {})
+
+ // store size of BUFR buffer into Local0
+ Store (SizeOf (BUFR), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x31)
+ }
+
+ If (LNotEqual (Local0, 12)) // BUFR size is 12
+ {
+ Return (0x32)
+ }
+
+ Store ("SizeOf(BUFR) PASS", Debug)
+
+ Return (0)
+ } // SBUF: SizeOf(Buffer) test control method
+
+
+ /****************************************************
+ //
+ // This section is commented because it is illegal to
+ // perform a SizeOf operation on a Buffer Field
+ //
+ Method (SIND)
+ { // SIND: SizeOf(Index(,,)) test control method
+ Name (BUFR, Buffer (12) {})
+
+ // store size of Index(BUFR,2,) buffer into Local0
+ Store (SizeOf (Index (BUFR, 2, )), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x41)
+ }
+
+ If (LNotEqual (Local0, 10)) // 12 - 2 = 10
+ {
+ Return (0x42)
+ }
+
+ Store ("SizeOf(Index(BUFR,,)) PASS", Debug)
+
+ // TBD: strings and packages
+
+ Return (0)
+ } // SIND: SizeOf(Index(,,)) test control method
+ ****************************************************/
+
+ Method (SLOC)
+ { // SLOC: SizeOf(Local) test control method
+ Name (BUFR, Buffer (12) {}) // uninitialized Buffer
+ Name (STR0, "String")
+ Name (PKG0, Package (4) {}) // uninitialized Package
+
+
+ // store BUFR Buffer into Local2
+ Store (BUFR, Local2)
+
+ // store size of BUFR buffer into Local0
+ Store (SizeOf (Local2), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x51)
+ }
+
+ If (LNotEqual (Local0, 12)) // BUFR size is 12
+ {
+ Return (0x52)
+ }
+
+ Store ("SizeOf(Local2=Buffer) PASS", Debug)
+
+
+ // store STR0 string into Local2
+ Store (STR0, Local2)
+
+ // store size of STR0 buffer into Local0
+ Store (SizeOf (Local2), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x53)
+ }
+
+ If (LNotEqual (Local0, 6)) // STR0 size is 6
+ {
+ Return (0x54)
+ }
+
+ Store ("SizeOf(Local2=String) PASS", Debug)
+
+
+ // store PKG0 Package into Local2
+ Store (PKG0, Local2)
+
+ // store size of PKG0 buffer into Local0
+ Store (SizeOf (Local2), Local0)
+
+ // save Local0 object type value into Local1
+ Store (ObjectType (Local0), Local1)
+
+ // validate Local0 is a Number
+ If (LNotEqual (Local1, 1)) // Number type is 1
+ {
+ Return (0x55)
+ }
+
+ If (LNotEqual (Local0, 4)) // PKG0 size is 4
+ {
+ Return (0x56)
+ }
+
+ Store ("SizeOf(Local2=Package) PASS", Debug)
+
+
+ Return (0)
+ } // SLOC: SizeOf(Local) test control method
+
+ Method (TEST)
+ {
+ Store ("++++++++ SizeOf Test", Debug)
+
+ // Store current operating system string into Local0
+ Store (_OS, Local0)
+
+ Store (SizeOf (_OS), Local3)
+
+ // save Local3 object type value into Local4
+ Store (ObjectType (Local3), Local4)
+
+ // validate Local3 is a Number
+ If (LNotEqual (Local4, 1)) // Number type is 1
+ {
+ // failure
+ Return (0x61)
+ }
+
+ // Store current operating system string into Local0
+ // This verifies above SizeOf(_OS) did not corrupt ACPI namespace
+ Store (_OS, Local0)
+
+ // Store SARG [Validate SizeOf(Arg)] return value into Local1
+ Store (SARG, Local1)
+
+ // save Local1 object type value into Local2
+ Store (ObjectType (Local1), Local2)
+
+ // validate Local1 is a Number
+ If (LNotEqual (Local2, 1)) // Number type is 1
+ {
+ // failure
+ Return (0x62)
+ }
+
+ // zero indicates pass, non-zero is an error code
+ If (LNotEqual (Local1, 0))
+ {
+ // return SARG error code
+ Return (Local1)
+ }
+
+
+ // Store SBUF [Validate SizeOf(Buffer)] return value into Local1
+ Store (SBUF, Local1)
+
+ // save Local1 object type value into Local2
+ Store (ObjectType (Local1), Local2)
+
+ // validate Local1 is a Number
+ If (LNotEqual (Local2, 1)) // Number type is 1
+ {
+ // failure
+ Return (0x63)
+ }
+
+ // zero indicates pass, non-zero is an error code
+ If (LNotEqual (Local1, 0))
+ {
+ // return SBUF error code
+ Return (Local1)
+ }
+
+ /****************************************************
+ //
+ // This section is commented because it is illegal to
+ // perform a SizeOf operation on a Buffer Field
+ //
+ // Store SIND [verify SizeOf(Index(,,))] return value into Local1
+ Store (SIND, Local1)
+
+ // save Local1 object type value into Local2
+ Store (ObjectType (Local1), Local2)
+
+ // validate Local1 is a Number
+ If (LNotEqual (Local2, 1)) // Number type is 1
+ {
+ // failure
+ Return (0x64)
+ }
+
+ // zero indicates pass, non-zero is an error code
+ If (LNotEqual (Local1, 0))
+ {
+ // return SARG error code
+ Return (Local1)
+ }
+ ****************************************************/
+
+ // Store SLOC [verify SizeOf(Local)] return value into Local1
+ Store (SLOC, Local1)
+
+ // save Local1 object type value into Local2
+ Store (ObjectType (Local1), Local2)
+
+ // validate Local1 is a Number
+ If (LNotEqual (Local2, 1)) // Number type is 1
+ {
+ // failure
+ Return (0x65)
+ }
+
+ // zero indicates pass, non-zero is an error code
+ If (LNotEqual (Local1, 0))
+ {
+ // return SLOC error code
+ Return (Local1)
+ }
+
+
+ // TBD: SizeOf (METH) -- where METH control method returns
+ // buffer, BufferField, string, package, package element
+
+
+ Return (0)
+ } // TEST
+ } // SIZO
+
+//
+// test SmiShare.asl
+//
+ Scope (\_SB) // System Bus
+ { // _SB system bus
+ // Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
+ OperationRegion(RAM1, SystemMemory, 0x400000, 0xA)
+
+ Field (RAM1, AnyAcc, NoLock, Preserve)
+ {
+ BI1T, 1, // Create some bits in memory to access
+ BI2T, 2,
+ BI3T, 3,
+ LST2, 2
+ } // End Field RAM1
+
+ Field (RAM1, WordAcc, NoLock, WriteAsZeros)
+ {
+ WRD, 16
+ } // End 2nd Field RAM1
+
+ Field (RAM1, ByteAcc, NoLock, WriteAsOnes)
+ {
+ BYTE, 8
+ } // End 3rd Field RAM1
+
+ Field (RAM1, ByteAcc, NoLock, Preserve)
+ {
+ SMIC, 8,
+ SMID, 8
+ }
+
+ Device (MBIT)
+ {
+ Method (_INI)
+ {
+ Store (0, BI1T)
+ Store (3, BI2T)
+ Store (7, BI3T)
+ Store (0, LST2)
+ } // End _INI Method
+ } // End Device MBIT
+
+ Device (MWRD)
+ {
+ Method (_INI)
+ {
+ Store (0, WRD)
+ } // End _INI Method
+ } // End Device MWRD
+
+ Device (MBYT)
+ {
+ Method (_INI)
+ {
+ Store (0, BYTE)
+ Store (0xC, SMIC)
+ Store (0xD, SMID)
+ } // End _INI Method
+ } // End Device MBYT
+
+ /*
+ // Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
+ OperationRegion(\RAM1, SystemMemory, 0x400000, 0xA)
+
+ Field (\RAM1, AnyAcc, NoLock, Preserve)
+ {
+ BI1T, 1, // Create some bits in memory to access
+ BI2T, 2,
+ BI3T, 3,
+ LST2, 2
+ } // End Field RAM1
+
+ Field (\RAM1, WordAcc, NoLock, WriteAsZeros)
+ {
+ WRD, 16
+ } // End 2nd Field RAM1
+
+ Field (\RAM1, ByteAcc, NoLock, WriteAsOnes)
+ {
+ BYTE, 8
+ } // End 3rd Field RAM1
+
+ Field (\RAM1, ByteAcc, NoLock, Preserve)
+ {
+ SMIC, 8,
+ SMID, 8
+ }
+ */
+ Method (SMIX)
+ {
+ Return (BYTE)
+ } // End SMIX
+
+ Method (EVNT)
+ {
+ Store (SMIX, Local0)
+
+ If (And (Local0, 0x01))
+ { Notify (\_SB_.SMIS, 0x21)}
+
+ If (And (Local0, 0x02))
+ { Notify (\_SB_.SMIS, 0x22)}
+
+ If (And (Local0, 0x04))
+ { Notify (\_SB_.SMIS, 0x24)}
+
+ If (And (Local0, 0x08))
+ { Notify (\_SB_.SMIS, 0x28)}
+
+ } // End Method EVNT
+
+ Device (SMIS)
+ {
+ Method (BINK)
+ {
+ Store (0, Local0) // Zero out Local0
+
+ If (LNotEqual (SMID, 0xD))
+ { Or (0x80, Local0, Local0)}
+
+ If (LNotEqual (SMIC, 0xC))
+ { Or (0x40, Local0, Local0)}
+
+ If (LNotEqual (BYTE, 0))
+ { Or (0x20, Local0, Local0)}
+
+ If (LNotEqual (WRD, 0))
+ { Or (0x10, Local0, Local0)}
+
+ If (LNotEqual (LST2, 0))
+ { Or (0x8, Local0, Local0)}
+
+ If (LNotEqual (BI3T, 0x7))
+ { Or (0x4, Local0, Local0)}
+
+ If (LNotEqual (BI2T, 0x3))
+ { Or (0x2, Local0, Local0)}
+
+ If (LNotEqual (BI1T, 0))
+ { Or (0x1, Local0, Local0)}
+
+ Return (Local0)
+ } // End Method BINK
+
+ Method (TEST)
+ {
+ Store ("++++++++ SmiShare Test", Debug)
+
+ // Expect EVNT to generate Notify value we just previously
+ // stored in BYTE
+ Store (0x20, BYTE)
+ EVNT ()
+ Store (0x21, BYTE)
+ EVNT ()
+ Store (0x22, BYTE)
+ EVNT ()
+ Store (0x23, BYTE)
+ EVNT ()
+
+ Return (0) // pass
+ } // End Method TEST
+ } // Device SMIS
+
+ Device(CNDT)
+ {
+ Method(TEST)
+ {
+ If (ECOK)
+ {
+ return("Broken")
+ }
+ Else
+ {
+ return("Works")
+ }
+ }
+
+ Method(ECOK)
+ {
+ Return(0x0)
+ }
+ }
+
+ } // _SB system bus
+
+
+/* Test a very big buffer */
+
+ Name(WQAB, Buffer(6756)
+ {
+ 0x46,0x4F,0x4D,0x42,0x01,0x00,0x00,0x00,
+ 0x54,0x1A,0x00,0x00,0xBA,0xAD,0x00,0x00,
+ 0x44,0x53,0x00,0x01,0x1A,0x7D,0xDA,0x54,
+ 0x98,0xBD,0x92,0x00,0x01,0x06,0x18,0x42,
+ 0x10,0x47,0x10,0x92,0x46,0x62,0x02,0x89,
+ 0x80,0x90,0x18,0x18,0x14,0x81,0x85,0x00,
+ 0x49,0x02,0x88,0xC4,0x41,0xE1,0x20,0xD4,
+ 0x9F,0x40,0x7E,0x05,0x20,0x74,0x28,0x40,
+ 0xA6,0x00,0x83,0x02,0x9C,0x22,0x88,0xA0,
+ 0x57,0x01,0x36,0x05,0x98,0x14,0x60,0x51,
+ 0x80,0x76,0x01,0x96,0x05,0xE8,0x16,0x20,
+ 0x1D,0x96,0x88,0x04,0x47,0x89,0x01,0x47,
+ 0xE9,0xC4,0x16,0x6E,0xD8,0xE0,0x85,0xA2,
+ 0x68,0x06,0x51,0x12,0x94,0x8B,0x20,0x5D,
+ 0x10,0x52,0x2E,0xC0,0x37,0x82,0x06,0x10,
+ 0xA5,0x77,0x01,0xB6,0x05,0x98,0x86,0x27,
+ 0xD2,0x20,0xE4,0x60,0x08,0x54,0xCE,0x80,
+ 0x20,0x69,0x44,0x21,0x1E,0xA7,0x44,0x08,
+ 0x0A,0x84,0x90,0xD4,0xF1,0xA0,0xA0,0x71,
+ 0x88,0xAD,0xCE,0x46,0x93,0xA9,0x74,0x7E,
+ 0x48,0x82,0x70,0xC6,0x2A,0x7E,0x3A,0x9A,
+ 0xD0,0xD9,0x9C,0x60,0xE7,0x18,0x72,0x3C,
+ 0x48,0xF4,0x20,0xB8,0x00,0x0F,0x1C,0x2C,
+ 0x34,0x84,0x22,0x6B,0x80,0xC1,0x8C,0xDD,
+ 0x63,0xB1,0x0B,0x4E,0x0A,0xEC,0x61,0xB3,
+ 0x01,0x19,0xA2,0x24,0x38,0xD4,0x11,0xC0,
+ 0x12,0x05,0x98,0x1F,0x87,0x0C,0x0F,0x95,
+ 0x8C,0x25,0x24,0x1B,0xAB,0x87,0xC2,0xA5,
+ 0x40,0x68,0x6C,0x27,0xED,0x19,0x45,0x2C,
+ 0x79,0x4A,0x82,0x49,0xE0,0x51,0x44,0x36,
+ 0x1A,0x27,0x28,0x1B,0x1A,0x25,0x03,0x42,
+ 0x9E,0x05,0x58,0x07,0x26,0x04,0x76,0x2F,
+ 0xC0,0x9A,0x00,0x73,0xB3,0x90,0xB1,0xB9,
+ 0xE8,0xFF,0x0F,0x71,0xB0,0x31,0xDA,0x9A,
+ 0xAE,0x90,0xC2,0xC4,0x88,0x12,0x2C,0x5E,
+ 0xC5,0xC3,0x10,0xCA,0x93,0x42,0xA8,0x48,
+ 0x95,0xA1,0x68,0xB4,0x51,0x2A,0x14,0xE0,
+ 0x4C,0x80,0x30,0x5C,0x1D,0x03,0x82,0x46,
+ 0x88,0x15,0x29,0x56,0xFB,0x83,0x20,0xF1,
+ 0x2D,0x40,0x54,0x01,0xA2,0x48,0xA3,0x41,
+ 0x9D,0x03,0x3C,0x5C,0x0F,0xF5,0xF0,0x3D,
+ 0xF6,0x93,0x0C,0x72,0x90,0x67,0xF1,0xA8,
+ 0x70,0x9C,0x06,0x49,0xE0,0x0B,0x80,0x4F,
+ 0x08,0x1E,0x38,0xDE,0x35,0xA0,0x66,0x7C,
+ 0xBC,0x4C,0x10,0x1C,0x6A,0x88,0x1E,0x68,
+ 0xB8,0x13,0x38,0x44,0x06,0xE8,0x49,0x3D,
+ 0x52,0x60,0x07,0x77,0x32,0xEF,0x01,0xAF,
+ 0x0A,0xCD,0x5E,0x12,0x08,0xC1,0xF1,0xF8,
+ 0x7E,0xC0,0x26,0x9C,0xC0,0xF2,0x07,0x81,
+ 0x1A,0x99,0xA1,0x3D,0xCA,0xD3,0x8A,0x19,
+ 0xF2,0x31,0xC1,0x04,0x16,0x0B,0x21,0x05,
+ 0x10,0x1A,0x0F,0xF8,0x6F,0x00,0x8F,0x17,
+ 0xBE,0x12,0xC4,0xF6,0x80,0x12,0x0C,0x0B,
+ 0x21,0x23,0xAB,0xF0,0x78,0xE8,0x28,0x7C,
+ 0x95,0x38,0x9C,0xD3,0x8A,0x67,0x82,0xE1,
+ 0x20,0xF4,0x05,0x90,0x00,0x51,0xE7,0x0C,
+ 0xD4,0x61,0xC1,0xE7,0x04,0x76,0x33,0x38,
+ 0x83,0x47,0x00,0x8F,0xE4,0x84,0xFC,0x2B,
+ 0xF1,0xC0,0xE0,0x03,0xE2,0xEF,0x1F,0xA7,
+ 0xEC,0x11,0x9C,0xA9,0x01,0x7D,0x1C,0xF0,
+ 0xFF,0x7F,0x28,0x7C,0x88,0x1E,0xDF,0x29,
+ 0x1F,0xAF,0x4F,0x17,0x96,0x35,0x4E,0xE8,
+ 0x77,0x08,0x9F,0x38,0x7C,0x64,0x71,0x44,
+ 0x08,0x39,0x39,0x05,0xA0,0x81,0x4F,0xF7,
+ 0xEC,0x22,0x9C,0xAE,0x27,0xE5,0x40,0xC3,
+ 0xA0,0xE3,0x04,0xC7,0x79,0x00,0x1C,0xE3,
+ 0x84,0x7F,0x2E,0x80,0x3F,0x40,0x7E,0xCA,
+ 0x78,0xC5,0x48,0xE0,0x98,0x23,0x44,0x9F,
+ 0x6B,0x3C,0x42,0x2C,0xFC,0x53,0x45,0xE1,
+ 0x03,0x21,0x63,0x04,0x17,0xA0,0xC7,0x08,
+ 0x7C,0x03,0x8E,0x11,0x7D,0x94,0xE0,0xEA,
+ 0x0F,0x1A,0x74,0x80,0xB8,0xFF,0xFF,0x00,
+ 0xE1,0x83,0x7A,0x80,0xC0,0x37,0xFA,0xD1,
+ 0x03,0x3D,0x2E,0x8B,0x3E,0x0F,0xC8,0xF8,
+ 0x89,0x46,0xF3,0xE2,0xA7,0x03,0x7E,0xF8,
+ 0x00,0x0F,0xA8,0x87,0x84,0x03,0xC5,0x4C,
+ 0x9B,0x83,0x3E,0xBB,0x1C,0x3A,0x76,0xB8,
+ 0xE0,0x3F,0x81,0x80,0x4B,0xDE,0x21,0x0C,
+ 0x14,0x23,0xC6,0x9F,0x83,0x7C,0x0A,0x03,
+ 0xFF,0xFF,0xFF,0x14,0x06,0xFE,0xE1,0xF0,
+ 0x20,0x4F,0x07,0x9F,0xB6,0xA8,0x74,0x18,
+ 0xD4,0x81,0x0B,0xB0,0x32,0x89,0x08,0xCF,
+ 0x12,0xB5,0x41,0xE8,0xD4,0xF0,0x36,0xF1,
+ 0xB6,0xE5,0x5B,0x40,0x9C,0xD3,0xEC,0xED,
+ 0xC0,0x45,0x30,0x22,0xD4,0x0C,0x45,0x4E,
+ 0x5A,0x11,0x63,0x44,0x79,0xDC,0x32,0xCA,
+ 0xDB,0xD6,0x0B,0x40,0xBC,0x13,0x7B,0xDE,
+ 0x32,0x46,0xF0,0xC8,0x0F,0x5C,0x2C,0xC6,
+ 0xEA,0xF5,0x5F,0xF3,0x81,0x0B,0x70,0xF6,
+ 0xFF,0x3F,0x70,0x01,0x1C,0x0A,0x7A,0x18,
+ 0x42,0x0F,0xC3,0x53,0x39,0x97,0x87,0xC8,
+ 0x53,0x89,0x18,0x35,0x4C,0xD4,0x67,0x28,
+ 0xDF,0x2D,0x7C,0x20,0x02,0xDF,0x99,0x0B,
+ 0xF8,0xFD,0xFF,0x0F,0x44,0x70,0x8E,0x29,
+ 0xB8,0x33,0x0D,0x78,0x7C,0xCE,0x40,0x20,
+ 0xA7,0xE2,0x43,0x0D,0x60,0x41,0xF4,0x13,
+ 0xC2,0x27,0x1A,0x2A,0x13,0x06,0x75,0xA8,
+ 0x01,0xAC,0x5C,0x61,0x9E,0x46,0xCF,0xF9,
+ 0x59,0xC6,0xA7,0x1A,0x1F,0x4A,0x8D,0x63,
+ 0x88,0x97,0x99,0x87,0x1A,0x1F,0x0B,0x5E,
+ 0x49,0x7D,0xA8,0x31,0x54,0x9C,0x87,0x1A,
+ 0x0F,0x37,0x50,0xD4,0x37,0x9B,0x67,0x1B,
+ 0xA3,0xC7,0xF7,0x0D,0xD5,0x10,0x0F,0x35,
+ 0x4C,0xF2,0x4A,0x35,0x16,0x1F,0x6A,0xC0,
+ 0xF1,0xFF,0x3F,0xD4,0x00,0xFC,0xFF,0xFF,
+ 0x1F,0x6A,0x00,0x47,0x47,0x03,0x38,0x47,
+ 0x46,0xDC,0xD1,0x00,0x5C,0x87,0x52,0xE0,
+ 0x70,0x34,0x00,0x1E,0x47,0x21,0x30,0x5F,
+ 0x68,0x7C,0x14,0x02,0x16,0xFF,0xFF,0xA3,
+ 0x10,0xF8,0x65,0x9F,0x83,0x50,0x42,0x8F,
+ 0x42,0x80,0xA0,0xDB,0xCF,0x53,0xC4,0xB3,
+ 0x8F,0x2F,0x3F,0x0F,0x04,0x11,0x5E,0xF3,
+ 0x7D,0x0A,0xF2,0x21,0xDF,0x47,0x21,0x06,
+ 0x63,0x28,0x5F,0x83,0x7C,0x14,0x62,0x50,
+ 0xAF,0x41,0xBE,0xEF,0x1B,0xE4,0xF1,0x22,
+ 0x48,0xEC,0x67,0x02,0x1F,0x85,0x98,0xE8,
+ 0xA3,0x10,0xA0,0xF0,0xFF,0x7F,0x14,0x02,
+ 0xF8,0xFF,0xFF,0x3F,0x0A,0x01,0xCE,0x02,
+ 0x1C,0x0D,0x40,0x37,0xAD,0x47,0x21,0xF0,
+ 0xDE,0x59,0x4E,0xFB,0x04,0x7C,0x16,0x02,
+ 0xCC,0xFE,0xFF,0xCF,0x42,0xC0,0xEC,0x28,
+ 0x74,0x14,0x67,0xF9,0x2A,0xF4,0x04,0xF0,
+ 0x02,0x10,0x23,0xCC,0x3B,0xD0,0x4B,0x26,
+ 0xBB,0x8B,0x1B,0xE7,0xC9,0xE5,0x2C,0x9E,
+ 0xC4,0x7D,0x09,0xF2,0x81,0xE2,0x59,0xC8,
+ 0x50,0xA7,0x1B,0xF4,0x8D,0xDC,0x03,0x8B,
+ 0x19,0x3F,0xC4,0xF3,0x90,0x21,0x9E,0x85,
+ 0x00,0x76,0xFD,0xFF,0xCF,0x42,0x00,0xFF,
+ 0xFF,0xFF,0x47,0x03,0xF8,0x2F,0x00,0x9F,
+ 0x85,0x80,0xE7,0x09,0xE0,0x41,0xDB,0x67,
+ 0x21,0x80,0x33,0x87,0xCB,0xF3,0x7F,0x05,
+ 0x3A,0x96,0xF7,0x08,0xCF,0xFA,0x24,0x5F,
+ 0x2F,0x3D,0xD3,0x87,0x82,0x67,0x21,0x86,
+ 0x75,0x18,0x3E,0x0B,0x31,0x88,0x17,0x4D,
+ 0x43,0xBC,0x70,0xFA,0x30,0xE0,0xFF,0x3F,
+ 0x5E,0xE0,0x57,0x4E,0x03,0x05,0x09,0xF4,
+ 0x2C,0x04,0x30,0xFE,0xFF,0x7F,0x16,0x02,
+ 0xC8,0xB8,0x46,0x9D,0x85,0x80,0xE5,0x6D,
+ 0xE5,0x19,0xDB,0xA7,0x95,0x04,0xFF,0xFF,
+ 0x67,0x21,0xC0,0x41,0x2E,0x23,0x07,0x21,
+ 0x4C,0xC4,0x87,0x83,0x8F,0x99,0x80,0x9E,
+ 0x29,0xBE,0xB8,0x1B,0xE3,0x09,0xE0,0x45,
+ 0xE2,0x31,0x93,0x1D,0x35,0x0D,0xF3,0x2C,
+ 0x64,0xBC,0xB3,0x78,0x0D,0x78,0x82,0xF7,
+ 0xE4,0x9F,0x85,0x18,0xD8,0x61,0x05,0x7B,
+ 0x14,0x32,0xA8,0xC1,0x63,0x87,0x08,0x13,
+ 0xE8,0x59,0x88,0xC5,0x7D,0xAE,0xE8,0x3C,
+ 0xE1,0xB3,0x10,0xF0,0xFE,0xFF,0x9F,0x25,
+ 0xE0,0x5E,0x0D,0x9E,0x85,0x00,0x13,0x87,
+ 0x0D,0x9F,0x35,0xC0,0x33,0x7C,0x8F,0xEA,
+ 0x1C,0x1E,0x8F,0x81,0x7F,0x56,0x1D,0xE7,
+ 0x04,0x96,0x7B,0xD1,0xB2,0x71,0xA0,0xA1,
+ 0x23,0xB2,0x3A,0x20,0x8D,0x0D,0x73,0x29,
+ 0x89,0x7C,0x72,0x6C,0xD4,0x56,0x04,0xA7,
+ 0x33,0x93,0x4F,0x00,0xD6,0x42,0x21,0x05,
+ 0x34,0x1A,0x8B,0xE1,0x9D,0xF9,0xE8,0x44,
+ 0x41,0x0C,0xE8,0xE3,0x90,0x6D,0x1C,0x0A,
+ 0x50,0x7B,0xD1,0x14,0xC8,0x39,0x07,0xA3,
+ 0x7F,0x76,0x74,0x36,0xBE,0x13,0x70,0x0D,
+ 0x10,0x3A,0x25,0x18,0xDA,0x6A,0x04,0xFC,
+ 0xFF,0x67,0x89,0x01,0x33,0xFE,0x53,0x8C,
+ 0x09,0x7C,0x8E,0xC1,0x1F,0x0C,0xF0,0x03,
+ 0x7F,0x31,0xA8,0xFA,0x5E,0xA0,0xFB,0x82,
+ 0xD5,0xDD,0x64,0x20,0xCC,0xC8,0x04,0xF5,
+ 0x9D,0x0E,0x40,0x01,0xE4,0x0B,0x81,0xCF,
+ 0x51,0x0F,0x05,0x6C,0x22,0x21,0xC2,0x44,
+ 0x33,0x3A,0x62,0xC2,0xA8,0xE8,0x13,0xA6,
+ 0x20,0x9E,0xB0,0x63,0x4D,0x18,0x3D,0x13,
+ 0x5F,0x74,0xD8,0x88,0x31,0x21,0xAE,0x1E,
+ 0xD0,0x26,0x18,0xD4,0x97,0x22,0x58,0x43,
+ 0xE6,0x63,0xF1,0x05,0x02,0x37,0x65,0x30,
+ 0xCE,0x89,0x5D,0x13,0x7C,0xD9,0xC1,0xCD,
+ 0x19,0x8C,0xF0,0x98,0xBB,0x18,0xBF,0x3A,
+ 0x79,0x74,0xFC,0xA0,0xE0,0x1B,0x0E,0xC3,
+ 0x7E,0x32,0xF3,0x8C,0xDE,0xCB,0x7C,0x8D,
+ 0xC3,0xC0,0x7A,0xBC,0x1C,0xD6,0x68,0x61,
+ 0x0F,0xED,0x3D,0xC4,0xFF,0xFF,0x43,0x8C,
+ 0xCF,0x13,0xC6,0x08,0xEB,0xDB,0x0B,0x38,
+ 0xEE,0x59,0xF0,0xEF,0x1A,0xE0,0xB9,0x84,
+ 0xF8,0xAE,0x01,0x30,0xF0,0xFF,0x7F,0xD7,
+ 0x00,0x4E,0xD7,0x04,0xDF,0x35,0x80,0xF7,
+ 0xD0,0x7D,0xD7,0x00,0xAE,0xD9,0xEF,0x1A,
+ 0xA8,0x63,0x80,0x15,0xDE,0x35,0xA0,0x5D,
+ 0xD9,0xDE,0xD7,0x9E,0xB0,0xAC,0xE9,0xB2,
+ 0x81,0x52,0x73,0xD9,0x00,0x14,0xFC,0xFF,
+ 0x2F,0x1B,0x80,0x01,0x29,0x13,0x46,0x85,
+ 0x9F,0x30,0x05,0xF1,0x84,0x1D,0xEC,0xB2,
+ 0x01,0x8A,0x18,0x97,0x0D,0xD0,0x8F,0xED,
+ 0x65,0x03,0x18,0xDC,0x13,0xF8,0x6D,0x03,
+ 0x78,0x43,0xFA,0xB6,0x01,0xD6,0xFF,0xFF,
+ 0x6D,0x03,0xAC,0xF9,0x6F,0x1B,0x28,0x0E,
+ 0xAB,0xBC,0x6D,0x40,0x3C,0xC9,0x33,0x02,
+ 0xAB,0xBA,0x6E,0xA0,0xF4,0x5C,0x37,0x00,
+ 0x12,0x88,0x99,0x30,0x2A,0xFE,0x84,0x29,
+ 0x88,0x27,0xEC,0x68,0xD7,0x0D,0x50,0x04,
+ 0xB9,0x6E,0x80,0x7E,0x5E,0x09,0xFE,0xFF,
+ 0xAF,0x1B,0xC0,0xE0,0xA2,0x80,0xB9,0x6F,
+ 0x00,0x6F,0x58,0x7E,0xDF,0x00,0x7C,0xDC,
+ 0xC4,0x31,0xF7,0x0D,0xC0,0xCC,0xFF,0xFF,
+ 0xBE,0x01,0xB0,0xE7,0xA2,0x80,0xBB,0x6F,
+ 0x00,0xEF,0x8B,0xB4,0xEF,0x1B,0x60,0xFE,
+ 0xFF,0xDF,0x37,0xC0,0x28,0x6D,0xFD,0x1E,
+ 0x1C,0x3D,0x21,0x78,0x7C,0xB8,0xFB,0xA5,
+ 0xC7,0xE7,0xBB,0x39,0x38,0x06,0x79,0x8C,
+ 0x87,0x76,0xC0,0xAF,0xEF,0x9E,0x98,0xEF,
+ 0xE6,0xC0,0xFF,0x4C,0x70,0x3C,0x18,0x68,
+ 0x1C,0x62,0xAB,0x97,0x06,0x72,0x34,0x38,
+ 0x3F,0xDC,0x19,0x81,0x61,0x15,0x7F,0xF2,
+ 0x47,0x38,0xC7,0xD0,0xD9,0xE1,0x20,0xB1,
+ 0x83,0xE0,0xC1,0x56,0x6D,0x02,0x85,0x86,
+ 0x50,0x14,0x18,0x14,0x8B,0x0F,0x18,0xF8,
+ 0x61,0xB3,0xB3,0x00,0x93,0x04,0x87,0x3A,
+ 0x02,0xF8,0x3E,0xD1,0xFC,0x38,0x74,0x37,
+ 0x38,0x54,0x8F,0xE5,0xA1,0x80,0x9E,0x01,
+ 0x71,0xC7,0x0C,0x32,0x69,0xCF,0x28,0xE2,
+ 0x53,0xC2,0x29,0x85,0x49,0xE0,0xF3,0x03,
+ 0x43,0xE3,0x04,0xAF,0x0D,0xA1,0xF9,0xFF,
+ 0xFF,0xA4,0xC0,0x3C,0xDF,0x31,0x04,0x6C,
+ 0x02,0xBB,0xBF,0x64,0xC8,0xDA,0xC0,0x75,
+ 0x4B,0x32,0x44,0x6F,0x38,0xB2,0x85,0xA2,
+ 0xE9,0x44,0x79,0xDF,0x88,0x62,0x67,0x08,
+ 0xC2,0x88,0x12,0x2C,0xC8,0xA3,0x42,0xAC,
+ 0x28,0x2F,0x05,0x46,0x88,0x18,0xE2,0x95,
+ 0x23,0xD0,0x09,0x87,0x0F,0xF2,0xD8,0x14,
+ 0xA7,0xFD,0x41,0x90,0x58,0x4F,0x02,0x8D,
+ 0xC5,0x91,0x46,0x83,0x3A,0x07,0x78,0xB8,
+ 0x3E,0xC4,0x78,0xF8,0x0F,0x21,0x06,0x39,
+ 0xC8,0x73,0x7B,0x54,0x38,0x4E,0x5F,0x25,
+ 0x4C,0xF0,0x02,0xE0,0x83,0x0A,0x1C,0xD7,
+ 0x80,0x9A,0xF1,0x33,0x06,0x58,0x8E,0xE3,
+ 0x3E,0xA9,0xC0,0x1D,0x8F,0xEF,0x07,0x6C,
+ 0xC2,0x09,0x2C,0x7F,0x10,0xA8,0xE3,0x0C,
+ 0x9F,0xE7,0x0B,0x8B,0x21,0x1F,0x13,0x4C,
+ 0x60,0xB1,0x27,0x1B,0x3A,0x1E,0xF0,0xDF,
+ 0x63,0x1E,0x2F,0x7C,0x32,0xF1,0x7C,0x4D,
+ 0x30,0x22,0x84,0x9C,0x8C,0x07,0x7D,0x87,
+ 0xC0,0x5C,0x6F,0xD8,0xB9,0x85,0x8B,0x3A,
+ 0x68,0xA0,0x4E,0x0B,0x3E,0x28,0xB0,0x9B,
+ 0x11,0xE6,0xB8,0xCE,0xCF,0x2A,0x60,0xF8,
+ 0xFF,0x9F,0x55,0x60,0x8F,0x10,0xFE,0xED,
+ 0xC1,0xF3,0xF2,0x95,0xE1,0xD5,0x21,0x81,
+ 0x43,0x8E,0x10,0x3D,0x2E,0x8F,0x10,0x73,
+ 0x3E,0xC2,0x0C,0x11,0x5C,0x67,0x01,0x70,
+ 0x0C,0x11,0xF8,0x1C,0x70,0xC0,0x71,0x69,
+ 0xE2,0x03,0xF5,0x01,0x07,0x70,0x70,0x4D,
+ 0xC3,0x1D,0x70,0xC0,0x71,0x16,0x60,0xFF,
+ 0xFF,0xC3,0x0D,0x2C,0x49,0x26,0x0E,0x23,
+ 0x18,0x11,0x30,0x28,0x02,0x02,0xA4,0xB3,
+ 0x80,0x0F,0x29,0x00,0x1F,0xAE,0x0C,0x0F,
+ 0x29,0xD8,0x93,0x86,0x07,0x8E,0x1B,0x85,
+ 0x07,0x8D,0x0B,0x30,0x68,0x7A,0xE2,0x80,
+ 0x7F,0x4C,0xF0,0x19,0x05,0x1C,0xE3,0x06,
+ 0xDF,0x2A,0x0C,0xFC,0xFF,0x3F,0x30,0xCC,
+ 0xE1,0xC2,0x63,0x39,0x8A,0xA0,0x07,0x1E,
+ 0xD4,0xF7,0x8C,0x33,0xF7,0x24,0x8F,0xD1,
+ 0x51,0x0F,0x27,0xF4,0xE4,0x85,0x3B,0x57,
+ 0xF9,0x0A,0x71,0x14,0x18,0xB8,0x77,0x29,
+ 0x8F,0xCF,0x17,0x2B,0xC3,0x63,0x46,0xFB,
+ 0x1E,0x72,0xD6,0x11,0x02,0xE2,0x2F,0x75,
+ 0x6C,0xC0,0x60,0x39,0x18,0x00,0x87,0x01,
+ 0xE3,0x13,0x0D,0x58,0x67,0x1B,0x3C,0xF4,
+ 0x69,0x31,0xC4,0xE3,0x0B,0xFB,0x56,0x61,
+ 0x82,0xEA,0x41,0x75,0x12,0xF4,0xD0,0xC0,
+ 0x01,0xE8,0xA1,0xC1,0x3F,0xB9,0x90,0xFB,
+ 0x2B,0x1D,0x82,0xB5,0xE2,0x69,0xDE,0x47,
+ 0x1E,0xF3,0xDC,0xA2,0xBC,0x0D,0x3C,0x07,
+ 0xF0,0xD3,0x82,0x87,0xE3,0x63,0x81,0xC7,
+ 0xE9,0x4B,0x58,0x82,0xF7,0x1A,0x9F,0x6C,
+ 0x1E,0x5C,0x58,0xB2,0x21,0xA0,0x06,0xEB,
+ 0x21,0x60,0xA6,0x9A,0xC0,0x49,0x46,0x80,
+ 0xCA,0x00,0xA1,0x1B,0xCB,0xE9,0x3E,0x8B,
+ 0x84,0x38,0xCD,0x47,0x99,0xC7,0x02,0x8F,
+ 0xF5,0xC1,0xC0,0xFF,0x7F,0xCD,0x23,0xD4,
+ 0x7D,0xCD,0x33,0x7B,0x3A,0xC0,0xAC,0x22,
+ 0xDC,0x7B,0xCE,0x1B,0x86,0xD1,0x9E,0x2D,
+ 0x7C,0xCD,0x78,0xD6,0x34,0x42,0x38,0x76,
+ 0x83,0xF3,0x48,0x8C,0xF0,0x82,0xC0,0x4E,
+ 0x0C,0x0F,0x30,0xC6,0x39,0x79,0xC3,0xFA,
+ 0xC2,0xCB,0x40,0x83,0x19,0xDB,0x97,0x01,
+ 0x36,0x2A,0xDF,0x88,0xC0,0x97,0xFC,0x62,
+ 0x00,0x65,0x16,0xBE,0x9E,0xF8,0xA0,0xC4,
+ 0x2E,0x06,0x2C,0xE5,0xC5,0x00,0x54,0x37,
+ 0x0C,0x5F,0x0C,0xE0,0x5F,0x89,0x5E,0x0C,
+ 0xC0,0x70,0x71,0xF2,0x3D,0xC0,0x1E,0xEE,
+ 0xA3,0x74,0x9C,0xBE,0xFD,0xBD,0x19,0xF8,
+ 0x6C,0xC0,0x60,0x3C,0xC3,0x30,0xC6,0x08,
+ 0xE3,0x51,0x86,0x31,0xC1,0xDC,0xB7,0x03,
+ 0xE8,0x39,0x87,0x81,0x4A,0x78,0x3B,0x80,
+ 0x72,0x0E,0xE8,0xF2,0x68,0x42,0x4F,0x01,
+ 0x4F,0x07,0x3E,0x29,0x1A,0xA2,0xAF,0xB1,
+ 0x0A,0x26,0x50,0xC4,0x07,0x0D,0x3E,0xB5,
+ 0x28,0x3E,0x15,0x78,0x2D,0xCF,0x4E,0xE1,
+ 0xE2,0x9C,0x89,0xA7,0x6A,0x38,0x03,0xBD,
+ 0xE6,0x86,0x63,0xFF,0x7F,0x38,0xFC,0xA9,
+ 0xE0,0x35,0x80,0x1D,0x24,0x3D,0x2D,0x23,
+ 0xC2,0x38,0xA4,0x3C,0x32,0xF8,0xB6,0x18,
+ 0xC7,0x90,0x0F,0x91,0xBE,0x13,0x18,0xF2,
+ 0x21,0xEF,0x79,0xC7,0xC0,0xAF,0x08,0x71,
+ 0x9E,0xB2,0x7C,0x67,0xF0,0x65,0x01,0x7C,
+ 0x91,0x2E,0x0B,0x68,0x68,0x9F,0x64,0x7C,
+ 0x41,0x30,0xEC,0x89,0xB3,0x00,0x77,0x05,
+ 0x50,0x81,0xFA,0xAE,0x00,0xFF,0x42,0xF0,
+ 0xAE,0x00,0x86,0x79,0xF9,0x56,0xC0,0x35,
+ 0x1D,0x4A,0xD0,0x67,0x12,0x5F,0x17,0x70,
+ 0x53,0x64,0xA9,0x8E,0x0A,0xD0,0x53,0x4C,
+ 0x02,0x75,0x47,0xF7,0x51,0x01,0xC6,0x4D,
+ 0xD9,0x07,0x54,0x76,0x5A,0x60,0x67,0x21,
+ 0x76,0x1D,0xC1,0x5D,0x49,0x18,0xCA,0xB3,
+ 0x81,0x2F,0x59,0xFC,0x70,0x00,0x03,0xDC,
+ 0xB3,0x38,0xC4,0x08,0xB1,0xD9,0x81,0xEB,
+ 0x75,0xD2,0x70,0x2F,0x44,0xEC,0xFF,0x7F,
+ 0x32,0x00,0xE3,0x51,0x1B,0x1C,0x27,0x9D,
+ 0xF0,0x91,0x9E,0x59,0xF8,0x49,0x19,0x30,
+ 0x71,0xF2,0x03,0xE3,0xC9,0x1A,0xC6,0x00,
+ 0xB8,0xBC,0x57,0x95,0x81,0xFC,0x43,0x90,
+ 0x20,0x18,0xD4,0x29,0x19,0x38,0x1C,0xC5,
+ 0x70,0xA7,0x64,0x78,0x50,0xF8,0xC3,0x00,
+ 0xE6,0x46,0xE8,0x7B,0x82,0xA1,0xDE,0x93,
+ 0x0E,0xE3,0x91,0xD0,0x04,0x3E,0x2D,0xC3,
+ 0xFA,0xFF,0x9F,0x96,0x81,0xD5,0xB1,0xDD,
+ 0x43,0xF6,0x59,0x01,0x77,0x76,0x80,0x3B,
+ 0x3D,0x7E,0x7A,0x00,0x9C,0x00,0x3D,0x3D,
+ 0x80,0xED,0xBC,0x01,0xF7,0x40,0x80,0x38,
+ 0xFE,0xA3,0x82,0x5F,0x59,0x28,0x1C,0x3F,
+ 0xB6,0xF3,0x63,0x09,0xEE,0x70,0xE0,0x23,
+ 0x83,0x0F,0x90,0xB8,0xA1,0xF8,0x50,0x81,
+ 0x3C,0x0B,0x80,0x62,0xF4,0x6C,0x04,0xEC,
+ 0x06,0xF3,0xD2,0x12,0xE5,0xFF,0xFF,0xDE,
+ 0xC0,0x4E,0x29,0xB8,0x83,0x00,0xF8,0x8E,
+ 0x01,0xE0,0x1D,0x0C,0x97,0x35,0x66,0x94,
+ 0x10,0x18,0x8D,0x19,0x77,0x08,0xE1,0x27,
+ 0x02,0xDC,0x98,0x3D,0x6E,0x8F,0x19,0x77,
+ 0x9C,0xE5,0xA3,0x7A,0xCA,0x08,0xE5,0x03,
+ 0x07,0x3B,0x67,0xBC,0x11,0xF0,0xA1,0x03,
+ 0x8F,0x03,0x0C,0xEE,0x48,0x01,0xC6,0xCB,
+ 0x01,0x1B,0x3B,0xB8,0x83,0x90,0x53,0x20,
+ 0x4B,0x87,0xD1,0xD8,0x71,0xB2,0x81,0x74,
+ 0x8C,0xF1,0x21,0xD7,0x63,0xC7,0x0D,0xD6,
+ 0x63,0xC7,0x1D,0x5F,0xB0,0xFF,0xFF,0xE3,
+ 0x0B,0x18,0xC6,0xC0,0xC5,0x0F,0x03,0x7D,
+ 0xF3,0xF3,0xE8,0x0C,0xEE,0x61,0xFB,0x04,
+ 0x13,0xE3,0xF9,0x25,0xC4,0x23,0xCC,0x8B,
+ 0x4B,0x84,0xA3,0x08,0xF2,0xE6,0x12,0xE7,
+ 0xD5,0x20,0xCC,0x63,0x4B,0x94,0x10,0x11,
+ 0x0E,0x26,0xCE,0x13,0x8C,0x11,0x0E,0x3C,
+ 0x8A,0x21,0x22,0x9C,0x40,0x88,0x93,0x3E,
+ 0xD9,0x20,0xE1,0x63,0x84,0x8D,0xF6,0x04,
+ 0xC3,0xC7,0xC2,0xCF,0x2B,0x1E,0x3C,0x3F,
+ 0xAD,0xF9,0x2E,0xE8,0xC9,0x9C,0xE3,0x43,
+ 0x96,0xA7,0xF6,0x38,0xE9,0xC3,0x2C,0x6E,
+ 0x50,0x0F,0x8E,0xEC,0xAE,0xE3,0xE3,0x35,
+ 0xF6,0x14,0xE4,0x21,0xF0,0x13,0x81,0x2F,
+ 0x88,0x9E,0xAC,0xEF,0x7A,0xEC,0x5E,0x66,
+ 0x8C,0xEA,0xA7,0x80,0x3A,0xA6,0x9C,0xC1,
+ 0x2B,0x04,0xBB,0xE7,0xF9,0x90,0xED,0xBB,
+ 0x24,0x1B,0x05,0xEE,0x90,0xE0,0x33,0x12,
+ 0x3F,0x55,0x78,0x18,0x1E,0x05,0x8C,0x19,
+ 0xBC,0x23,0x1C,0x5A,0x88,0x03,0x7E,0xDF,
+ 0x65,0x43,0x8D,0x71,0x7A,0x3E,0x7F,0xB0,
+ 0x41,0xC0,0x87,0x3A,0x54,0x0F,0xF3,0xA8,
+ 0x5E,0x0A,0x19,0xCE,0xD9,0xC1,0x1D,0x04,
+ 0xF6,0xF8,0xE1,0x41,0xF0,0x9B,0x25,0x1F,
+ 0x04,0x3B,0xDF,0xBC,0xC1,0x19,0xE4,0xFF,
+ 0x7F,0x0C,0xB0,0xCF,0x54,0x3E,0x9A,0x20,
+ 0x8E,0x80,0xE8,0xF3,0x87,0xC7,0xF0,0x26,
+ 0xC7,0x87,0x83,0x3D,0x7A,0xE0,0x4E,0x22,
+ 0x70,0x8F,0x5D,0x07,0xED,0x6B,0x9C,0x2F,
+ 0x5A,0x30,0xEE,0x7B,0xCF,0x22,0xE0,0xC7,
+ 0x78,0x6C,0x01,0xC7,0xA1,0x04,0xDC,0xC1,
+ 0x8E,0x6B,0x1C,0x42,0x51,0x60,0x74,0x28,
+ 0xC1,0xC5,0x00,0x12,0x8C,0x63,0x9C,0xD1,
+ 0xD0,0x97,0x48,0x1F,0xD2,0xE0,0x0C,0x1A,
+ 0xF6,0x3C,0x9F,0x50,0xB8,0x3D,0x01,0x8A,
+ 0x4E,0x28,0x20,0xC3,0x7D,0x06,0xC1,0x9E,
+ 0x10,0xF8,0x19,0x84,0xFD,0xFF,0x0F,0x8E,
+ 0x1E,0xF7,0x7B,0xA3,0x4F,0x8D,0x6C,0xEE,
+ 0x0F,0x01,0x27,0x70,0xEE,0xEC,0xD4,0x8C,
+ 0x3B,0x33,0x60,0xCF,0x1F,0x1E,0x02,0x3F,
+ 0x17,0x78,0xF8,0x1E,0x02,0x7E,0xF0,0x0F,
+ 0xCC,0x06,0x07,0xE3,0x29,0xC2,0xD7,0x0E,
+ 0x0E,0xCE,0x4F,0x03,0x06,0xE7,0xAF,0x50,
+ 0x9F,0xE7,0x19,0x38,0xF6,0xD4,0xEB,0x7B,
+ 0x87,0xE7,0xEB,0x43,0x05,0xFE,0xA6,0xE7,
+ 0x43,0x05,0x38,0x0E,0x0F,0xFC,0xB0,0xC2,
+ 0x86,0xF0,0x28,0x80,0x3F,0xB5,0xF8,0xF8,
+ 0x17,0xE7,0x29,0x82,0xDD,0x46,0xB0,0x87,
+ 0x0B,0xC0,0x51,0xB4,0xB3,0x18,0x2A,0xCC,
+ 0x59,0x8C,0xFC,0xFF,0xCF,0x51,0xA8,0xB3,
+ 0x18,0x3D,0x5C,0x00,0x2E,0x04,0x1F,0x0F,
+ 0x40,0x73,0x10,0x78,0x5C,0xF0,0x85,0xE0,
+ 0x48,0x0E,0xE4,0xE9,0x00,0xF0,0x19,0x4A,
+ 0xC3,0xA1,0x09,0x13,0x03,0x06,0x75,0x3E,
+ 0xF0,0x09,0xC5,0xC7,0x0E,0x7E,0x36,0xF0,
+ 0x8D,0xDC,0x43,0xE5,0xA7,0x66,0x5F,0xF2,
+ 0x11,0xE0,0x02,0x75,0xA0,0x61,0xA0,0x46,
+ 0xE4,0x23,0xD2,0xFF,0xFF,0xB9,0x0D,0x1B,
+ 0x60,0x68,0xF4,0x1C,0x0E,0xE3,0x80,0xEB,
+ 0x73,0x38,0x76,0x40,0x3E,0x87,0xC3,0x3F,
+ 0x47,0xC3,0x1F,0x1B,0x3B,0xDD,0xF3,0x81,
+ 0xC1,0xBA,0x7E,0x63,0x06,0x06,0xB6,0x6F,
+ 0x91,0x07,0x06,0x1C,0x51,0xCF,0xC6,0x57,
+ 0x08,0x0F,0x0C,0x6C,0x80,0x1E,0x18,0xF0,
+ 0x89,0x05,0x21,0x27,0x03,0x43,0x9D,0x32,
+ 0x8C,0x1C,0xF3,0x89,0xC3,0xC3,0xF0,0xA1,
+ 0x22,0xEA,0x33,0xC0,0x23,0x1E,0x1B,0x1B,
+ 0xFB,0xFF,0x8F,0x0D,0x2C,0xC7,0x16,0x8F,
+ 0x0D,0xFC,0x47,0x78,0xFC,0xD8,0xE0,0x8C,
+ 0xE5,0xD1,0xC4,0x97,0x99,0x23,0x3B,0x8D,
+ 0x33,0x7B,0x0D,0xF1,0xD1,0xEE,0xF1,0xDB,
+ 0x63,0x03,0x97,0x85,0xB1,0x01,0xA5,0x90,
+ 0x63,0x43,0x1F,0x52,0x7C,0x0A,0xB0,0x71,
+ 0x54,0x32,0x0F,0x1F,0xAF,0x7C,0x62,0x38,
+ 0xBA,0x20,0x6F,0xE8,0xBE,0x5C,0xF8,0x48,
+ 0x63,0x30,0x5F,0x5A,0x7C,0x06,0xE5,0x43,
+ 0x04,0xD7,0x57,0xC5,0x43,0x04,0x3E,0xA1,
+ 0x86,0x88,0x1E,0xCF,0xFF,0xFF,0x11,0xCC,
+ 0x43,0x64,0x43,0x03,0xAF,0x87,0xA1,0x01,
+ 0xA5,0x98,0xC0,0x5E,0x85,0x87,0x46,0x4F,
+ 0x3F,0x3E,0x04,0x30,0x08,0xDF,0x06,0xD8,
+ 0x55,0xC0,0x57,0x21,0x83,0x24,0x18,0xE7,
+ 0x64,0x41,0x07,0x07,0x8E,0x21,0x79,0x70,
+ 0xF0,0x07,0xE3,0x21,0x70,0x60,0xCF,0xE0,
+ 0xB9,0xE8,0x31,0xD8,0xA7,0x1D,0x9F,0x4A,
+ 0xC0,0x77,0xE6,0x04,0xC7,0xE9,0x1D,0x7B,
+ 0x29,0xF0,0x08,0x1E,0xAD,0x3C,0x02,0x7E,
+ 0xB4,0x02,0x66,0xFF,0xFF,0xA3,0x15,0x30,
+ 0x09,0x7A,0xE6,0xA4,0x03,0x77,0x34,0x18,
+ 0xD4,0xD1,0x0A,0x5C,0x11,0xC0,0x75,0xDC,
+ 0xF0,0xD1,0x02,0xCE,0x50,0x0F,0xDA,0x07,
+ 0x65,0xCF,0xDA,0x97,0x21,0x76,0xB4,0x00,
+ 0x97,0x89,0x43,0x08,0xD0,0x04,0x3E,0x89,
+ 0x67,0xEF,0x43,0x03,0xB3,0x8A,0xA1,0x01,
+ 0xA5,0xA3,0x01,0xEE,0x44,0x81,0xFD,0xFF,
+ 0x9F,0x28,0x60,0xDE,0x30,0x70,0x07,0x0A,
+ 0xC0,0xCD,0xE9,0xDB,0xE3,0xE2,0xD0,0x38,
+ 0xC4,0xE7,0xA7,0x73,0xF6,0xD1,0xE8,0x4C,
+ 0x71,0x67,0x11,0x30,0x9C,0x7D,0x11,0x8F,
+ 0x18,0x03,0xF9,0x81,0x21,0x59,0x30,0x28,
+ 0x16,0x0F,0xC5,0x07,0x03,0x0E,0xEC,0x23,
+ 0x02,0x3B,0x17,0xB0,0x73,0xAD,0xE1,0xF8,
+ 0x59,0xC0,0xA7,0x84,0xB7,0xA6,0x17,0x7B,
+ 0x9F,0xD7,0x7D,0xD6,0x08,0xC9,0xCE,0xF4,
+ 0x3E,0x89,0xE2,0x0E,0xA2,0x70,0x4E,0x9F,
+ 0xE0,0x22,0xF0,0x65,0xDF,0xA3,0xE0,0xA7,
+ 0x07,0xCF,0xF1,0x8D,0xC1,0xA7,0x07,0xE6,
+ 0x7E,0xF8,0x9A,0xF1,0x33,0xC3,0xE3,0x43,
+ 0x88,0x27,0xE2,0xDA,0xA6,0x20,0x5B,0x18,
+ 0x42,0x09,0xF4,0xFF,0x8F,0x10,0xE5,0x6D,
+ 0x20,0xCA,0x29,0x44,0x88,0x12,0xA4,0xB1,
+ 0xC9,0x0B,0x35,0xCA,0xD9,0x45,0x6E,0x6D,
+ 0xF6,0x82,0x0B,0x14,0x2A,0x66,0x9C,0x28,
+ 0xEF,0x10,0xB1,0xDA,0x1F,0x04,0x91,0xF4,
+ 0x32,0xD0,0x71,0xC9,0x91,0x0E,0x7D,0xE8,
+ 0x61,0xFB,0x04,0x8C,0x3F,0x48,0xE2,0xAE,
+ 0x2A,0x3E,0x28,0xF8,0x00,0x80,0x77,0x09,
+ 0xA8,0x5B,0x9D,0xC7,0xED,0xF3,0x06,0xF8,
+ 0xAF,0x17,0x58,0x82,0xF2,0x07,0x81,0x1A,
+ 0x99,0xA1,0x3D,0xCC,0xB7,0x19,0x43,0xBE,
+ 0x07,0x1C,0x16,0x3B,0x27,0xF9,0xF0,0x08,
+ 0x1C,0x8E,0x01,0x4F,0x1B,0xBE,0x51,0x7B,
+ 0xBE,0x3E,0x62,0x01,0x8E,0xFE,0xFF,0x47,
+ 0x2C,0x30,0x9D,0xDF,0x7D,0x82,0x01,0xC7,
+ 0xCD,0x82,0x9F,0x61,0x00,0x67,0x40,0xCF,
+ 0x30,0x60,0x1F,0x2A,0x6E,0x08,0x5C,0xEE,
+ 0x8A,0x28,0x90,0x05,0xC2,0xA0,0x0E,0xFD,
+ 0xE4,0x08,0x42,0xCF,0x9C,0x70,0x86,0x72,
+ 0xB2,0xBD,0x5F,0x1D,0xC8,0x2D,0xC2,0x43,
+ 0x3D,0x8B,0xC7,0x04,0x76,0xDA,0x02,0x36,
+ 0xFF,0xFF,0xE3,0x29,0xB0,0x98,0xF7,0xD3,
+ 0x69,0x84,0x63,0x03,0xFB,0x71,0x0B,0x38,
+ 0x1D,0xCC,0xE0,0xDC,0x7F,0xD8,0x2D,0x1A,
+ 0x37,0x34,0xB0,0x0D,0xCC,0x43,0x03,0x3E,
+ 0x27,0x47,0x30,0x9E,0x98,0xF8,0x55,0xE2,
+ 0xE1,0x89,0x1F,0x43,0xC0,0xFA,0xFF,0x3F,
+ 0x99,0x01,0xF6,0x84,0x1E,0xCB,0x50,0xD2,
+ 0x4E,0x66,0x80,0xC0,0xFB,0xD8,0x3B,0xC3,
+ 0x4B,0x83,0xE7,0x74,0xD2,0xCF,0x62,0x3E,
+ 0x99,0x19,0x21,0x0A,0xBB,0x8F,0x19,0xAD,
+ 0x37,0x14,0xCD,0x3C,0xE8,0x3B,0x99,0x51,
+ 0x62,0x46,0x6A,0x0E,0x4C,0x48,0x11,0x0F,
+ 0x27,0x4A,0x88,0x60,0xAF,0x13,0x6F,0x67,
+ 0x4F,0x66,0x4C,0xD6,0xC9,0x0C,0x24,0xFF,
+ 0xFF,0x93,0x19,0x98,0x5C,0x9F,0xCC,0x80,
+ 0xCA,0x39,0x0A,0x7F,0x32,0x03,0x78,0x74,
+ 0xC0,0xC2,0x9D,0xCC,0xC0,0xF2,0xFF,0x3F,
+ 0xC4,0x00,0xCE,0xC7,0x0A,0x63,0x0C,0x3C,
+ 0xDA,0xC1,0x0C,0x15,0xE6,0x6C,0x86,0x0E,
+ 0x72,0x08,0xA1,0xC1,0x0E,0x21,0x50,0xE6,
+ 0x72,0xA0,0xA7,0xF0,0x9A,0xE0,0x73,0x14,
+ 0xD8,0x0F,0x67,0xC0,0xE1,0xD4,0x80,0x0F,
+ 0x74,0xE2,0x42,0x8F,0xC2,0x23,0x0E,0x58,
+ 0xFD,0xC0,0xC8,0xFF,0xFF,0x64,0x06,0x18,
+ 0x78,0x6A,0xF8,0x40,0x82,0x63,0x31,0xEA,
+ 0x1B,0xC4,0x21,0xBE,0x8D,0xF8,0xE8,0xFE,
+ 0x6A,0xE2,0x4B,0x00,0xE6,0x42,0xE2,0xD3,
+ 0x09,0xB3,0x70,0x38,0x03,0x5A,0x43,0x60,
+ 0x57,0x26,0xCF,0x9C,0x0F,0xE1,0x6C,0x3C,
+ 0x7A,0xDC,0xE9,0x04,0xDE,0x38,0x7C,0x3A,
+ 0x01,0x5E,0x07,0x0C,0xCC,0x0C,0xC2,0x3F,
+ 0x84,0xB0,0x21,0x9C,0xAA,0xC7,0x70,0xEE,
+ 0xAF,0x38,0x3E,0x9D,0x80,0xF3,0xFF,0x7F,
+ 0x62,0x03,0x0C,0x0A,0x7E,0x32,0xF8,0xB8,
+ 0x46,0x25,0xC2,0xA0,0x8E,0xE6,0x80,0x7B,
+ 0x98,0x27,0x36,0x26,0x6F,0xC5,0x1A,0x8B,
+ 0x4F,0x6C,0x30,0xFF,0xFF,0x27,0x36,0x80,
+ 0xD1,0x87,0x20,0xB0,0xFD,0xFF,0x0F,0x41,
+ 0x60,0x1C,0xA0,0x0F,0x41,0x80,0x9B,0xD3,
+ 0x09,0xEE,0xC4,0x07,0xB6,0x63,0x10,0x60,
+ 0x6D,0xE8,0x3E,0x06,0x81,0xF9,0xFF,0x3F,
+ 0x5A,0x98,0xA3,0xE0,0xC2,0x8E,0x7C,0x28,
+ 0x29,0xA7,0x3E,0xB4,0x0C,0x20,0x69,0x38,
+ 0xC9,0x01,0x9D,0xD3,0x3D,0x70,0x92,0x75,
+ 0xEA,0x40,0x8F,0xC7,0xA0,0xAF,0x1C,0xBE,
+ 0x12,0xF0,0x23,0x07,0x93,0x00,0xAA,0x41,
+ 0xFA,0xCC,0x07,0x9C,0x8E,0x1C,0xE0,0x38,
+ 0x26,0x05,0xC6,0xDE,0x0E,0xDE,0x22,0x3D,
+ 0x89,0xA7,0xA1,0xE3,0x0C,0x51,0x38,0x26,
+ 0x39,0x18,0x44,0x7A,0x95,0x62,0x03,0x7C,
+ 0xAB,0xF1,0xD9,0xC8,0x07,0x10,0x78,0xE3,
+ 0xF6,0xD8,0x61,0xFF,0xFF,0x0F,0x75,0xC0,
+ 0x01,0xE2,0xA4,0xF8,0x21,0xC3,0x98,0x67,
+ 0xC5,0x0F,0x75,0x80,0xF5,0x18,0x27,0x3A,
+ 0x94,0xF0,0x43,0x1D,0x20,0xE8,0xFF,0x7F,
+ 0xA8,0x03,0x86,0x38,0x6F,0x24,0xD1,0x1E,
+ 0xEA,0x98,0xE8,0x43,0x1D,0x40,0xC8,0xFF,
+ 0xFF,0xA1,0x0E,0x18,0x9E,0x87,0x00,0xAE,
+ 0x9C,0xEF,0xC0,0x7C,0x22,0x02,0xEF,0xFF,
+ 0xFF,0x7C,0x07,0xB8,0x1B,0x2D,0xCC,0x51,
+ 0x70,0x41,0xAF,0x0E,0x03,0x51,0x09,0x30,
+ 0x28,0x02,0xC7,0x5F,0x9B,0x60,0x1C,0xEA,
+ 0x7C,0x87,0x3E,0x2F,0x78,0xD8,0x4F,0x05,
+ 0x9E,0xC4,0xA9,0xFA,0x5A,0x70,0x14,0x4F,
+ 0x00,0x3E,0xE1,0x01,0xFF,0xA1,0xC1,0x9A,
+ 0x44,0xF1,0x43,0x03,0xF5,0x11,0xE4,0xFF,
+ 0x7F,0x68,0xC0,0x28,0xEA,0xF9,0x06,0x7D,
+ 0xCC,0xF2,0xD9,0x20,0xE6,0x0B,0x48,0x84,
+ 0x07,0x10,0x5F,0x1F,0xD8,0x71,0xD2,0x67,
+ 0xA0,0x40,0x51,0xDE,0x37,0xF8,0x09,0x07,
+ 0x5C,0x83,0xF3,0x09,0x07,0xBC,0x87,0x23,
+ 0x1F,0x4B,0xC0,0x77,0xD0,0x84,0x73,0x81,
+ 0xF1,0x8D,0x8D,0x9D,0x06,0xC0,0x76,0x00,
+ 0x06,0xDF,0x69,0x00,0x1C,0xC7,0x24,0x7E,
+ 0x3A,0x04,0x13,0xCC,0xC1,0xBC,0x34,0xFB,
+ 0xFF,0xEF,0xFD,0x94,0x43,0xCF,0x86,0x80,
+ 0x75,0x49,0x07,0x43,0x94,0x88,0xB3,0x21,
+ 0x20,0xFD,0xFF,0x7F,0x36,0xC4,0x20,0xC4,
+ 0x09,0xFC,0x12,0xD1,0xDC,0xD9,0x90,0xAE,
+ 0xD8,0x67,0x43,0x80,0xE1,0xFF,0xFF,0x23,
+ 0x00,0xF6,0x7C,0x04,0x38,0x3D,0x64,0x83,
+ 0xE7,0x14,0x08,0xE3,0xE4,0x03,0x38,0xFE,
+ 0xFF,0x8F,0x15,0xE6,0x18,0x78,0xEA,0x97,
+ 0x9B,0x8F,0x03,0x54,0xD4,0x2B,0xC2,0x30,
+ 0x94,0xC5,0x87,0x05,0x1F,0x11,0xF8,0x61,
+ 0xC1,0x23,0xA8,0x78,0x9C,0xF4,0x74,0xE3,
+ 0x33,0x21,0x3B,0x24,0x38,0xFC,0x20,0xE9,
+ 0x41,0x13,0x3C,0xE7,0x23,0x78,0xB7,0x1E,
+ 0x38,0xA7,0x02,0xC0,0x4D,0xAE,0x27,0xA3,
+ 0x4E,0x17,0x0E,0x70,0x8E,0x92,0x8D,0x63,
+ 0x08,0xE5,0x70,0xCC,0xB7,0x87,0xA6,0xC9,
+ 0x4E,0x56,0x30,0x63,0x41,0xEA,0x24,0xE0,
+ 0x01,0x38,0x10,0x8C,0xB4,0x93,0x68,0x34,
+ 0x86,0xB3,0x5A,0x18,0xC1,0x19,0xC4,0xC7,
+ 0x11,0xE7,0x3A,0x19,0xA1,0x3F,0x07,0x3E,
+ 0x15,0x61,0x82,0xDC,0x4B,0xE8,0xBC,0x7D,
+ 0x37,0xE0,0x57,0x61,0x8F,0xC5,0xFF,0x7F,
+ 0x60,0xDF,0x4E,0xC0,0x31,0x17,0xAB,0x01,
+ 0x45,0x0D,0xC0,0x68,0x98,0x53,0xC0,0x53,
+ 0x09,0xB8,0x82,0xCD,0x0D,0x7D,0x61,0xB1,
+ 0xD6,0xA9,0xE8,0x14,0xF4,0x3E,0x70,0x70,
+ 0xC0,0x63,0xF6,0x1E,0x1C,0x2C,0x34,0x0F,
+ 0x0E,0x6C,0xD9,0x06,0x87,0x56,0x72,0x17,
+ 0x21,0x87,0x0F,0xFC,0xEC,0x80,0x03,0xA0,
+ 0x67,0x07,0x0B,0xC9,0xB3,0x03,0x9B,0xBE,
+ 0xB3,0x08,0x28,0x70,0xFE,0xFF,0x11,0xDE,
+ 0x3B,0x7C,0x6E,0x79,0xF6,0x60,0x63,0x78,
+ 0x74,0x31,0x9A,0xD1,0xB9,0xA6,0xDB,0x04,
+ 0x4A,0xC5,0x6D,0x82,0x82,0xF8,0x06,0xE0,
+ 0x84,0x34,0xBA,0x75,0xE2,0x66,0x62,0xFC,
+ 0x47,0x0C,0x1F,0x11,0x0E,0xE9,0x6C,0x4D,
+ 0x30,0x0F,0xA4,0x9E,0x81,0xBE,0xB3,0xE1,
+ 0x67,0x1F,0xF2,0xC1,0xC5,0xD3,0xF0,0xF5,
+ 0x86,0xDC,0x3B,0xE8,0xB4,0x7D,0x66,0xC0,
+ 0x1C,0x74,0x7D,0x9D,0x7A,0x83,0x27,0x57,
+ 0x09,0xEA,0xE1,0x02,0x42,0x2F,0x34,0xBE,
+ 0xDC,0x25,0x78,0xE0,0xF4,0xE9,0xEE,0xBD,
+ 0x84,0x9D,0xF1,0x12,0xBC,0xE0,0x25,0x98,
+ 0x77,0x10,0xA8,0x51,0x79,0x10,0x98,0xAB,
+ 0x3C,0xCB,0x37,0x06,0x54,0xB2,0x8B,0x16,
+ 0x3D,0xC3,0xBC,0xC3,0xF8,0x92,0xE0,0xEB,
+ 0x87,0xCF,0x2D,0x5E,0xC0,0xEB,0x16,0x0C,
+ 0x82,0x67,0xA0,0x57,0x17,0xDF,0xD9,0x0D,
+ 0xFC,0x2A,0xF0,0x46,0x13,0x22,0x98,0x61,
+ 0x0F,0xFF,0xDD,0xDD,0xA8,0xBE,0xE9,0x18,
+ 0xEB,0x75,0xC4,0x23,0xE5,0xC7,0x96,0x03,
+ 0x8A,0xF4,0xF2,0xE6,0x09,0xF8,0x2C,0xE3,
+ 0x53,0xDD,0x49,0xF9,0x7A,0x68,0xF4,0x57,
+ 0x08,0x1F,0x7E,0x8C,0xEC,0x73,0x0E,0x3B,
+ 0xDF,0xB1,0x41,0x71,0xC4,0x07,0x86,0x97,
+ 0x1A,0x4F,0x85,0x9D,0xBB,0x60,0x1C,0x1C,
+ 0xD8,0xB1,0x08,0x73,0x7C,0x05,0xD7,0xC9,
+ 0xE6,0xFF,0xFF,0xE4,0x00,0x6E,0x78,0xCC,
+ 0xC1,0xD7,0xE7,0x0D,0xDF,0x0C,0x3C,0x2E,
+ 0x7E,0xE4,0xF0,0x49,0xE3,0xA5,0xD3,0xD8,
+ 0xA7,0xE9,0xA3,0xD1,0xCB,0x9B,0x4F,0x2F,
+ 0x18,0x58,0x5F,0x1A,0x38,0xAC,0xD1,0xC2,
+ 0x3E,0x06,0x9C,0xB9,0x2F,0x44,0xB8,0xC3,
+ 0x23,0x58,0x00,0xF1,0xB7,0x92,0x47,0x0E,
+ 0x4F,0xC0,0x80,0x4C,0xD3,0xBA,0x74,0x20,
+ 0xE2,0xA7,0x3C,0x2B,0x5F,0x99,0x2E,0x43,
+ 0x0C,0xE3,0xA9,0xF2,0xF1,0xC3,0xB3,0xF1,
+ 0x51,0xC0,0xC7,0x28,0xCF,0xFC,0x8C,0x22,
+ 0xBD,0x32,0x10,0x50,0x9D,0x88,0xB8,0x42,
+ 0x18,0x89,0xA1,0xD1,0x9D,0x83,0xC7,0x1F,
+ 0x22,0x05,0x31,0xA0,0x6F,0x2E,0xC0,0xF4,
+ 0x4C,0x04,0x5C,0xFE,0xFF,0x37,0x17,0x80,
+ 0xFF,0xFF,0xFF,0x9B,0x0B,0xE0,0xE6,0xFE,
+ 0xE0,0x9B,0x0B,0x70,0x8D,0xB4,0x2A,0x7A,
+ 0x61,0x77,0x08,0x18,0xD4,0x9D,0x1D,0x70,
+ 0x78,0x2B,0x78,0x67,0x87,0xF5,0xFF,0xBF,
+ 0xB3,0xC3,0xC3,0x8C,0x13,0xE5,0x85,0x21,
+ 0xC6,0x3B,0x3B,0x0B,0xF0,0x26,0xD0,0x51,
+ 0xC6,0x77,0x76,0x80,0x1F,0x67,0xD8,0x77,
+ 0x69,0xF0,0x5E,0x75,0x81,0xF5,0xFF,0xFF,
+ 0xAA,0x0B,0x3C,0x04,0xDF,0xA7,0x41,0x3E,
+ 0x5E,0x30,0x8C,0x83,0x2B,0x27,0xA1,0xC7,
+ 0x02,0x6B,0x85,0x41,0xDD,0xA9,0xC1,0xA5,
+ 0x09,0x5C,0x17,0x5F,0x1F,0x6A,0x7C,0xA4,
+ 0xC5,0x9F,0x2F,0x70,0x01,0x86,0x4C,0x4F,
+ 0x65,0x30,0xAE,0x29,0x3E,0x95,0x61,0xEE,
+ 0x0E,0x1E,0x90,0x8F,0x18,0xC0,0x67,0x15,
+ 0x1E,0x18,0xEE,0xB4,0xE0,0x9B,0x92,0x41,
+ 0xCF,0x31,0xA8,0x8F,0x3C,0x27,0xEF,0x7B,
+ 0xC2,0xE3,0x84,0xA3,0x9E,0x83,0xE8,0xD8,
+ 0xC0,0x71,0xDC,0xC0,0xFD,0xFF,0xC7,0x06,
+ 0xEF,0x70,0x83,0x3B,0xE8,0xF8,0x62,0x70,
+ 0x5C,0x18,0xB8,0xE7,0x02,0x0F,0xC3,0x37,
+ 0x1D,0x8F,0x08,0x33,0xFE,0xD7,0x3F,0x23,
+ 0x04,0xC4,0x5F,0x8C,0xD8,0x80,0xC1,0x78,
+ 0x6B,0xF3,0xF5,0x0D,0x37,0x60,0x5F,0x1D,
+ 0x7C,0xC1,0xF0,0x09,0xCC,0xE8,0x2F,0x30,
+ 0x4F,0x62,0x3E,0x36,0x90,0x0B,0x1C,0x1D,
+ 0x30,0x38,0x00,0x3D,0x60,0xF8,0x87,0x8B,
+ 0x77,0x39,0x30,0x5C,0x05,0x7D,0x5C,0xF0,
+ 0xB1,0xC7,0x8A,0xEE,0x72,0xE8,0x9B,0x9C,
+ 0x61,0xE2,0x18,0xE2,0x0D,0x8C,0xDD,0x25,
+ 0xC8,0x61,0x0E,0xEA,0x5D,0xC2,0x73,0xE0,
+ 0x67,0x0B,0x9F,0xE0,0x7C,0xF3,0x09,0x71,
+ 0xAA,0x8F,0x56,0xEF,0x01,0x3E,0x7A,0xBC,
+ 0x77,0xF9,0xEC,0xC4,0x2E,0x02,0x3E,0x72,
+ 0x19,0xC7,0xD3,0xF4,0x15,0xD0,0x43,0x36,
+ 0xD8,0xAB,0x86,0x4F,0x60,0x3E,0xBA,0xE1,
+ 0x8E,0x51,0x9E,0x89,0xA7,0xEF,0x3B,0x08,
+ 0x3B,0x92,0x1C,0x75,0xA8,0x6B,0x7A,0x44,
+ 0xF9,0xFF,0x9F,0xD0,0x81,0xF8,0xD6,0x06,
+ 0xCE,0x68,0xF7,0x0F,0xF4,0x36,0x3D,0x32,
+ 0xCC,0xD1,0x00,0xD6,0x25,0x04,0x5C,0x77,
+ 0x0C,0x5F,0x42,0x80,0x4F,0xD0,0x4B,0x04,
+ 0xFA,0x9A,0xE1,0xD1,0x3D,0x02,0x60,0xAE,
+ 0x18,0xEC,0x58,0xE0,0xC3,0x86,0xAF,0x01,
+ 0xEC,0x5E,0xE0,0x30,0xF7,0x08,0x50,0x81,
+ 0x7A,0x78,0xF0,0xD5,0xDE,0x23,0x40,0x71,
+ 0xB2,0xF4,0xA1,0xC1,0x03,0xB5,0xAA,0x33,
+ 0x26,0x94,0x23,0x26,0x3F,0x9B,0xF9,0x26,
+ 0x81,0xB9,0x5D,0xFA,0x26,0x01,0x37,0xCF,
+ 0x2C,0x50,0x49,0x20,0xF4,0xFF,0xBF,0x49,
+ 0xC0,0x85,0xE9,0xF2,0x32,0x43,0xE7,0x7F,
+ 0xE0,0xBE,0xD5,0x79,0x84,0x3E,0x44,0x30,
+ 0x94,0xF7,0x3C,0x9F,0xC2,0xF8,0x19,0xC2,
+ 0x07,0x4C,0x76,0xA6,0xE0,0x67,0x4D,0xDC,
+ 0x1D,0xC0,0x28,0x6F,0x9E,0x9E,0x00,0x3B,
+ 0x7F,0x1A,0xF9,0xDD,0xE0,0x5D,0xC0,0xD3,
+ 0xF7,0xBD,0x88,0x9F,0x28,0xC0,0x17,0xEC,
+ 0x4E,0x07,0x05,0xFA,0x84,0x3C,0x22,0xA3,
+ 0xFA,0x88,0xC0,0x2F,0x49,0x60,0x3C,0x92,
+ 0xF8,0x40,0x01,0x84,0xEE,0x05,0xA8,0xD3,
+ 0x07,0x47,0x3D,0xE3,0x17,0x54,0x63,0xBE,
+ 0x5B,0x3D,0xC2,0x79,0x72,0x98,0xCB,0x01,
+ 0x8B,0x73,0x4D,0x02,0xD5,0x71,0x97,0x8F,
+ 0x0E,0xEE,0xB5,0x15,0xFB,0xFF,0x27,0x38,
+ 0xB8,0x77,0x96,0x77,0x3E,0x43,0x79,0x90,
+ 0xE0,0xBB,0xB6,0x82,0xE3,0xAA,0x06,0xE3,
+ 0xD8,0xC2,0x2F,0x79,0x80,0x9D,0x61,0x71,
+ 0xC1,0x7F,0x0F,0x03,0x51,0x89,0x30,0x28,
+ 0x02,0xCB,0xBB,0xB7,0x52,0xF8,0x43,0x06,
+ 0xE3,0x4D,0x81,0x4F,0x1A,0x3B,0x6A,0xE0,
+ 0xFB,0xFF,0x1F,0x35,0xD8,0x86,0x8A,0xBB,
+ 0x29,0x82,0x75,0xAA,0x98,0x21,0xF0,0x60,
+ 0x0F,0x00,0x9F,0xAF,0x7C,0x06,0x50,0x14,
+ 0x18,0xD4,0xA1,0x1D,0xCE,0x6D,0x18,0x70,
+ 0x30,0x62,0xDC,0xA5,0x10,0xEE,0x94,0xDF,
+ 0x51,0x62,0x3F,0x97,0xB3,0xE9,0xE2,0xAE,
+ 0xE6,0x3E,0x9D,0xB0,0x0B,0x32,0x8C,0xB3,
+ 0xC0,0x23,0xC0,0xAB,0x39,0xBF,0x20,0x3F,
+ 0x17,0xBF,0x10,0x3C,0x26,0x85,0x78,0x53,
+ 0x7A,0x25,0x36,0xC6,0x93,0x71,0x73,0xB7,
+ 0x62,0x72,0xDE,0x79,0x41,0x36,0xC6,0xD1,
+ 0x44,0x8C,0x72,0x6E,0x0F,0x03,0x91,0x5F,
+ 0x90,0x7D,0x3F,0x79,0x21,0x88,0x18,0xCD,
+ 0x10,0x41,0x9F,0x97,0x8D,0x15,0x28,0xDE,
+ 0x0B,0x32,0x13,0xF8,0x56,0xD0,0xC1,0xC5,
+ 0x17,0x64,0xEC,0xFF,0xFF,0x82,0x0C,0x30,
+ 0xE2,0x64,0x04,0xF8,0x3C,0x71,0xE0,0xCE,
+ 0x35,0x30,0xFE,0xFF,0x97,0x6A,0xD8,0x27,
+ 0x1B,0xC0,0xD9,0xD0,0x7D,0xB2,0x01,0xF7,
+ 0x68,0xE1,0x1D,0x4D,0x10,0x27,0x1B,0x0A,
+ 0xE4,0xE0,0xEB,0xA2,0x70,0x3C,0xF4,0x49,
+ 0x84,0x1E,0x9D,0x7C,0x94,0xC4,0x9D,0x19,
+ 0x3C,0x91,0x77,0x16,0x8F,0xE2,0x65,0xD0,
+ 0xF7,0x82,0x13,0x79,0x7D,0xB0,0x9C,0x63,
+ 0x24,0xA8,0x46,0xE2,0xE3,0x03,0xFC,0xEB,
+ 0x8B,0x8F,0x91,0xF0,0xF9,0xFC,0xC3,0xF2,
+ 0x60,0x0C,0xF9,0xFF,0x7F,0x8A,0xC4,0x80,
+ 0x3C,0xBB,0x3C,0x86,0xF0,0x0B,0x24,0xDC,
+ 0xD3,0xCC,0x01,0x60,0x64,0x5D,0x1E,0xD1,
+ 0x67,0x47,0x8E,0x11,0xD7,0x17,0x45,0x5F,
+ 0x81,0x7D,0x10,0x38,0x9F,0xE7,0x44,0xB0,
+ 0x8E,0x9A,0x1F,0x6D,0xF8,0xF8,0x39,0xF8,
+ 0x5B,0xC1,0x03,0xA5,0x8F,0x45,0x21,0x1E,
+ 0x91,0xF8,0x39,0x11,0x5C,0x26,0xCE,0x89,
+ 0x40,0xE2,0xD0,0x0B,0xE3,0xB4,0x80,0x1B,
+ 0x88,0xCF,0x94,0xD8,0x29,0x9F,0x08,0x3B,
+ 0x97,0x60,0x46,0x07,0xAE,0xCB,0xBD,0x47,
+ 0x07,0xFE,0x93,0x00,0x1E,0xEB,0xFF,0xFF,
+ 0x78,0x07,0xBE,0x93,0xBA,0xEF,0x26,0xBE,
+ 0xC8,0xF8,0x50,0xF4,0x7C,0x07,0xF8,0x0F,
+ 0x77,0xB8,0x43,0xC5,0x39,0xDF,0x01,0xD2,
+ 0xFE,0xFF,0xE7,0x3B,0x60,0x79,0xB6,0x7E,
+ 0xBE,0x03,0xBB,0xC8,0xF3,0x1D,0x40,0xAC,
+ 0xFF,0xFF,0xF9,0x0E,0xB0,0x73,0x46,0xC3,
+ 0x9D,0xEF,0xC0,0x76,0xB4,0x01,0xCC,0x4D,
+ 0xE3,0xD1,0x06,0xDC,0xC3,0x85,0x3D,0x0C,
+ 0xAE,0xD0,0xA6,0x4F,0x8D,0x46,0xAD,0x1A,
+ 0x94,0xA9,0x51,0xE6,0xFF,0xDF,0xA0,0x56,
+ 0x9F,0x4A,0x8D,0x19,0xCB,0x0E,0xA5,0x80,
+ 0x8F,0x0A,0x8D,0xCD,0xF2,0x28,0x04,0x62,
+ 0x31,0xAF,0x06,0x81,0x38,0x2C,0x08,0x8D,
+ 0xF4,0xCA,0x11,0x88,0x25,0x3F,0xFB,0x05,
+ 0x62,0xB9,0x6F,0x06,0x81,0x38,0xE0,0x1B,
+ 0x4C,0xE0,0xE4,0x61,0x25,0x70,0xF2,0x6E,
+ 0x10,0x88,0x23,0x83,0x50,0xA1,0x3A,0x40,
+ 0x58,0x4C,0x10,0x1A,0xCA,0x07,0x08,0x93,
+ 0xFE,0x48,0x10,0x20,0x31,0x02,0xC2,0xC2,
+ 0xBD,0xBF,0x04,0x62,0x69,0xEF,0x09,0x81,
+ 0x58,0x88,0x15,0x10,0x16,0x17,0x84,0x86,
+ 0xD3,0x02,0xC2,0x24,0x99,0x01,0x61,0x81,
+ 0x40,0xA8,0x7C,0x35,0x20,0x4C,0xA4,0x1B,
+ 0x40,0xBA,0x7A,0x81,0x38,0x88,0x1E,0x10,
+ 0x26,0xC3,0x0F,0x08,0x0B,0x0D,0x42,0xA3,
+ 0x3D,0x30,0x04,0x48,0x0C,0x81,0xB0,0xF8,
+ 0x8E,0x40,0x98,0xF8,0x57,0x91,0x40,0x9C,
+ 0xDF,0x12,0xC4,0x4D,0x69,0x88,0x35,0x01,
+ 0x31,0x0D,0x9E,0x80,0x98,0x22,0x10,0x01,
+ 0x39,0xF6,0xD3,0x43,0x40,0xD6,0x60,0x0A,
+ 0x88,0x45,0x07,0x11,0x90,0x85,0xA8,0x02,
+ 0x62,0x79,0x5D,0x01,0xB1,0xF0,0x20,0x02,
+ 0x72,0xE6,0x97,0x9F,0x80,0xAC,0xE0,0xA5,
+ 0xF3,0x10,0xC0,0xDE,0x10,0x81,0x48,0x72,
+ 0x10,0x01,0x39,0xB0,0x2F,0x20,0x16,0x1F,
+ 0x44,0x40,0xCE,0xFA,0x28,0x14,0x90,0x83,
+ 0x83,0x68,0x10,0xE4,0x6B,0x26,0x20,0xA7,
+ 0x07,0x11,0x10,0xF9,0x04,0x05,0x21,0x6A,
+ 0xBD,0x81,0x30,0x3D,0x8F,0x42,0x0D,0x85,
+ 0x80,0x50,0xE5,0xEA,0xCE,0x31,0x2C,0x07,
+ 0x08,0xCD,0x05,0x22,0x30,0xAB,0x70,0x07,
+ 0xC4,0x54,0x81,0x08,0xC8,0x09,0x80,0xC8,
+ 0xFF,0x9F,0x60,0x2A,0x10,0x9A,0x12,0x8C,
+ 0xEA,0x92,0x07,0xC4,0x12,0x80,0xD0,0x54,
+ 0x20,0x34,0x25,0x88,0x00,0xAD,0xCA,0x1E,
+ 0x10,0x53,0x0A,0x42,0x95,0x83,0xD0,0x74,
+ 0x20,0x54,0xB6,0xBE,0xC3,0x02,0x05,0x11,
+ 0x90,0xA3,0x83,0x50,0xE1,0xFE,0x40,0x98,
+ 0xDE,0x97,0x86,0x00,0x9D,0x0E,0x44,0x40,
+ 0x4E,0x0C,0x42,0x15,0x7C,0x32,0x82,0x10,
+ 0xB1,0x20,0x54,0xC1,0x27,0x23,0x28,0xD1,
+ 0xF2,0xB2,0x13,0x90,0xF5,0x81,0x50,0xBD,
+ 0x20,0x02,0x73,0x36,0x20,0x9A,0x17,0x84,
+ 0xE6,0x07,0xA3,0x5A,0x8D,0x02,0x31,0xFD,
+ 0x20,0x34,0x0F,0x88,0xC0,0xAC,0xE0,0xF9,
+ 0x71,0xC0,0x0C,0x84,0xAA,0x04,0x11,0x98,
+ 0x73,0x01,0xD1,0xAC,0x20,0x34,0x3B,0x18,
+ 0xD5,0xFE,0x0F,0xD1,0x00,0x08,0x08,0xCD,
+ 0x07,0xA2,0xC3,0x00,0x79,0x96,0x09,0xC8,
+ 0x1A,0x41,0xA8,0x66,0x10,0x81,0x39,0x27,
+ 0x10,0xCD,0x0E,0x42,0x95,0xFD,0x4D,0x82,
+ 0x91,0x8C,0x0F,0xD0,0x40,0x24,0x37,0x08,
+ 0xD5,0xF1,0x0C,0x0A,0x46,0x74,0x83,0x08,
+ 0xC8,0x59,0x40,0x68,0x36,0x30,0x9A,0x4C,
+ 0xED,0x91,0x80,0xBA,0x05,0x61,0xE9,0x41,
+ 0x68,0x3A,0xBB,0x83,0xA7,0x20,0x54,0x81,
+ 0x5E,0x30,0xA6,0x19,0x44,0x87,0x05,0x02,
+ 0x42,0x73,0x81,0x51,0x1D,0xAF,0x96,0x40,
+ 0x44,0x1B,0x08,0xD5,0x0A,0xA2,0x81,0x93,
+ 0x1F,0x53,0x10,0x92,0x14,0x84,0xFC,0xFF,
+ 0x07,0xAA,0xC7,0x9C,0x40,0xAC,0xFA,0x5B,
+ 0x25,0x50,0x27,0x01,0xA1,0xC9,0x40,0x74,
+ 0x7C,0x20,0x0F,0xB8,0x83,0x64,0x20,0x54,
+ 0x29,0x88,0xC0,0xAC,0xF4,0x63,0xA4,0x23,
+ 0x05,0x51,0x7D,0xBC,0xA0,0x20,0x34,0xD1,
+ 0x3B,0x2C,0x08,0x7B,0xB8,0x69,0xA8,0xE4,
+ 0x59,0xA5,0xA1,0x12,0x10,0x9A,0x0D,0x44,
+ 0xC7,0x04,0xF2,0xAA,0x79,0x4C,0x60,0x20,
+ 0x54,0x2F,0x08,0xCD,0x01,0x42,0x13,0x83,
+ 0x08,0xD4,0xA9,0xBF,0x37,0x1A,0x2A,0xF9,
+ 0x5B,0x09,0xC4,0xCA,0x5E,0x69,0x02,0xB1,
+ 0xDE,0xA7,0x4E,0x20,0xE6,0x1D,0x98,0xA9,
+ 0x05,0xA1,0xEA,0x41,0x04,0xE6,0xB4,0x40,
+ 0x54,0x81,0x78,0x10,0xA6,0x08,0x44,0x60,
+ 0x4E,0x02,0x44,0xD3,0x81,0xD0,0xEC,0x60,
+ 0x54,0xE7,0xA3,0x4D,0x40,0xD6,0x0E,0x42,
+ 0xB3,0x80,0x08,0xCC,0x59,0x1E,0x69,0x02,
+ 0xB1,0x92,0x2F,0x9D,0x0E,0x24,0x04,0x84,
+ 0x26,0xD3,0x7F,0x68,0xA1,0x05,0x80,0x99,
+ 0x84,0x04,0x20,0x4C,0x16,0x88,0x0E,0x27,
+ 0xD6,0x08,0x22,0x40,0xC7,0x01,0xA3,0xD1,
+ 0x40,0x68,0x5C,0x40,0x9A,0x1D,0x90,0x2A,
+ 0x6D,0x00,0xC6,0x54,0x83,0xD0,0x24,0x20,
+ 0x02,0x74,0x2C,0x10,0x01,0x5A,0x74,0x04,
+ 0x30,0x16,0x01,0x84,0x46,0x05,0xA1,0xC9,
+ 0x2A,0x80,0xB2,0x9C,0x20,0x1A,0x20,0xC9,
+ 0x30,0x60,0x0A,0x42,0x33,0x81,0xD0,0x8C,
+ 0x20,0x54,0x7C,0x07,0x10,0x16,0x04,0x84,
+ 0x86,0x03,0xD1,0x00,0xFE,0xFF,0x8F,0x0C,
+ 0x02,0xD1,0x00,0x9C,0x23,0xC4,0x61,0x85,
+ 0x82,0xD0,0xF4,0x20,0x34,0x6C,0x09,0x50,
+ 0x16,0x1D,0x44,0xC7,0x23,0x92,0x02,0x8C,
+ 0x05,0x02,0xA1,0x31,0x41,0x68,0x6C,0x10,
+ 0x1A,0x29,0x06,0x28,0x13,0x54,0xE3,0x50,
+ 0x44,0x7B,0x80,0x31,0x99,0x20,0x54,0x36,
+ 0x88,0xC0,0x1C,0x14,0x88,0x86,0x07,0xA1,
+ 0x62,0x82,0x00,0x52,0x10,0x01,0x12,0x20,
+ 0x1A,0x1E,0x84,0x8A,0x29,0x32,0x74,0x0A,
+ 0x42,0x55,0x24,0x39,0x9A,0x50,0x10,0x1D,
+ 0x4D,0x08,0x08,0xCD,0x07,0x46,0x75,0x35,
+ 0x39,0x6E,0x50,0x10,0xAA,0x1D,0x84,0x06,
+ 0x05,0xA1,0x39,0xA2,0x80,0xB2,0xEC,0x20,
+ 0x02,0xB2,0x9E,0x2A,0x87,0x0A,0x0A,0x22,
+ 0x30,0xA7,0x02,0xA2,0x49,0x41,0xA8,0x8E,
+ 0x2C,0x47,0x0A,0x9A,0x06,0x84,0x25,0x06,
+ 0xA1,0xC9,0xDA,0x80,0xB0,0x0C,0x75,0x0E,
+ 0x24,0x14,0x84,0xE6,0x04,0xA1,0x4A,0xF2,
+ 0x0C,0x8F,0x82,0xE8,0x38,0x42,0x80,0x68,
+ 0x7A,0x10,0xAA,0xA6,0xCF,0x00,0x28,0x88,
+ 0x06,0x40,0x40,0x68,0x4E,0x30,0xAA,0xA8,
+ 0xD1,0xD1,0x84,0x82,0x50,0xDD,0x2F,0x4E,
+ 0x81,0xF8,0xFF,0x0F,
+ }) // END MBUF
+
+} //end DefinitionBlock
+