From 69fdad5b24646a8c32606076333c35e101d3ffd6 Mon Sep 17 00:00:00 2001 From: Al Stone Date: Aug 08 2018 15:20:02 +0000 Subject: Start adding in CI tests with some basic smoke tests Signed-off-by: Al Stone --- diff --git a/tests/.gitignore b/tests/.gitignore new file mode 100644 index 0000000..5dc7c63 --- /dev/null +++ b/tests/.gitignore @@ -0,0 +1,2 @@ +tests.retry +artifacts diff --git a/tests/badcode/.gitignore b/tests/badcode/.gitignore new file mode 100644 index 0000000..3bb3fb7 --- /dev/null +++ b/tests/badcode/.gitignore @@ -0,0 +1,3 @@ +badcode.aml +badcode.asl.actual +badcode.asl.expected diff --git a/tests/badcode/PURPOSE b/tests/badcode/PURPOSE new file mode 100644 index 0000000..24d4fe1 --- /dev/null +++ b/tests/badcode/PURPOSE @@ -0,0 +1,3 @@ +PURPOSE of tests/badcode +Description: sanity check that iasl is handling bad ASL properly +Author: Al Stone diff --git a/tests/badcode/badcode.asl b/tests/badcode/badcode.asl new file mode 100644 index 0000000..996adfc --- /dev/null +++ b/tests/badcode/badcode.asl @@ -0,0 +1,406 @@ +/* + * 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 + * + * Output: + * Compilation complete. 45 Errors, 22 Warnings, 3 Remarks, 16 Optimizations + * + */ +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) + } + + // Method MTH4 does not explicitly return a value + + Method (MTH4) {} + Method (MTH5) {Store (MTH4(), Local0)} + + // Invalid _HID values + + Device (H1) + { + Name (_HID, "*PNP0C0A") // Illegal leading asterisk + } + Device (H2) + { + Name (_HID, "PNP") // Too short, must be 7 or 8 chars + } + Device (H3) + { + Name (_HID, "MYDEVICE01") // Too long, must be 7 or 8 chars + } + Device (H4) + { + Name (_HID, "acpi0001") // non-hex chars must be uppercase + } + Device (H5) + { + Name (_HID, "PNP-123") // HID must be alphanumeric + } + Device (H6) + { + Name (_HID, "") // Illegal Null HID + Name (_CID, "") // Illegal Null CID + } + + // 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) + + // GPE methods that cause type collision (L vs. E) + + Scope (\_GPE) + { + Method (_L1D) + { + } + Method (_E1D) + { + } + } + + // Predefined names that should not have a return value + + Method (_FDM, 1) + { + Return (Buffer(1){0x33}) + } + Method (_Q22) + { + Return ("Unexpected Return Value") + } + + // _REG must have a corresponding Operation Region declaration + // within the same scope + + Device (EC) + { + Method (_REG, 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 + ,, ) + + // Null descriptor (intended to be modified at runtime) must + // have a resource tag (to allow it to be modified at runtime) + DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x00000000, // Granularity + 0x00000000, // Range Minimum + 0x00000000, // Range Maximum + 0x00000000, // Translation Offset + 0x00000000, // Length + ,, ) + + // Missing StartDependentFn macro + + EndDependentFn () + }) + + // Test descriptor for CreateXxxxField operators in REM1 below + + Name (RSC3, ResourceTemplate () + { + DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x00000000, // Granularity + 0x000C8000, // Range Minimum + 0x000C8FFF, // Range Maximum + 0x00000000, // Translation Offset + 0x00001000, // Length + ,, DWI1) + }) + + Method (REM1) + { + // Tagged resource field larger than field being created + + CreateWordField (RSC3, \DWI1._LEN, LEN) + CreateByteField (RSC3, \DWI1._MIN, MIN) + CreateBitField (RSC3, \DWI1._RNG, RNG1) + + // Tagged resource field smaller than field being created + + CreateQWordField (RSC3, \DWI1._MAX, MAX) + CreateBitField (RSC3, \DWI1._GRA, GRA) + CreateField (RSC3, \DWI1._MIF, 5, MIF) + CreateField (RSC3, \DWI1._RNG, 3, RNG2) + } + + Method (L100) + { + /* Method Local is set but never used */ + + Store (40, Local0) + } +} diff --git a/tests/badcode/badcode.asl.result b/tests/badcode/badcode.asl.result new file mode 100644 index 0000000..100cb51 --- /dev/null +++ b/tests/badcode/badcode.asl.result @@ -0,0 +1,266 @@ +badcode.asl 25: Mutex (MTX1, 32) +Error 6125 - ^ SyncLevel must be in the range 0-15 + +badcode.asl 29: Name (BIG, 0x1234567887654321) +Warning 3038 - ^ Truncating 64-bit constant found in 32-bit table + +badcode.asl 33: Name (PKG1, Package(5) {0,1}) +Remark 2063 - ^ Initializer list shorter than declared package length + +badcode.asl 37: Name (PATH, Buffer() {"\_SB_.PCI2._CRS"}) +Warning 3046 - ^ Invalid or unknown escape sequence + +badcode.asl 41: Name (ESC1, "abcdefg\x00hijklmn") +Warning 3055 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL + +badcode.asl 49: FLD1, 8 +Error 6030 - ^ Access width of Field Unit extends beyond region limit + +badcode.asl 55: Field (OPR2, DWordAcc, NoLock, Preserve) +Error 6100 - ^ Host Operation Region requires ByteAcc access + +badcode.asl 60: Field (OPR3, WordAcc, NoLock, Preserve) +Error 6099 - ^ Host Operation Region requires BufferAcc access + +badcode.asl 67: Method (MTH1, 0, NotSerialized, 32) +Error 6125 - SyncLevel must be in the range 0-15 ^ + +badcode.asl 71: Store (Arg3, Local0) +Warning 3144 - ^ Method Local is set but never used (Local0) + +badcode.asl 71: Store (Arg3, Local0) +Error 6006 - ^ Method argument is not initialized (Arg3) + +badcode.asl 71: Store (Arg3, Local0) +Remark 2087 - ^ Not a parameter, used as local only (Arg3) + +badcode.asl 72: Store (Local1, Local2) +Warning 3144 - ^ Method Local is set but never used (Local2) + +badcode.asl 72: Store (Local1, Local2) +Error 6066 - ^ Method local variable is not initialized (Local1) + +badcode.asl 76: Subtract (MTX1, 4, Local3) +Warning 3144 - Method Local is set but never used ^ (Local3) + +badcode.asl 76: Subtract (MTX1, 4, Local3) +Error 6058 - Invalid type ^ ([Mutex] found, Subtract operator requires [Integer|String|Buffer]) + +badcode.asl 80: CreateField (BUF1, 0, Subtract (4, 4), FLD1) +Remark 2089 - Object is not referenced ^ (Name [FLD1] is within a method [MTH1]) + +badcode.asl 80: CreateField (BUF1, 0, Subtract (4, 4), FLD1) +Error 6083 - Operand evaluates to zero ^ + +badcode.asl 84: Acquire (MTX1, 100) +Warning 3130 - ^ Result is not used, possible operator timeout will be missed + +badcode.asl 85: Wait (EVT1, 1) +Warning 3130 - ^ Result is not used, possible operator timeout will be missed + +badcode.asl 89: Add (INT1, 8) +Error 6114 - ^ Result is not used, operator has no effect + +badcode.asl 94: Store (5, INT1) +Warning 3134 - ^ Statement is unreachable + +badcode.asl 97: Method (MTH2) +Remark 2119 - ^ Control Method marked Serialized (Due to use of Switch operator) + +badcode.asl 97: Method (MTH2) +Warning 3115 - ^ Not all control paths return a value (MTH2) + +badcode.asl 101: Switch (ToInteger (INT1)) +Error 6078 - ^ No Case statements under Switch + +badcode.asl 120: Store (MTH2 (), Local0) +Warning 3144 - ^ Method Local is set but never used (Local0) + +badcode.asl 120: Store (MTH2 (), Local0) +Warning 3122 - ^ Called method may not always return a value + +badcode.asl 126: Method (MTH5) {Store (MTH4(), Local0)} +Warning 3144 - Method Local is set but never used ^ (Local0) + +badcode.asl 126: Method (MTH5) {Store (MTH4(), Local0)} +Error 6080 - Called method returns no value ^ + +badcode.asl 132: Name (_HID, "*PNP0C0A") // Illegal leading asterisk +Error 6061 - Invalid leading asterisk ^ (*PNP0C0A) + +badcode.asl 136: Name (_HID, "PNP") // Too short, must be 7 or 8 chars +Error 6033 - ^ _HID string must be exactly 7 or 8 characters (PNP) + +badcode.asl 140: Name (_HID, "MYDEVICE01") // Too long, must be 7 or 8 chars +Error 6033 - ^ _HID string must be exactly 7 or 8 characters (MYDEVICE01) + +badcode.asl 144: Name (_HID, "acpi0001") // non-hex chars must be uppercase +Error 6034 - ^ _HID prefix must be all uppercase or decimal digits (acpi0001) + +badcode.asl 148: Name (_HID, "PNP-123") // HID must be alphanumeric +Error 6002 - ^ String must be entirely alphanumeric (PNP-123) + +badcode.asl 152: Name (_HID, "") // Illegal Null HID +Error 6091 - ^ Invalid zero-length (null) string + +badcode.asl 153: Name (_CID, "") // Illegal Null CID +Error 6091 - ^ Invalid zero-length (null) string + +badcode.asl 158: Name (_PRW, 4) +Error 6105 - ^ Invalid object type for reserved name (_PRW: found Integer, Package required) + +badcode.asl 159: Name (_FDI, Buffer () {0}) +Error 6105 - ^ Invalid object type for reserved name (_FDI: found Buffer, Package required) + +badcode.asl 164: Method (_OSC, 5) +Warning 3101 - ^ Reserved method has too many arguments (_OSC requires 4) + +badcode.asl 164: Method (_OSC, 5) +Warning 3107 - ^ Reserved method must return a value (Buffer required for _OSC) + +badcode.asl 170: Name (_L01, 1) +Error 6103 - ^ Reserved name must be a control method (with zero arguments) + +badcode.asl 171: Name (_E02, 2) +Error 6103 - ^ Reserved name must be a control method (with zero arguments) + +badcode.asl 172: Name (_Q03, 3) +Error 6103 - ^ Reserved name must be a control method (with zero arguments) + +badcode.asl 173: Name (_ON, 0) +Error 6103 - ^ Reserved name must be a control method (with zero arguments) + +badcode.asl 174: Name (_INI, 1) +Error 6103 - ^ Reserved name must be a control method (with zero arguments) + +badcode.asl 175: Name (_PTP, 2) +Error 6103 - ^ Reserved name must be a control method (with arguments) + +badcode.asl 184: Method (_E1D) +Error 6032 - ^ Name conflicts with a previous GPE method (_L1D) + +badcode.asl 193: Return (Buffer(1){0x33}) +Warning 3104 - ^ Reserved method should not return a value (_FDM) + +badcode.asl 197: Return ("Unexpected Return Value") +Warning 3104 - Reserved method should not return a value ^ (_Q22) + +badcode.asl 203: Device (EC) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +badcode.asl 205: Method (_REG, 2) +Warning 3079 - ^ _REG has no corresponding Operation Region + +badcode.asl 219: StartDependentFn (0, 0) +Error 6019 - ^ Dependent function macros cannot be nested + +badcode.asl 225: }) +Error 6070 - ^ Missing EndDependentFn() macro in dependent resource list + +badcode.asl 242: 0x00002000, // Length +Error 6049 - ^ Length is larger than Min/Max window + +badcode.asl 247: 0x00001001, // Range Minimum +Error 6001 - ^ Must be a multiple of alignment/granularity value + +badcode.asl 248: 0x00002002, // Range Maximum +Error 6001 - ^ Must be a multiple of alignment/granularity value + +badcode.asl 255: 0xFFFF, // Address +Warning 3060 - ^ Maximum 10-bit ISA address (0x3FF) + +badcode.asl 264: 0x05 // Access Size +Error 6042 - ^ Invalid AccessSize (Maximum is 4 - QWord access) + +badcode.asl 268: QWordSpace (0xB0, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5, +Error 6139 - Constant out of range ^ (0xB0, allowable: 0xC0-0xFF) + +badcode.asl 279: 0x0200, // Range Minimum +Error 6051 - ^ Address Min is greater than Address Max + +badcode.asl 291: 0x00001002, // Length +Error 6049 - ^ Length is larger than Min/Max window + +badcode.asl 296: 0x00000010, +Error 6048 - ^ Granularity must be zero or a power of two minus one + +badcode.asl 305: 0x0000000000000B02, // Range Minimum +Error 6001 - ^ Must be a multiple of alignment/granularity value + +badcode.asl 315: 0x00000000002FFFFE, // Range Maximum +Error 6001 - ^ Must be a multiple of alignment/granularity value (-1) + +badcode.asl 326: 0x00000000, // Length +Error 6043 - ^ Invalid combination of Length and Min/Max fixed flags + +badcode.asl 335: 0x00000100, // Length +Error 6043 - ^ Invalid combination of Length and Min/Max fixed flags + +badcode.asl 344: 0x00000200, // Length +Error 6043 - ^ Invalid combination of Length and Min/Max fixed flags + +badcode.asl 349: 0x0000000F, // Granularity +Error 6047 - ^ Granularity must be zero for fixed Min/Max + +badcode.asl 358: DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, +Error 6090 - ^ Min/Max/Length/Gran are all zero, but no resource tag + +badcode.asl 368: EndDependentFn () +Error 6071 - ^ Missing StartDependentFn() macro in dependent resource list + +badcode.asl 388: CreateWordField (RSC3, \DWI1._LEN, LEN) +Warning 3128 - ResourceTag larger than Field ^ (Size mismatch, Tag: 32 bits, Field: 16 bits) + +badcode.asl 388: CreateWordField (RSC3, \DWI1._LEN, LEN) +Remark 2089 - Object is not referenced ^ (Name [LEN_] is within a method [REM1]) + +badcode.asl 389: CreateByteField (RSC3, \DWI1._MIN, MIN) +Warning 3128 - ResourceTag larger than Field ^ (Size mismatch, Tag: 32 bits, Field: 8 bits) + +badcode.asl 389: CreateByteField (RSC3, \DWI1._MIN, MIN) +Remark 2089 - Object is not referenced ^ (Name [MIN_] is within a method [REM1]) + +badcode.asl 390: CreateBitField (RSC3, \DWI1._RNG, RNG1) +Warning 3128 - ResourceTag larger than Field ^ (Size mismatch, Tag: 2 bits, Field: 1 bit) + +badcode.asl 390: CreateBitField (RSC3, \DWI1._RNG, RNG1) +Remark 2089 - Object is not referenced ^ (Name [RNG1] is within a method [REM1]) + +badcode.asl 394: CreateQWordField (RSC3, \DWI1._MAX, MAX) +Warning 3129 - ResourceTag smaller than Field ^ (Size mismatch, Tag: 32 bits, Field: 64 bits) + +badcode.asl 394: CreateQWordField (RSC3, \DWI1._MAX, MAX) +Remark 2089 - Object is not referenced ^ (Name [MAX_] is within a method [REM1]) + +badcode.asl 395: CreateBitField (RSC3, \DWI1._GRA, GRA) +Warning 3128 - ResourceTag larger than Field ^ (Size mismatch, Tag: 32 bits, Field: 1 bit) + +badcode.asl 395: CreateBitField (RSC3, \DWI1._GRA, GRA) +Remark 2089 - Object is not referenced ^ (Name [GRA_] is within a method [REM1]) + +badcode.asl 396: CreateField (RSC3, \DWI1._MIF, 5, MIF) +Warning 3129 - ResourceTag smaller than Field ^ (Size mismatch, Tag: 1 bit, Field: 5 bits) + +badcode.asl 396: CreateField (RSC3, \DWI1._MIF, 5, MIF) +Remark 2089 - Object is not referenced ^ (Name [MIF_] is within a method [REM1]) + +badcode.asl 397: CreateField (RSC3, \DWI1._RNG, 3, RNG2) +Warning 3129 - ResourceTag smaller than Field ^ (Size mismatch, Tag: 2 bits, Field: 3 bits) + +badcode.asl 397: CreateField (RSC3, \DWI1._RNG, 3, RNG2) +Remark 2089 - Object is not referenced ^ (Name [RNG2] is within a method [REM1]) + +badcode.asl 404: Store (40, Local0) +Warning 3144 - ^ Method Local is set but never used (Local0) + + +Intel ACPI Component Architecture +ASL+ Optimizing Compiler/Disassembler version VVVVVVVV +Copyright (c) 2000 - 2018 Intel Corporation + +Ignoring all errors, forcing AML file generation + +ASL Input: badcode.asl - 408 lines, 11587 bytes, 81 keywords +AML Output: badcode.aml - 1195 bytes, 61 named objects, 20 executable opcodes + +Compilation complete. 46 Errors, 28 Warnings, 11 Remarks, 16 Optimizations, 1 Constants Folded diff --git a/tests/badcode/runtest.sh b/tests/badcode/runtest.sh new file mode 100755 index 0000000..2b23b3f --- /dev/null +++ b/tests/badcode/runtest.sh @@ -0,0 +1,35 @@ +#!/bin/bash +# +# run the misc tests: we need to do this in a script since +# these are expected to fail which would normally cause %check +# to stop. however, this is expected behavior. we are running +# iasl precisely because we expect it to stop when presented with +# faulty ASL. +# +# this script assumes it is in the source 'tests' directory at +# start. +# + +PWD=$(pwd) +BINDIR="/usr/bin" +VERSION=$($BINDIR/iasl -v | grep Optimizing | cut -d" " -f5) + +# create file to compare against +pushd ./badcode > /dev/null +sed -e "s/VVVVVVVV/$VERSION/" \ + badcode.asl.result > badcode.asl.expected + +# see if badcode.asl failed as expected +# NB: the -f option is required so we can see all of the errors +$BINDIR/iasl -f badcode.asl > badcode.asl.actual 2>&1 +diff badcode.asl.actual badcode.asl.expected >/dev/null 2>&1 +RET=$? +popd > /dev/null + +if [ $RET -eq 0 ] +then + echo PASS badcode +else + echo FAIL badcode +fi +exit $RET diff --git a/tests/converterSample/.gitignore b/tests/converterSample/.gitignore new file mode 100644 index 0000000..e2e45e1 --- /dev/null +++ b/tests/converterSample/.gitignore @@ -0,0 +1,3 @@ +converterSample.aml +converterSample.asl.actual +converterSample.asl.expected diff --git a/tests/converterSample/PURPOSE b/tests/converterSample/PURPOSE new file mode 100644 index 0000000..ccc4b56 --- /dev/null +++ b/tests/converterSample/PURPOSE @@ -0,0 +1,3 @@ +PURPOSE of tests/converterSample +Description: sanity check that iasl is handling ASL converters properly +Author: Al Stone diff --git a/tests/converterSample/converterSample.asl b/tests/converterSample/converterSample.asl new file mode 100644 index 0000000..380b65c --- /dev/null +++ b/tests/converterSample/converterSample.asl @@ -0,0 +1,83 @@ +/* + * top of the + * definition block + */ +DefinitionBlock( + "converterSample.aml", /* These comments */ + "DSDT", /* within the */ + 0x02, /* definition block header */ + "Intel", /* are not retained. */ + "Many", /* They will be */ + 0x00000001 /* Discarded */) +{ + + /* first comment of named object b */ + Name (b, 5) + Name(p008, Package() + { + 0, 0, + 0, 0xffffffff, + 0x00012345, 0x00007abc, + 0x00000012, 0x00000034, + 0x00000001, 0x000000ff, + 0x00000001, 0x0000ffff, + 0x00000001, 0xffffffff, + + // bit-size of multiplicand + 0x67812345, 2, + + // bit-size of multiplier + 3, 0x45678123, + + 0xffffffff, 0xffffffff, + + // ACPI: Overflow conditions are ignored and results are undefined. + }) + + Method(MAIN) { + /********************************************************************** + * * + * This is a long * + * multi-line * + * comment * + * * + **********************************************************************/ + //c12 + if(1==1)//c13 + { //c14 + Name(b,0); + } //c15 + } + + //c16 + Name (a, + Package(3) + {/*c20*/ + 0x04, /*c21*/ + /*c22*/ + 0x05, /*c23*/ + 0x06 /*c24*/ + }/*c25*/ + )/*c26*/ + + + //c34 + Method(SCOP) + { + //c35 + Name (a1, 0x04) + } + + OperationRegion(GNVS,SystemMemory,0xFFFF0000,0xAA55) + + Field(GNVS,AnyAcc,Lock,Preserve) + { + //c36 + Offset(0),//c37 + OSYS, 8//c38 + } + + +} //c39 +/*ending + comment*/ diff --git a/tests/converterSample/converterSample.asl.result b/tests/converterSample/converterSample.asl.result new file mode 100644 index 0000000..dcc98cb --- /dev/null +++ b/tests/converterSample/converterSample.asl.result @@ -0,0 +1,21 @@ +converterSample.asl 37: Method(MAIN) { +Remark 2120 - ^ Control Method should be made Serialized (due to creation of named objects within) + +converterSample.asl 48: Name(b,0); +Remark 2089 - Object is not referenced ^ (Name [B___] is within a method [MAIN]) + +converterSample.asl 65: Method(SCOP) +Remark 2120 - ^ Control Method should be made Serialized (due to creation of named objects within) + +converterSample.asl 68: Name (a1, 0x04) +Remark 2089 - Object is not referenced ^ (Name [A1__] is within a method [SCOP]) + + +Intel ACPI Component Architecture +ASL+ Optimizing Compiler/Disassembler version VVVVVVVV +Copyright (c) 2000 - 2018 Intel Corporation + +ASL Input: converterSample.asl - 85 lines, 1968 bytes, 11 keywords +AML Output: converterSample.aml - 180 bytes, 9 named objects, 2 executable opcodes + +Compilation complete. 0 Errors, 0 Warnings, 4 Remarks, 11 Optimizations, 1 Constants Folded diff --git a/tests/converterSample/runtest.sh b/tests/converterSample/runtest.sh new file mode 100755 index 0000000..df680fa --- /dev/null +++ b/tests/converterSample/runtest.sh @@ -0,0 +1,34 @@ +#!/bin/bash +# +# run the misc tests: we need to do this in a script since +# these are expected to fail which would normally cause %check +# to stop. however, this is expected behavior. we are running +# iasl precisely because we expect it to stop when presented with +# faulty ASL. +# +# this script assumes it is in the source 'tests' directory at +# start. +# + +PWD=$(pwd) +BINDIR="/usr/bin" +VERSION=$($BINDIR/iasl -v | grep Optimizing | cut -d" " -f5) + +# create file to compare against +pushd ./converterSample > /dev/null +sed -e "s/VVVVVVVV/$VERSION/" \ + converterSample.asl.result > converterSample.asl.expected + +# see if converterSample.asl compiles as expected +$BINDIR/iasl converterSample.asl > converterSample.asl.actual 2>&1 +diff converterSample.asl.actual converterSample.asl.expected >/dev/null 2>&1 +RET=$? +popd > /dev/null + +if [ $RET -eq 0 ] +then + echo PASS converterSample +else + echo FAIL converterSample +fi +exit $RET diff --git a/tests/grammar/.gitignore b/tests/grammar/.gitignore new file mode 100644 index 0000000..49ce4e9 --- /dev/null +++ b/tests/grammar/.gitignore @@ -0,0 +1,3 @@ +grammar.aml +grammar.asl.actual +grammar.asl.expected diff --git a/tests/grammar/PURPOSE b/tests/grammar/PURPOSE new file mode 100644 index 0000000..2ddc725 --- /dev/null +++ b/tests/grammar/PURPOSE @@ -0,0 +1,3 @@ +PURPOSE of tests/grammar +Description: sanity check that iasl is handling ASL grammar properly +Author: Al Stone diff --git a/tests/grammar/grammar.asl b/tests/grammar/grammar.asl new file mode 100644 index 0000000..5200ccc --- /dev/null +++ b/tests/grammar/grammar.asl @@ -0,0 +1,10282 @@ +/* + * Some or all of this work - Copyright (c) 2006 - 2018, 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, Serialized) + { + 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, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) { + + _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, 3) + { + 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_, 2) + { + Local0 = ToDecimalString (Arg1) + if (LEqual (Arg0, 0)) + { + Printf ("+*+*+*+* MTHD_ERROR at line %o: Results not equal!", Local0) + } + if (LEqual (Arg0, 1)) + { + Printf ("+*+*+*+* MTHD_ERROR at line %o: Numeric result is incorrect!", Local0) + } + if (LEqual (Arg0, 2)) + { + Printf ("+*+*+*+* MTHD_ERROR at line %o: Operand was clobbered!", Local0) + } + + 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, __LINE__) + Return(Local0) + } + + Store (\NOSV.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\IDXF.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\_SB_.NSTL.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\RTBF.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\_SB_.RTLV.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\_SB_.RETP.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\WHLR.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\ANDO.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\BRKP.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\ADSU.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\INDC.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\LOPS.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\FDSO.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\MLDV.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\NBIT.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\SHFT.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\XORD.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\CRBF.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\IDX4.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\EVNT.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\SZLV.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\_SB_.BYTF.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\DWDF.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\DVAX.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\IDX6.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\IDX5.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\_SB_.IDX0.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\_SB_.IDX3.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\IDX7.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\MTCH.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\WHLB.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\_SB_.IDX2.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\SIZO.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + Store (\_SB_.SMIS.TEST(), Local0) + if (LGreater (Local0, 0)) + { + ERR_ (1, __LINE__) + Return(Local0) + } + + if (LGreater (ERRS, 0)) + { + Store ("****** There were errors during the execution of the test ******", Debug) + } + + // Flush all notifies + + Sleep (250) + + // + // 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,, Serialized) + { + 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, __LINE__) + } + else + { + Store (DerefOf (Index (BUF2, 0)), Local0) + if (LNotEqual (Local0, 0x08)) + { + ERR_ (1, __LINE__) + } + else + { + Store ("++++++++ Bit BufferField I/O PASS", Debug) + } + } + + Store (0x1A, BYT2) + Store (BYT2, Local0) + if (LNotEqual (Local0, 0x1A)) + { + ERR_ (1, __LINE__) + } + else + { + Store ("++++++++ Byte BufferField I/O PASS", Debug) + } + + Store (0x1234, WRD2) + Store (WRD2, Local0) + if (LNotEqual (Local0, 0x1234)) + { + ERR_ (1, __LINE__) + } + else + { + Store ("++++++++ Word BufferField I/O PASS", Debug) + } + + Store (0x123, FLD2) + Store (FLD2, Local0) + if (LNotEqual (Local0, 0x123)) + { + ERR_ (1, __LINE__) + } + else + { + Store ("++++++++ 12-bit BufferField I/O PASS", Debug) + } + + Store (0x12345678, DWD2) + Store (DWD2, Local0) + if (LNotEqual (Local0, 0x12345678)) + { + ERR_ (1, __LINE__) + } + else + { + Store ("++++++++ Dword BufferField I/O PASS", Debug) + } + + Store (0x1234567887654321, QWD2) + Store (QWD2, Local0) + if (LNotEqual (Local0, 0x1234567887654321)) + { + ERR_ (1, __LINE__) + } + else + { + Store ("++++++++ Qword BufferField I/O PASS", Debug) + } + } + + + /* Field execution */ + + Method (FLDX,, Serialized) + { + 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, Serialized) + { + 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, __LINE__) + } + + + /* 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, __LINE__) + } + + + /* 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, __LINE__) + } + + + /* 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, __LINE__) + } + + + /* 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, __LINE__) + } + + + /* 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, __LINE__) + } + + + /* 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, __LINE__) + } + if (LNotEqual (Local1, 7)) + { + ERR_ (2, __LINE__) + } + + + Add (Local0, Local1, Local2) + if (LNotEqual (Local0, 3)) + { + ERR_ (2, __LINE__) + } + if (LNotEqual (Local1, 7)) + { + ERR_ (2, __LINE__) + } + } + + + 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, __LINE__) + } + + Store ("++++++++ FindSetRightBit (0x00100100, Local1)", Debug) + FindSetRightBit (0x00100100, Local1) + if (LNotEqual (Local1, 9)) + { + ERR_ (1, __LINE__) + } + + Store ("++++++++ And (0xF0F0F0F0, 0x11111111, Local2)", Debug) + And (0xF0F0F0F0, 0x11111111, Local2) + if (LNotEqual (Local2, 0x10101010)) + { + ERR_ (1, __LINE__) + } + + Store ("++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)", Debug) + NAnd (0xF0F0F0F0, 0x11111111, Local3) + if (LNotEqual (Local3, 0xEFEFEFEF)) + { + ERR_ (1, __LINE__) + } + + Store ("++++++++ Or (0x11111111, 0x22222222, Local4)", Debug) + Or (0x11111111, 0x22222222, Local4) + if (LNotEqual (Local4, 0x33333333)) + { + ERR_ (1, __LINE__) + } + + Store ("++++++++ NOr (0x11111111, 0x22222222, Local5)", Debug) + NOr (0x11111111, 0x22222222, Local5) + if (LNotEqual (Local5, 0xCCCCCCCC)) + { + ERR_ (1, __LINE__) + } + + Store ("++++++++ XOr (0x11113333, 0x22222222, Local6)", Debug) + XOr (0x11113333, 0x22222222, Local6) + if (LNotEqual (Local6, 0x33331111)) + { + ERR_ (1, __LINE__) + } + + Store ("++++++++ ShiftLeft (0x11112222, 2, Local7)", Debug) + ShiftLeft (0x11112222, 2, Local7) + if (LNotEqual (Local7, 0x44448888)) + { + ERR_ (1, __LINE__) + } + + Store ("++++++++ ShiftRight (Local7, 2, Local7)", Debug) + ShiftRight (Local7, 2, Local7) + if (LNotEqual (Local7, 0x11112222)) + { + ERR_ (1, __LINE__) + } + + + Store ("++++++++ Not (Local0, Local1)", Debug) + Store (0x22224444, Local0) + Not (Local0, Local1) + if (LNotEqual (Local0, 0x22224444)) + { + ERR_ (2, __LINE__) + } + + if (LNotEqual (Local1, 0xDDDDBBBB)) + { + ERR_ (1, __LINE__) + } + + 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, __LINE__) + } + + if (LNotEqual (Local7, 0x0)) + { + ERR_ (1, __LINE__) + } + + + 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,, Serialized) + { + 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 + } + }) + + Store (RefOf (MAIN), Local5) + + // For this to work, ABCD must NOT exist. + + Store (CondRefOf (ABCD, Local0), Local1) + if (LNotEqual (Local1, 0)) + { + ERR_ (2, __LINE__) + } + + Store (CondRefOf (BBUF, Local0), Local1) + if (LNotEqual (Local1, Ones)) + { + ERR_ (2, __LINE__) + } + + Store (DeRefOf (Index (BBUF, 3)), Local6) + if (LNotEqual (Local6, 0xB3)) + { + ERR_ (2, __LINE__) + } + + Store (DeRefOf (Index (DeRefOf (Index (NEST, 1)), 3)), Local0) + if (LNotEqual (Local0, 0x14)) + { + ERR_ (2, __LINE__) + } + + + Store (0x11223344, Local0) + Store (RefOf (Local0), Local1) + + Store (DerefOf (Local1), Local2) + If (LNotEqual (Local2, 0x11223344)) + { + ERR_ (2, __LINE__) + } + + + /* 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, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) + { // 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,, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) + { + 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, Serialized) // 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, Serialized) // 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,, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) + { + + 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, Serialized) + { // 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,, Serialized) + { // 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,, Serialized) + { // 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,, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) + { + 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,, Serialized) + { + + 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,, Serialized) + { + // 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,, Serialized) + { + // 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,, Serialized) + { + // 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,, Serialized) + { + // 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,, Serialized) + { + // 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,, Serialized) + { + 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,, Serialized) + { // _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,, Serialized) + { // 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,, Serialized) + { // 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,, Serialized) + { // 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,, Serialized) + { // 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,, Serialized) + { // 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) + + Notify (\_SB_, 0x29) + 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 + + Method (NTFY) + { + Notify (\_SB_, 1) + Notify (\_TZ_.TZ1, 2) + Notify (\_PR_.CPU0, 3) + + Notify (\_SB_, 0x81) + Notify (\_TZ_.TZ1, 0x82) + Notify (\_PR_.CPU0, 0x83) + } + + 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 () + + NTFY () + 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 diff --git a/tests/grammar/grammar.asl.result b/tests/grammar/grammar.asl.result new file mode 100644 index 0000000..f63e0f5 --- /dev/null +++ b/tests/grammar/grammar.asl.result @@ -0,0 +1,374 @@ +grammar.asl 120: Device (A1) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 135: Device (A2) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 145: Device (A3) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 155: Device (A4) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 171: Device (IRES) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 199: Name (_NPK, Package () +Warning 3133 - ^ Unknown reserved name (_NPK) + +grammar.asl 208: Device (RES) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 399: CreateByteField (PRT0, R000._ASZ, RSIZ) +Remark 2089 - Object is not referenced ^ (Name [RSIZ] is within a method [_CRS]) + +grammar.asl 513: Name (_STR, Unicode ("test")) +Remark 2089 - ^ Object is not referenced (Name [_STR] is within a method [TCOP]) + +grammar.asl 515: Store (MFLD, Local0) +Warning 3144 - ^ Method Local is set but never used (Local0) + +grammar.asl 522: NAME (ESC1, "abcdefg\x00hijklmn") +Warning 3055 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL + +grammar.asl 523: NAME (ESC2, "abcdefg\000hijklmn") +Warning 3055 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL + +grammar.asl 620: RCIV (Subtract (Arg0, 1)) +Remark 2098 - ^ Recursive method call (RCIV) + +grammar.asl 668: Method(SMWE, 4) +Remark 2146 - ^ Method Argument is never used (Arg0) + +grammar.asl 668: Method(SMWE, 4) +Remark 2146 - ^ Method Argument is never used (Arg1) + +grammar.asl 668: Method(SMWE, 4) +Remark 2146 - ^ Method Argument is never used (Arg2) + +grammar.asl 668: Method(SMWE, 4) +Remark 2146 - ^ Method Argument is never used (Arg3) + +grammar.asl 673: Method(SMRE, 4) +Remark 2146 - ^ Method Argument is never used (Arg0) + +grammar.asl 673: Method(SMRE, 4) +Remark 2146 - ^ Method Argument is never used (Arg1) + +grammar.asl 673: Method(SMRE, 4) +Remark 2146 - ^ Method Argument is never used (Arg2) + +grammar.asl 673: Method(SMRE, 4) +Remark 2146 - ^ Method Argument is never used (Arg3) + +grammar.asl 701: CreateField (\_SB_.SBUF, 148, 96, FLDV) +Remark 2089 - Object is not referenced ^ (Name [FLDV] is within a method [_INI]) + +grammar.asl 733: Method(_SRS) +Warning 3102 - ^ Reserved method has too few arguments (_SRS requires 1) + +grammar.asl 738: Device(EIO) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 822: If(LNot(SMRE(0x09,0x17,Local2,RefOf(Local3)))){ +Warning 3144 - Method Local is set but never used ^ (Local3) + +grammar.asl 913: Device (DEV1) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 963: Divide (Local0, Local1, Local3) +Warning 3144 - Method Local is set but never used ^ (Local3) + +grammar.asl 988: Method (R226, 2) +Remark 2146 - ^ Method Argument is never used (Arg0) + +grammar.asl 988: Method (R226, 2) +Remark 2146 - ^ Method Argument is never used (Arg1) + +grammar.asl 1011: Store (Local0, Local1) +Warning 3144 - ^ Method Local is set but never used (Local1) + +grammar.asl 1296: Method (OBJ1, 1, SERIALIZED) +Remark 2146 - ^ Method Argument is never used (Arg0) + +grammar.asl 1300: Name(BUFR, Buffer (Local0) {}) +Remark 2089 - ^ Object is not referenced (Name [BUFR] is within a method [OBJ1]) + +grammar.asl 1307: Alias (MTX1, MTX2) +Remark 2089 - Object is not referenced ^ (Name [MTX2] is within a method [OBJ1]) + +grammar.asl 1329: CreateField (BUF2, 148, 96, FLD3) +Remark 2089 - Object is not referenced ^ (Name [FLD3] is within a method [FLDS]) + +grammar.asl 1394: Store (0x1234567887654321, QWD2) +Warning 3038 - ^ Truncating 64-bit constant found in 32-bit table + +grammar.asl 1396: if (LNotEqual (Local0, 0x1234567887654321)) +Warning 3038 - Truncating 64-bit constant found in 32-bit table ^ + +grammar.asl 1476: SizeOf (BUFO) +Error 6114 - ^ Result is not used, operator has no effect + +grammar.asl 1496: Alias (MTX2, MTXA) +Remark 2089 - Object is not referenced ^ (Name [MTXA] is within a method [OBJ2]) + +grammar.asl 1502: Acquire (MTX2, 1) +Warning 3130 - ^ Result is not used, possible operator timeout will be missed + +grammar.asl 1650: Add (Local0, Local1) +Error 6114 - ^ Result is not used, operator has no effect + +grammar.asl 1661: Add (Local0, Local1, Local2) +Warning 3144 - Method Local is set but never used ^ (Local2) + +grammar.asl 1777: Store (LAnd (0xFFFFFFFF, 0x11111111), Local0) +Warning 3144 - Method Local is set but never used ^ (Local0) + +grammar.asl 1780: Store (LEqual (0xFFFFFFFF, 0x11111111), Local1) +Warning 3144 - Method Local is set but never used ^ (Local1) + +grammar.asl 1783: Store (LGreater (0xFFFFFFFF, 0x11111111), Local2) +Warning 3144 - Method Local is set but never used ^ (Local2) + +grammar.asl 1786: Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3) +Warning 3144 - Method Local is set but never used ^ (Local3) + +grammar.asl 1789: Store (LLess (0xFFFFFFFF, 0x11111111), Local4) +Warning 3144 - Method Local is set but never used ^ (Local4) + +grammar.asl 1792: Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5) +Warning 3144 - Method Local is set but never used ^ (Local5) + +grammar.asl 1821: Method (COND) +Warning 3115 - ^ Not all control paths return a value (COND) + +grammar.asl 1930: Store (RefOf (MAIN), Local5) +Warning 3144 - Method Local is set but never used ^ (Local5) + +grammar.asl 2005: Device (IFEL) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 2162: Device (NOSV) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 2583: Device (IDXF) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 2611: Store (IFE0, Local0) +Warning 3144 - ^ Method Local is set but never used (Local0) + +grammar.asl 2612: Store (IFE1, Local1) +Warning 3144 - ^ Method Local is set but never used (Local1) + +grammar.asl 2613: Store (IFE2, Local2) +Warning 3144 - ^ Method Local is set but never used (Local2) + +grammar.asl 2630: Device (NSTL) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 2658: Device (RTBF) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 2756: Device (GPE2) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 2771: Device (PRW2) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 2819: Device (PRW1) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 2886: Store (Arg0, Local0) +Warning 3144 - ^ Method Local is set but never used (Local0) + +grammar.asl 2889: Device (RTLV) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 2993: Name (_CRS,0) +Error 6105 - ^ Invalid object type for reserved name (_CRS: found Integer, Buffer required) + +grammar.asl 3017: Device (RETP) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 3053: Device (WHLR) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 3109: Device (ANDO) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 3383: Device (BRKP) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 3420: Device (ADSU) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 3513: Device (INDC) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 3611: Device (LOPS) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 3956: Device (FDSO) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 4120: Device (MLDV) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 4253: Device (NBIT) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 4489: Device (SHFT) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 4685: Device (XORD) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 5022: Device (CRBF) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 5100: Device (IDX4) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 5639: Device (EVNT) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 5867: Device (SZLV) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 5960: Device (BYTF) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 5970: Device (C005) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 5972: Device (C013) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 6027: Name (_HID, "*PNP0A06") +Error 6061 - Invalid leading asterisk ^ (*PNP0A06) + +grammar.asl 6166: Name (C18C, Package (2) +Remark 2063 - ^ Initializer list shorter than declared package length + +grammar.asl 6190: Device (C19B) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 6199: Divide (Local1, 10, Local0, Local2) // Local0 = Local1 / 10 +Warning 3144 - Method Local is set but never used ^ (Local0) + +grammar.asl 6244: Device (DWDF) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 6276: Method (MKW_, 2) +Remark 2146 - ^ Method Argument is never used (Arg0) + +grammar.asl 6276: Method (MKW_, 2) +Remark 2146 - ^ Method Argument is never used (Arg1) + +grammar.asl 6285: Device (DVAX) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 6328: Device (IDX6) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 6352: Device (TST_) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 6371: Store (IFE0, Local0) +Warning 3144 - ^ Method Local is set but never used (Local0) + +grammar.asl 6372: Store (IFE1, Local1) +Warning 3144 - ^ Method Local is set but never used (Local1) + +grammar.asl 6373: Store (IFE2, Local2) +Warning 3144 - ^ Method Local is set but never used (Local2) + +grammar.asl 6376: Store (\IDX6.IFE0, Local3) +Warning 3144 - Method Local is set but never used ^ (Local3) + +grammar.asl 6377: Store (\IDX6.IFE1, Local4) +Warning 3144 - Method Local is set but never used ^ (Local4) + +grammar.asl 6379: Store (\IDX6.TST_.IFE0, Local5) +Warning 3144 - Method Local is set but never used ^ (Local5) + +grammar.asl 6380: Store (\IDX6.TST_.IFE1, Local6) +Warning 3144 - Method Local is set but never used ^ (Local6) + +grammar.asl 6393: Device (IDX5) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 6478: Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."}) +Warning 3046 - Invalid or unknown escape sequence ^ + +grammar.asl 6709: Device (BITI) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 6817: And (Local0, 1, Local0) // Local0 &= 1 +Error 6066 - ^ Method local variable is not initialized (Local0) + +grammar.asl 6903: Name (_HID, "*PNP0C0A") // Control Method Battey ID +Error 6061 - Invalid leading asterisk ^ (*PNP0C0A) + +grammar.asl 6912: Device (IDX3) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 7057: Device(IDX7) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 7736: Device (MTCH) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 7757: CreateDWordField (TMD0, 4, DMA0) +Remark 2089 - Object is not referenced ^ (Name [DMA0] is within a method [TEST]) + +grammar.asl 7758: CreateDWordField (TMD0, 8, PIO1) +Remark 2089 - Object is not referenced ^ (Name [PIO1] is within a method [TEST]) + +grammar.asl 7759: CreateDWordField (TMD0, 12, DMA1) +Remark 2089 - Object is not referenced ^ (Name [DMA1] is within a method [TEST]) + +grammar.asl 7760: CreateDWordField (TMD0, 16, CHNF) +Remark 2089 - Object is not referenced ^ (Name [CHNF] is within a method [TEST]) + +grammar.asl 7934: Device (WHLB) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 8295: Device (IDX2) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 8678: Device (SIZO) +Warning 3141 - ^ Missing dependency (Device object requires a _HID or _ADR in same scope) + +grammar.asl 8720: Name (PKG2, Package (4) +Remark 2063 - ^ Initializer list shorter than declared package length + +grammar.asl 9132: Store (_OS, Local0) +Warning 3144 - ^ Method Local is set but never used (Local0) + +grammar.asl 9262: Device (MBIT) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 9273: Device (MWRD) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 9281: Device (MBYT) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 9354: Device (SMIS) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar.asl 9408: Device(CNDT) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + + +Intel ACPI Component Architecture +ASL+ Optimizing Compiler/Disassembler version VVVVVVVV +Copyright (c) 2000 - 2018 Intel Corporation + +Ignoring all errors, forcing AML file generation + +ASL Input: grammar.asl - 10284 lines, 323650 bytes, 4818 keywords +AML Output: grammar.aml - 43469 bytes, 670 named objects, 4148 executable opcodes + +Compilation complete. 6 Errors, 88 Warnings, 27 Remarks, 1232 Optimizations, 75 Constants Folded diff --git a/tests/grammar/runtest.sh b/tests/grammar/runtest.sh new file mode 100755 index 0000000..7cd3e93 --- /dev/null +++ b/tests/grammar/runtest.sh @@ -0,0 +1,35 @@ +#!/bin/bash +# +# run the misc tests: we need to do this in a script since +# these are expected to fail which would normally cause %check +# to stop. however, this is expected behavior. we are running +# iasl precisely because we expect it to stop when presented with +# faulty ASL. +# +# this script assumes it is in the source 'tests' directory at +# start. +# + +PWD=$(pwd) +BINDIR="/usr/bin" +VERSION=$($BINDIR/iasl -v | grep Optimizing | cut -d" " -f5) + +# create file to compare against +pushd ./grammar > /dev/null +sed -e "s/VVVVVVVV/$VERSION/" \ + grammar.asl.result > grammar.asl.expected + +# see if grammar.asl failed as expected +# NB: the -f option is required so we can see all of the errors +$BINDIR/iasl -f grammar.asl > grammar.asl.actual 2>&1 +diff grammar.asl.actual grammar.asl.expected >/dev/null 2>&1 +RET=$? +popd > /dev/null + +if [ $RET -eq 0 ] +then + echo PASS grammar +else + echo FAIL grammar +fi +exit $RET diff --git a/tests/grammar2/.gitignore b/tests/grammar2/.gitignore new file mode 100644 index 0000000..e129ef2 --- /dev/null +++ b/tests/grammar2/.gitignore @@ -0,0 +1,3 @@ +grammar2.aml +grammar2.asl.actual +grammar2.asl.expected diff --git a/tests/grammar2/PURPOSE b/tests/grammar2/PURPOSE new file mode 100644 index 0000000..2ddc725 --- /dev/null +++ b/tests/grammar2/PURPOSE @@ -0,0 +1,3 @@ +PURPOSE of tests/grammar +Description: sanity check that iasl is handling ASL grammar properly +Author: Al Stone diff --git a/tests/grammar2/grammar2.asl b/tests/grammar2/grammar2.asl new file mode 100755 index 0000000..eeedbc2 --- /dev/null +++ b/tests/grammar2/grammar2.asl @@ -0,0 +1,11652 @@ +/* + * Intel ACPI Component Architecture + * AML/ASL+ Disassembler version 20180313 (32-bit version) + * Copyright (c) 2000 - 2018 Intel Corporation + * + * Disassembling to symbolic ASL+ operators + * + * Disassembly of grammar.xxx, Thu Mar 22 09:44:49 2018 + * + * Original Table Header: + * Signature "DSDT" + * Length 0x0002192B (137515) + * Revision 0x01 **** 32-bit table (V1), no 64-bit math support + * Checksum 0x2C **** Incorrect checksum, should be 0x5D + * OEM ID "Intel" + * OEM Table ID "GRMTEST" + * OEM Revision 0x20090511 (537462033) + * Compiler ID "INTL" + * Compiler Version 0x20180313 (538444563) + */ +/* + * Some or all of this work - Copyright (c) 2006 - 2018, 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 ("", "DSDT", 1, "Intel", "GRMTEST", 0x20090511) +{ + External (\ABCD, UnknownObj) + /* Device with _STA and _INI */ + + Device (A1) + { + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + + Method (_INI, 0, NotSerialized) // _INI: Initialize + { + Return (Zero) + } + } + + /* Device with no _STA, has _INI */ + + Device (A2) + { + Method (_INI, 0, NotSerialized) // _INI: Initialize + { + Return (Zero) + } + } + + /* Device with _STA, no _INI */ + + Device (A3) + { + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + } + + /* Device with _STA and _INI, but not present */ + + Device (A4) + { + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (Zero) + } + + Method (_INI, 0, NotSerialized) // _INI: Initialize + { + Return (Zero) + } + } + + /* Resource descriptors */ + + Device (IRES) + { + Name (PRT0, ResourceTemplate () + { + IRQ (Edge, ActiveHigh, Exclusive, ) + {3,4,5,6,7,9,10,11,14,15} + StartDependentFn (0x01, 0x01) + { + IRQNoFlags () + {0,1,2} + } + EndDependentFn () + }) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Debug = "_CRS:" + Debug = PRT0 /* \IRES.PRT0 */ + Return (PRT0) /* \IRES.PRT0 */ + } + + Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings + { + Debug = "_SRS:" + Debug = Arg0 + Return (Zero) + } + } + + Name (_NPK, Package (0x04) + { + 0x1111, + 0x2222, + 0x3333, + 0x4444 + }) + Device (RES) + { + Name (_PRT, Package (0x04) // _PRT: PCI Routing Table + { + 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, Serialized) // _CRS: Current Resource Settings + { + Name (PRT0, ResourceTemplate () + { + WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode, + 0x0000, // Granularity + 0xFFF2, // Range Minimum + 0xFFF3, // Range Maximum + 0x0032, // Translation Offset + 0x0002, // Length + ,, _Y00) + WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, + 0x0000, // Granularity + 0x0000, // Range Minimum + 0x00FF, // Range Maximum + 0x0000, // Translation Offset + 0x0100, // Length + ,, ) + WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5, + 0x0000, // Granularity + 0xA000, // Range Minimum + 0xBFFF, // Range Maximum + 0x0000, // Translation Offset + 0x2000, // Length + ,, ) + IO (Decode16, + 0x0CF8, // Range Minimum + 0x0CFF, // Range Maximum + 0x01, // Alignment + 0x08, // Length + ) + WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000, // Granularity + 0x0000, // Range Minimum + 0x0CF7, // Range Maximum + 0x0000, // Translation Offset + 0x0CF8, // Length + ,, , TypeStatic, DenseTranslation) + WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000, // Granularity + 0x0D00, // Range Minimum + 0xFFFF, // Range Maximum + 0x0000, // Translation Offset + 0xF300, // Length + ,, , TypeStatic, DenseTranslation) + DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x00000000, // Granularity + 0x00000000, // Range Minimum + 0x00000CF7, // Range Maximum + 0x00000000, // Translation Offset + 0x00000CF8, // Length + ,, , TypeStatic, DenseTranslation) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, // Granularity + 0x000C8000, // Range Minimum + 0x000EFFFF, // Range Maximum + 0x00000000, // Translation Offset + 0x00028000, // Length + ,, , AddressRangeMemory, TypeStatic) + DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5, + 0x00000000, // Granularity + 0x000C8000, // Range Minimum + 0x000EFFFF, // Range Maximum + 0x00000000, // Translation Offset + 0x00028000, // Length + ,, ) + QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000000000000000, // Granularity + 0x0000000000000000, // Range Minimum + 0x0000000000000CF7, // Range Maximum + 0x0000000000000000, // Translation Offset + 0x0000000000000CF8, // Length + 0x44, "This is a ResouceSource string", , TypeStatic, DenseTranslation) + QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000000000000000, // Granularity + 0x0000000000000000, // Range Minimum + 0x0000000000000CF7, // Range Maximum + 0x0000000000000000, // Translation Offset + 0x0000000000000CF8, // Length + ,, , TypeStatic, DenseTranslation) + QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x0000000000000000, // Granularity + 0x0000000000100000, // Range Minimum + 0x00000000FFDFFFFF, // Range Maximum + 0x0000000000000000, // Translation Offset + 0x00000000FFD00000, // Length + ,, , AddressRangeMemory, TypeStatic) + QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5, + 0x0000000000000000, // Granularity + 0x0000000000000000, // Range Minimum + 0x0000000000000CF7, // Range Maximum + 0x0000000000000000, // Translation Offset + 0x0000000000000CF8, // Length + ,, ) + ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000000000000000, // Granularity + 0x0000000000000000, // Range Minimum + 0x0000000000000CF7, // Range Maximum + 0x0000000000000000, // Translation Offset + 0x0000000000000CF8, // Length + 0x0000000000000000, // Type-Specific Attributes + , TypeStatic, DenseTranslation) + ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x0000000000000000, // Granularity + 0x0000000000100000, // Range Minimum + 0x00000000FFDFFFFF, // Range Maximum + 0x0000000000000000, // Translation Offset + 0x00000000FFD00000, // Length + 0x0000000000000000, // Type-Specific Attributes + , AddressRangeMemory, TypeStatic) + ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3, + 0x0000000000000000, // Granularity + 0x0000000000100000, // Range Minimum + 0x00000000FFDFFFFF, // Range Maximum + 0x0000000000000000, // Translation Offset + 0x00000000FFD00000, // Length + 0x0000000000000000, // Type-Specific Attributes + ) + IO (Decode16, + 0x0010, // Range Minimum + 0x0020, // Range Maximum + 0x01, // Alignment + 0x10, // Length + ) + IO (Decode16, + 0x0090, // Range Minimum + 0x00A0, // Range Maximum + 0x01, // Alignment + 0x10, // Length + ) + FixedIO ( + 0x0061, // Address + 0x01, // Length + ) + IRQNoFlags () + {2} + DMA (Compatibility, BusMaster, Transfer8_16, ) + {4} + DMA (Compatibility, BusMaster, Transfer8, ) + {2,5,7} + Memory32Fixed (ReadWrite, + 0x00100000, // Address Base + 0x00000000, // Address Length + ) + Memory32Fixed (ReadOnly, + 0xFFFE0000, // Address Base + 0x00020000, // Address Length + ) + Memory32 (ReadOnly, + 0x00020000, // Range Minimum + 0xFFFE0000, // Range Maximum + 0x00000004, // Alignment + 0x00000200, // Length + ) + Memory24 (ReadOnly, + 0x1111, // Range Minimum + 0x2222, // Range Maximum + 0x0004, // Alignment + 0x0200, // Length + ) + Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0x0E, "\\_SB_.TEST", ) + { + 0x00000E01, + } + Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x06, "xxxx", ) + { + 0x00000601, + 0x00000003, + 0x00000002, + 0x00000001, + } + Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive, ,, ) + { + 0xFFFF0000, + 0x00000003, + 0x00000002, + 0x00000001, + 0x00000005, + 0x00000007, + 0x00000009, + } + VendorShort () // Length = 0x03 + { + 0x01, 0x02, 0x03 // ... + } + VendorLong () // Length = 0x09 + { + /* 0000 */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // ........ + /* 0008 */ 0x09 // . + } + Register (SystemIO, + 0x08, // Bit Width + 0x00, // Bit Offset + 0x00000000000000B2, // Address + ,_Y01) + Register (SystemMemory, + 0x08, // Bit Width + 0x00, // Bit Offset + 0x00000000000000B2, // Address + ,) + StartDependentFnNoPri () + { + IRQNoFlags () + {0,1,2} + IRQ (Level, ActiveLow, Shared, ) + {3,4,5,6,7,9,10,11,14,15} + } + EndDependentFn () + }) + CreateWordField (PRT0, \RES._CRS._Y00._MIN, BMIN) // _MIN: Minimum Base Address + CreateByteField (PRT0, \RES._CRS._Y01._ASZ, RSIZ) // _ASZ: Access Size + BMIN = 0x03 + Return (PRT0) /* \RES_._CRS.PRT0 */ + } + + Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings + { + Name (BUF0, ResourceTemplate () + { + StartDependentFn (0x01, 0x02) + { + IO (Decode16, + 0x03D8, // Range Minimum + 0x03F8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + ) + IRQNoFlags () + {4} + } + StartDependentFn (0x02, 0x01) + { + IO (Decode16, + 0x03D8, // Range Minimum + 0x03E8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + ) + IRQNoFlags () + {4} + } + StartDependentFn (0x00, 0x02) + { + IO (Decode16, + 0x02E8, // Range Minimum + 0x02F8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + ) + IRQNoFlags () + {3} + } + StartDependentFn (0x00, 0x02) + { + IO (Decode16, + 0x02D8, // Range Minimum + 0x02E8, // Range Maximum + 0x01, // Alignment + 0x08, // Length + ) + IRQNoFlags () + {3} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, + 0x0100, // Range Minimum + 0x03F8, // Range Maximum + 0x08, // Alignment + 0x08, // Length + ) + IRQNoFlags () + {1,3,4,5,6,7,8,10,11,12,13,14,15} + } + EndDependentFn () + }) + Return (BUF0) /* \RES_._PRS.BUF0 */ + } + + Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings + { + Return (Zero) + } + } + + Name (\_S0, Package (0x04) // _S0_: S0 System State + { + 0x00, + 0x00, + 0x00, + 0x00 + }) + Name (\_S3, Package (0x04) // _S3_: S3 System State + { + 0x05, + 0x05, + 0x00, + 0x00 + }) + Name (\_S4, Package (0x04) // _S4_: S4 System State + { + 0x06, + 0x06, + 0x00, + 0x00 + }) + Name (\_S5, Package (0x04) // _S5_: S5 System State + { + 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, 0x00) + /* Custom operation region */ + + OperationRegion (MYOP, 0x80, 0xFD60, 0x06) + Field (MYOP, ByteAcc, NoLock, Preserve) + { + MFLD, 8 + } + + Method (TCOP, 0, Serialized) + { + Name (_STR, Unicode ("test")) // _STR: Description String + MFLD = 0x04 + Local0 = MFLD /* \MFLD */ + } + + Name (ERRS, 0x00) + /* Warning should be issued for premature string termination */ + + Name (ESC1, "abcdefghijklmn") + Name (ESC2, "abcdefghijklmn") + Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\x1A") + Name (CRSA, ResourceTemplate () + { + WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, + 0x0000, // Granularity + 0x0019, // Range Minimum + 0x001D, // Range Maximum + 0x0000, // Translation Offset + 0x0005, // Length + ,, ) + WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, NonISAOnlyRanges, + 0x0000, // Granularity + 0xC000, // Range Minimum + 0xCFFF, // Range Maximum + 0x0000, // Translation Offset + 0x1000, // Length + ,, , TypeStatic, DenseTranslation) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, + 0x00000000, // Granularity + 0xD8000000, // Range Minimum + 0xDBFFFFFF, // Range Maximum + 0x00000000, // Translation Offset + 0x04000000, // Length + ,, , AddressRangeMemory, TypeStatic) + }) + Name (CRSB, ResourceTemplate () + { + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, + 0x00000000, // Granularity + 0xD8000000, // Range Minimum + 0xDBFFFFFF, // Range Maximum + 0x00000000, // Translation Offset + 0x04000000, // Length + ,, , AddressRangeMemory, TypeStatic) + }) + Name (CRSC, ResourceTemplate () + { + VendorShort () // Length = 0x03 + { + 0x01, 0x02, 0x03 // ... + } + }) + Name (CRSD, ResourceTemplate () + { + VendorLong () // Length = 0x09 + { + /* 0000 */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // ........ + /* 0008 */ 0x09 // . + } + }) + Name (CRSE, ResourceTemplate () + { + IRQNoFlags () + {3,4,10,11} + IRQNoFlags () + {3,4,10,11} + }) + Name (CRSR, Buffer ((SizeOf (CRSA) + SizeOf (CRSB))){}) + Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings + { + Return (CRSR) /* \CRSR */ + } + + /* */ + /* Unnamed scope */ + /* */ + Scope (\) + { + Name (BXXX, 0xFFFFFFFF) + } + + Name (LANS, 0x00) + PowerResource (LANP, 0x01, 0x0000) + { + Method (_STA, 0, NotSerialized) // _STA: Status + { + If (((LANS & 0x30) == 0x30)) + { + Return (One) + } + Else + { + Return (Zero) + } + } + + Method (_ON, 0, NotSerialized) // _ON_: Power On + { + If (!_STA ()) + { + LANS = 0x30 + } + } + + Method (_OFF, 0, NotSerialized) // _OFF: Power Off + { + If (_STA ()) + { + LANS = 0x00 + } + } + } + + /* Can a method define another method? */ + /********************************** + Method (TASK, 2, SERIALIZED) + { + Sleep (100) + Method (TAS2) + { + Sleep (100) + } + TAS2() + Return + } + ************************************/ + /* A recursive method */ + Method (RCIV, 1, NotSerialized) + { + Debug = Arg0 + If ((Arg0 == 0x00)) + { + Return (Zero) + } + + RCIV ((Arg0 - 0x01)) + } + + Method (RTOP, 0, NotSerialized) + { + RCIV (0x64) + } + + Scope (\_PR) + { + Processor (CPU0, 0x00, 0xFFFFFFFF, 0x00){} + } + + 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, 0x0BB8) + Name (B2DC, 0x0A28) + Name (B1LF, 0x0BB8) + Name (B2LF, 0x0A28) + Name (BPIF, 0x00) + Name (PBLL, 0x00) + Name (RBIF, Package (0x0D) + { + 0x01, + 0x0898, + 0x0898, + 0x01, + 0x2A30, + 0x00, + 0x00, + 0x01, + 0x01, + "CA54200-5003/5", + "1", + "LION", + "Fujitsu" + }) + Method (SMWE, 4, NotSerialized) + { + Return (Ones) + } + + Method (SMRE, 4, NotSerialized) + { + Return (Ones) + } + + /* + Method(RDBT,0,Serialized){ + If(LNot(SMWE(0x09,0x15,1,1))){ + Store(0x18,Local2) + } + } + */ + Scope (_SB) + { + Name (SBUF, Buffer (0x80){}) + CreateBitField (SBUF, 0x03, BITY) + CreateByteField (SBUF, 0x01, BYTY) + CreateWordField (SBUF, 0x02, WRDZ) + CreateDWordField (SBUF, 0x04, DWDZ) + CreateQWordField (SBUF, 0x08, QWDZ) + CreateField (SBUF, 0x80, 0x0C, FLDZ) + CreateField (SBUF, 0x94, 0x60, FLDY) + CreateField (SBUF, 0x94, 0x60, \_SB.FLDW) + Method (_INI, 0, NotSerialized) // _INI: Initialize + { + CreateField (\_SB.SBUF, 0x94, 0x60, FLDV) + } + + Device (PCI0) + { + Name (_HID, EisaId ("PNP0A03") /* PCI Bus */) // _HID: Hardware ID + Name (_ADR, 0x00) // _ADR: Address + Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings + { + Name (PRT0, ResourceTemplate ()/* PRT0 */ /*Minimum bus number suported under this bridge. */ + { + WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode, + 0x0000, // Granularity + 0xFFF1, // Range Minimum + 0xFFF2, // Range Maximum + 0x0032, // Translation Offset + 0x0002, // Length + ,, _Y02) + }) + CreateWordField (PRT0, \_SB.PCI0._CRS._Y02._MIN, BMIN) // _MIN: Minimum Base Address + BMIN = 0x03 + Return (PRT0) /* \_SB_.PCI0._CRS.PRT0 */ + } /* _CRS */ + + Method (_SRS, 0, NotSerialized) // _SRS: Set Resource Settings + { + Return (Zero) + } + + Device (EIO) + { + OperationRegion (FJIO, SystemIO, 0xFD60, 0x06) + Field (FJIO, ByteAcc, NoLock, Preserve) + { + GIDX, 8, + GDTA, 8, + PIDX, 8, + PDTA, 8, + SIDX, 8, + SDTA, 8 + } + + IndexField (GIDX, GDTA, ByteAcc, NoLock, Preserve) + { + Offset (0x02), + , 5, + VGAS, 2, + Offset (0x04), + , 4, + DCKE, 1, + Offset (0x05), + , 6, + ACPW, 1, + Offset (0x0A), + B1P, 1, + B2P, 1, + B1C, 1, + B2C, 1, + B1ER, 1, + B2ER, 1, + Offset (0x0B), + 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) + { + Local1 = 0x1FFF + If (Arg0) + { + Local1 = 0x2FFF + } + + Local2 = 0x18 + If (Arg1) + { + Local2 = 0x10 + } + + If (!SMRE (0x09, 0x15, 0x01, RefOf (Local0))) + { + If (!SMWE (0x08, 0x14, 0x01, Local1)) + { + If (!SMRE (0x09, 0x17, Local2, RefOf (Local3))) + { + Arg2 = Local1 + } + } + + Local0 |= 0x0FFF + SMWE (0x08, 0x14, 0x01, Local0) + } + } + + Method (MKWD, 2, NotSerialized) + { + If ((Arg1 & 0x80)) + { + Local0 = (0xFFFF0000 | Arg0) + Local0 |= (Arg1 << 0x08) + Local0 = (Zero - Local0) + } + Else + { + Local0 = Arg0 + Local0 |= (Arg1 << 0x08) + } + + Return (Local0) + } + + Device (CMB1) + { + Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID + Name (_UID, 0x01) // _UID: Unique ID + 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, 0, NotSerialized) // _INI: Initialize + { + B1PS = B1P /* \CMB1.B1P_ */ + B1RS = B1CP /* \CMB1.B1CP */ + B1CS = B1C /* \CMB1.B1C_ */ + } + + Method (_BIF, 0, NotSerialized) // _BIF: Battery Information + { + RDBT (Zero, Zero, RefOf (B1DC)) + RDBT (Zero, One, RefOf (B1LF)) + RBIF [0x01] = B1DC /* \B1DC */ + RBIF [0x02] = B1LF /* \B1LF */ + RBIF [0x09] = "CA54200-5003/5" + RBIF [0x0A] = "1" + Return (RBIF) /* \RBIF */ + } + + Method (_BST, 0, Serialized) // _BST: Battery Status + { + _INI () + Local0 = Zero + If ((B1P && !B1C)) + { + Local0 |= 0x01 + } + + If ((B1P && B1C)) + { + Local0 |= 0x02 + } + + If ((B1CP <= 0x01)) + { + Local0 |= 0x04 + } + + Local1 = MKWD (B1CL, B1CH) + Store ((((B1CP * B1LF) + 0x63) / 0x64), Local2) + Local3 = MKWD (B1VL, B1VH) + Name (STAT, Package (0x04){}) + STAT [0x00] = Local0 + STAT [0x01] = Local1 + STAT [0x02] = Local2 + STAT [0x03] = Local3 + If (!BPIF) + { + /* \_SB.PCI0.EIO.EC0.IECT() */ + /* \_SB.PCI0.EIO.EC0.SECT() */ + BPIF = One + } + + Return (STAT) /* \CMB1._BST.STAT */ + } + } + + Device (DEV1) + { + } + + Scope (\_TZ) + { + ThermalZone (TZ1) + { + Name (_PSL, Package (0x01) // _PSL: Passive List + { + \_PR.CPU0 + }) + } + } + + Method (TZ2, 0, Serialized) + { + Name (_PSL, Package (0x01) // _PSL: Passive List + { + \_PR.CPU0 + }) + Return (_PSL) /* \TZ2_._PSL */ + } + + ThermalZone (THM1) + { + } + + Method (NOTI, 0, NotSerialized) + { + Notify (\DEV1, 0x00) // Bus Check + Notify (\THM1, 0x00) // Bus Check + Notify (\_PR.CPU0, 0x00) // Bus Check + } + + Method (_ERR, 3, NotSerialized) + { + ERRS++ + Debug = "Run-time exception:" + Debug = Arg0 + Debug = Arg1 + Return (0x00) /* Map error to AE_OK */ + } + + Method (DIV0, 0, NotSerialized) + { + Local0 = 0x01 + Local1 = 0x00 + Divide (Local0, Local1, Local3) + Debug = "DIV0 - noabort" + } + + Method (ERR, 2, NotSerialized) + { + Local0 = ToDecimalString (Arg1) + If ((Arg0 == 0x00)) + { + Debug = Concatenate (Concatenate ("+*+*+*+* MTHD_ERROR at line ", Local0), ": Results not equal!") + } + + If ((Arg0 == 0x01)) + { + Debug = Concatenate (Concatenate ("+*+*+*+* MTHD_ERROR at line ", Local0), ": Numeric result is incorrect!") + } + + If ((Arg0 == 0x02)) + { + Debug = Concatenate (Concatenate ("+*+*+*+* MTHD_ERROR at line ", Local0), ": Operand was clobbered!") + } + + Notify (DEV1, Arg0) + ERRS++ + } + + Method (R226, 2, NotSerialized) + { + } + + Method (R225, 2, NotSerialized) + { + R226 (Arg0, Arg1) + } + + Method (R224, 2, NotSerialized) + { + R225 (Arg1, Arg0) + } + + Method (R223, 2, NotSerialized) + { + R224 (Arg0, Arg1) + } + + Method (R222, 2, NotSerialized) + { + R223 (Arg1, Arg0) + } + + Method (R111, 0, NotSerialized) + { + Local0 = 0x01010101 + R222 (0xABAB, Local0) + Local1 = Local0 + } + + Method (MAIN, 0, NotSerialized) + { + /* SIZE() */ + + Local0 = NUM1 () + \CMB1._BST () + RDBT (0x01, 0x02, 0x03) + OBJ1 (0x01) + OBJ2 (0x02) + CHEK () + RETZ () + BITZ () + LOGS () + REFS () + COND () + TZ2 () + /* */ + /* iPCO tests added */ + /* */ + Local0 = \IFEL.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x040D) + Return (Local0) + } + + Local0 = \NOSV.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0414) + Return (Local0) + } + + Local0 = \IDXF.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x041B) + Return (Local0) + } + + Local0 = \_SB.NSTL.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0422) + Return (Local0) + } + + Local0 = \RTBF.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0429) + Return (Local0) + } + + Local0 = \_SB.RTLV.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0430) + Return (Local0) + } + + Local0 = \_SB.RETP.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0437) + Return (Local0) + } + + Local0 = \WHLR.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x043E) + Return (Local0) + } + + Local0 = \ANDO.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0445) + Return (Local0) + } + + Local0 = \BRKP.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x044C) + Return (Local0) + } + + Local0 = \ADSU.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0453) + Return (Local0) + } + + Local0 = \INDC.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x045A) + Return (Local0) + } + + Local0 = \LOPS.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0461) + Return (Local0) + } + + Local0 = \FDSO.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0468) + Return (Local0) + } + + Local0 = \MLDV.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x046F) + Return (Local0) + } + + Local0 = \NBIT.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0476) + Return (Local0) + } + + Local0 = \SHFT.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x047D) + Return (Local0) + } + + Local0 = \XORD.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0484) + Return (Local0) + } + + Local0 = \CRBF.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x048B) + Return (Local0) + } + + Local0 = \IDX4.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0492) + Return (Local0) + } + + Local0 = \EVNT.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x0499) + Return (Local0) + } + + Local0 = \SZLV.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04A0) + Return (Local0) + } + + Local0 = \_SB.BYTF.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04A7) + Return (Local0) + } + + Local0 = \DWDF.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04AE) + Return (Local0) + } + + Local0 = \DVAX.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04B5) + Return (Local0) + } + + Local0 = \IDX6.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04BC) + Return (Local0) + } + + Local0 = \IDX5.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04C3) + Return (Local0) + } + + Local0 = \_SB.IDX0.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04CA) + Return (Local0) + } + + Local0 = \_SB.IDX3.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04D1) + Return (Local0) + } + + Local0 = \IDX7.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04D8) + Return (Local0) + } + + Local0 = \MTCH.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04DF) + Return (Local0) + } + + Local0 = \WHLB.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04E6) + Return (Local0) + } + + Local0 = \_SB.IDX2.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04ED) + Return (Local0) + } + + Local0 = \SIZO.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04F4) + Return (Local0) + } + + Local0 = \_SB.SMIS.TEST () + If ((Local0 > 0x00)) + { + ERR (0x01, 0x04FB) + Return (Local0) + } + + If ((ERRS > 0x00)) + { + Debug = "****** There were errors during the execution of the test ******" + } + + /* Flush all notifies */ + + Sleep (0xFA) + /* */ + /* Last Test */ + /* */ + Return (0x00) /* Success */ + } + + Method (OBJ1, 1, Serialized) + { + Local0 = 0x03 + Name (BUFR, Buffer (Local0){}) + Name (BUF1, Buffer (0x04) + { + 0x01, 0x02, 0x03, 0x04 // .... + }) + Name (BUF2, Buffer (0x04){}) + BUF2 = BUF1 /* \OBJ1.BUF1 */ + Mutex (MTX1, 0x04) + Alias (MTX1, MTX2) + } + + Mutex (MTXT, 0x00) + Mutex (MTXX, 0x00) + /* + * Field Creation + */ + Method (FLDS, 0, Serialized) + { + Debug = "++++++++ Creating BufferFields" + Name (BUF2, Buffer (0x80){}) + CreateBitField (BUF2, 0x03, BIT2) + CreateByteField (BUF2, 0x01, BYT2) + CreateWordField (BUF2, 0x02, WRD2) + CreateDWordField (BUF2, 0x04, DWD2) + CreateQWordField (BUF2, 0x08, QWD2) + CreateField (BUF2, 0x80, 0x0C, FLD2) + CreateField (BUF2, 0x94, 0x60, FLD3) + BIT2 = 0x01 + Local0 = BIT2 /* \FLDS.BIT2 */ + If ((Local0 != 0x01)) + { + ERR (0x01, 0x0537) + } + Else + { + Local0 = DerefOf (BUF2 [0x00]) + If ((Local0 != 0x08)) + { + ERR (0x01, 0x053E) + } + Else + { + Debug = "++++++++ Bit BufferField I/O PASS" + } + } + + BYT2 = 0x1A + Local0 = BYT2 /* \FLDS.BYT2 */ + If ((Local0 != 0x1A)) + { + ERR (0x01, 0x054A) + } + Else + { + Debug = "++++++++ Byte BufferField I/O PASS" + } + + WRD2 = 0x1234 + Local0 = WRD2 /* \FLDS.WRD2 */ + If ((Local0 != 0x1234)) + { + ERR (0x01, 0x0555) + } + Else + { + Debug = "++++++++ Word BufferField I/O PASS" + } + + FLD2 = 0x0123 + Local0 = FLD2 /* \FLDS.FLD2 */ + If ((Local0 != 0x0123)) + { + ERR (0x01, 0x0560) + } + Else + { + Debug = "++++++++ 12-bit BufferField I/O PASS" + } + + DWD2 = 0x12345678 + Local0 = DWD2 /* \FLDS.DWD2 */ + If ((Local0 != 0x12345678)) + { + ERR (0x01, 0x056B) + } + Else + { + Debug = "++++++++ Dword BufferField I/O PASS" + } + + QWD2 = 0x1234567887654321 + Local0 = QWD2 /* \FLDS.QWD2 */ + If ((Local0 != 0x1234567887654321)) + { + ERR (0x01, 0x0576) + } + Else + { + Debug = "++++++++ Qword BufferField I/O PASS" + } + } + + /* Field execution */ + + Method (FLDX, 0, Serialized) + { + Field (\_SB.MEM.SMEM, AnyAcc, NoLock, Preserve) + { + /* Field: SMEM overlay using 32-bit field elements */ + + SMD0, /* 32-bits */ 32, + SMD1, /* 32-bits */ 32, + SMD2, /* 32-bits */ 32, + SMD3, /* 32-bits */ 32 + } /* 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, /* larger than an integer (32 or 64) */ 69, + SME1, /* larger than an integer */ 97 + } /* Field: SMEM overlay using greater than 32-bit field elements */ + } + + Method (MTX, 0, NotSerialized) + { + /* Test "Force release" of mutex on method exit */ + + Acquire (MTXT, 0xFFFF) + Acquire (MTXX, 0xFFFF) + Debug = "++++++++ Acquiring Mutex MTX2" + Acquire (_GL, 0xFFFF) + Debug = "++++++++ Releasing Mutex MTX2" + Release (_GL) + } + + Method (OBJ2, 1, Serialized) + { + Debug = "++++++++ Creating Buffer BUFO" + Name (BUFO, Buffer (0x20){}) + Debug = "++++++++ Creating OpRegion OPR2" + OperationRegion (OPR2, SystemMemory, Arg0, 0x0100) + Debug = "++++++++ Creating Field(s) in OpRegion OPR2" + Field (OPR2, ByteAcc, NoLock, Preserve) + { + IDX2, 8, + DAT2, 8, + BNK2, 4 + } + + Debug = "++++++++ Creating BankField BNK2 in OpRegion OPR2" + /* */ + /* mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1 */ + /* */ + BankField (OPR2, BNK2, 0x00, ByteAcc, NoLock, Preserve) + { + FET0, 4, + FET1, 3 + } + + Debug = "++++++++ Creating IndexField" + IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve) + { + FET2, 4, + FET3, 3 + } + + Debug = "++++++++ SizeOf (BUFO)" + SizeOf (BUFO) + Debug = "++++++++ Store (SizeOf (BUFO), Local0)" + Local0 = SizeOf (BUFO) + Debug = "++++++++ Concatenate (\"abd\", \"def\", Local0)" + Concatenate ("abd", "def", Local0) + Debug = Local0 + Debug = "++++++++ Concatenate (\"abd\", 0x7B, Local0)" + Concatenate ("abd", 0x7B, Local0) + Debug = Local0 + Debug = "++++++++ Creating Event EVT2" + Event (EVT2) + Debug = "++++++++ Creating Mutex MTX2" + Mutex (MTX2, 0x00) + Debug = "++++++++ Creating Alias MTXA to MTX2" + Alias (MTX2, MTXA) + Debug = "++++++++ Acquiring Mutex MTX2" + Acquire (MTX2, 0xFFFF) + Debug = "++++++++ Acquiring Mutex MTX2 (2nd acquire)" + Acquire (MTX2, 0x0001) + Debug = "++++++++ Releasing Mutex MTX2" + Release (MTX2) + /* Type 1 opcodes */ + + Debug = "++++++++ Signalling Event EVT2" + Signal (EVT2) + Debug = "++++++++ Resetting Event EVT2" + Reset (EVT2) + Debug = "++++++++ Signalling Event EVT2" + Signal (EVT2) + Debug = "++++++++ Waiting Event EVT2" + Wait (EVT2, 0xFFFF) + Debug = "++++++++ Sleep" + Sleep (0x64) + Debug = "++++++++ Stall" + Stall (0xFE) + Debug = "++++++++ NoOperation" + Noop + /* Type 2 Opcodes */ + + Debug = "++++++++ Return from Method OBJ2" + Return (0x04) + } + + Method (NUM1, 0, NotSerialized) + { + /* ADD */ + + Debug = "++++++++ Add (0x12345678, 0x11111111, Local0)" + Local0 = (0x12345678 + 0x11111111) + Debug = "++++++++ Store (Add (0x12345678, 0x11111111), Local1)" + Store ((0x12345678 + 0x11111111), Local1) + Debug = "++++++++ Checking result from ADD" + If ((Local0 != Local1)) + { + ERR (0x00, 0x060E) + } + + /* SUBTRACT */ + + Debug = "++++++++ Subtract (0x87654321, 0x11111111, Local4)" + Local4 = (0x87654321 - 0x11111111) + Debug = "++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)" + Store ((0x87654321 - 0x11111111), Local5) + Debug = "++++++++ Checking result from SUBTRACT" + If ((Local4 != Local5)) + { + ERR (0x00, 0x061D) + } + + /* MULTIPLY */ + + Debug = "++++++++ Multiply (33, 10, Local6)" + Local6 = (0x21 * 0x0A) + Debug = "++++++++ Store (Multiply (33, 10), Local7)" + Store ((0x21 * 0x0A), Local7) + Debug = "++++++++ Checking result from MULTIPLY" + If ((Local6 != Local7)) + { + ERR (0x00, 0x062D) + } + + /* DIVIDE */ + + Debug = "++++++++ Divide (100, 9, Local1, Local2)" + Divide (0x64, 0x09, Local1, Local2) + Debug = "++++++++ Store (Divide (100, 9), Local3)" + Store ((0x64 / 0x09), Local3) + Debug = "++++++++ Checking (quotient) result from DIVIDE" + If ((Local2 != Local3)) + { + ERR (0x00, 0x063C) + } + + /* INCREMENT */ + + Debug = "++++++++ Increment (Local0)" + Local0 = 0x01 + Local1 = 0x02 + Local0++ + Debug = "++++++++ Checking result from INCREMENT" + If ((Local0 != Local1)) + { + ERR (0x00, 0x064A) + } + + /* DECREMENT */ + + Debug = "++++++++ Decrement (Local0)" + Local0 = 0x02 + Local1 = 0x01 + Local0-- + Debug = "++++++++ Checking result from DECREMENT" + If ((Local0 != Local1)) + { + ERR (0x00, 0x0658) + } + + /* TOBCD */ + /* FROMBCD */ + Debug = "++++++++ ToBCD (0x1234, Local5)" + ToBCD (0x1234, Local5) + Debug = "++++++++ FromBCD (Local5, Local6)" + FromBCD (Local5, Local6) + Debug = "++++++++ Return (Local6)" + Return (Local6) + } + + Method (CHEK, 0, NotSerialized) + { + Local0 = 0x03 + Debug = 0x03 + Debug = Local0 + Local1 = 0x07 + (Local0 + Local1) + If ((Local0 != 0x03)) + { + ERR (0x02, 0x0675) + } + + If ((Local1 != 0x07)) + { + ERR (0x02, 0x0679) + } + + Local2 = (Local0 + Local1) + If ((Local0 != 0x03)) + { + ERR (0x02, 0x0680) + } + + If ((Local1 != 0x07)) + { + ERR (0x02, 0x0684) + } + } + + Method (RET1, 0, NotSerialized) + { + Local0 = 0x03 + Return (Local0) + } + + Method (RET2, 0, NotSerialized) + { + Return (RET1 ()) + } + + Method (RETZ, 0, NotSerialized) + { + RET2 () + } + + Method (BITZ, 0, NotSerialized) + { + Debug = "++++++++ FindSetLeftBit (0x00100100, Local0)" + FindSetLeftBit (0x00100100, Local0) + If ((Local0 != 0x15)) + { + ERR (0x01, 0x06A0) + } + + Debug = "++++++++ FindSetRightBit (0x00100100, Local1)" + FindSetRightBit (0x00100100, Local1) + If ((Local1 != 0x09)) + { + ERR (0x01, 0x06A7) + } + + Debug = "++++++++ And (0xF0F0F0F0, 0x11111111, Local2)" + Local2 = (0xF0F0F0F0 & 0x11111111) + If ((Local2 != 0x10101010)) + { + ERR (0x01, 0x06AE) + } + + Debug = "++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)" + NAnd (0xF0F0F0F0, 0x11111111, Local3) + If ((Local3 != 0xEFEFEFEF)) + { + ERR (0x01, 0x06B5) + } + + Debug = "++++++++ Or (0x11111111, 0x22222222, Local4)" + Local4 = (0x11111111 | 0x22222222) + If ((Local4 != 0x33333333)) + { + ERR (0x01, 0x06BC) + } + + Debug = "++++++++ NOr (0x11111111, 0x22222222, Local5)" + NOr (0x11111111, 0x22222222, Local5) + If ((Local5 != 0xCCCCCCCC)) + { + ERR (0x01, 0x06C3) + } + + Debug = "++++++++ XOr (0x11113333, 0x22222222, Local6)" + Local6 = (0x11113333 ^ 0x22222222) + If ((Local6 != 0x33331111)) + { + ERR (0x01, 0x06CA) + } + + Debug = "++++++++ ShiftLeft (0x11112222, 2, Local7)" + Local7 = (0x11112222 << 0x02) + If ((Local7 != 0x44448888)) + { + ERR (0x01, 0x06D1) + } + + Debug = "++++++++ ShiftRight (Local7, 2, Local7)" + Local7 >>= 0x02 + If ((Local7 != 0x11112222)) + { + ERR (0x01, 0x06D8) + } + + Debug = "++++++++ Not (Local0, Local1)" + Local0 = 0x22224444 + Local1 = ~Local0 + If ((Local0 != 0x22224444)) + { + ERR (0x02, 0x06E1) + } + + If ((Local1 != 0xDDDDBBBB)) + { + ERR (0x01, 0x06E6) + } + + Return (Local7) + } + + Method (LOGS, 0, NotSerialized) + { + Debug = "++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)" + Local0 = (0xFFFFFFFF && 0x11111111) + Debug = "++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)" + Local1 = (0xFFFFFFFF == 0x11111111) + Debug = "++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)" + Local2 = (0xFFFFFFFF > 0x11111111) + Debug = "++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)" + Local3 = (0xFFFFFFFF >= 0x11111111) + Debug = "++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)" + Local4 = (0xFFFFFFFF < 0x11111111) + Debug = "++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)" + Local5 = (0xFFFFFFFF <= 0x11111111) + Debug = "++++++++ Store (LNot (0x31313131), Local6)" + Local6 = 0x1111 + Local7 = !Local6 + If ((Local6 != 0x1111)) + { + ERR (0x02, 0x0707) + } + + If ((Local7 != 0x00)) + { + ERR (0x01, 0x070C) + } + + Debug = "++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)" + Local7 = (0xFFFFFFFF != 0x11111111) + Debug = "++++++++ Lor (0x0, 0x1)" + If ((0x00 || 0x01)) + { + Debug = "+_+_+_+_+ Lor (0x0, 0x1) returned TRUE" + } + + Return (Local7) + } + + Method (COND, 0, NotSerialized) + { + Debug = "++++++++ Store (0x4, Local0)" + Local0 = 0x04 + Debug = "++++++++ While (Local0)" + While (Local0) + { + Debug = "++++++++ Decrement (Local0)" + Local0-- + } + + Debug = "++++++++ Store (0x3, Local6)" + Local6 = 0x03 + Debug = "++++++++ While (Subtract (Local6, 1))" + While ((Local6 - 0x01)) + { + Debug = "++++++++ Decrement (Local6)" + Local6-- + } + + Debug = "++++++++ [LVL1] If (LGreater (0x2, 0x1))" + If ((0x02 > 0x01)) + { + Debug = "++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))" + If ((0x11111111 == 0x22222222)) + { + Debug = "++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE" + } + Else + { + Debug = "++++++++ [LVL3] If (LNot (0x0))" + If (!0x00) + { + Debug = "++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))" + If ((0xEEEEEEEE && 0x02)) + { + Debug = "++++++++ [LVL5] If (LLess (0x44444444, 0x3))" + If ((0x44444444 < 0x03)) + { + Debug = "++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE" + } + Else + { + Debug = "++++++++ Exiting from nested IF/ELSE statements" + } + } + } + } + } + + Debug = "++++++++ [LVL1] If (LGreater (0x2, 0x1))" + If ((0x02 > 0x01)) + { + Debug = "++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))" + If ((0x11111111 == 0x22222222)) + { + Debug = "++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE" + } + Else + { + Debug = "++++++++ [LVL3] If (LNot (0x0))" + If (!0x00) + { + Debug = "++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))" + If ((0xEEEEEEEE && 0x02)) + { + Debug = "++++++++ [LVL5] If (LLess (0x44444444, 0x3))" + If ((0x44444444 < 0x03)) + { + Debug = "++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE" + } + Else + { + Debug = "++++++++ Returning from nested IF/ELSE statements" + Return (Local6) + } + } + } + } + } + } + + Method (REFS, 0, Serialized) + { + Name (BBUF, Buffer (0x08) + { + 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7 // ........ + }) + Name (NEST, Package (0x02) + { + Package (0x06) + { + 0x01, + 0x02, + 0x03, + 0x04, + 0x05, + 0x06 + }, + + Package (0x06) + { + 0x11, + 0x12, + 0x12, + 0x14, + 0x15, + 0x16 + } + }) + Local5 = RefOf (MAIN) + /* For this to work, ABCD must NOT exist. */ + + Local1 = CondRefOf (ABCD, Local0) + If ((Local1 != 0x00)) + { + ERR (0x02, 0x0791) + } + + Local1 = CondRefOf (BBUF, Local0) + If ((Local1 != Ones)) + { + ERR (0x02, 0x0797) + } + + Local6 = DerefOf (BBUF [0x03]) + If ((Local6 != 0xB3)) + { + ERR (0x02, 0x079D) + } + + Local0 = DerefOf (DerefOf (NEST [0x01]) [0x03]) + If ((Local0 != 0x14)) + { + ERR (0x02, 0x07A3) + } + + Local0 = 0x11223344 + Local1 = RefOf (Local0) + Local2 = DerefOf (Local1) + If ((Local2 != 0x11223344)) + { + ERR (0x02, 0x07AD) + } + /* 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, Serialized) + { + Name (STAT, Package (0x04){}) + STAT [0x00] = 0x44443333 + } + + /*================================================================= */ + /*================================================================= */ + /*===================== iPCO TESTS ================================ */ + /*================================================================= */ + /*================================================================= */ + /* */ + /* */ + /* test IfElseOp.asl */ + /* */ + /* test for IfOp and ElseOp, including validation of object stack cleanup */ + /* */ + Device (IFEL) + { + Name (DWRD, 0x01) + Name (RSLT, 0x00) + /* IFNR control method executes IfOp branch with NO nested Return */ + /* and no Else branch */ + Method (IFNR, 0, NotSerialized) + { + RSLT = DWRD /* \IFEL.DWRD */ + If ((DWRD == 0x01)) + { + RSLT = 0x00 + } + } /* IFNR */ + + /* NINR control method does not execute If branch and has no Else branch */ + + Method (NINR, 0, NotSerialized) + { + RSLT = 0x00 + If ((DWRD != 0x01)) + { + RSLT = DWRD /* \IFEL.DWRD */ + } + } /* NINR */ + + /* IENR control method executes IfOp branch with NO nested Return */ + + Method (IENR, 0, NotSerialized) + { + If ((DWRD == 0x01)) + { + RSLT = 0x00 + } + Else + { + RSLT = DWRD /* \IFEL.DWRD */ + } + } /* IENR */ + + /* ELNR control method executes ElseOp branch with NO nested Return */ + + Method (ELNR, 0, NotSerialized) + { + If ((DWRD != 0x01)) + { + RSLT = DWRD /* \IFEL.DWRD */ + } + Else + { + RSLT = 0x00 + } + } /* ELNR */ + + /* IFRT control method executes IfOp branch with nested Return with */ + /* no Else branch */ + Method (IFRT, 0, NotSerialized) + { + If ((DWRD == 0x01)) + { + Return (0x00) + } + + Return (DWRD) /* \IFEL.DWRD */ + } /* IFRT */ + + /* IERT control method executes IfOp branch with nested Return with */ + /* Else branch */ + Method (IERT, 0, NotSerialized) + { + If ((DWRD == 0x01)) + { + Return (0x00) + } + Else + { + Return (DWRD) /* \IFEL.DWRD */ + } + } /* IERT */ + + /* ELRT control method executes ElseOp branch with nested Return */ + + Method (ELRT, 0, NotSerialized) + { + If ((DWRD != 0x01)) + { + Return (DWRD) /* \IFEL.DWRD */ + } + Else + { + Return (0x00) + } + } /* ELRT */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ IfElseOp Test" + /* IfOp with NO return value */ + + IFNR () + If ((RSLT != 0x00)) + { + Return (RSLT) /* \IFEL.RSLT */ + } + + /* IfOp with NO return value */ + + NINR () + If ((RSLT != 0x00)) + { + Return (RSLT) /* \IFEL.RSLT */ + } + + /* IfOp with NO return value */ + + IENR () + If ((RSLT != 0x00)) + { + Return (RSLT) /* \IFEL.RSLT */ + } + + /* ElseOp with NO return value */ + + ELNR () + If ((RSLT != 0x00)) + { + Return (RSLT) /* \IFEL.RSLT */ + } + + /* IfOp with return value */ + + RSLT = IFRT () + If ((RSLT != 0x00)) + { + Return (RSLT) /* \IFEL.RSLT */ + } + + /* IfOp with return value */ + + RSLT = IERT () + If ((RSLT != 0x00)) + { + Return (RSLT) /* \IFEL.RSLT */ + } + + /* ElseOp with return value */ + + RSLT = ELRT () + If ((RSLT != 0x00)) + { + Return (RSLT) /* \IFEL.RSLT */ + } + + Return (0x00) + } /* 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, 0, Serialized) + { + Debug = "++++++++ NoSave Test" + Name (WRD, 0x1234) + /* */ + /* Begin test of nested operators without saving results */ + /* */ + /* Test If (And ()) with no save of And result */ + If ((0x03 & 0x01)) + { + WRD = 0x01 /* pass -- just do something */ + } + Else + { + Return (0x01) /* fail */ + } + + /* Test If (And ()) with no save of And result */ + + If ((0x04 & 0x01)) + { + Return (0x02) /* fail */ + } + Else + { + WRD = 0x02 /* pass -- just do something */ + } + + /* Test If (NAnd ()) with no save of NAnd result */ + + If (NAnd (0x03, 0x01)) + { + WRD = 0x03 /* pass -- just do something */ + } + Else + { + Return (0x03) /* fail */ + } + + /* Test If (NAnd ()) with no save of NAnd result */ + + If (NAnd (0xFFFFFFFF, 0xFFFFFFFF)) + { + Return (0x04) /* fail */ + } + Else + { + WRD = 0x04 /* pass -- just do something */ + } + + /* Test If (NOr ()) with no save of NOr result */ + + If (NOr (0x00, 0x01)) + { + WRD = 0x05 /* pass -- just do something */ + } + Else + { + Return (0x05) /* fail */ + } + + /* Test If (NOr ()) with no save of NOr result */ + + If (NOr (0xFFFFFFFE, 0x01)) + { + Return (0x06) /* fail */ + } + Else + { + WRD = 0x06 /* pass -- just do something */ + } + + /* Test If (Not ()) with no save of Not result */ + + If (~0x01) + { + WRD = 0x07 /* pass -- just do something */ + } + Else + { + Return (0x07) /* fail */ + } + + /* Test If (Not ()) with no save of Not result */ + + If (~0xFFFFFFFF) + { + Return (0x08) /* fail */ + } + Else + { + WRD = 0x08 /* pass -- just do something */ + } + + /* Test If (Or ()) with no save of Or result */ + + If ((0x03 | 0x01)) + { + WRD = 0x09 /* pass -- just do something */ + } + Else + { + Return (0x09) /* fail */ + } + + /* Test If (Or ()) with no save of Or result */ + + If ((0x00 | 0x00)) + { + Return (0x0A) /* fail */ + } + Else + { + WRD = 0x0A /* pass -- just do something */ + } + + /* Test If (XOr ()) with no save of XOr result */ + + If ((0x03 ^ 0x01)) + { + WRD = 0x0B /* pass -- just do something */ + } + Else + { + Return (0x0B) /* fail */ + } + + /* Test If (XOr ()) with no save of XOr result */ + + If ((0x03 ^ 0x03)) + { + Return (0x0C) /* fail */ + } + Else + { + WRD = 0x0C /* pass -- just do something */ + } + + /* */ + /* Begin test of logical operators with no destination operands */ + /* */ + /* Test If (LAnd ()) with no save of LAnd result */ + If ((0x03 && 0x03)) + { + WRD = 0x15 /* pass -- just do something */ + } + Else + { + Return (0x15) /* fail */ + } + + /* Test If (LAnd ()) with no save of LAnd result */ + + If ((0x03 && 0x00)) + { + Return (0x16) /* fail */ + } + Else + { + WRD = 0x16 /* pass -- just do something */ + } + + /* Test If (LAnd ()) with no save of LAnd result */ + + If ((0x00 && 0x03)) + { + Return (0x17) /* fail */ + } + Else + { + WRD = 0x17 /* pass -- just do something */ + } + + /* Test If (LAnd ()) with no save of LAnd result */ + + If ((0x00 && 0x00)) + { + Return (0x18) /* fail */ + } + Else + { + WRD = 0x18 /* pass -- just do something */ + } + + /* Test If (LEqual ()) with no save of LEqual result */ + + If ((0x03 == 0x03)) + { + WRD = 0x1F /* pass -- just do something */ + } + Else + { + Return (0x1F) /* fail */ + } + + /* Test If (LEqual ()) with no save of LEqual result */ + + If ((0x01 == 0x03)) + { + Return (0x20) /* fail */ + } + Else + { + WRD = 0x20 /* pass -- just do something */ + } + + /* Test If (LGreater ()) with no save of LGreater result */ + + If ((0x03 > 0x01)) + { + WRD = 0x29 /* pass -- just do something */ + } + Else + { + Return (0x29) /* fail */ + } + + /* Test If (LGreater ()) with no save of LGreater result */ + + If ((0x04 > 0x04)) + { + Return (0x2A) /* fail */ + } + Else + { + WRD = 0x2A /* pass -- just do something */ + } + + /* Test If (LGreater ()) with no save of LGreater result */ + + If ((0x01 > 0x04)) + { + Return (0x2B) /* fail */ + } + Else + { + WRD = 0x2B /* pass -- just do something */ + } + + /* Test If (LGreaterEqual ()) with no save of LGreaterEqual result */ + + If ((0x03 >= 0x01)) + { + WRD = 0x2C /* pass -- just do something */ + } + Else + { + Return (0x2C) /* fail */ + } + + /* Test If (LGreaterEqual ()) with no save of LGreaterEqual result */ + + If ((0x03 >= 0x03)) + { + WRD = 0x2D /* pass -- just do something */ + } + Else + { + Return (0x2D) /* fail */ + } + + /* Test If (LGreaterEqual ()) with no save of LGreaterEqual result */ + + If ((0x03 >= 0x04)) + { + Return (0x2E) /* fail */ + } + Else + { + WRD = 0x2E /* pass -- just do something */ + } + + /* Test If (LLess ()) with no save of LLess result */ + + If ((0x01 < 0x03)) + { + WRD = 0x33 /* pass -- just do something */ + } + Else + { + Return (0x33) /* fail */ + } + + /* Test If (LLess ()) with no save of LLess result */ + + If ((0x02 < 0x02)) + { + Return (0x34) /* fail */ + } + Else + { + WRD = 0x34 /* pass -- just do something */ + } + + /* Test If (LLess ()) with no save of LLess result */ + + If ((0x04 < 0x02)) + { + Return (0x35) /* fail */ + } + Else + { + WRD = 0x35 /* pass -- just do something */ + } + + /* Test If (LLessEqual ()) with no save of LLessEqual result */ + + If ((0x01 <= 0x03)) + { + WRD = 0x36 /* pass -- just do something */ + } + Else + { + Return (0x36) /* fail */ + } + + /* Test If (LLessEqual ()) with no save of LLessEqual result */ + + If ((0x02 <= 0x02)) + { + WRD = 0x37 /* pass -- just do something */ + } + Else + { + Return (0x37) /* fail */ + } + + /* Test If (LLessEqual ()) with no save of LLessEqual result */ + + If ((0x04 <= 0x02)) + { + Return (0x38) /* fail */ + } + Else + { + WRD = 0x38 /* pass -- just do something */ + } + + /* Test If (LNot ()) with no save of LNot result */ + + If (!0x00) + { + WRD = 0x3D /* pass -- just do something */ + } + Else + { + Return (0x3D) /* fail */ + } + + /* Test If (LNot ()) with no save of LNot result */ + + If (!0x01) + { + Return (0x3E) /* fail */ + } + Else + { + WRD = 0x3E /* pass -- just do something */ + } + + /* Test If (LNotEqual ()) with no save of LNotEqual result */ + + If ((0x03 != 0x03)) + { + Return (0x3F) /* fail */ + } + Else + { + WRD = 0x3F /* pass -- just do something */ + } + + /* Test If (LNotEqual ()) with no save of LNotEqual result */ + + If ((0x01 != 0x03)) + { + WRD = 0x40 /* pass -- just do something */ + } + Else + { + Return (0x40) /* fail */ + } + + /* Test If (LOr ()) with no save of LOr result */ + + If ((0x03 || 0x01)) + { + WRD = 0x47 /* pass -- just do something */ + } + Else + { + Return (0x47) /* fail */ + } + + /* Test If (LOr ()) with no save of LOr result */ + + If ((0x00 || 0x01)) + { + WRD = 0x48 /* pass -- just do something */ + } + Else + { + Return (0x48) /* fail */ + } + + /* Test If (LOr ()) with no save of LOr result */ + + If ((0x03 || 0x00)) + { + WRD = 0x49 /* pass -- just do something */ + } + Else + { + Return (0x49) /* fail */ + } + + /* Test If (LOr ()) with no save of LOr result */ + + If ((0x00 || 0x00)) + { + Return (0x4A) /* fail */ + } + Else + { + WRD = 0x4A /* pass -- just do something */ + } + + Return (0x00) + } /* 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, 0x0100, 0x02) + Field (SIO, ByteAcc, NoLock, Preserve) + { + INDX, 8, + DATA, 8 + } + + IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes) + { + AccessAs (ByteAcc, 0x00), + IFE0, 8, + IFE1, 8, + IFE2, 8, + IFE3, 8, + IFE4, 8, + IFE5, 8, + IFE6, 8, + IFE7, 8, + IFE8, 8, + IFE9, 8 + } + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ IndxFld Test" + Local0 = IFE0 /* \IDXF.IFE0 */ + Local1 = IFE1 /* \IDXF.IFE1 */ + Local2 = IFE2 /* \IDXF.IFE2 */ + Return (0x00) + } /* TEST */ + } /* IDXF */ + + /* */ + /* test NestdLor.asl */ + /* */ + Scope (\_SB) /* System Bus */ + { + /* _SB system bus */ + + Name (ZER0, 0x00) + Name (ZER1, 0x00) + Name (ZER2, 0x00) + Name (ONE0, 0x01) + Device (NSTL) + { + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ NestdLor Test" + If ((ZER0 || (ZER1 || (ZER2 || ONE0)))) + { + /* Indicate Pass */ + + Local0 = 0x00 + } + Else + { + /* Indicate Fail */ + + Local0 = 0x01 + } + + 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, NotSerialized) + { + Return (Arg0) + } + + Method (RBUF, 0, Serialized) + { + /* RBUF: Return Buffer from local variable */ + + Name (ABUF, Buffer (0x11) + { + "ARBITRARY_BUFFER" + }) + /* store local buffer ABUF into Local0 */ + + Local0 = ABUF /* \RTBF.RBUF.ABUF */ + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Buffer */ + + If ((Local1 != 0x03)) /* Buffer type is 3 */ + { + Return (0x01) /* failure */ + } + + /* store value returned by control method SUBR into Local0 */ + + Local0 = SUBR (ABUF) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Buffer */ + + If ((Local1 != 0x03)) /* Buffer type is 3 */ + { + Return (0x02) /* failure */ + } + + /* allocate buffer using Local1 as buffer size (run-time evaluation) */ + + Local1 = 0x05 + Name (BUFR, Buffer (Local1){}) + /* store value returned by control method SUBR into Local0 */ + + Local0 = SUBR (BUFR) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Buffer */ + + If ((Local1 != 0x03)) /* Buffer type is 3 */ + { + Return (0x03) /* failure */ + } + + /* store BUFR Buffer into Local0 */ + + Local0 = BUFR /* \RTBF.RBUF.BUFR */ + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Buffer */ + + If ((Local1 != 0x03)) /* Buffer type is 3 */ + { + Return (0x04) /* failure */ + } + + /* return Local0 Buffer */ + + Return (Local0) + } /* RBUF */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ RetBuf Test" + /* store RBUF Buffer return value into Local0 */ + + Local0 = RBUF () + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Buffer */ + + If ((Local1 != 0x03)) /* Buffer type is 3 */ + { + Return (0x0A) /* failure */ + } + Else + { + Return (0x00) /* 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, 0, NotSerialized) // _Lxx: Level-Triggered GPE + { + Debug = "Method GPE2._L03 invoked" + Return (Zero) + } + + Method (_E05, 0, NotSerialized) // _Exx: Edge-Triggered GPE + { + Debug = "Method GPE2._E05 invoked" + Return (Zero) + } + } + + Device (PRW2) + { + Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake + { + Package (0x02) + { + \GPE2, + 0x05 + }, + + 0x03 + }) + } + + Scope (\_GPE) + { + Name (ACST, 0xFF) + Method (_L08, 0, NotSerialized) // _Lxx: Level-Triggered GPE + { + Debug = "Method _GPE._L08 invoked" + Return (Zero) + } + + Method (_E09, 0, NotSerialized) // _Exx: Edge-Triggered GPE + { + Debug = "Method _GPE._E09 invoked" + Return (Zero) + } + + Method (_E11, 0, NotSerialized) // _Exx: Edge-Triggered GPE + { + Debug = "Method _GPE._E11 invoked" + Notify (\PRW1, 0x02) // Device Wake + } + + Method (_L22, 0, NotSerialized) // _Lxx: Level-Triggered GPE + { + Debug = "Method _GPE._L22 invoked" + Return (Zero) + } + + Method (_L33, 0, NotSerialized) // _Lxx: Level-Triggered GPE + { + Debug = "Method _GPE._L33 invoked" + Return (Zero) + } + + Method (_E64, 0, NotSerialized) // _Exx: Edge-Triggered GPE + { + Debug = "Method _GPE._E64 invoked" + Return (Zero) + } + } /* _GPE */ + + Device (PRW1) + { + Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake + { + 0x11, + 0x03 + }) + } + + Device (PWRB) + { + Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */) // _HID: Hardware ID + Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake + { + 0x33, + 0x03 + }) + } + + Scope (\_SB) /* System Bus */ + { + /* _SB system bus */ + + Device (ACAD) + { + /* ACAD: AC adapter device */ + + Name (_HID, "ACPI0003" /* Power Source Device */) /* AC adapter device */ // _HID: Hardware ID + Name (_PCL, Package (0x01) // _PCL: Power Consumer List + { + \_SB + }) + OperationRegion (AREG, SystemIO, 0x0372, 0x02) + Field (AREG, ByteAcc, NoLock, Preserve) + { + AIDX, 8, + ADAT, 8 + } + + IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve) + { + , 1, + ACIN, 1, + , 2, + CHAG, 1, + Offset (0x01), + , 7, + ABAT, 1 + } /* IndexField */ + + Method (_PSR, 0, NotSerialized) // _PSR: Power Source + { + Local0 = \_GPE.ACST + Local1 = ACIN /* \_SB_.ACAD.ACIN */ + If ((\_GPE.ACST != Local1)) + { + \_GPE.ACST = Local1 + /* 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, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + + Method (_INI, 0, NotSerialized) // _INI: Initialize + { + \_GPE.ACST = ACIN /* \_SB_.ACAD.ACIN */ + } + } /* ACAD: AC adapter device */ + + /* test implicit return from control method */ + + Method (DIS, 1, NotSerialized) + { + Local0 = Arg0 + } + + Device (RTLV) + { + /* test implicit return inside nested if with explicit return of Lvalue */ + + Method (_DCK, 1, NotSerialized) // _DCK: Dock Present + { + If (Arg0) + { + /* dock */ + + Local0 = 0x87 + If (Local0) + { + DIS (0x23) + Return (0x01) + } + + Return (0x00) + } /* dock */ + Else + { + /* undock */ + + Local0 = Arg0 + If (Local0) + { + DIS (0x23) + Return (0x01) + } + + Return (0x00) + } /* undock */ + } /* _DCK control method */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ RetLVal Test" + /* store _PSR return value into Local0 */ + + Local0 = \_SB.ACAD._PSR () + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number/Integer type is 1 */ + { + Return (0x01) /* failure */ + } + + /* test implicit return inside nested if with explicit return of Lvalue */ + + Local2 = _DCK (0x01) + /* save Local2 object type value into Local3 */ + + Local3 = ObjectType (Local2) + /* validate Local2 is a Number */ + + If ((Local3 != 0x01)) /* Number/Integer type is 1 */ + { + Return (0x02) /* failure */ + } + + If ((Local2 != 0x01)) + { + Return (0x03) /* failure */ + } + + Return (0x00) /* 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 Device */) /* PCI interrupt link */ // _HID: Hardware ID + Name (_UID, 0x01) // _UID: Unique ID + } + + Device (LNKB) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID + Name (_UID, 0x02) // _UID: Unique ID + } + + Device (LNKC) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID + Name (_UID, 0x03) // _UID: Unique ID + } + + Device (LNKD) + { + Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID + Name (_UID, 0x04) // _UID: Unique ID + } + + Device (PCI1) + { + /* PCI1: Root PCI Bus */ + + Name (_HID, "PNP0A03" /* PCI Bus */) /* Need _HID for root device (String format) */ // _HID: Hardware ID + Name (_ADR, 0x00) // _ADR: Address + Name (_CRS, 0x00) // _CRS: Current Resource Settings + Name (_PRT, Package (0x0C) // _PRT: PCI Routing Table + { + Package (0x04) + { + 0x0004FFFF, + 0x00, + LNKA, + 0x00 + }, /* Slot 1, INTA */ + + Package (0x04) + { + 0x0004FFFF, + 0x01, + LNKB, + 0x00 + }, /* Slot 1, INTB */ + + Package (0x04) + { + 0x0004FFFF, + 0x02, + LNKC, + 0x00 + }, /* Slot 1, INTC */ + + Package (0x04) + { + 0x0004FFFF, + 0x03, + LNKD, + 0x00 + }, /* Slot 1, INTD */ + + Package (0x04) + { + 0x0005FFFF, + 0x00, + \_SB.LNKB, + 0x00 + }, /* Slot 2, INTA */ + + Package (0x04) + { + 0x0005FFFF, + 0x01, + \_SB.LNKC, + 0x00 + }, /* Slot 2, INTB */ + + Package (0x04) + { + 0x0005FFFF, + 0x02, + \_SB.LNKD, + 0x00 + }, /* Slot 2, INTC */ + + Package (0x04) + { + 0x0006FFFF, + 0x03, + \_SB.LNKA, + 0x00 + }, /* Slot 2, INTD */ + + Package (0x04) + { + 0x0006FFFF, + 0x00, + LNKC, + 0x00 + }, /* Slot 3, INTA */ + + Package (0x04) + { + 0x0006FFFF, + 0x01, + LNKD, + 0x00 + }, /* Slot 3, INTB */ + + Package (0x04) + { + 0x0006FFFF, + 0x02, + LNKA, + 0x00 + }, /* Slot 3, INTC */ + + Package (0x04) + { + 0x0006FFFF, + 0x03, + LNKB, + 0x00 + } /* Slot 3, INTD */ + }) + Device (PX40) + { + /* Map f0 space, Start PX40 */ + + Name (_ADR, 0x00070000) /* Address+function. */ // _ADR: Address + } + } /* PCI0: Root PCI Bus */ + + Device (RETP) + { + Method (RPKG, 0, NotSerialized) + { + /* RPKG: Return Package from local variable */ + /* store _PRT package into Local0 */ + Local0 = \_SB.PCI1._PRT + /* return Local0 Package */ + + Return (Local0) + } /* RPKG */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ RetPkg Test" + /* store RPKG package return value into Local0 */ + + Local0 = RPKG () + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Package */ + + If ((Local1 != 0x04)) /* Package type is 4 */ + { + Return (0x01) + } /* failure */ + Else + { + Return (0x00) + } /* success */ + } /* TEST */ + } /* RETP */ + } /* _SB_ */ + + /* */ + /* test WhileRet.asl */ + /* */ + /* WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp. */ + /* */ + Device (WHLR) + { + Name (LCNT, 0x00) + Method (WIR, 0, NotSerialized) + { + /* WIR: control method that returns inside of IfOp inside of WhileOp */ + + While ((LCNT < 0x04)) + { + If ((LCNT == 0x02)) + { + Return (0x00) + } + + LCNT++ + } + + Return (LCNT) /* \WHLR.LCNT */ + } /* WIR: control method that returns inside of IfOp inside of WhileOp */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ WhileRet Test" + Local0 = WIR () + 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, 0x00400000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + SMDW, /* 32-bit DWORD */ 32, + SMWD, /* 16-bit WORD */ 16, + SMBY, /* 8-bit BYTE */ 8 + }/* 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, 0x00) + /*And with DWord Data */ + + Name (DWD1, 0xFFFFFFFF) + Name (DWD2, 0xFFFFFFFF) + Name (DRSL, 0x00) + Method (ANDP, 0, NotSerialized) + { + /*Check with 1 And 1 on byte data */ + + BRSL = (BYT1 & BYT2) /* \ANDO.BYT2 */ + If ((BRSL != 0xFF)) + { + Return (0x01) + } + + /*Check with 1 And 1 on Word data */ + + WRSL = (WRD1 & WRD2) /* \ANDO.WRD2 */ + If ((WRSL != 0xFFFF)) + { + Return (0x01) /* failure */ + } + + /*Check with 1 And 1 Dword */ + + DRSL = (DWD1 & DWD2) /* \ANDO.DWD2 */ + If ((DRSL != 0xFFFFFFFF)) + { + Return (0x01) /* failure */ + } + + /*Check with 0 And 0 on byte data */ + + BYT1 = 0x00 + BYT2 = 0x00 + BRSL = 0x00 + BRSL = (BYT1 & BYT2) /* \ANDO.BYT2 */ + If ((BRSL != 0x00)) + { + Return (0x01) /* failure */ + } + + /*Check with 0 And 0 on Word data */ + + WRD1 = 0x00 + WRD2 = 0x00 + WRSL = 0x00 + WRSL = (WRD1 & WRD2) /* \ANDO.WRD2 */ + If ((WRSL != 0x00)) + { + Return (0x01) /* failure */ + } + + /*Check with 0 And 0 Dword */ + + DWD1 = 0x00 + DWD2 = 0x00 + DRSL = 0x00 + DRSL = (DWD1 & DWD2) /* \ANDO.DWD2 */ + If ((DRSL != 0x00)) + { + Return (0x01) /* failure */ + } + + /*Check with 1 And 0 on byte data */ + + BYT1 = 0x55 + BYT2 = 0xAA + BRSL = 0x00 + BRSL = (BYT1 & BYT2) /* \ANDO.BYT2 */ + If ((BRSL != 0x00)) + { + Return (0x01) /* failure */ + } + + /*Check with 1 And 0 on Word data */ + + WRD1 = 0x5555 + WRD2 = 0xAAAA + WRSL = 0x00 + WRSL = (WRD1 & WRD2) /* \ANDO.WRD2 */ + If ((WRSL != 0x00)) + { + Return (0x01) /* failure */ + } + + /*Check with 1 And 0 on Dword */ + + DWD1 = 0x55555555 + DWD2 = 0xAAAAAAAA + DRSL = 0x00 + DRSL = (DWD1 & DWD2) /* \ANDO.DWD2 */ + If ((DRSL != 0x00)) + { + Return (0x01) /* failure */ + } + + TOUD = 0x1FFF + Local0 = TOUD /* \ANDO.TOUD */ + If ((Local0 != 0x1FFF)) + { + Return (0x01) /* failure */ + } + + /*TBD- Do We need to check for system memory data also for each test case ?? */ + + Return (0x00) + }/*ANDP */ + + Method (OROP, 0, NotSerialized) + { + /*Check with 1 Ored with 1 on byte data */ + + BYT1 = 0xFF + BYT2 = 0xFF + BRSL = 0x00 + BRSL = (BYT1 | BYT2) /* \ANDO.BYT2 */ + If ((BRSL != 0xFF)) + { + Return (0x01) /* failure */ + } + + /*Check with 1 Ored with 1 on Word data */ + + WRD1 = 0xFFFF + WRD2 = 0xFFFF + WRSL = 0x00 + WRSL = (WRD1 | WRD2) /* \ANDO.WRD2 */ + If ((WRSL != 0xFFFF)) + { + Return (0x01) /* failure */ + } + + /*Check with 1 Ored with 1 on Dword data */ + + DWD1 = 0xFFFFFFFF + DWD2 = 0xFFFFFFFF + DRSL = 0x00 + DRSL = (DWD1 | DWD2) /* \ANDO.DWD2 */ + If ((DRSL != 0xFFFFFFFF)) + { + Return (0x01) /* failure */ + } + + /*Check with 0 Ored with 0 on byte data */ + + BYT1 = 0x00 + BYT2 = 0x00 + BRSL = 0x00 + BRSL = (BYT1 | BYT2) /* \ANDO.BYT2 */ + If ((BRSL != 0x00)) + { + Return (0x01) /* failure */ + } + + /*Check with 0 Ored with 0 on Word data */ + + WRD1 = 0x00 + WRD2 = 0x00 + WRSL = 0x00 + WRSL = (WRD1 | WRD2) /* \ANDO.WRD2 */ + If ((WRSL != 0x00)) + { + Return (0x01) /* failure */ + } + + /*Check with 0 Ored with 0 Dword data */ + + DWD1 = 0x00 + DWD2 = 0x00 + DRSL = 0x00 + DRSL = (DWD1 | DWD2) /* \ANDO.DWD2 */ + If ((DRSL != 0x00)) + { + Return (0x01) /* failure */ + } + + /*Check with 1 Ored with 0 on byte data */ + + BYT1 = 0x55 + BYT2 = 0xAA + BRSL = 0x00 + BRSL = (BYT1 | BYT2) /* \ANDO.BYT2 */ + If ((BRSL != 0xFF)) + { + Return (0x01) /* failure */ + } + + /*Check with 1 Ored with 0 on Word data */ + + WRD1 = 0x5555 + WRD2 = 0xAAAA + WRSL = 0x00 + WRSL = (WRD1 | WRD2) /* \ANDO.WRD2 */ + If ((WRSL != 0xFFFF)) + { + Return (0x01) /* failure */ + } + + /*Check with 1 Ored with 0 on Dword data */ + + DWD1 = 0x55555555 + DWD2 = 0xAAAAAAAA + DRSL = 0x00 + DRSL = (DWD1 | DWD2) /* \ANDO.DWD2 */ + If ((DRSL != 0xFFFFFFFF)) + { + Return (0x01) /* failure */ + } + + /*TBD - Do We need to check for system memory data also for each test case ?? */ + + Return (0x00) + }/*OROP */ + + Method (TEST, 0, Serialized) + { + Debug = "++++++++ AndOrOp Test" + Name (RSLT, 0x01) + /*Call Andop method */ + + RSLT = ANDP () + If ((RSLT == 0x01)) + { + Return (RSLT) /* \ANDO.TEST.RSLT */ + } + + /*Call OrOp Method */ + + RSLT = OROP () + If ((RSLT == 0x01)) + { + Return (RSLT) /* \ANDO.TEST.RSLT */ + } + + /* */ + /* Return original conditions to allow iterative execution */ + /* */ + BYT1 = 0xFF + BYT2 = 0xFF + BRSL = 0x00 + WRD1 = 0xFFFF + WRD2 = 0xFFFF + WRSL = 0x00 + DWD1 = 0xFFFFFFFF + DWD2 = 0xFFFFFFFF + DRSL = 0x00 + Return (0x00) + } /*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, 0x00) + Method (BK1, 0, NotSerialized) + { + BreakPoint + Return (0x00) + } + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ BreakPnt Test" + CNT0 = 0x00 + /*Check BreakPoint statement */ + + While ((CNT0 < 0x0A)) + { + CNT0++ + } + + /*Check the BreakPoint statement */ + + If ((CNT0 == 0x0A)) + { + /* BreakPoint */ + + Return (0x00) + } + + /*failed */ + + Return (0x01) + } + } + + /* */ + /* test AddSubOp.asl */ + /* */ + Device (ADSU) + { + /* create System Memory Operation Region and field overlays */ + + OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + SMDW, /* 32-bit DWORD */ 32, + SMWD, /* 16-bit WORD */ 16, + SMBY, /* 8-bit BYTE */ 8 + } /* Field(RAM) */ + + Method (TEST, 0, Serialized) + { + Debug = "++++++++ AddSubOp Test" + Name (DWRD, 0x12345678) + Name (WRD, 0x1234) + Name (BYT, 0x12) + /* Test AddOp with DWORD data */ + + DWRD = 0x12345678 + DWRD += 0x07 + If ((DWRD != 0x1234567F)) + { + Return (DWRD) /* \ADSU.TEST.DWRD */ + } + + /* Test AddOp with WORD data */ + + WRD += 0x05 + If ((WRD != 0x1239)) + { + Return (WRD) /* \ADSU.TEST.WRD_ */ + } + + /* Test AddOp with BYTE data */ + + BYT += 0x03 + If ((BYT != 0x15)) + { + Return (BYT) /* \ADSU.TEST.BYT_ */ + } + + /* Test SubtractOp with DWORD data */ + + DWRD -= 0x07 + If ((DWRD != 0x12345678)) + { + Return (DWRD) /* \ADSU.TEST.DWRD */ + } + + /* Test SubtractOp with WORD data */ + + WRD -= 0x03 + If ((WRD != 0x1236)) + { + Return (WRD) /* \ADSU.TEST.WRD_ */ + } + + /* Test SubtractOp with BYTE data */ + + BYT -= 0x03 + If ((BYT != 0x12)) + { + Return (BYT) /* \ADSU.TEST.BYT_ */ + } + + /* test AddOp with DWORD SystemMemory OpRegion */ + + SMDW = 0x01234567 + SMDW += 0x08 + If ((SMDW != 0x0123456F)) + { + Return (SMDW) /* \ADSU.SMDW */ + } + + /* test SubtractOp with DWORD SystemMemory OpRegion */ + + SMDW -= 0x07 + If ((SMDW != 0x01234568)) + { + Return (SMDW) /* \ADSU.SMDW */ + } + + /* test AddOp with WORD SystemMemory OpRegion */ + + SMWD = 0x0123 + SMWD += 0x06 + If ((SMWD != 0x0129)) + { + Return (SMWD) /* \ADSU.SMWD */ + } + + /* test SubtractOp with WORD SystemMemory OpRegion */ + + SMWD -= 0x05 + If ((SMWD != 0x0124)) + { + Return (SMWD) /* \ADSU.SMWD */ + } + + /* test AddOp with BYTE SystemMemory OpRegion */ + + SMBY = 0x01 + SMBY += 0x04 + If ((SMBY != 0x05)) + { + Return (SMBY) /* \ADSU.SMBY */ + } + + /* test SubtractOp with BYTE SystemMemory OpRegion */ + + SMBY -= 0x03 + If ((SMBY != 0x02)) + { + Return (SMBY) /* \ADSU.SMBY */ + } + + Return (0x00) + } /* TEST */ + } /* ADSU */ + + /* */ + /* test IncDecOp.asl */ + /* */ + Device (INDC) + { + /* create System Memory Operation Region and field overlays */ + + OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + SMDW, /* 32-bit DWORD */ 32, + SMWD, /* 16-bit WORD */ 16, + SMBY, /* 8-bit BYTE */ 8 + } /* Field(RAM) */ + + Method (TEST, 0, Serialized) + { + Debug = "++++++++ IncDecOp Test" + Name (DWRD, 0x12345678) + Name (WRD, 0x1234) + Name (BYT, 0x12) + /* Test IncrementOp with DWORD data */ + + DWRD = 0x12345678 + DWRD++ + If ((DWRD != 0x12345679)) + { + Return (DWRD) /* \INDC.TEST.DWRD */ + } + + /* Test IncrementOp with WORD data */ + + WRD++ + If ((WRD != 0x1235)) + { + Return (WRD) /* \INDC.TEST.WRD_ */ + } + + /* Test IncrementOp with BYTE data */ + + BYT++ + If ((BYT != 0x13)) + { + Return (BYT) /* \INDC.TEST.BYT_ */ + } + + /* Test DecrementOp with DWORD data */ + + DWRD-- + If ((DWRD != 0x12345678)) + { + Return (DWRD) /* \INDC.TEST.DWRD */ + } + + /* Test DecrementOp with WORD data */ + + WRD-- + If ((WRD != 0x1234)) + { + Return (WRD) /* \INDC.TEST.WRD_ */ + } + + /* Test DecrementOp with BYTE data */ + + BYT-- + If ((BYT != 0x12)) + { + Return (BYT) /* \INDC.TEST.BYT_ */ + } + + /* test IncrementOp with DWORD SystemMemory OpRegion */ + + SMDW = 0x01234567 + SMDW++ + If ((SMDW != 0x01234568)) + { + Return (SMDW) /* \INDC.SMDW */ + } + + /* test DecrementOp with DWORD SystemMemory OpRegion */ + + SMDW-- + If ((SMDW != 0x01234567)) + { + Return (SMDW) /* \INDC.SMDW */ + } + + /* test IncrementOp with WORD SystemMemory OpRegion */ + + SMWD = 0x0123 + SMWD++ + If ((SMWD != 0x0124)) + { + Return (SMWD) /* \INDC.SMWD */ + } + + /* test DecrementOp with WORD SystemMemory OpRegion */ + + SMWD-- + If ((SMWD != 0x0123)) + { + Return (SMWD) /* \INDC.SMWD */ + } + + /* test IncrementOp with BYTE SystemMemory OpRegion */ + + SMBY = 0x01 + SMBY++ + If ((SMBY != 0x02)) + { + Return (SMBY) /* \INDC.SMBY */ + } + + /* test DecrementOp with BYTE SystemMemory OpRegion */ + + SMBY-- + If ((SMBY != 0x01)) + { + Return (SMBY) /* \INDC.SMBY */ + } + + Return (0x00) + } /* 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, 0x00400000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + SMDW, /* 32-bit DWORD */ 32, + SMWD, /* 16-bit WORD */ 16, + SMBY, /* 8-bit BYTE */ 8 + }/* 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, 0x00) + /*And with DWord Data */ + + Name (DWD1, 0xFFFFFFFF) + Name (DWD2, 0xFFFFFFFF) + Name (DRSL, 0x00) + Name (RSLT, 0x01) + Method (ANDL, 2, NotSerialized) + { + /*test with the arguments passed */ + + If ((Arg0 == Arg1)) + { + RSLT = (Arg0 && Arg1) + If ((Ones != RSLT)) + { + Return (0x0B) + } + } + + /*test with he locals */ + + Local0 = Arg0 + Local1 = Arg1 + If ((Local0 == Local1)) + { + RSLT = (Local0 && Local1) + If ((Ones != RSLT)) + { + Return (0x0C) + } + } + + /*test with BYTE data */ + + If ((BYT1 == BYT2)) + { + BRSL = (BYT1 && BYT2) + If ((Ones != BRSL)) + { + Return (0x0D) + } + } + + /*test with WORD data */ + + If ((WRD1 == WRD2)) + { + WRSL = (WRD1 && WRD2) + If ((Ones != WRSL)) + { + Return (0x0E) + } + } + + /*test with DWORD data */ + + If ((DWD1 == DWD2)) + { + DRSL = (DWD1 && DWD2) + If ((Ones != DRSL)) + { + Return (0x0F) + } + } + + /*Test for system memory data for each test case. */ + + BYT1 = 0xFF + SMBY = 0xFF + BRSL = 0x00 + /*test with BYTE system memory data */ + + If ((BYT1 == SMBY)) + { + BRSL = (BYT1 && SMBY) + If ((Ones != BRSL)) + { + Return (0x10) + } + } + + WRD1 = 0xFFFF + SMWD = 0xFFFF + WRSL = 0x00 + /*test with WORD system memory data */ + + If ((WRD1 == SMWD)) + { + WRSL = (WRD1 && SMWD) + If ((Ones != WRSL)) + { + Return (0x11) + } + } + + DRSL = 0x00 + DWD1 = 0x00FFFFFF + SMDW = 0x00FFFFFF + /*test with DWORD system memory data */ + + If ((DWD1 == SMDW)) + { + DRSL = (DWD1 && SMDW) + If ((Ones != DRSL)) + { + Return (0x12) + } + } + + Return (0x00) + }/*ANDL */ + + /*Test the LOr Operator */ + + Method (ORL, 2, NotSerialized) + { + /*ORL_ */ + /*test with the arguments passed */ + If ((Arg0 == Arg1)) + { + RSLT = (Arg0 || Arg1) + If ((Ones != RSLT)) + { + Return (0x15) + } + } + + /*test with he locals */ + + Local0 = Arg0 + Local1 = Arg1 + If ((Local0 == Local1)) + { + RSLT = (Local0 || Local1) + If ((Ones != RSLT)) + { + Return (0x16) + } + } + + /*Check with 1 LOred with 0 on byte data */ + + BYT1 = 0xFF + BYT2 = 0x00 + BRSL = 0x00 + If ((BYT1 != BYT2)) + { + BRSL = (BYT1 || BYT2) + If ((Ones != BRSL)) + { + Return (0x17) + } + } + + /*Check with 1 LOred with 0 on WORD data */ + + WRD1 = 0xFFFF + WRD2 = 0x00 + WRSL = 0x00 + If ((WRD1 != WRD2)) + { + WRSL = (WRD1 || WRD2) + If ((Ones != WRSL)) + { + Return (0x18) + } + } + + /*Check with 1 LOred with 0 on DWORD data */ + + DWD1 = 0xFFFFFFFF + DWD2 = 0x00 + DRSL = 0x00 + If ((DWD1 != DWD2)) + { + DRSL = (DWD1 || DWD2) + If ((Ones != DRSL)) + { + Return (0x19) + } + } + + BYT1 = 0x00 + SMBY = 0xFF + BRSL = 0x00 + /*test with BYTE system memory data */ + + If ((BYT1 == SMBY)) + { + BRSL = (BYT1 || SMBY) + If ((Ones != BRSL)) + { + Return (0x1A) + } + } + + WRD1 = 0x00 + SMWD = 0xFFFF + WRSL = 0x00 + /*test with WORD system memory data */ + + If ((WRD1 == SMWD)) + { + WRSL = (WRD1 || SMWD) + If ((Ones != WRSL)) + { + Return (0x1B) + } + } + + DWD1 = 0x00 + SMDW = 0xFFFFFFFF + DRSL = 0x00 + /*test with DWORD system memory data */ + + If ((DWD1 == SMDW)) + { + DRSL = (DWD1 && SMDW) + If ((Ones != DRSL)) + { + Return (0x1C) + } + } + + Return (0x00) + }/*ORL_ */ + + /*This method tests LGreater and LNot operator */ + + Method (LSGR, 2, NotSerialized) + { + /*LSGR */ + /*Test on arguements passed */ + /*in test data, Arg1 > Arg0 */ + If ((Ones == (Arg1 <= Arg0))) + { + Return (0x1F) + } + + /*test LLessEqual */ + + If ((Ones == !(Arg1 >= Arg0))) + { + Return (0x20) + } + + If ((Ones == (Arg1 < Arg0))) + { + Return (0x21) + } + + /*test LLessEqual */ + + If ((Ones == (Arg1 <= Arg0))) + { + Return (0x22) + } + + Local0 = Arg0 + Local1 = Arg1 + /*test with the locals */ + + If ((Local1 <= Local0)) + { + Return (0x23) + } + + /*test on Byte data */ + + BYT1 = 0x12 + BYT2 = 0x21 + If ((BYT2 <= BYT1)) + { + Return (0x24) + } + + If ((BYT1 >= BYT2)) + { + Return (0x25) + } + + /*test LGreaterEqual with byte data */ + + If (!(BYT2 >= BYT1)) + { + Return (0x26) + } + + /*test LLessEqual byte data */ + + If (!(BYT1 <= BYT2)) + { + Return (0x27) + } + + /*test on Word data */ + + WRD1 = 0x1212 + WRD2 = 0x2121 + If ((WRD2 <= WRD1)) + { + Return (0x0136) + } + + If ((WRD1 >= WRD2)) + { + Return (0x0137) + } + + /*Test LGreaterEqual with Word Data */ + + If (!(WRD2 >= WRD1)) + { + Return (0x0138) + } + + /*Test LLessEqual with Word Data */ + + If (!(WRD1 <= WRD2)) + { + Return (0x0139) + } + + /*test on DWord data */ + + DWD1 = 0x12121212 + DWD2 = 0x21212121 + If ((DWD2 <= DWD1)) + { + Return (0x013A) + } + + If ((DWD1 >= DWD2)) + { + Return (0x013B) + } + + /*Test LGreaterEqual with Dword */ + + If (!(DWD2 >= DWD1)) + { + Return (0x013C) + } + + /*Test LLessEqual DWord */ + + If (!(DWD1 <= DWD2)) + { + Return (0x013D) + } + + Return (0x00) + }/*LSGR */ + + /*The test method */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ LOps Test" + RSLT = 0x00 + /*Call LAndOp method */ + + RSLT = ANDL (0x02, 0x02) + If ((RSLT != 0x00)) + { + Return (RSLT) /* \LOPS.RSLT */ + } + + /*Call LOrOp Method */ + + RSLT = ORL (0x05, 0x05) + If ((RSLT != 0x00)) + { + Return (RSLT) /* \LOPS.RSLT */ + } + + /*Call LSGR Method */ + + RSLT = LSGR (0x05, 0x07) + If ((RSLT != 0x00)) + { + Return (RSLT) /* \LOPS.RSLT */ + } + + Return (0x00) + }/*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, 0x00400000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + SMDW, /* 32-bit DWORD */ 32, + SMWD, /* 16-bit WORD */ 16, + SMBY, /* 8-bit BYTE */ 8 + } /* Field(RAM) */ + + /* Byte Data */ + + Name (BYT1, 0x01) + Name (BRSL, 0x00) + /* Word Data */ + + Name (WRD1, 0x0100) + Name (WRSL, 0x00) + /* DWord Data */ + + Name (DWD1, 0x00010000) + Name (DRSL, 0x00) + Name (RSLT, 0x01) + Name (CNTR, 0x01) + Method (SHFT, 2, NotSerialized) + { + /* SHFT */ + + Local0 = Arg0 + Local1 = Arg1 + FindSetLeftBit (Arg0, BRSL) /* \FDSO.BRSL */ + If ((BRSL != Arg1)) + { + Return (0x11) + } + + If ((Arg0 != Local0)) + { + Return (0x12) + } + + FindSetLeftBit (Local0, BRSL) /* \FDSO.BRSL */ + If ((BRSL != Local1)) + { + Return (0x13) + } + + If ((Arg0 != Local0)) + { + Return (0x14) + } + + /* test the byte value for SetLeftBit */ + + BYT1 = 0x07 + FindSetLeftBit (BYT1, BRSL) /* \FDSO.BRSL */ + If ((BRSL != 0x03)) + { + Return (0x15) + } + + If ((BYT1 != 0x07)) + { + Return (0x16) + } + + BYT1 = 0x01 + CNTR = 0x01 + While ((CNTR <= 0x08)) + { + /* FindSetLeftBit check loop for byte data */ + + FindSetLeftBit (BYT1, BRSL) /* \FDSO.BRSL */ + If ((BRSL != CNTR)) + { + Return (0x17) + } + + /* Shift the bits to check the same */ + + BYT1 <<= 0x01 + CNTR++ + } /* FindSetLeftBit check loop for byte data */ + + /* Check BYTE value for SetRightBit */ + + BYT1 = 0x07 + FindSetRightBit (BYT1, BRSL) /* \FDSO.BRSL */ + If ((BRSL != 0x01)) + { + Return (0x21) + } + + If ((BYT1 != 0x07)) + { + Return (0x22) + } + + CNTR = 0x01 + BYT1 = 0xFF + While ((CNTR <= 0x08)) + { + /* FindSetRightBit check loop for byte data */ + + FindSetRightBit (BYT1, BRSL) /* \FDSO.BRSL */ + If ((BRSL != CNTR)) + { + Return (0x23) + } + + BYT1 <<= 0x01 + CNTR++ + } /* FindSetRightBit check loop for byte data */ + + /* Test Word value for SetLeftBit */ + + CNTR = 0x09 + WRD1 = 0x0100 + While ((CNTR <= 0x10)) + { + /* FindSetLeftBit check loop for Word data */ + + FindSetLeftBit (WRD1, WRSL) /* \FDSO.WRSL */ + If ((WRSL != CNTR)) + { + Return (0x31) + } + + /* Shift the bits to check the same */ + + WRD1 <<= 0x01 + CNTR++ + } /* FindSetLeftBit check loop for Word data */ + + /* Check Word value for SetRightBit */ + + CNTR = 0x09 + WRD1 = 0xFF00 + While ((CNTR <= 0x10)) + { + /* FindSetRightBit check loop for Word data */ + + FindSetRightBit (WRD1, WRSL) /* \FDSO.WRSL */ + If ((WRSL != CNTR)) + { + Return (0x32) + } + + WRD1 <<= 0x01 + CNTR++ + } /* FindSetRightBit check loop for Word data */ + + /* Test the DWord value for SetLeftBit */ + + CNTR = 0x11 + DWD1 = 0x00010000 + While ((CNTR <= 0x20)) + { + /* FindSetLeftBit check loop for Dword */ + + FindSetLeftBit (DWD1, DRSL) /* \FDSO.DRSL */ + If ((DRSL != CNTR)) + { + Return (0x41) + } + + /* Shift the bits to check the same */ + + DWD1 <<= 0x01 + CNTR++ + } /* FindSetLeftBit check loop for Dword */ + + /* Check DWord value for SetRightBit */ + + CNTR = 0x11 + DWD1 = 0xFFFF0000 + While ((CNTR <= 0x20)) + { + /* FindSetRightBit Check loop for DWORD */ + + FindSetRightBit (DWD1, DRSL) /* \FDSO.DRSL */ + If ((DRSL != CNTR)) + { + Return (0x42) + } + + DWD1 <<= 0x01 + CNTR++ + } /* FindSetRightBit Check loop for DWORD */ + + Return (0x00) + } /* SHFT */ + + /* Test method called from amlexec */ + + Method (TEST, 0, NotSerialized) + { + /* TEST */ + + Debug = "++++++++ FdSetOps Test" + RSLT = SHFT (0x80, 0x08) + If ((RSLT != 0x00)) + { + Return (RSLT) /* \FDSO.RSLT */ + } + + Return (0x00) /* pass */ + } /* TEST */ + } /* Device FDSO */ + + /* */ + /* test MulDivOp.asl */ + /* */ + Device (MLDV) + { + /* create System Memory Operation Region and field overlays */ + + OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + SMDW, /* 32-bit DWORD */ 32, + SMWD, /* 16-bit WORD */ 16, + SMBY, /* 8-bit BYTE */ 8 + } /* Field(RAM) */ + + Method (TEST, 0, Serialized) + { + Debug = "++++++++ MulDivOp Test" + Name (RMDR, 0x00) + Name (DWRD, 0x12345678) + Name (WRD, 0x1234) + Name (BYT, 0x12) + /* Test MultiplyOp with DWORD data */ + + DWRD = 0x12345678 + DWRD *= 0x03 + If ((DWRD != 0x369D0368)) + { + Return (DWRD) /* \MLDV.TEST.DWRD */ + } + + /* Test MultiplyOp with WORD data */ + + WRD *= 0x04 + If ((WRD != 0x48D0)) + { + Return (WRD) /* \MLDV.TEST.WRD_ */ + } + + /* Test MultiplyOp with BYTE data */ + + BYT *= 0x05 + If ((BYT != 0x5A)) + { + Return (BYT) /* \MLDV.TEST.BYT_ */ + } + + /* Test DivideOp with DWORD data */ + + Divide (DWRD, 0x03, DWRD, RMDR) /* \MLDV.TEST.RMDR */ + If ((DWRD != 0x12345678)) + { + Return (DWRD) /* \MLDV.TEST.DWRD */ + } + + If ((RMDR != 0x00)) + { + Return (RMDR) /* \MLDV.TEST.RMDR */ + } + + /* Test DivideOp with WORD data */ + + Divide (WRD, 0x04, WRD, RMDR) /* \MLDV.TEST.RMDR */ + If ((WRD != 0x1234)) + { + Return (WRD) /* \MLDV.TEST.WRD_ */ + } + + If ((RMDR != 0x00)) + { + Return (RMDR) /* \MLDV.TEST.RMDR */ + } + + /* Test DivideOp with BYTE data */ + + Divide (BYT, 0x05, BYT, RMDR) /* \MLDV.TEST.RMDR */ + If ((BYT != 0x12)) + { + Return (BYT) /* \MLDV.TEST.BYT_ */ + } + + If ((RMDR != 0x00)) + { + Return (RMDR) /* \MLDV.TEST.RMDR */ + } + + /* test MultiplyOp with DWORD SystemMemory OpRegion */ + + SMDW = 0x01234567 + SMDW *= 0x02 + If ((SMDW != 0x02468ACE)) + { + Return (SMDW) /* \MLDV.SMDW */ + } + + /* test DivideOp with DWORD SystemMemory OpRegion */ + + Divide (SMDW, 0x03, SMDW, RMDR) /* \MLDV.TEST.RMDR */ + If ((SMDW != 0x00C22E44)) + { + Return (SMDW) /* \MLDV.SMDW */ + } + + If ((RMDR != 0x02)) + { + Return (RMDR) /* \MLDV.TEST.RMDR */ + } + + /* test MultiplyOp with WORD SystemMemory OpRegion */ + + SMWD = 0x0123 + SMWD *= 0x03 + If ((SMWD != 0x0369)) + { + Return (SMWD) /* \MLDV.SMWD */ + } + + /* test DivideOp with WORD SystemMemory OpRegion */ + + Divide (SMWD, 0x02, SMWD, RMDR) /* \MLDV.TEST.RMDR */ + If ((SMWD != 0x01B4)) + { + Return (SMWD) /* \MLDV.SMWD */ + } + + If ((RMDR != 0x01)) + { + Return (RMDR) /* \MLDV.TEST.RMDR */ + } + + /* test MultiplyOp with BYTE SystemMemory OpRegion */ + + SMBY = 0x01 + SMBY *= 0x07 + If ((SMBY != 0x07)) + { + Return (SMBY) /* \MLDV.SMBY */ + } + + /* test DivideOp with BYTE SystemMemory OpRegion */ + + Divide (SMBY, 0x04, SMBY, RMDR) /* \MLDV.TEST.RMDR */ + If ((SMBY != 0x01)) + { + Return (SMBY) /* \MLDV.SMBY */ + } + + If ((RMDR != 0x03)) + { + Return (RMDR) /* \MLDV.TEST.RMDR */ + } + + Return (0x00) + } /* 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, 0x00400000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + SMDW, /* 32-bit DWORD */ 32, + SMWD, /* 16-bit WORD */ 16, + SMBY, /* 8-bit BYTE */ 8 + }/* 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, 0x00) + /*And with DWord Data */ + + Name (DWD1, 0xFFFFFFFF) + Name (DWD2, 0xFFFFFFFF) + Name (DRSL, 0x00) + Name (RSLT, 0x01) + Name (ARSL, 0x00) + Name (LRSL, 0x00) + Method (NNDB, 2, NotSerialized) + { + /*NNDB */ + + SMDW = 0xFFFFFFFF + SMWD = 0xFFFF + SMBY = 0xFF + NAnd (Arg0, Arg1, ARSL) /* \NBIT.ARSL */ + If ((ARSL != 0xFFFFFFFD)) + { + Return (0x0B) + } + + Local0 = Arg0 + Local1 = Arg1 + NAnd (Local0, Local1, LRSL) /* \NBIT.LRSL */ + If ((LRSL != 0xFFFFFFFD)) + { + Return (0x0C) + } + + /*Byte data */ + + NAnd (BYT1, BYT2, BRSL) /* \NBIT.BRSL */ + If ((BRSL != 0xFFFFFF00)) + { + Return (0x0D) + } + + /*Word Data */ + + NAnd (WRD1, WRD2, WRSL) /* \NBIT.WRSL */ + If ((WRSL != 0xFFFF0000)) + { + Return (0x0E) + } + + /*DWord Data */ + + NAnd (DWD1, DWD2, DRSL) /* \NBIT.DRSL */ + If ((DRSL != 0x00)) + { + Return (0x0F) + } + + /*Byte data */ + + NAnd (SMBY, 0xFF, BRSL) /* \NBIT.BRSL */ + If ((BRSL != 0xFFFFFF00)) + { + Return (0x10) + } + + /*Word Data */ + + NAnd (SMWD, 0xFFFF, WRSL) /* \NBIT.WRSL */ + If ((WRSL != 0xFFFF0000)) + { + Return (0x11) + } + + /*DWord Data */ + + NAnd (SMDW, 0xFFFFFFFF, DRSL) /* \NBIT.DRSL */ + If ((DRSL != 0x00)) + { + Return (0x12) + } + + Return (0x00) + }/*NNDB */ + + Method (NNOR, 2, NotSerialized) + { + /*NNOR */ + + NOr (Arg0, Arg1, ARSL) /* \NBIT.ARSL */ + If ((ARSL != 0xFFFFFFFD)) + { + Return (0x15) + } + + Local0 = Arg0 + Local1 = Arg1 + NOr (Local0, Local1, LRSL) /* \NBIT.LRSL */ + If ((LRSL != 0xFFFFFFFD)) + { + Return (0x16) + } + + /*Byte data */ + + NOr (BYT1, BYT2, BRSL) /* \NBIT.BRSL */ + If ((BRSL != 0xFFFFFF00)) + { + Return (0x17) + } + + /*Word Data */ + + NOr (WRD1, WRD2, WRSL) /* \NBIT.WRSL */ + If ((WRSL != 0xFFFF0000)) + { + Return (0x18) + } + + /*DWord Data */ + + NOr (DWD1, DWD2, DRSL) /* \NBIT.DRSL */ + If ((DRSL != 0x00)) + { + Return (0x19) + } + + /*System Memory Byte data */ + + NOr (SMBY, 0xFF, BRSL) /* \NBIT.BRSL */ + If ((BRSL != 0xFFFFFF00)) + { + Return (0x1A) + } + + /*System Memory Word Data */ + + NOr (SMWD, 0xFFFF, WRSL) /* \NBIT.WRSL */ + If ((WRSL != 0xFFFF0000)) + { + Return (0x1B) + } + + /*System Memory DWord Data */ + + NOr (SMDW, 0xFFFFFFFF, DRSL) /* \NBIT.DRSL */ + If ((DRSL != 0x00)) + { + Return (0x1C) + } + + Return (0x00) + }/*NNOR */ + + Method (NNOT, 2, NotSerialized) + { + /*NNOT */ + + ARSL = (Arg0 | Arg1) + ARSL = ~ARSL /* \NBIT.ARSL */ + If ((ARSL != 0xFFFFFFFD)) + { + Return (0x1F) + } + + Local0 = Arg0 + Local1 = Arg1 + LRSL = (Local0 | Local1) + LRSL = ~LRSL /* \NBIT.LRSL */ + If ((LRSL != 0xFFFFFFFD)) + { + Return (0x20) + } + + /*Byte data */ + + BRSL = (BYT1 | BYT2) /* \NBIT.BYT2 */ + BRSL = ~BRSL /* \NBIT.BRSL */ + If ((BRSL != 0xFFFFFF00)) + { + Return (0x21) + } + + /*Word Data */ + + WRSL = (WRD1 | WRD2) /* \NBIT.WRD2 */ + WRSL = ~WRSL /* \NBIT.WRSL */ + If ((WRSL != 0xFFFF0000)) + { + Return (0x22) + } + + /*DWord Data */ + + DRSL = (DWD1 | DWD2) /* \NBIT.DWD2 */ + DRSL = ~DRSL /* \NBIT.DRSL */ + If ((DRSL != 0x00)) + { + Return (0x23) + } + + /*System Memory Byte data */ + + BRSL = (SMBY | 0xFF) + BRSL = ~BRSL /* \NBIT.BRSL */ + If ((BRSL != 0xFFFFFF00)) + { + Return (0x24) + } + + /*System Memory Word Data */ + + WRSL = (SMWD | 0xFFFF) + WRSL = ~WRSL /* \NBIT.WRSL */ + If ((WRSL != 0xFFFF0000)) + { + Return (0x25) + } + + /*System Memory DWord Data */ + + DRSL = (SMDW | 0xFFFFFFFF) + DRSL = ~DRSL /* \NBIT.DRSL */ + If ((DRSL != 0x00)) + { + Return (0x26) + } + + Return (0x00) + }/*NNOT */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ NBitOps Test" + RSLT = NNDB (0x02, 0x02) + If ((RSLT != 0x00)) + { + Return (RSLT) /* \NBIT.RSLT */ + } + + RSLT = NNOR (0x02, 0x02) + If ((RSLT != 0x00)) + { + Return (RSLT) /* \NBIT.RSLT */ + } + + RSLT = NNOT (0x02, 0x02) + If ((RSLT != 0x00)) + { + Return (RSLT) /* \NBIT.RSLT */ + } + + Return (0x00) + } + }/*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, 0x00400000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + SMDW, /* 32-bit DWORD */ 32, + SMWD, /* 16-bit WORD */ 16, + SMBY, /* 8-bit BYTE */ 8 + }/* Field(RAM) */ + + Name (SHFC, 0x00) + /*And with Byte Data */ + + Name (BYT1, 0xFF) + Name (BRSL, 0x00) + /*And with Word Data */ + + Name (WRD1, 0xFFFF) + Name (WRSL, 0x00) + /*And with DWord Data */ + + Name (DWD1, 0xFFFFFFFF) + Name (DRSL, 0x00) + Name (RSLT, 0x01) + Name (ARSL, 0x00) + Name (LRSL, 0x00) + Method (SLFT, 2, NotSerialized) + { + /*SLFT */ + + SMDW = 0xFFFFFFFF + SMWD = 0xFFFF + SMBY = 0xFF + /*Arg0-> 2 & Arg1->2 */ + + ARSL = (Arg0 << Arg1) + If ((ARSL != 0x08)) + { + Return (0x0B) + } + + Local0 = Arg0 + Local1 = Arg1 + /*Local0->8 and Local1->2 */ + + LRSL = (Local0 << Local1) + If ((LRSL != 0x08)) + { + Return (0x0C) + } + + SHFC = 0x02 + /*Byte data */ + + BRSL = (BYT1 << SHFC) /* \SHFT.SHFC */ + If ((BRSL != 0x03FC)) + { + Return (0x0D) + } + + SHFC = 0x04 + /*Word Data */ + + WRSL = (WRD1 << SHFC) /* \SHFT.SHFC */ + If ((WRSL != 0x000FFFF0)) + { + Return (0x0E) + } + + SHFC = 0x08 + /*DWord Data */ + + DRSL = (DWD1 << SHFC) /* \SHFT.SHFC */ + If ((DRSL != 0xFFFFFF00)) + { + Return (0x0F) + } + + /*System Memory Byte data */ + + SHFC = 0x04 + BRSL = (SMBY << SHFC) /* \SHFT.SHFC */ + If ((BRSL != 0x0FF0)) + { + Return (0x10) + } + + /*Word Data */ + + SHFC = 0x04 + WRSL = (SMWD << SHFC) /* \SHFT.SHFC */ + If ((WRSL != 0x000FFFF0)) + { + Return (0x11) + } + + /*DWord Data */ + + SHFC = 0x08 + DRSL = (SMDW << SHFC) /* \SHFT.SHFC */ + If ((DRSL != 0xFFFFFF00)) + { + Return (0x12) + } + + Return (0x00) + }/*SLFT */ + + Method (SRGT, 2, NotSerialized) + { + /*SRGT */ + /*And with Byte Data */ + BYT1 = 0xFF + BRSL = 0x00 + /*And with Word Data */ + + WRD1 = 0xFFFF + WRSL = 0x00 + /*And with DWord Data */ + + DWD1 = 0xFFFFFFFF + DRSL = 0x00 + /*Reinitialize the result objects */ + + ARSL = 0x00 + LRSL = 0x00 + SMDW = 0xFFFFFFFF + SMWD = 0xFFFF + SMBY = 0xFF + /*Arg0-> 2 & Arg1->2 */ + + ARSL = (Arg0 >> Arg1) + If ((ARSL != 0x00)) + { + Return (0x15) + } + + Local0 = Arg0 + Local1 = Arg1 + /*Local0->8 and Local1->2 */ + + LRSL = (Local0 >> Local1) + If ((LRSL != 0x00)) + { + Return (0x16) + } + + SHFC = 0x02 + /*Byte data */ + + BRSL = (BYT1 >> SHFC) /* \SHFT.SHFC */ + If ((BRSL != 0x3F)) + { + Return (0x17) + } + + SHFC = 0x04 + /*Word Data */ + + WRSL = (WRD1 >> SHFC) /* \SHFT.SHFC */ + If ((WRSL != 0x0FFF)) + { + Return (0x18) + } + + SHFC = 0x08 + /*DWord Data */ + + DRSL = (DWD1 >> SHFC) /* \SHFT.SHFC */ + If ((DRSL != 0x00FFFFFF)) + { + Return (0x19) + } + + /*System Memory Byte data */ + + SHFC = 0x04 + BRSL = (SMBY >> SHFC) /* \SHFT.SHFC */ + If ((BRSL != 0x0F)) + { + Return (0x1A) + } + + /*Word Data */ + + SHFC = 0x04 + WRSL = (SMWD >> SHFC) /* \SHFT.SHFC */ + If ((WRSL != 0x0FFF)) + { + Return (0x1B) + } + + /*DWord Data */ + + SHFC = 0x08 + DRSL = (SMDW >> SHFC) /* \SHFT.SHFC */ + If ((DRSL != 0x00FFFFFF)) + { + Return (0x1C) + } + + Return (0x00) + }/*SRGT */ + + /*Test method called from amlexec */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ ShftOp Test" + RSLT = SLFT (0x02, 0x02) + If ((RSLT != 0x00)) + { + Return (RSLT) /* \SHFT.RSLT */ + } + + RSLT = SRGT (0x02, 0x02) + If ((RSLT != 0x00)) + { + Return (RSLT) /* \SHFT.RSLT */ + } + + Return (0x00) + } + }/*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, 0, Serialized) + { + Debug = "++++++++ Xor Test" + /*Overlay in system memory */ + + OperationRegion (RAM, SystemMemory, 0x00800000, 0x0100) + Field (RAM, ByteAcc, NoLock, Preserve) + { + RES1, /*Offset */ 1, + BYT1, /*First BYTE */ 8, + BYT2, /*Second BYTE */ 8, + RBYT, /*Result Byte */ 8, + RES2, /*Offset */ 1, + WRD1, /*First WORD field */ 16, + WRD2, /*Second WORD field */ 16, + RWRD, /*RSLT WORD field */ 16, + RES3, /*Offset */ 1, + DWD1, /*First Dword */ 32, + DWD2, /*Second Dword */ 32, + RDWD, /*Result Dword */ 32, + RES4, /*Offset */ 1 + } + + /* Store bits in the single bit fields for checking */ + /* at the end */ + RES1 = 0x01 + RES2 = 0x01 + RES3 = 0x01 + RES4 = 0x01 + /* Check the stored single bits */ + + If ((RES1 != 0x01)) + { + Return (0x01) + } + + If ((RES2 != 0x01)) + { + Return (0x01) + } + + If ((RES3 != 0x01)) + { + Return (0x01) + } + + If ((RES4 != 0x01)) + { + Return (0x01) + } + + /************************************************* */ + /* (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition */ + BYT1 = 0x00 + BYT2 = 0x00 + Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */ + RBYT = Local0 + If ((RBYT != 0x00)) + { + Return (0x01) + } + + /* (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition */ + + BYT1 = 0xFF + BYT2 = 0xFF + Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */ + RBYT = Local0 + If ((RBYT != 0x00)) + { + Return (0x01) + } + + /* (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition */ + + BYT1 = 0x55 + BYT2 = 0xAA + Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */ + RBYT = Local0 + If ((RBYT != 0xFF)) + { + Return (0x01) + } + + /*(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition */ + + BYT1 = 0xAA + BYT2 = 0x55 + Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */ + RBYT = Local0 + If ((RBYT != 0xFF)) + { + Return (0x01) + } + + BYT1 = 0x12 + BYT2 = 0xED + Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */ + RBYT = Local0 + If ((RBYT != 0xFF)) + { + Return (0x01) + } + + /* Store known values for checking later */ + + BYT1 = 0x12 + If ((BYT1 != 0x12)) + { + Return (0x01) + } + + BYT2 = 0xFE + If ((BYT2 != 0xFE)) + { + Return (0x01) + } + + RBYT = 0xAB + If ((RBYT != 0xAB)) + { + Return (0x01) + } + + /************************************************ */ + /* (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition */ + WRD1 = 0x00 + WRD2 = 0x00 + RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */ + If ((RWRD != 0x00)) + { + Return (0x01) + } + + /* (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition */ + + WRD1 = 0xFFFF + WRD2 = 0xFFFF + RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */ + If ((RWRD != 0x00)) + { + Return (0x01) + } + + /* (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition */ + + WRD1 = 0x5555 + WRD2 = 0xAAAA + RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */ + If ((RWRD != 0xFFFF)) + { + Return (0x01) + } + + /*(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition */ + + WRD1 = 0xAAAA + WRD2 = 0x5555 + RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */ + If ((RWRD != 0xFFFF)) + { + Return (0x01) + } + + WRD1 = 0x1234 + WRD2 = 0xEDCB + RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */ + If ((RWRD != 0xFFFF)) + { + Return (0x01) + } + + /* Store known values for checking later */ + + WRD1 = 0x1234 + If ((WRD1 != 0x1234)) + { + Return (0x01) + } + + WRD2 = 0xFEDC + If ((WRD2 != 0xFEDC)) + { + Return (0x01) + } + + RWRD = 0x87AB + If ((RWRD != 0x87AB)) + { + Return (0x01) + } + + /*************************************************** */ + /* (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition */ + DWD1 = 0x00 + DWD2 = 0x00 + RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */ + If ((RDWD != 0x00)) + { + Return (0x01) + } + + /* (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition */ + + DWD1 = 0xFFFFFFFF + DWD2 = 0xFFFFFFFF + RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */ + If ((RDWD != 0x00)) + { + Return (0x01) + } + + /* (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition */ + + DWD1 = 0x55555555 + DWD2 = 0xAAAAAAAA + RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */ + If ((RDWD != 0xFFFFFFFF)) + { + Return (0x01) + } + + /*(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition */ + + DWD1 = 0xAAAAAAAA + DWD2 = 0x55555555 + RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */ + If ((RDWD != 0xFFFFFFFF)) + { + Return (0x01) + } + + /* (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition */ + + DWD1 = 0x12345678 + DWD2 = 0xEDCBA987 + RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */ + If ((RDWD != 0xFFFFFFFF)) + { + Return (0x01) + } + + DWD1 = 0x12345678 + If ((DWD1 != 0x12345678)) + { + Return (0x01) + } + + DWD2 = 0xFEDCBA98 + If ((DWD2 != 0xFEDCBA98)) + { + Return (0x01) + } + + RDWD = 0x91827364 + If ((RDWD != 0x91827364)) + { + Return (0x01) + } + + /***************************************************** */ + /* Check the stored single bits */ + If ((RES1 != 0x01)) + { + Return (0x01) + } + + If ((RES2 != 0x01)) + { + Return (0x01) + } + + If ((RES3 != 0x01)) + { + Return (0x01) + } + + If ((RES4 != 0x01)) + { + Return (0x01) + } + + /* Change all of the single bit fields to zero */ + + RES1 = 0x00 + RES2 = 0x00 + RES3 = 0x00 + RES4 = 0x00 + /* Now, check all of the fields */ + /* Byte */ + If ((BYT1 != 0x12)) + { + Return (0x01) + } + + If ((BYT2 != 0xFE)) + { + Return (0x01) + } + + If ((RBYT != 0xAB)) + { + Return (0x01) + } + + /* Word */ + + If ((WRD1 != 0x1234)) + { + Return (0x01) + } + + If ((WRD2 != 0xFEDC)) + { + Return (0x01) + } + + If ((RWRD != 0x87AB)) + { + Return (0x01) + } + + /* Dword */ + + If ((DWD1 != 0x12345678)) + { + Return (0x01) + } + + If ((DWD2 != 0xFEDCBA98)) + { + Return (0x01) + } + + If ((RDWD != 0x91827364)) + { + Return (0x01) + } + + /* Bits */ + + If ((RES1 != 0x00)) + { + Return (0x01) + } + + If ((RES2 != 0x00)) + { + Return (0x01) + } + + If ((RES3 != 0x00)) + { + Return (0x01) + } + + If ((RES4 != 0x00)) + { + Return (0x01) + } + + Return (0x00) + } /* 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, 0, NotSerialized) + { + Debug = "++++++++ CrBytFld Test" + /* Local0 is unitialized buffer with 4 elements */ + + Local0 = Buffer (0x04){} + /* create Byte Field named BF0 based on Local0 element 0 */ + + CreateByteField (Local0, 0x00, BF0) + /* validate CreateByteField did not alter Local0 */ + + Local1 = ObjectType (Local0) /* Local1 = Local0 object type */ + If ((Local1 != 0x03)) /* Buffer object type value is 3 */ + { + Return (0x02) + } + + /* store something into BF0 */ + + BF0 = 0x01 + /* validate Store did not alter Local0 object type */ + + Local1 = ObjectType (Local0) /* Local1 = Local0 object type */ + If ((Local1 != 0x03)) /* Buffer object type value is 3 */ + { + Return (0x03) + } + + /* verify that the Store into BF0 was successful */ + + If ((BF0 != 0x01)) + { + Return (0x04) + } + + /* create Byte Field named BF1 based on Local0 element 1 */ + + CreateByteField (Local0, 0x01, BF1) + /* validate CreateByteField did not alter Local0 */ + + Local1 = ObjectType (Local0) /* Local1 = Local0 object type */ + If ((Local1 != 0x03)) /* Buffer object type value is 3 */ + { + Return (0x0A) + } + + /* store something into BF1 */ + + BF1 = 0x05 + /* validate Store did not alter Local0 object type */ + + Local1 = ObjectType (Local0) /* Local1 = Local0 object type */ + If ((Local1 != 0x03)) /* Buffer object type value is 3 */ + { + Return (0x0B) + } + + /* verify that the Store into BF1 was successful */ + + If ((BF1 != 0x05)) + { + Return (0x0C) + } + + /* verify that the Store into BF1 did not alter BF0 */ + + If ((BF0 != 0x01)) + { + Return (0x0D) + } + + /* store something into BF0 */ + + BF0 = 0xFFFF + /* verify that the Store into BF0 was successful */ + + If ((BF0 != 0xFF)) + { + Return (0x14) + } + + /* verify that the Store into BF0 did not alter BF1 */ + + If ((BF1 != 0x05)) + { + Return (0x15) + } + + Return (0x00) + } /* 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, Serialized) + { + /* MADM: Misaligned Dynamic RAM SystemMemory OperationRegion */ + + OperationRegion (RAM, SystemMemory, Arg0, 0x0100) + Field (RAM, DWordAcc, NoLock, Preserve) + { + /* aligned field definition (for verification) */ + + DWD0, /* aligned DWORD field */ 32, + DWD1, /* aligned DWORD field */ 32 + } + + Field (RAM, ByteAcc, NoLock, Preserve) + { + /* bit access field definition */ + + BIT0, /* single bit field entry */ 1, + BIT1, /* single bit field entry */ 1, + BIT2, /* single bit field entry */ 1, + BIT3, /* single bit field entry */ 1, + BIT4, /* single bit field entry */ 1, + BIT5, /* single bit field entry */ 1, + BIT6, /* single bit field entry */ 1, + BIT7, /* single bit field entry */ 1, + BIT8, /* single bit field entry */ 1, + BIT9, /* single bit field entry */ 1, + BITA, /* single bit field entry */ 1, + BITB, /* single bit field entry */ 1, + BITC, /* single bit field entry */ 1, + BITD, /* single bit field entry */ 1, + BITE, /* single bit field entry */ 1, + BITF, /* single bit field entry */ 1, + BI10, /* single bit field entry */ 1, + BI11, /* single bit field entry */ 1, + BI12, /* single bit field entry */ 1, + BI13, /* single bit field entry */ 1, + BI14, /* single bit field entry */ 1, + BI15, /* single bit field entry */ 1, + BI16, /* single bit field entry */ 1, + BI17, /* single bit field entry */ 1, + BI18, /* single bit field entry */ 1, + BI19, /* single bit field entry */ 1, + BI1A, /* single bit field entry */ 1, + BI1B, /* single bit field entry */ 1, + BI1C, /* single bit field entry */ 1, + BI1D, /* single bit field entry */ 1, + BI1E, /* single bit field entry */ 1, + BI1F, /* single bit field entry */ 1 + } /* bit access field definition */ + + Field (RAM, ByteAcc, NoLock, Preserve) + { + /* two-bit access field definition */ + + B2_0, /* single bit field entry */ 2, + B2_1, /* single bit field entry */ 2, + B2_2, /* single bit field entry */ 2, + B2_3, /* single bit field entry */ 2, + B2_4, /* single bit field entry */ 2, + B2_5, /* single bit field entry */ 2, + B2_6, /* single bit field entry */ 2, + B2_7, /* single bit field entry */ 2, + B2_8, /* single bit field entry */ 2, + B2_9, /* single bit field entry */ 2, + B2_A, /* single bit field entry */ 2, + B2_B, /* single bit field entry */ 2, + B2_C, /* single bit field entry */ 2, + B2_D, /* single bit field entry */ 2, + B2_E, /* single bit field entry */ 2, + B2_F, /* single bit field entry */ 2 + } /* bit access field definition */ + + /* initialize memory contents using aligned field entries */ + + DWD0 = 0x5AA55AA5 + DWD1 = 0x5AA55AA5 + /* set memory contents to known values using misaligned field entries */ + + BIT0 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BIT0 != 0x00)) + { + Return (0x01) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55AA4)) + { + Return (0x02) + } + + /* set memory contents to known values using misaligned field entries */ + + BIT1 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BIT1 != 0x01)) + { + Return (0x03) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55AA6)) + { + Return (0x04) + } + + /* set memory contents to known values using misaligned field entries */ + + BIT2 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BIT2 != 0x00)) + { + Return (0x05) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55AA2)) + { + Return (0x06) + } + + /* set memory contents to known values using misaligned field entries */ + + BIT3 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BIT3 != 0x01)) + { + Return (0x07) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55AAA)) + { + Return (0x08) + } + + /* set memory contents to known values using misaligned field entries */ + + BIT4 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BIT4 != 0x01)) + { + Return (0x09) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55ABA)) + { + Return (0x0A) + } + + /* set memory contents to known values using misaligned field entries */ + + BIT5 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BIT5 != 0x00)) + { + Return (0x0B) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55A9A)) + { + Return (0x0C) + } + + /* set memory contents to known values using misaligned field entries */ + + BIT6 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BIT6 != 0x01)) + { + Return (0x0D) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55ADA)) + { + Return (0x0E) + } + + /* set memory contents to known values using misaligned field entries */ + + BIT7 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BIT7 != 0x00)) + { + Return (0x0F) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55A5A)) + { + Return (0x10) + } + + /* set memory contents to known values using misaligned field entries */ + + BIT8 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BIT8 != 0x01)) + { + Return (0x11) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55B5A)) + { + Return (0x12) + } + + /* set memory contents to known values using misaligned field entries */ + + BIT9 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BIT9 != 0x00)) + { + Return (0x13) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA5595A)) + { + Return (0x14) + } + + /* set memory contents to known values using misaligned field entries */ + + BITA = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BITA != 0x01)) + { + Return (0x15) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA55D5A)) + { + Return (0x16) + } + + /* set memory contents to known values using misaligned field entries */ + + BITB = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BITB != 0x00)) + { + Return (0x17) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA5555A)) + { + Return (0x18) + } + + /* set memory contents to known values using misaligned field entries */ + + BITC = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BITC != 0x00)) + { + Return (0x19) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA5455A)) + { + Return (0x1A) + } + + /* set memory contents to known values using misaligned field entries */ + + BITD = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BITD != 0x01)) + { + Return (0x1B) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA5655A)) + { + Return (0x1C) + } + + /* set memory contents to known values using misaligned field entries */ + + BITE = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BITE != 0x00)) + { + Return (0x1D) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA5255A)) + { + Return (0x1E) + } + + /* set memory contents to known values using misaligned field entries */ + + BITF = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BITF != 0x01)) + { + Return (0x1F) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA5A55A)) + { + Return (0x20) + } + + /* set memory contents to known values using misaligned field entries */ + + BI10 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BI10 != 0x00)) + { + Return (0x21) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA4A55A)) + { + Return (0x22) + } + + /* set memory contents to known values using misaligned field entries */ + + BI11 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BI11 != 0x01)) + { + Return (0x23) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA6A55A)) + { + Return (0x24) + } + + /* set memory contents to known values using misaligned field entries */ + + BI12 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BI12 != 0x00)) + { + Return (0x25) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AA2A55A)) + { + Return (0x26) + } + + /* set memory contents to known values using misaligned field entries */ + + BI13 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BI13 != 0x01)) + { + Return (0x27) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5AAAA55A)) + { + Return (0x28) + } + + /* set memory contents to known values using misaligned field entries */ + + BI14 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BI14 != 0x01)) + { + Return (0x29) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5ABAA55A)) + { + Return (0x2A) + } + + /* set memory contents to known values using misaligned field entries */ + + BI15 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BI15 != 0x00)) + { + Return (0x2B) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5A9AA55A)) + { + Return (0x2C) + } + + /* set memory contents to known values using misaligned field entries */ + + BI16 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BI16 != 0x01)) + { + Return (0x2D) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5ADAA55A)) + { + Return (0x2E) + } + + /* set memory contents to known values using misaligned field entries */ + + BI17 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BI17 != 0x00)) + { + Return (0x2F) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5A5AA55A)) + { + Return (0x30) + } + + /* set memory contents to known values using misaligned field entries */ + + BI18 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BI18 != 0x01)) + { + Return (0x31) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5B5AA55A)) + { + Return (0x32) + } + + /* set memory contents to known values using misaligned field entries */ + + BI19 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BI19 != 0x00)) + { + Return (0x33) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x595AA55A)) + { + Return (0x34) + } + + /* set memory contents to known values using misaligned field entries */ + + BI1A = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BI1A != 0x01)) + { + Return (0x35) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x5D5AA55A)) + { + Return (0x36) + } + + /* set memory contents to known values using misaligned field entries */ + + BI1B = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BI1B != 0x00)) + { + Return (0x37) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x555AA55A)) + { + Return (0x38) + } + + /* set memory contents to known values using misaligned field entries */ + + BI1C = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BI1C != 0x00)) + { + Return (0x39) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x455AA55A)) + { + Return (0x3A) + } + + /* set memory contents to known values using misaligned field entries */ + + BI1D = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BI1D != 0x01)) + { + Return (0x3B) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x655AA55A)) + { + Return (0x3C) + } + + /* set memory contents to known values using misaligned field entries */ + + BI1E = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((BI1E != 0x00)) + { + Return (0x3D) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x255AA55A)) + { + Return (0x3E) + } + + /* set memory contents to known values using misaligned field entries */ + + BI1F = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((BI1F != 0x01)) + { + Return (0x3F) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55AA55A)) + { + Return (0x40) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_0 = 0x03 + /* verify memory contents using misaligned field entries */ + + If ((B2_0 != 0x03)) + { + Return (0x41) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55AA55B)) + { + Return (0x42) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_1 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((B2_1 != 0x01)) + { + Return (0x43) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55AA557)) + { + Return (0x44) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_2 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((B2_2 != 0x00)) + { + Return (0x45) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55AA547)) + { + Return (0x46) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_3 = 0x03 + /* verify memory contents using misaligned field entries */ + + If ((B2_3 != 0x03)) + { + Return (0x47) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55AA5C7)) + { + Return (0x48) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_4 = 0x03 + /* verify memory contents using misaligned field entries */ + + If ((B2_4 != 0x03)) + { + Return (0x49) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55AA7C7)) + { + Return (0x4A) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_5 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((B2_5 != 0x00)) + { + Return (0x4B) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55AA3C7)) + { + Return (0x4C) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_6 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((B2_6 != 0x01)) + { + Return (0x4D) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55A93C7)) + { + Return (0x4E) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_7 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((B2_7 != 0x01)) + { + Return (0x4F) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55A53C7)) + { + Return (0x50) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_8 = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((B2_8 != 0x00)) + { + Return (0x51) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55853C7)) + { + Return (0x52) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_9 = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((B2_9 != 0x01)) + { + Return (0x53) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA55453C7)) + { + Return (0x54) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_A = 0x02 + /* verify memory contents using misaligned field entries */ + + If ((B2_A != 0x02)) + { + Return (0x55) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA56453C7)) + { + Return (0x56) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_B = 0x02 + /* verify memory contents using misaligned field entries */ + + If ((B2_B != 0x02)) + { + Return (0x57) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA5A453C7)) + { + Return (0x58) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_C = 0x03 + /* verify memory contents using misaligned field entries */ + + If ((B2_C != 0x03)) + { + Return (0x59) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xA7A453C7)) + { + Return (0x5A) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_D = 0x03 + /* verify memory contents using misaligned field entries */ + + If ((B2_D != 0x03)) + { + Return (0x5B) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0xAFA453C7)) + { + Return (0x5C) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_E = 0x01 + /* verify memory contents using misaligned field entries */ + + If ((B2_E != 0x01)) + { + Return (0x5D) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x9FA453C7)) + { + Return (0x5E) + } + + /* set memory contents to known values using misaligned field entries */ + + B2_F = 0x00 + /* verify memory contents using misaligned field entries */ + + If ((B2_F != 0x00)) + { + Return (0x5F) + } + + /* verify memory contents using aligned field entries */ + + If ((DWD0 != 0x1FA453C7)) + { + Return (0x60) + } + + Return (0x00) /* pass */ + } /* MADM: Misaligned Dynamic RAM SystemMemory OperationRegion */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ IndexOp4 Test" + /* MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments: */ + /* Arg0 -- SystemMemory OperationRegion base address */ + Local0 = MADM (0x00800000) + If ((Local0 != 0x00)) /* 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, NotSerialized) + { + /* 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 */ + + Local0 = Wait (EVNT, Arg0) + /* validate Local0 is a Number */ + + Local1 = ObjectType (Local0) + If ((Local1 != 0x01)) /* Number is type 1 */ + { + Return (0x21) + } /* Local1 indicates Local0 is not a Number */ + + If ((Local0 != 0x00)) /* Number is type 1 */ + { + Return (0x22) + } /* timeout occurred without acquiring signal */ + + Debug = "Acquire 1st existing signal PASS" + /* acquire existing signal */ + + Local0 = Wait (EVNT, Arg0) + /* validate Local0 is a Number */ + + Local1 = ObjectType (Local0) + If ((Local1 != 0x01)) /* Number is type 1 */ + { + Return (0x31) + } /* Local1 indicates Local0 is not a Number */ + + If ((Local0 != 0x00)) /* Number is type 1 */ + { + Return (0x32) + } /* timeout occurred without acquiring signal */ + + Debug = "Acquire 2nd existing signal PASS" + /* ensure WaitOp timeout test cases do not hang */ + + If ((Arg0 == 0xFFFF)) + { + Arg0 = 0xFFFE + } + + /* acquire non-existing signal */ + + Local0 = Wait (EVNT, Arg0) + /* validate Local0 is a Number */ + + Local1 = ObjectType (Local0) + If ((Local1 != 0x01)) /* Number is type 1 */ + { + Return (0x41) + } /* Local1 indicates Local0 is not a Number */ + + If ((Local0 == 0x00)) /* Number is type 1 */ + { + Return (0x42) + } /* non-existant signal was acquired */ + + Debug = "Acquire signal timeout PASS" + /* prime EVNT with two outstanding signals */ + + Signal (EVNT) + Signal (EVNT) + /* reset EVNT to initialization (zero) state */ + + Reset (EVNT) + /* acquire non-existing signal */ + + Local0 = Wait (EVNT, Arg0) + /* validate Local0 is a Number */ + + Local1 = ObjectType (Local0) + If ((Local1 != 0x01)) /* Number is type 1 */ + { + Return (0x51) + } /* Local1 indicates Local0 is not a Number */ + + If ((Local0 == 0x00)) /* Number is type 1 */ + { + Return (0x52) + } /* non-existant signal was acquired */ + + Debug = "Reset signal PASS" + /* acquire non-existing signal using Lvalue timeout */ + + Local0 = Wait (EVNT, Zero) + /* validate Local0 is a Number */ + + Local1 = ObjectType (Local0) + If ((Local1 != 0x01)) /* Number is type 1 */ + { + Return (0x61) + } /* Local1 indicates Local0 is not a Number */ + + If ((Local0 == 0x00)) /* Number is type 1 */ + { + Return (0x62) + } /* non-existant signal was acquired */ + + Debug = "Zero Lvalue PASS" + /* acquire non-existing signal using Lvalue timeout */ + + Local0 = Wait (EVNT, One) + /* validate Local0 is a Number */ + + Local1 = ObjectType (Local0) + If ((Local1 != 0x01)) /* Number is type 1 */ + { + Return (0x71) + } /* Local1 indicates Local0 is not a Number */ + + If ((Local0 == 0x00)) /* Number is type 1 */ + { + Return (0x72) + } /* non-existant signal was acquired */ + + Debug = "One Lvalue PASS" + /* Lvalue Event test cases */ + /* ILLEGAL SOURCE OPERAND Store (EVNT, Local2) */ + /* validate Local2 is an Event */ + Local1 = ObjectType (EVNT) + If ((Local1 != 0x07)) /* 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 */ + + Local0 = Wait (EVNT, Arg0) + /* validate Local0 is a Number */ + + Local1 = ObjectType (Local0) + If ((Local1 != 0x01)) /* Number is type 1 */ + { + Return (0x82) + } /* Local1 indicates Local0 is not a Number */ + + If ((Local0 != 0x00)) /* Number is type 1 */ + { + Return (0x83) + } /* timeout occurred without acquiring signal */ + + Debug = "Acquire Lvalue existing signal PASS" + /* acquire non-existing signal */ + + Local0 = Wait (EVNT, Arg0) + /* validate Local0 is a Number */ + + Local1 = ObjectType (Local0) + If ((Local1 != 0x01)) /* Number is type 1 */ + { + Return (0x84) + } /* Local1 indicates Local0 is not a Number */ + + If ((Local0 == 0x00)) /* Number is type 1 */ + { + Return (0x85) + } /* non-existant signal was acquired */ + + Debug = "Acquire Lvalue signal timeout PASS" + Return (0x00) /* success */ + } /* TEVN control method to test ResetOp, SignalOp, and WaitOp */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ Event Test" + Local0 = TEVN (0x64) + 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 (0x03) + { + 0x0123, + 0x4567, + 0x89AB + }) /* PKG0 */ + Name (PKG1, Package (0x03) + { + Package (0x03) + { + 0x0123, + 0x4567, + 0x89AB + }, + + Package (0x03) + { + 0xCDEF, + 0xFEDC, + 0xBA98 + }, + + Package (0x03) + { + 0x7654, + 0x3210, + 0x1234 + } + }) /* PKG1 */ + Name (PKG2, Package (0x04) + { + 0x0123, + 0x4567, + 0x89AB, + 0x8888 + }) /* PKG2 */ + Name (PKG3, Package (0x05) + { + 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 (0x0A){}) + Name (BUF1, Buffer (0x0A){}) + Name (BUF2, Buffer (0x08){}) + Name (BUF3, Buffer (0x05){}) + /* End Buffers ********************************************************** */ + + Device (SZLV) + { + Method (CMPR, 2, NotSerialized) + { + /* CMPR is passed two arguments. If unequal, return 1 to indicate */ + /* that, otherwise return 0 to indicate SizeOf each is equal. */ + Local0 = 0x01 + If ((SizeOf (Arg0) == SizeOf (Arg1))) + { + Local0 = 0x00 + } + + Return (Local0) + } /* CMPR */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ SizeOfLv Test" + /* 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 ((0x00 != CMPR (STR0, STR1))) + { + Return (0x01) + } + + If ((0x00 != CMPR (STR3, BUF3))) + { + Return (0x02) + } + + If ((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 */ + Local0 = STR0 /* \STR0 */ + Local1 = STR1 /* \STR1 */ + If ((SizeOf (Local0) != SizeOf (Local1))) + { + Return (0x04) + } + + /* Now create a case where Local0 and Local1 are different */ + + Local1 = STR2 /* \STR2 */ + If ((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 ((0x05 != SizeOf (BUF3))) + { + Return (0x06) + } + + Return (0x00) + } /* 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, 0, NotSerialized) + { + Debug = "++++++++ BytField Test" + Return (\_TZ.C19B.RSLT) + } /* TEST */ + } /* BYTF */ + + Device (C005) + { + /* Device C005 */ + + Device (C013) + { + /* Device C013 */ + } /* Device C013 */ + } /* Device C005 */ + + Method (C115, 0, NotSerialized) + { + /* C115 control method */ + + Acquire (\_GL, 0xFFFF) + Local0 = \_SB.C005.C013.C058.C07E + Release (\_GL) + Local0 &= 0x10 + Store ((Local0 >> 0x04), Local1) + If ((Local1 == 0x00)) + { + Return (0x01) + } + Else + { + Return (0x00) + } + } /* C115 control method */ + } /* _SB system bus */ + + OperationRegion (C018, SystemIO, 0x5028, 0x04) + Field (C018, AnyAcc, NoLock, Preserve) + { + /* Field overlaying C018 */ + + C019, 32 + } /* Field overlaying C018 */ + + OperationRegion (C01A, SystemIO, 0x5030, 0x04) + Field (C01A, ByteAcc, NoLock, Preserve) + { + /* Field overlaying C01A */ + + C01B, 8, + C01C, 8, + C01D, 8, + C01E, 8 + } /* Field overlaying C01A */ + + Mutex (\C01F, 0x00) + Name (\C020, 0x00) + Name (\C021, 0x00) + Method (\C022, 0, NotSerialized) + { + /* \C022 control method */ + + Acquire (\C01F, 0xFFFF) + If ((\C021 == 0x00)) + { + Local0 = C019 /* \C019 */ + Local0 &= 0xFFFEFFFE + C019 = Local0 + \C021++ + } + + Release (\C01F) + } /* \C022 control method */ + + Scope (\_SB.C005.C013) + { + /* Scope \_SB.C005.C013 */ + + Device (C058) + { + /* Device C058 */ + + Name (_HID, "*PNP0A06") // _HID: Hardware ID + OperationRegion (C059, SystemIO, 0xE0, 0x02) + Field (C059, ByteAcc, NoLock, Preserve) + { + /* Field overlaying C059 */ + + C05A, 8, + C05B, 8 + } /* Field overlaying C059 */ + + OperationRegion (C05C, SystemIO, 0xE2, 0x02) + Field (C05C, ByteAcc, NoLock, Preserve) + { + /* Field overlaying C05C */ + + C05D, 8, + C05E, 8 + } /* Field overlaying C05C */ + + IndexField (C05D, C05E, ByteAcc, NoLock, Preserve) + { + Offset (0x82), + /* IndexField overlaying C05D/C05E */ + + 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, + Offset (0xA0), + 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, 0x02) + Field (C07F, ByteAcc, NoLock, Preserve) + { + /* Field overlaying C07F */ + + C080, 8, + C081, 8 + } /* Field overlaying C07F */ + + OperationRegion (C082, SystemIO, 0xE0, 0x01) + Field (C082, ByteAcc, NoLock, Preserve) + { + /* Field overlaying C082 */ + + C083, 8 + } /* Field overlaying C082 */ + + OperationRegion (C084, SystemIO, 0xFF, 0x01) + Field (C084, ByteAcc, NoLock, Preserve) + { + /* Field overlaying C084 */ + + C085, 8 + } /* Field overlaying C084 */ + + OperationRegion (C086, SystemIO, 0xFD, 0x01) + Field (C086, ByteAcc, NoLock, Preserve) + { + /* Field overlaying C086 */ + + C087, 8 + } /* Field overlaying C086 */ + + Mutex (C088, 0x00) + Mutex (C089, 0x00) + Mutex (C08A, 0x00) + Mutex (C08B, 0x00) + Mutex (C08C, 0x00) + Mutex (C08D, 0x00) + Name (C08E, 0xFFFFFFFD) + Name (C08F, 0x00) + Method (C0AA, 4, NotSerialized) + { + /* C0AA control method */ + + Local7 = Buffer (0x04){} + CreateByteField (Local7, 0x00, C0AB) + CreateByteField (Local7, 0x01, C0AC) + CreateByteField (Local7, 0x02, C0AD) + CreateByteField (Local7, 0x03, C0AE) + Acquire (^C08B, 0xFFFF) + Acquire (\_GL, 0xFFFF) + \C022 () + \_SB.C005.C013.C058.C06B = 0x01 + While ((0x00 != \_SB.C005.C013.C058.C06B)) + { + Stall (0x64) + } + + \_SB.C005.C013.C058.C06E = Arg3 + \_SB.C005.C013.C058.C06D = Arg2 + \_SB.C005.C013.C058.C06C = Arg1 + \_SB.C005.C013.C058.C06B = Arg0 + While ((0x00 != \_SB.C005.C013.C058.C06B)) + { + Stall (0x64) + } + + C0AB = \_SB.C005.C013.C058.C06E + C0AC = \_SB.C005.C013.C058.C06D + C0AD = \_SB.C005.C013.C058.C06C + C0AE = \_SB.C005.C013.C058.C06B + If ((Arg0 != 0x17)) + { + \_SB.C005.C013.C058.C06B = 0x02 + Stall (0x64) + } + + Release (\_GL) + Release (^C08B) + Return (Local7) + } /* C0AA control method */ + } /* Device C058 */ + } /* Scope \_SB.C005.C013 */ + + Scope (\_TZ) + { + /* \_TZ thermal zone scope */ + + Name (C18B, Package (0x02) + { + Package (0x02) + { + Package (0x05) + { + 0x05AC, + 0x0CD2, + 0x0D68, + 0x0DE0, + 0x0E4E + }, + + Package (0x05) + { + 0x0D04, + 0x0D9A, + 0x0DFE, + 0x0E80, + 0x0FA2 + } + }, + + Package (0x02) + { + Package (0x05) + { + 0x05AC, + 0x0CD2, + 0x0D68, + 0x0DE0, + 0x0E4E + }, + + Package (0x05) + { + 0x0D04, + 0x0D9A, + 0x0DFE, + 0x0E80, + 0x0FA2 + } + } + }) /* C18B */ + Name (C18C, Package (0x02) + { + Package (0x02) + { + Package (0x03) + { + 0x64, + 0x4B, + 0x32 + }, + + Package (0x03) + { + 0x64, + 0x4B, + 0x32 + } + } + }) /* C81C */ + Name (C18D, 0x00) + Name (C18E, 0x00) + Name (C18F, 0x00) + Name (C190, 0x00) + Name (C191, 0x03) + Name (C192, 0x00) + Name (C193, 0x01) + Name (C194, 0x02) + Mutex (C195, 0x00) + Name (C196, 0x01) + Name (C197, 0x0B9C) + Name (C198, 0x0B9C) + Name (C199, 0xFFFFFFFD) + Name (C19A, 0x00) + Device (C19B) + { + /* Device C19B */ + + Name (RSLT, 0x00) /* default to zero */ + Method (XINI, 0, NotSerialized) + { + /* _INI control method (Uses Global Lock -- can't run under AcpiExec) */ + + C19A = \_SB.C115 () + \_TZ.C19C._SCP (0x00) + Local1 = (0x0EB2 - 0x0AAC) /* Local1 = AACh - EB2h */ + Divide (Local1, 0x0A, Local0, Local2) /* Local0 = Local1 / 10 */ + /* Local2 = Local1 % 10 */ + + \_SB.C005.C013.C058.C0AA (0x0E, Local2, 0x00, 0x00) + C18D = DerefOf (DerefOf (\_TZ.C18C [C19A]) [0x00]) + C18E = DerefOf (DerefOf (\_TZ.C18C [C19A]) [0x01]) + C18F = DerefOf (DerefOf (\_TZ.C18C [C19A]) [0x02]) + RSLT = 0x01 /* set RSLT to 1 if _INI control method completes */ + } /* _INI control method */ + /* PowerResource (C19D) {...} */ + } /* Device C19B */ + + ThermalZone (C19C) + { + Method (_SCP, 1, NotSerialized) // _SCP: Set Cooling Policy + { + /* _SCP control method */ + + Local0 = Arg0 + If ((Local0 == 0x00)) + { + \_TZ.C192 = 0x00 + \_TZ.C193 = 0x01 + \_TZ.C194 = 0x02 + \_TZ.C191 = 0x03 + } + Else + { + \_TZ.C191 = 0x00 + \_TZ.C192 = 0x01 + \_TZ.C193 = 0x02 + \_TZ.C194 = 0x03 + } + } /* _SCP control method */ + } /* ThermalZone C19C */ + } /* \_TZ thermal zone scope */ + + /* */ + /* test DwrdFld.asl */ + /* */ + Name (BUFR, Buffer (0x0A) + { + /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ + /* 0008 */ 0x00, 0x00 // .. + }) + Device (DWDF) + { + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ DwrdFld Test" + CreateByteField (BUFR, 0x00, BYTE) + BYTE = 0xAA + CreateWordField (BUFR, 0x01, WORD) + WORD = 0xBBCC + CreateDWordField (BUFR, 0x03, DWRD) + DWRD = 0xDDEEFF00 + CreateByteField (BUFR, 0x07, BYT2) + BYT2 = 0x11 + CreateWordField (BUFR, 0x08, WRD2) + WRD2 = 0x2233 + Return (0x00) + } /* End Method TEST */ + } /* Device DWDF */ + + /* */ + /* test DivAddx.asl */ + /* */ + Name (B1LO, 0xAA) + Name (B1HI, 0xBB) + Method (MKW, 2, NotSerialized) + { + /* This control method will take two bytes and make them into a WORD */ + + Local0 = (B1HI * 0x0100) /* Make high byte.....high */ + Local0 |= B1LO /* OR in the low byte */ /* \B1LO */ + Return (Local0) /* Return the WORD */ + } /* MKW_ */ + + Device (DVAX) + { + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ DivAddx Test" + B1LO = 0x19 + B1HI = 0x00 + /* 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 (((0x03 * MKW (B1LO, B1HI)) + 0x63), /* Dividend, */ + +0x64, /* Divisor */Local4, /* Remainder */ + Local2) /* Quotient */ + If (((0x4A == Local4) && (0x01 == Local2))) + { + /* Indicate Pass */ + + Local0 = 0x00 + } + Else + { + /* Indicate Fail */ + + Local0 = 0x01 + } + + 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, 0x0100, 0x02) + Field (SIO, ByteAcc, NoLock, Preserve) + { + INDX, 8, + DATA, 8 + } + + IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes) + { + AccessAs (ByteAcc, 0x00), + 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, 0x0100, 0x02) + Field (SIO2, ByteAcc, NoLock, Preserve) + { + IND2, 8, + DAT2, 8 + } + + IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes) + { + IFE0, /* duplicate IndexField name with different scope */ 8, + IFE1, 8 + } + } /* TST_: provides a different namespace scope for IFE0 and IFE1 */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ IndexOp6 Test" + Local0 = IFE0 /* \IDX6.IFE0 */ + Local1 = IFE1 /* \IDX6.IFE1 */ + Local2 = IFE2 /* \IDX6.IFE2 */ + /* validate name resolution of IndexFields with different scopes */ + + Local3 = \IDX6.IFE0 + Local4 = \IDX6.IFE1 + /* verioading of namespace can resolve following names */ + + Local5 = \IDX6.TST.IFE0 + Local6 = \IDX6.TST.IFE1 + Return (0x00) + } /* 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, 0x00) /* 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, Serialized) + { + /* 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 ((SizeOf (Arg0) < SizeOf (Arg1))) + { + Return (0x00) + } + + /* increment length to include NULL termination character */ + + Local0 = (SizeOf (Arg0) + 0x01) /* 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 */ + + BUF0 = Arg0 + BUF1 = Arg1 + /* validate BUF0 and BUF1 are still buffers */ + + Local1 = ObjectType (BUF0) + If ((Local1 != 0x03)) /* Buffer is type 3 */ + { + Return (0x14) + } + + Local1 = ObjectType (BUF1) + If ((Local1 != 0x03)) /* Buffer is type 3 */ + { + Return (0x15) + } + + /* Decrement because the Index base below is zero based */ + /* while Local0 length is one based. */ + Local0-- + While (Local0) + { + /* loop through all BUF0 buffer elements */ + + Local0-- + /* check if BUF0[n] == BUF1[n] */ + + If ((DerefOf (BUF0 [Local0]) == DerefOf (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, 0, NotSerialized) + { + Debug = "++++++++ IndexOp5 Test" + If (MCTH (\_OS, "Microsoft Windows NT")) + { + OSFL = 0x01 + } + + If ((OSFL != 0x01)) + { + Return (0x0B) + } + + Return (0x00) + } /* TEST */ + } /* IDX5 */ + + /* */ + /* test IndexOp.asl */ + /* */ + Scope (\_SB) /* System Bus */ + { + /* _SB system bus */ + + Method (C097, 0, NotSerialized) + { + Return (0x01) + } + + Device (PCI2) + { + /* Root PCI Bus */ + + Name (_HID, EisaId ("PNP0A03") /* PCI Bus */) // _HID: Hardware ID + Name (_ADR, 0x00) // _ADR: Address + Name (_CRS, Buffer (0x1A) // _CRS: Current Resource Settings + { + "_SB_.PCI2._CRS..........." + }) + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } + + Device (ISA) + { + /* ISA bridge */ + + Name (_ADR, 0x00030000) /* ISA bus ID */ // _ADR: Address + Device (EC0) + { + /* Embedded Controller */ + + Name (_GPE, 0x00) /* EC use GPE0 */ // _GPE: General Purpose Events + Name (_ADR, 0x00030000) /* PCI address */ // _ADR: Address + Method (_STA, 0, NotSerialized) // _STA: Status + { + Return (0x0F) + } /* EC is functioning */ + + Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings + { + IO (Decode16, + 0x0062, // Range Minimum + 0x0062, // Range Maximum + 0x01, // Alignment + 0x01, // Length + ) + IO (Decode16, + 0x0066, // Range Minimum + 0x0066, // Range Maximum + 0x01, // Alignment + 0x01, // Length + ) + }) + /* create EC's region and field */ + + OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + /* AC information */ + + ADP, /* AC Adapter 1:On-line, 0:Off-line */ 1, + AFLT, /* AC Adapter Fault 1:Fault 0:Normal */ 1, + BAT0, /* BAT0 1:present, 0:not present */ 1, + , 1, + Offset (0x04), + /* CMBatt information */ + + BPU0, /* Power Unit */ 32, + BDC0, /* Designed Capacity */ 32, + BFC0, /* Last Full Charge Capacity */ 32, + BTC0, /* Battery Technology */ 32, + BDV0, /* Design Voltage */ 32, + BST0, /* Battery State */ 32, + BPR0, /* Battery Present Rate */ 32, + /* (Designed Capacity)x(%)/{(h)x100} */ + + BRC0, /* Battery Remaining Capacity */ 32, + /* (Designed Capacity)(%)^100 */ + + BPV0, /* Battery Present Voltage */ 32, + BTP0, /* Trip Point */ 32, + BCW0, /* Design capacity of Warning */ 32, + BCL0, /* Design capacity of Low */ 32, + BCG0, /* capacity granularity 1 */ 32, + BG20, /* capacity granularity 2 */ 32, + BMO0, /* Battery model number field */ 32, + BIF0, /* OEM Information(00h) */ 32, + BSN0, /* Battery Serial Number */ 32, + BTY0, /* Battery Type (e.g., "Li-Ion") */ 32, + BTY1, /* Battery Type (e.g., "Li-Ion") */ 32 + } /* Field */ + } /* EC0: Embedded Controller */ + } /* ISA bridge */ + } /* PCI2 Root PCI Bus */ + + Device (IDX0) + { + /* Test device name */ + + Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) /* Control Method Battey ID */ // _HID: Hardware ID + Name (_PCL, Package (0x01) // _PCL: Power Consumer List + { + \_SB + }) + Method (_STA, 0, NotSerialized) // _STA: Status + { + /* _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, 0, Serialized) // _BIF: Battery Information + { + Name (BUFR, Package (0x0D){}) + BUFR [0x00] = \_SB.PCI2.ISA.EC0.BPU0 /* Power Unit */ + BUFR [0x01] = \_SB.PCI2.ISA.EC0.BDC0 /* Designed Capacity */ + BUFR [0x02] = \_SB.PCI2.ISA.EC0.BFC0 /* Last Full Charge Capa. */ + BUFR [0x03] = \_SB.PCI2.ISA.EC0.BTC0 /* Battery Technology */ + BUFR [0x04] = \_SB.PCI2.ISA.EC0.BDV0 /* Designed Voltage */ + BUFR [0x05] = \_SB.PCI2.ISA.EC0.BCW0 /* Designed warning level */ + BUFR [0x06] = \_SB.PCI2.ISA.EC0.BCL0 /* Designed Low level */ + BUFR [0x07] = \_SB.PCI2.ISA.EC0.BCG0 /* Capacity granularity 1 */ + BUFR [0x08] = \_SB.PCI2.ISA.EC0.BG20 /* Capacity granularity 2 */ + BUFR [0x09] = "" /* Model Number */ + BUFR [0x0A] = "" /* Serial Number */ + BUFR [0x0B] = "LiOn" /* Battery Type */ + BUFR [0x0C] = "Chicony" /* OEM Information */ + Return (BUFR) /* \_SB_.IDX0._BIF.BUFR */ + } /* _BIF */ + + Method (_BST, 0, Serialized) // _BST: Battery Status + { + Name (BUFR, Package (0x04) + { + 0x01, + 0x0100, + 0x76543210, + 0x0180 + }) + Return (BUFR) /* \_SB_.IDX0._BST.BUFR */ + } /* _BST */ + + Method (_BTP, 1, NotSerialized) // _BTP: Battery Trip Point + { + \_SB.PCI2.ISA.EC0.BTP0 = Arg0 /* Set Battery Trip point */ + } + + Method (TEST, 0, Serialized) + { + Debug = "++++++++ IndexOp Test" + /* test storing into uninitialized package elements */ + + Name (PBUF, Package (0x04){}) /* leave unitialized */ + PBUF [0x00] = 0x01234567 + PBUF [0x01] = 0x89ABCDEF + PBUF [0x02] = 0xFEDCBA98 + PBUF [0x03] = 0x76543210 + /* verify values stored into uninitialized package elements */ + + If ((DerefOf (PBUF [0x00]) != 0x01234567)) + { + Return (0x10) + } + + If ((DerefOf (PBUF [0x01]) != 0x89ABCDEF)) + { + Return (0x11) + } + + If ((DerefOf (PBUF [0x02]) != 0xFEDCBA98)) + { + Return (0x12) + } + + If ((DerefOf (PBUF [0x03]) != 0x76543210)) + { + Return (0x13) + } + + /* store _BIF package return value into Local0 */ + + Local0 = _BIF () + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Package */ + + If ((Local1 != 0x04)) /* Package type is 4 */ + { + Return (0x21) + } /* failure */ + + /* test storing into buffer field elements */ + + Name (BUFR, Buffer (0x10) + { + /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ + /* 0008 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........ + }) /* BUFR */ + /* test storing into buffer field elements */ + + BUFR [0x00] = 0x01234567 /* should only store 0x67 */ + BUFR [0x04] = 0x89ABCDEF /* should only store 0xEF */ + BUFR [0x08] = 0xFEDCBA98 /* should only store 0x98 */ + BUFR [0x0C] = 0x76543210 /* should only store 0x10 */ + /* verify storing into buffer field elements */ + + If ((DerefOf (BUFR [0x00]) != 0x67)) + { + Return (0x30) + } + + If ((DerefOf (BUFR [0x01]) != 0x00)) + { + Return (0x31) + } + + If ((DerefOf (BUFR [0x04]) != 0xEF)) + { + Return (0x34) + } + + If ((DerefOf (BUFR [0x08]) != 0x98)) + { + Return (0x38) + } + + If ((DerefOf (BUFR [0x0C]) != 0x10)) + { + Return (0x3C) + } + + Return (0x00) /* 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, 0x00800000, 0x0100) + Field (RAM, AnyAcc, NoLock, Preserve) + { + /* Any access */ + + TREE, 3, + WRD0, 16, + WRD1, 16, + WRD2, 16, + WRD3, 16, + WRD4, 16, + DWRD, /* DWORD field */ 32 + } + + Field (RAM, AnyAcc, NoLock, Preserve) + { + /* Any access */ + + THRE, 3, + WD00, 16, + WD01, 16, + WD02, 16, + WD03, 16, + WD04, 16, + BYT0, /* Start off with a BYTE */ 8, + BIT0, /* single-bit field */ 1, + BIT1, /* single-bit field */ 1, + BIT2, /* single-bit field */ 1, + BIT3, /* single-bit field */ 1, + BIT4, /* single-bit field */ 1, + BIT5, /* single-bit field */ 1, + BIT6, /* single-bit field */ 1, + BIT7, /* single-bit field */ 1, + BIT8, /* single-bit field */ 1, + BIT9, /* single-bit field */ 1, + BITA, /* single-bit field */ 1, + BITB, /* single-bit field */ 1, + BITC, /* single-bit field */ 1, + BITD, /* single-bit field */ 1, + BITE, /* single-bit field */ 1, + BITF, /* single-bit field */ 1, + BYTZ, /* End with a BYTE for a total of 32 bits */ 8 + } + + Device (BITI) + { + /* Test device name */ + + Method (MBIT, 0, NotSerialized) + { + If ((DWRD != 0x00)) + { + Local0 = 0xFF00 + } + Else + { + /* Prime Local0 with 0...assume passing condition */ + + Local0 = 0x00 + /* set memory contents to known values using DWORD field */ + + DWRD = 0x5A5A5A5A + /* 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) + { + Local0 |= 0x01 + } + + If (!BIT1) + { + Local0 |= 0x02 + } + + If (BIT2) + { + Local0 |= 0x04 + } + + If (!BIT3) + { + Local0 |= 0x08 + } + + /* Now check the upper nibble. Only the "even" bits should */ + /* be set. BIT4, BIT6. BIT5 and BIT7 should be clear. */ + If (!BIT4) + { + Local0 |= 0x10 + } + + If (BIT5) + { + Local0 |= 0x20 + } + + If (!BIT6) + { + Local0 |= 0x40 + } + + If (BIT7) + { + Local0 |= 0x80 + } + } /* End Else DWRD zeroed out */ + + Return (Local0) + } /* MBIT: Test single bit memory accesses */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ BitIndex Test" + /* Zero out DWRD */ + + DWRD = 0x00 + /* MBIT returns zero if successful */ + /* This may be causing problems -- Return (MBIT) */ + Local0 = MBIT () + 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, 0x0D) + Name (C175, 0x08) + Device (C158) + { + /* C158: AC Adapter device */ + + Name (_HID, "ACPI0003" /* Power Source Device */) /* AC Adapter device */ // _HID: Hardware ID + Name (_PCL, Package (0x01) // _PCL: Power Consumer List + { + \_SB + }) + Method (_PSR, 0, NotSerialized) // _PSR: Power Source + { + Acquire (\_GL, 0xFFFF) + Release (\_GL) + Local0 &= 0x01 /* Local0 &= 1 */ + Return (Local0) + } /* _PSR */ + } /* C158: AC Adapter device */ + + Name (C176, Package (0x04) + { + "Primary", + "MultiBay", + "DockRight", + "DockLeft" + }) + Name (C177, Package (0x04) + { + 0x99F5, + 0x99F5, + 0x995F, + 0x995F + }) + Name (C178, Package (0x04) + { + Package (0x04) + { + 0x00, + 0x00, + 0x966B, + 0x4190 + }, + + Package (0x04) + { + 0x00, + 0x00, + 0x966B, + 0x4190 + }, + + Package (0x04) + { + 0x00, + 0x00, + 0x966B, + 0x4190 + }, + + Package (0x04) + { + 0x00, + 0x00, + 0x966B, + 0x4190 + } + }) /* C178 */ + Name (C179, Package (0x04) + { + 0x00, + 0x00, + 0x966B, + 0x4190 + }) + Name (C17A, Package (0x04) + { + Package (0x03) + { + 0x00, + 0x00, + 0x00 + }, + + Package (0x03) + { + 0x00, + 0x00, + 0x00 + }, + + Package (0x03) + { + 0x00, + 0x00, + 0x00 + }, + + Package (0x03) + { + 0x00, + 0x00, + 0x00 + } + }) /* C17A */ + Method (C17B, 1, Serialized) + { + /* C17B: _BIF implementation */ + + Name (C17C, Package (0x0D) + { + /* C17C: _BIF control method return package */ + + 0x00, /* Power Unit (0 ==> mWh and mW) */ + 0x99F5, /* Design Capacity */ + 0x99F5, /* Last Full Charge Capacity */ + 0x01, /* Battery Technology (1 ==> rechargeable) */ + 0x3840, /* Design Voltage */ + 0x1280, /* Design Capacity of Warning */ + 0x0AC7, /* Design Capacity of Low */ + 0x01, /* Battery Capacity Granularity 1 (Low -- Warning) */ + 0x01, /* Battery Capacity Granularity 2 (Warning -- Full) */ + "2891", /* Model Number (ASCIIZ) */ + "(-Unknown-)", /* Serial Number (ASCIIZ) */ + "LIon", /* Battery Type (ASCIIZ) */ + 0x00 /* OEM Information (ASCIIZ) */ + }) /* C17C: _BIF control method return package */ + Local0 = (Arg0 & 0x07) /* Local0 = Arg0 & 7 */ + Local4 = (Local0 >> 0x01) /* Local4 = Local0 >> 1 */ + C178 [Local4] = C179 /* C178->Local4 = C179 */ /* \_SB_.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) */ + C179 [0x02] = 0x1234 /* C179[2] = 0x1234 */ + Local2 = DerefOf (C179 [0x02]) /* Local2 = C179[2] */ + If ((Local2 != 0x1234)) + { + Return (0x1234) + } + + /* Local2 = C178[0,2] */ + + Local2 = DerefOf (DerefOf (C178 [0x00]) [0x02]) + If ((Local2 != 0x966B)) + { + Return (0x1234) + } + + /* Restore data to allow iterative execution */ + + C179 [0x02] = 0x966B /* C179[2] = 0x966B */ + /* C178[0,3] = 0x5678 */ + + DerefOf (C178 [0x00]) [0x03] = 0x5678 + /* Local2 = C178[0,3] */ + + Local2 = DerefOf (DerefOf (C178 [0x00]) [0x03]) + If ((Local2 != 0x5678)) + { + Return (0x5678) + } + + Local2 = DerefOf (C179 [0x03]) /* Local2 = C179[3] */ + If ((Local2 != 0x4190)) + { + Return (0x5678) + } + + /* Restore data to allow iterative execution */ + + DerefOf (C178 [0x00]) [0x03] = 0x4190 /* C179[2] = 0x4190 */ + Return (C17C) /* \_SB_.C17B.C17C */ + } /* C17B: _BIF implementation */ + + Device (C154) + { + /* C154: Battery 0 */ + + Name (_HID, "*PNP0C0A") /* Control Method Battey ID */ // _HID: Hardware ID + Name (_UID, 0x00) /* first instance */ // _UID: Unique ID + Method (_BIF, 0, NotSerialized) // _BIF: Battery Information + { + /* _BIF */ + + Return (C17B (0x30)) + } /* _BIF */ + } /* C154: Battery 0 */ + + Device (IDX3) + { + Method (LCLB, 0, Serialized) + { + /* 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 (0x0A) + { + /* 0000 */ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, // ........ + /* 0008 */ 0x08, 0x09 // .. + }) + /* save PKG into Local1 */ + + Local1 = BUFR /* \_SB_.IDX3.LCLB.BUFR */ + /* save Local2 object type value into Local3 */ + + Local3 = ObjectType (Local1) + /* validate Local1 is a Buffer */ + + If ((Local3 != 0x03)) /* Buffer type is 3 */ + { + Return (0x9F) + } + + Local0 = 0x00 + While ((Local0 < 0x05)) + { + /* While (Local0 < 5) */ + /* Local2 = Local1[Local0] */ + Local2 = DerefOf (Local1 [Local0]) + /* save Local2 object type value into Local3 */ + + Local3 = ObjectType (Local2) + /* validate Local2 is a Number */ + + If ((Local3 != 0x01)) /* Number type is 1 */ + { + Return (0x9E) + } + + /* validate Local1[Local0] value == Local0 */ + + If ((Local0 != Local2)) + { + /* Local0 != Local2 == PKG[Local0] */ + /* Local4 = 0x90 + loop index (Local0) */ + Local4 = (0x90 + Local0) + /* return 0x90 + loop index */ + + Return (Local4) + } + + Local0++ + } /* While (Local0 < 5) */ + + Debug = "DerefOf(Index(LocalBuffer,,)) PASS" + Return (0x00) /* Pass */ + } /* LCLB control method: test Index(Local#) where Local# is buffer */ + + Method (LCLP, 0, Serialized) + { + /* 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 (0x0A) + { + 0x00, + 0x01, + 0x02, + 0x03, + 0x04, + 0x05, + 0x06, + 0x07, + 0x08, + 0x09 + }) + /* save PKG into Local1 */ + + Local1 = PKG /* \_SB_.IDX3.LCLP.PKG_ */ + /* save Local2 object type value into Local3 */ + + Local3 = ObjectType (Local1) + /* validate Local1 is a Package */ + + If ((Local3 != 0x04)) /* Package type is 4 */ + { + Return (0x8F) + } + + Local0 = 0x00 + While ((Local0 < 0x05)) + { + /* While (Local0 < 5) */ + /* Local2 = Local1[Local0] */ + Local2 = DerefOf (Local1 [Local0]) + /* save Local2 object type value into Local3 */ + + Local3 = ObjectType (Local2) + /* validate Local2 is a Number */ + + If ((Local3 != 0x01)) /* Number type is 1 */ + { + Return (0x8E) + } + + /* validate Local1[Local0] value == Local0 */ + + If ((Local0 != Local2)) + { + /* Local0 != Local2 == PKG[Local0] */ + /* Local4 = 0x80 + loop index (Local0) */ + Local4 = (0x80 + Local0) + /* return 0x80 + loop index */ + + Return (Local4) + } + + Local0++ + } /* While (Local0 < 5) */ + + Debug = "DerefOf(Index(LocalPackage,,)) PASS" + Return (0x00) /* Pass */ + } /* LCLP control method: test Index(Local#) where Local# is package */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ IndexOp3 Test" + /* store _BIF package return value into Local0 */ + + Local0 = \_SB.C154._BIF () + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Package */ + + If ((Local1 != 0x04)) /* Package type is 4 */ + { + /* failure: did not return a Package (type 4) */ + /* if Local0 is a Number, it contains an error code */ + If ((Local1 == 0x01)) /* Number type is 1 */ + { + Return (Local0) + } /* return Local0 error code */ + Else + { + Return (0x01) + } /* return default error code */ + } /* failure: did not return a Package (type 4) */ + + /* save LCLB control method return value into Local2 */ + + Local2 = LCLB () + If ((Local2 != 0x00)) + { + Return (Local2) + } /* return failure code */ + + /* save LCLP control method return value into Local2 */ + + Local2 = LCLP () + If ((Local2 != 0x00)) + { + Return (Local2) + } /* return failure code */ + + Return (0x00) /* Pass */ + } /* TEST */ + } /* IDX3: Test device name */ + } /* _SB system bus */ + + /* */ + /* MTL developed test to exercise Indexes into buffers */ + /* */ + Device (IDX7) + { + Name (PKG4, Package (0x05) + { + 0x02, + "A short string", + Buffer (0x04) + { + 0x0A, 0x0B, 0x0C, 0x0D // .... + }, + + 0x1234, + Package (0x02) + { + IDX7, + 0x03 + } + }) + /* */ + /* Generic Test method */ + /* */ + /* This test returns 0xE (14) - ObjectType = Buffer Field */ + Method (TST1, 0, Serialized) + { + Name (DEST, Buffer (0x3F) + { + "Destination buffer that is longer than the short source buffer" + }) + /* verify object type returned by Index(Buffer,Element,) */ + + Store (DEST [0x02], Local1) + Local2 = ObjectType (Local1) + If ((Local2 == 0x0E)) + { + Return (0x00) + } + Else + { + Return (0x01) + } + } + + Method (TST2, 0, Serialized) + { + Name (BUF0, Buffer (0x05) + { + 0x01, 0x02, 0x03, 0x04, 0x05 // ..... + }) + BUF0 [0x02] = 0x55 + Local0 = DerefOf (BUF0 [0x02]) + If ((Local0 == 0x55)) + { + Return (0x00) + } + Else + { + Return (0x02) + } + } + + Method (TST3, 0, Serialized) + { + Name (BUF1, Buffer (0x05) + { + 0x01, 0x02, 0x03, 0x04, 0x05 // ..... + }) + Store (BUF1 [0x01], Local0) + Local1 = DerefOf (Local0) + If ((Local1 == 0x02)) + { + Return (0x00) + } + Else + { + Return (0x03) + } + } + + Method (TST4, 0, NotSerialized) + { + /* Index (PKG4, 0) is a Number */ + + Store (PKG4 [0x00], Local0) + Local1 = ObjectType (Local0) + If ((Local1 == 0x01)) + { + Return (0x00) + } + Else + { + Return (0x04) + } + } + + Method (TST5, 0, NotSerialized) + { + /* Index (PKG4, 1) is a String */ + + Store (PKG4 [0x01], Local0) + Local1 = ObjectType (Local0) + If ((Local1 == 0x02)) + { + Return (0x00) + } + Else + { + Return (0x05) + } + } + + Method (TST6, 0, NotSerialized) + { + /* Index (PKG4, 2) is a Buffer */ + + Store (PKG4 [0x02], Local0) + Local1 = ObjectType (Local0) + If ((Local1 == 0x03)) + { + Return (0x00) + } + Else + { + Return (0x06) + } + } + + Method (TST7, 0, NotSerialized) + { + /* Index (PKG4, 3) is a Number */ + + Store (PKG4 [0x03], Local0) + Local1 = ObjectType (Local0) + If ((Local1 == 0x01)) + { + Return (0x00) + } + Else + { + Return (0x07) + } + } + + Method (TST8, 0, NotSerialized) + { + /* Index (PKG4, 4) is a Package */ + + Store (PKG4 [0x04], Local0) + Local1 = ObjectType (Local0) + If ((Local1 == 0x04)) + { + Return (0x00) + } + Else + { + Return (0x08) + } + } + + Method (TST9, 0, NotSerialized) + { + /* DerefOf (Index (PKG4, 0)) is a Number */ + + Local0 = DerefOf (PKG4 [0x00]) + If ((Local0 == 0x02)) + { + Return (0x00) + } + Else + { + Return (0x09) + } + } + + Method (TSTA, 0, NotSerialized) + { + /* DerefOf (Index (PKG4, 1)) is a String */ + + Local0 = DerefOf (PKG4 [0x01]) + Local1 = SizeOf (Local0) + If ((Local1 == 0x0E)) + { + Return (0x00) + } + Else + { + Return (0x0A) + } + } + + Method (TSTB, 0, NotSerialized) + { + /* DerefOf (Index (PKG4, 2)) is a Buffer */ + + Local0 = DerefOf (PKG4 [0x02]) + Local1 = SizeOf (Local0) + If ((Local1 == 0x04)) + { + Return (0x00) + } + Else + { + Return (0x0B) + } + } + + Method (TSTC, 0, NotSerialized) + { + /* DerefOf (Index (PKG4, 3)) is a Number */ + + Local0 = DerefOf (PKG4 [0x03]) + If ((Local0 == 0x1234)) + { + Return (0x00) + } + Else + { + Return (0x0C) + } + } + + Method (TSTD, 0, NotSerialized) + { + /* DerefOf (Index (PKG4, 4)) is a Package */ + + Local0 = DerefOf (PKG4 [0x04]) + Local1 = SizeOf (Local0) + If ((Local1 == 0x02)) + { + Return (0x00) + } + Else + { + Return (0x0D) + } + } + + Method (TSTE, 0, NotSerialized) + { + /* DerefOf (Index (PKG4, 2)) is a Buffer */ + + Local0 = DerefOf (PKG4 [0x02]) + /* DerefOf (Index (Local0, 1)) is a Number */ + + Local1 = DerefOf (Local0 [0x01]) + If ((Local1 == 0x0B)) + { + Return (0x00) + } + Else + { + Return (0x0E) + } + } + + Method (TSTF, 0, Serialized) + { + Name (SRCB, Buffer (0x0C){}) /* 12 characters */ + SRCB = "Short Buffer" + Name (DEST, Buffer (0x3F) + { + "Destination buffer that is longer than the short source buffer" + }) + /* overwrite DEST contents, starting at buffer position 2 */ + + DEST [0x02] = SRCB /* \IDX7.TSTF.SRCB */ + /* */ + /* The DEST buffer element should be replaced with the last element of */ + /* the SRCB element (i.e. 's'->'r') */ + Local0 = DerefOf (DEST [0x02]) + If ((Local0 != 0x72)) /* 'r' */ + { + /* DEST element does not match the value from SRCB */ + + Return ((Local0 | 0x1000)) + } + + Return (0x00) + } + + Method (TSTG, 0, Serialized) + { + Name (SRCB, Buffer (0x0C){}) /* 12 characters */ + SRCB = "Short Buffer" + Name (DEST, Buffer (0x3F) + { + "Destination buffer that is longer than the short source buffer" + }) + /* overwrite DEST contents, starting at buffer position 2 */ + + DEST [0x02] = SRCB /* \IDX7.TSTG.SRCB */ + /* */ + /* The next element of DEST should be unchanged */ + /* */ + Local0 = DerefOf (DEST [0x03]) + If ((Local0 != 0x74)) /* 't' */ + { + /* DEST has been changed */ + + Return ((Local0 | 0x2000)) + } + + /* */ + /* The next element of DEST should be unchanged */ + /* */ + Local0 = DerefOf (DEST [0x04]) + If ((Local0 != 0x69)) /* 'i' */ + { + /* DEST has been changed */ + + Return ((Local0 | 0x2100)) + } + + /* */ + /* The next element of DEST should be unchanged */ + /* */ + Local0 = DerefOf (DEST [0x05]) + If ((Local0 != 0x6E)) /* 'n' */ + { + /* DEST has been changed */ + + Return ((Local0 | 0x2200)) + } + + /* */ + /* The next element of DEST should be unchanged */ + /* */ + Local0 = DerefOf (DEST [0x06]) + If ((Local0 != 0x61)) /* 'a' */ + { + /* DEST has been changed */ + + Return ((Local0 | 0x2300)) + } + + /* */ + /* The next element of DEST should be unchanged */ + /* */ + Local0 = DerefOf (DEST [0x07]) + If ((Local0 != 0x74)) /* 't' */ + { + /* DEST has been changed */ + + Return ((Local0 | 0x2400)) + } + + /* */ + /* Verify DEST elements beyond end of SRCB buffer copy */ + /* have not been changed */ + Local0 = DerefOf (DEST [0x0E]) + If ((Local0 != 0x66)) /* 'f' */ + { + /* DEST has been changed */ + + Return ((Local0 | 0x2400)) + } + + Return (0x00) + } + + /* */ + /* 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, 0, Serialized) + { + /* Create a Destination Buffer */ + + Name (DBUF, Buffer (0x1B) + { + "abcdefghijklmnopqrstuvwxyz" + }) + /* Store a number > UINT8 into an index of the buffer */ + + DBUF [0x02] = 0x12345678 + /* Check the results */ + + Local0 = DerefOf (DBUF [0x02]) + If ((Local0 != 0x78)) /* 0x78 */ + { + Return ((Local0 | 0x3000)) + } + + Local0 = DerefOf (DBUF [0x03]) + If ((Local0 != 0x64)) /* 'd' */ + { + Return ((Local0 | 0x3100)) + } + + Local0 = DerefOf (DBUF [0x04]) + If ((Local0 != 0x65)) /* 'e' */ + { + Return ((Local0 | 0x3200)) + } + + Local0 = DerefOf (DBUF [0x05]) + If ((Local0 != 0x66)) /* 'f' */ + { + Return ((Local0 | 0x3300)) + } + + Return (0x00) + } + + Method (TSTI, 0, Serialized) + { + /* Create a Destination Buffer */ + + Name (DBUF, Buffer (0x1B) + { + "abcdefghijklmnopqrstuvwxyz" + }) + /* Store a String into an index of the buffer */ + + DBUF [0x02] = "ABCDEFGH" + /* Check the results */ + + Local0 = DerefOf (DBUF [0x02]) + If ((Local0 != 0x48)) /* 'H' */ + { + Return ((Local0 | 0x4000)) + } + + Local0 = DerefOf (DBUF [0x03]) + If ((Local0 != 0x64)) /* 'd' */ + { + Return ((Local0 | 0x4100)) + } + + Local0 = DerefOf (DBUF [0x04]) + If ((Local0 != 0x65)) /* 'e' */ + { + Return ((Local0 | 0x4200)) + } + + Local0 = DerefOf (DBUF [0x05]) + If ((Local0 != 0x66)) /* 'f' */ + { + Return ((Local0 | 0x4300)) + } + + Return (0x00) + } + + Method (TSTJ, 0, Serialized) + { + /* Create a Destination Buffer */ + + Name (DBUF, Buffer (0x1B) + { + "abcdefghijklmnopqrstuvwxyz" + }) + /* Store a number > UINT8 into an index of the buffer */ + + DBUF [0x02] = 0x1234 + /* Check the results */ + + Local0 = DerefOf (DBUF [0x02]) + If ((Local0 != 0x34)) /* 0x34 */ + { + Return ((Local0 | 0x3000)) + } + + Local0 = DerefOf (DBUF [0x03]) + If ((Local0 != 0x64)) /* 'd' */ + { + Return ((Local0 | 0x3100)) + } + + Local0 = DerefOf (DBUF [0x04]) + If ((Local0 != 0x65)) /* 'e' */ + { + Return ((Local0 | 0x3200)) + } + + Local0 = DerefOf (DBUF [0x05]) + If ((Local0 != 0x66)) /* 'f' */ + { + Return ((Local0 | 0x3300)) + } + + Return (0x00) + } + + Method (TSTK, 0, Serialized) + { + /* Create a Destination Buffer */ + + Name (DBUF, Buffer (0x1B) + { + "abcdefghijklmnopqrstuvwxyz" + }) + /* Store a number > UINT8 into an index of the buffer */ + + DBUF [0x02] = 0x00123456 + /* Check the results */ + + Local0 = DerefOf (DBUF [0x02]) + If ((Local0 != 0x56)) /* 0x56 */ + { + Return ((Local0 | 0x3000)) + } + + Local0 = DerefOf (DBUF [0x03]) + If ((Local0 != 0x64)) /* 'd' */ + { + Return ((Local0 | 0x3100)) + } + + Local0 = DerefOf (DBUF [0x04]) + If ((Local0 != 0x65)) /* 'e' */ + { + Return ((Local0 | 0x3200)) + } + + Local0 = DerefOf (DBUF [0x05]) + If ((Local0 != 0x66)) /* 'f' */ + { + Return ((Local0 | 0x3300)) + } + + Return (0x00) + } + + Method (TSTL, 0, Serialized) + { + /* Create a Destination Buffer */ + + Name (DBUF, Buffer (0x1B) + { + "abcdefghijklmnopqrstuvwxyz" + }) + /* Store a number > UINT8 into an index of the buffer */ + + DBUF [0x02] = 0x12 + /* Check the results */ + + Local0 = DerefOf (DBUF [0x02]) + If ((Local0 != 0x12)) /* 0x12 */ + { + Return ((Local0 | 0x3000)) + } + + Local0 = DerefOf (DBUF [0x03]) + If ((Local0 != 0x64)) /* 'd' */ + { + Return ((Local0 | 0x3100)) + } + + Local0 = DerefOf (DBUF [0x04]) + If ((Local0 != 0x65)) /* 'e' */ + { + Return ((Local0 | 0x3200)) + } + + Local0 = DerefOf (DBUF [0x05]) + If ((Local0 != 0x66)) /* 'f' */ + { + Return ((Local0 | 0x3300)) + } + + Return (0x00) + } + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ IndexOp7 Test" + Local0 = TST1 () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TST2 () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TST3 () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TST4 () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TST5 () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TST6 () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TST7 () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TST8 () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TST9 () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TSTA () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TSTB () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TSTC () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TSTD () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TSTE () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + /* No longer ACPI compliant */ + /* + Store(TSTF(), Local0) + if (LGreater (Local0, 0)) + { + Return(Local0) + } + */ + Local0 = TSTG () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TSTH () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + /* No longer ACPI compliant */ + /* + Store(TSTI(), Local0) + if (LGreater (Local0, 0)) + { + Return(Local0) + } + */ + Local0 = TSTJ () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TSTK () + If ((Local0 > 0x00)) + { + Return (Local0) + } + + Local0 = TSTL () + If ((Local0 > 0x00)) + { + 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, 0, Serialized) + { + Debug = "++++++++ MatchOp Test" + Name (TIM0, Package (0x08) + { + Package (0x04) + { + 0x78, + 0xB4, + 0xF0, + 0x0384 + }, + + Package (0x04) + { + 0x23, + 0x21, + 0x10, + 0x00 + }, + + Package (0x04) + { + 0x0B, + 0x09, + 0x04, + 0x00 + }, + + Package (0x05) + { + 0x70, + 0x49, + 0x36, + 0x27, + 0x19 + }, + + Package (0x05) + { + 0x00, + 0x01, + 0x02, + 0x01, + 0x02 + }, + + Package (0x05) + { + 0x00, + 0x00, + 0x00, + 0x01, + 0x01 + }, + + Package (0x04) + { + 0x04, + 0x03, + 0x02, + 0x00 + }, + + Package (0x04) + { + 0x02, + 0x01, + 0x00, + 0x00 + } + }) /* TIM0 */ + Name (TMD0, Buffer (0x14) + { + 0xFF, 0xFF, 0xFF, 0xFF // .... + }) + CreateDWordField (TMD0, 0x00, PIO0) /* 0xFFFFFFFF */ + CreateDWordField (TMD0, 0x04, DMA0) + CreateDWordField (TMD0, 0x08, PIO1) + CreateDWordField (TMD0, 0x0C, DMA1) + CreateDWordField (TMD0, 0x10, CHNF) + /* validate PIO0 value */ + + Local3 = PIO0 /* \MTCH.TEST.PIO0 */ + /* save Local3 object type value into Local2 */ + + Local2 = ObjectType (Local3) + /* validate Local3 is a Number */ + + If ((Local2 != 0x01)) /* Number type is 1 */ + { + Return (0x02) + } /* failure */ + + /* validate Local3 Number value */ + + If ((Local3 != 0xFFFFFFFF)) /* Number value 0xFFFFFFFF */ + { + Return (0x03) + } /* failure */ + + Debug = "DWordField PASS" + Local5 = 0x00 + Local6 = Match (DerefOf (TIM0 [0x01]), MLE, Local5, MTR, 0x00, + 0x00) + /* save Local6 object type value into Local2 */ + + Local2 = ObjectType (Local6) + /* validate Local6 is a Number */ + + If ((Local2 != 0x01)) /* Number type is 1 */ + { + Return (0x04) + } /* failure */ + + Debug = "Match(DerefOf(Index(TIM0,1)),... PASS" + /* validate following produces a nested package to validate */ + /* that MatchOp did not corrupt SearchPackage (TIM0) */ + Local4 = DerefOf (TIM0 [0x01]) + /* save Local4 object type value into Local2 */ + + Local2 = ObjectType (Local4) + /* validate Local4 is a Package */ + + If ((Local2 != 0x04)) /* Package type is 4 */ + { + Return (0x05) + } /* failure */ + + Debug = "DerefOf(Index(TIM0,1)),... PASS" + Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO0, MTR, 0x00, + 0x00) & 0x03) + /* save Local0 object type value into Local2 */ + + Local2 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local2 != 0x01)) /* Number type is 1 */ + { + Return (0x06) + } /* failure */ + + /* validate Local0 Number value */ + + If ((Local0 != 0x03)) /* Number value 3 */ + { + Return (0x07) + } /* failure */ + + Debug = "And(Match(DerefOf(Index(TIM0,0)),... PASS" + /* again, validate following produces a nested package */ + + Local4 = DerefOf (TIM0 [0x01]) + /* save Local4 object type value into Local2 */ + + Local2 = ObjectType (Local4) + /* validate Local4 is a Package */ + + If ((Local2 != 0x04)) /* Package type is 4 */ + { + Return (0x08) + } /* failure */ + + Debug = "DerefOf(Index(TIM0,1)),... PASS again" + /* again, validate following produces a nested package */ + + Local4 = DerefOf (TIM0 [0x01]) + /* save Local4 object type value into Local2 */ + + Local2 = ObjectType (Local4) + /* validate Local4 is a Package */ + + If ((Local2 != 0x04)) /* Package type is 4 */ + { + Return (0x09) + } /* failure */ + + Debug = "DerefOf(Index(TIM0,1)),... PASS again" + /* test nested DerefOf(Index) operators */ + + Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0]) + /* save Local1 object type value into Local2 */ + + Local2 = ObjectType (Local1) + /* validate Local1 is a Number */ + + If ((Local2 != 0x01)) /* Number type is 1 */ + { + Return (0x0A) + } /* failure */ + + /* zero indicates pass, non-zero is an error code */ + + If ((Local1 != 0x00)) + { + Return (0x0B) + } /* failure */ + + Debug = "DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS" + /* again, validate following produces a nested package */ + + Local4 = DerefOf (TIM0 [0x01]) + /* save Local4 object type value into Local2 */ + + Local2 = ObjectType (Local4) + /* validate Local4 is a Package */ + + If ((Local2 != 0x04)) /* Package type is 4 */ + { + Return (0x0C) + } /* failure */ + + Debug = "DerefOf(Index(TIM0,1)),... PASS again" + /* retest nested DerefOf(Index) operators */ + + Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0]) + /* save Local1 object type value into Local2 */ + + Local2 = ObjectType (Local1) + /* validate Local1 is a Number */ + + If ((Local2 != 0x01)) /* Number type is 1 */ + { + Return (0x0D) + } /* failure */ + + /* zero indicates pass, non-zero is an error code */ + + If ((Local1 != 0x00)) + { + Return (0x0E) + } /* failure */ + + Debug = "DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again" + /* again, validate following produces a nested package */ + + Local4 = DerefOf (TIM0 [0x01]) + /* save Local4 object type value into Local2 */ + + Local2 = ObjectType (Local4) + /* validate Local4 is a Package */ + + If ((Local2 != 0x04)) /* Package type is 4 */ + { + Return (0x0F) + } /* failure */ + + Debug = "DerefOf(Index(TIM0,1)),... PASS again" + Return (0x00) /* 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, 0x00) + Name (CNT1, 0x00) + Method (TEST, 0, NotSerialized) + { + /* Check Break statement nested in If nested in While nested in */ + /* While only exits inner-most While loop */ + CNT0 = 0x00 + While ((CNT0 < 0x04)) + { + CNT1 = 0x00 + While ((CNT1 < 0x0A)) + { + If ((CNT1 == 0x01)) + { + Break /* exit encompassing loop */ + } + + CNT1++ + } + + If ((CNT1 != 0x01)) + { + /* failure */ + + Return (0x07) + } + + CNT0++ + } + + /* Verify Break only exited inner-most While loop */ + + If ((CNT0 != 0x04)) + { + /* failure */ + + Return (0x08) + } + + Debug = "While/While/If/Break PASS" + Debug = "++++++++ WhileBrk Test" + /* Check Break statement nested in While */ + + CNT0 = 0x00 + While ((CNT0 < 0x0A)) + { + Break + CNT0++ + } + + If ((CNT0 != 0x00)) /* instruction after Break executed */ + { + Return (0x04) + } + + CNT0 = 0x00 + /* Test While Term */ + + While ((CNT0 < 0x0A)) + { + CNT0++ + } + + /* Check if the while loop was executed until the condition is satisfied. */ + + If ((CNT0 != 0x0A)) + { + Return (0x01) + } + + /* While loop in a reverse order */ + + While ((CNT0 > 0x00)) + { + CNT0-- + } + + /* Check if the while loop was executed until the condition is satisfied. */ + + If ((CNT0 != 0x00)) + { + Return (0x02) + } + + Debug = "While/Break PASS" + /* Check Break statement nested in If nested in While */ + + CNT0 = 0x00 + While ((CNT0 < 0x0A)) + { + If ((CNT0 == 0x05)) + { + Break + /* if we execute the next instruction, */ + /* Break did not exit the loop */ + CNT0 = 0x14 /* exit While loop with value larger */ + /* than above */ + } + + CNT0++ /* check if Break exited both If and While */ + } /* While */ + + If ((CNT0 > 0x13)) + { + /* instruction after Break inside IfOp executed */ + + Return (0x05) + } + + /* */ + /* Break will exit out of the while loop, therefore */ + /* the CNT0 counter should still Increment until 5 */ + /* */ + If ((CNT0 != 0x05)) + { + /* instruction after Break inside WhileOp executed */ + + Return (0x06) + } + + Debug = "While/If/Break PASS" + /* All the conditions passed */ + + Return (0x00) + } /* 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, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID + Name (_STA, 0x0F) // _STA: Status + OperationRegion (SMEM, SystemMemory, 0x00800000, 0x0100) + Field (SMEM, AnyAcc, NoLock, Preserve) + { + /* Field: SMEM overlay using 32-bit field elements */ + + SMD0, /* 32-bits */ 32, + SMD1, /* 32-bits */ 32, + SMD2, /* 32-bits */ 32, + SMD3, /* 32-bits */ 32 + } /* Field: SMEM overlay using 32-bit field elements */ + + Field (SMEM, AnyAcc, NoLock, Preserve) + { + /* Field: SMEM overlay using greater than 32-bit field elements */ + + SME0, /* larger than an integer (32 or 64) */ 69, + SME1, /* larger than an integer */ 97 + } /* Field: SMEM overlay using greater than 32-bit field elements */ + + OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000) + Field (SRAM, AnyAcc, NoLock, Preserve) + { + Offset (0x6800), + /* Field: SRAM overlay */ + + IEAX, 32, + IEBX, 32, + IECX, 32, + IEDX, 32, + IESI, 32, + IEDI, 32, + IEBP, 32, + Offset (0x6820), + OEAX, 32, + OEBX, 32, + OECX, 32, + OEDX, 32, + OESI, 32, + OEDI, 32, + OEBP, 32, + Offset (0x68FF), + ACST, 1, + BES1, 1, + BES2, 1, + Offset (0x6900), + BMN1, 104, + BSN1, 88, + BTP1, 72, + BPU1, 32, + BDC1, 32, + BLF1, 32, + BTC1, 32, + BDV1, 32, + BST1, 32, + BPR1, 32, + BRC1, 32, + BPV1, 32, + Offset (0x6949), + BCW1, 32, + BCL1, 32, + BG11, 32, + BG21, 32, + BOI1, 32, + Offset (0x6A03), + BMN2, 104, + BSN2, 88, + BTP2, 72, + BPU2, 32, + BDC2, 32, + BLF2, 32, + BTC2, 32, + BDV2, 32, + BST2, 32, + BPR2, 32, + BRC2, 32, + BPV2, 32, + Offset (0x6A4C), + BCW2, 32, + BCL2, 32, + BG12, 32, + BG22, 32, + BOI2, 32, + Offset (0x6B03), + AC01, 16, + AC11, 16, + PSV1, 16, + CRT1, 16, + TMP1, 16, + AST1, 16, + AC21, 16, + AC31, 16, + AC02, 16, + AC12, 16, + PSV2, 16, + CRT2, 16, + TMP2, 16, + AST2, 16, + AC22, 16, + AC32, 16, + AC03, 16, + AC13, 16, + PSV3, 16, + CRT3, 16, + TMP3, 16, + AST3, 16, + AC23, 16, + AC33, 16, + Offset (0x6B43), + TMPF, 16, + Offset (0x6BF3), + FANH, 1, + FANL, 7, + TF11, 1, + TF21, 1, + TF31, 1, + , 1, + TF10, 1, + TF20, 1, + TF30, 1, + Offset (0x6BF5), + TP11, 1, + TP21, 1, + TP31, 1, + Offset (0x6C03), + GP50, 1, + GP51, 1, + GP52, 1, + GP53, 1, + Offset (0x6C04), + GP60, 1, + GP61, 1, + GP62, 1, + GP63, 1, + GP64, 1, + GP65, 1, + GP66, 1, + Offset (0x6C05), + GP70, 1, + GP71, 1, + GP72, 1, + GP73, 1, + GP74, 1, + GP75, 1, + GP76, 1, + Offset (0x6C06), + WED0, 1, + WED1, 1, + WED2, 1, + WED3, 1, + WED4, 1, + Offset (0x6C07), + SBL0, 1, + SBL1, 1, + SBL2, 1, + SBL3, 1, + Offset (0x6C08), + LIDS, 1, + VALF, 1, + , 2, + DCKI, 1, + DCKF, 1, + BT1F, 1, + BT2F, 1, + Offset (0x6D03), + HKCD, 8, + Offset (0x6D05), + DLID, 32, + DSRN, 32, + Offset (0x6D11), + BDID, 32, + DSPW, 1, + VGAF, 1, + VWE0, 1, + VWE1, 1, + PPSC, 1, + SPSC, 1, + EWLD, 1, + EWPS, 1, + Offset (0x7003), + PRES, 32768 + } /* Field: SRAM overlay */ + } /* MEM */ + + Device (BAT1) + { + /* BAT1 */ + + Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) /* Control Method Battey ID */ // _HID: Hardware ID + Name (_UID, 0x01) // _UID: Unique ID + Name (_PCL, Package (0x01) // _PCL: Power Consumer List + { + \_SB + }) + Method (_STA, 0, NotSerialized) // _STA: Status + { + /* _STA */ + + If (\_SB.MEM.BES1) + { + Return (0x1F) + } /* battery present */ + Else + { + Return (0x0F) + } /* battery not present */ + } /* _STA */ + + Method (_BIF, 0, Serialized) // _BIF: Battery Information + { + /* _BIF */ + + Name (BUFR, Package (0x0D){}) + BUFR [0x00] = \_SB.MEM.BPU1 + BUFR [0x01] = \_SB.MEM.BDC1 + BUFR [0x02] = \_SB.MEM.BLF1 + BUFR [0x03] = \_SB.MEM.BTC1 + BUFR [0x04] = \_SB.MEM.BDV1 + BUFR [0x05] = \_SB.MEM.BCW1 + BUFR [0x06] = \_SB.MEM.BCL1 + BUFR [0x07] = \_SB.MEM.BG11 + BUFR [0x08] = \_SB.MEM.BG21 + BUFR [0x09] = \_SB.MEM.BMN1 + BUFR [0x0A] = \_SB.MEM.BSN1 + BUFR [0x0B] = \_SB.MEM.BTP1 + BUFR [0x0C] = \_SB.MEM.BOI1 + Return (BUFR) /* \_SB_.BAT1._BIF.BUFR */ + } /* _BIF */ + } /* BAT1 */ + + Device (IDX2) + { + Method (B2IB, 0, Serialized) + { + /* B2IB: store from Buffer into Index'ed Buffer */ + + Name (SRCB, Buffer (0x0D) + { + "Short Buffer" + }) /* 12 characters plus NULL */ + Name (DEST, Buffer (0x3F) + { + "Destination buffer that is longer than the short source buffer" + }) + /* verify object type returned by Index(Buffer,Element,) */ + + Store (DEST [0x02], Local1) + Local2 = ObjectType (Local1) + If ((Local2 != 0x0E)) /* 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 */ + Local3 = DerefOf (Local1) + Local4 = ObjectType (Local3) + If ((Local4 != 0x01)) /* Number is type 1 */ + { + /* Local2 indicates Local1 is not a Number */ + + Return (0x62) + } + ElseIf ((Local3 != 0x73)) /* expect 's' element from DEST */ + { + Return (0x63) + } + + Debug = "DerefOf(Index(Buffer,,)) PASS" + /* */ + /* 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] */ + DEST [0x02] = SRCB /* \_SB_.IDX2.B2IB.SRCB */ + /* */ + /* Check that the next byte is not changed */ + /* */ + Local0 = DerefOf (DEST [0x03]) + If ((Local0 != 0x74)) /* 't' */ + { + /* DEST element is not matching original value */ + + If ((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. */ + /* */ + Local0 = DerefOf (DEST [0x0E]) + /* */ + /* This should be an 'f'. */ + /* */ + If ((Local0 != 0x66)) + { + /* DEST element was zero'd by buffer copy */ + + If ((Local0 == 0x00)) + { + /* DEST element is zero */ + + Return (0x6A) + } + Else + { + /* DEST element is unknown value */ + + Return (0x6B) + } + } + + Debug = "Store(SRCB,Index(Buffer,,)) PASS" + /* */ + /* verify altering SRCB does NOT alter DEST */ + /* */ + SRCB [0x01] = 0x6A /* SRCB = "Sjort Buffer" */ + Local0 = DerefOf (SRCB [0x01]) + If ((Local0 != 0x6A)) /* 'j' */ + { + /* SRCB element is unaltered */ + + Return (0x71) + } + + Local0 = DerefOf (DEST [0x03]) /* DEST = "Destination buffer that... */ + If ((Local0 != 0x74)) /* 't' */ + { + /* DEST element is altered */ + + If ((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 */ + + DEST [0x04] = 0x6B /* DEST = "DeSkination buffer..." */ + Local0 = DerefOf (DEST [0x04]) + If ((Local0 != 0x6B)) /* 'k' */ + { + /* DEST element is unaltered */ + + Return (0x74) + } + + Local0 = DerefOf (SRCB [0x02]) + If ((Local0 != 0x6F)) /* 'o' */ + { + /* SRC element is altered */ + + If ((Local0 == 0x6B)) /* 'k' */ + { + /* DEST change altered SRCB element */ + + Return (0x75) + } + Else + { + /* SRCB element is unknown value */ + + Return (0x76) + } + } + + Debug = "SRCB and DEST independent PASS" + /* verify string can be written to Index target/destination */ + /* Only FIRST byte is written */ + DEST [0x02] = "New Buff" /* DEST = "DeNkination buffer..." */ + Local0 = DerefOf (DEST [0x02]) + If ((Local0 != 0x4E)) /* 'N' */ + { + /* DEST element is unaltered */ + + Return (0x81) + } + + Local0 = DerefOf (DEST [0x06]) + If ((Local0 != 0x61)) /* 'a' */ + { + /* DEST element is unaltered */ + + Return (0x82) + } + + Local0 = DerefOf (DEST [0x0A]) + If ((Local0 != 0x6E)) /* 'n' */ + { + /* DEST element is unaltered */ + + Return (0x83) + } + + Debug = "Store(String,Index) PASS" + Return (0x00) /* pass */ + } /* B2IB: store from Buffer into Index'ed Buffer */ + + Method (FB2P, 0, Serialized) + { + /* FB2P: store from Field Buffer into Index'ed Package */ + + Name (DEST, Package (0x02){}) + /* initialize memory using 32-bit field elements */ + + \_SB.MEM.SMD0 = 0x01234567 + \_SB.MEM.SMD1 = 0x89ABCDEF + \_SB.MEM.SMD2 = 0xFEDCBA98 + \_SB.MEM.SMD3 = 0x76543210 + /* move greater than 64-bit buffers into DEST package */ + + DEST [0x00] = \_SB.MEM.SME0 + DEST [0x01] = \_SB.MEM.SME1 + /* validate DEST contents */ + + Local0 = DerefOf (DEST [0x00]) + Local1 = DerefOf (DEST [0x01]) + /* verify Local0 and Local1 are Buffers */ + + Local2 = ObjectType (Local0) + If ((Local2 != 0x03)) /* Buffer type is 3 */ + { + Return (0x11) + } + + Local3 = ObjectType (Local1) + If ((Local3 != 0x03)) /* Buffer type is 3 */ + { + Return (0x12) + } + + /* validate DEST buffer contents */ + + Local4 = DerefOf (DerefOf (DEST [0x00]) [0x00]) + If ((Local4 != 0x67)) + { + Return (0x13) + } + + Local4 = DerefOf (DerefOf (DEST [0x00]) [0x01]) + If ((Local4 != 0x45)) + { + Return (0x14) + } + + Local4 = DerefOf (DerefOf (DEST [0x00]) [0x04]) + If ((Local4 != 0xEF)) + { + Return (0x15) + } + + Local4 = DerefOf (DerefOf (DEST [0x00]) [0x05]) + If ((Local4 != 0xCD)) + { + Return (0x16) + } + + Debug = "Store(Mem,PkgElement) PASS" + /* validate changing source \_SB.MEM.SMD* does not impact DEST */ + + \_SB.MEM.SMD0 = 0x12345678 + Local5 = DerefOf (DerefOf (DEST [0x00]) [0x00]) + If ((Local5 != 0x67)) + { + Return (0x21) + } + + Local5 = DerefOf (DerefOf (DEST [0x00]) [0x01]) + If ((Local5 != 0x45)) + { + Return (0x22) + } + + /* validate changing DEST does not impact source \_SB.MEM.SMD* */ + + DerefOf (DEST [0x00]) [0x00] = 0x30 + Local5 = DerefOf (DerefOf (DEST [0x00]) [0x00]) + If ((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 */ + /* */ + Local5 = \_SB.MEM.SMD0 + If ((Local5 != 0x12345678)) + { + Return (0x24) + } + + Debug = "Mem and Pkg independent PASS" + Return (0x00) + } /* FB2P: store from Field Buffer into Index'ed Package */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ IndexOp2 Test" + /* store _BIF package return value into Local0 */ + + Local0 = \_SB.BAT1._BIF () + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Package */ + + If ((Local1 != 0x04)) /* Package type is 4 */ + { + /* failure */ + + Return (0x02) + } + + /* 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) */ + Local2 = B2IB () /* Local2 is B2IB return value */ + /* save Local2 object type value into Local3 */ + + Local3 = ObjectType (Local2) + /* validate Local2 is a Number */ + + If ((Local3 != 0x01)) /* Number type is 1 */ + { + /* failure */ + + Return (0x04) + } + + /* zero indicates pass, non-zero is an error code */ + + If ((Local2 != 0x00)) + { + /* return B2IB error code */ + + Return (Local2) + } + + /* call FB2P (store from Field Buffer into Index'ed Package) */ + + Local2 = FB2P () /* Local2 is FB2P return value */ + /* save Local2 object type value into Local3 */ + + Local3 = ObjectType (Local2) + /* validate Local2 is a Number */ + + If ((Local3 != 0x01)) /* Number type is 1 */ + { + /* failure */ + + Return (0x05) + } + + /* zero indicates pass, non-zero is an error code */ + + If ((Local2 != 0x00)) + { + /* return FB2P error code */ + + Return (Local2) + } + + Return (0x00) + } /* 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, NotSerialized) + { + /* SAR0: SizeOf(Arg) test control method */ + /* Local0 Arg0 length */ + /* Local1 Local0 object type */ + /* Store first string size (Arg0) into Local7 */ + Local0 = SizeOf (Arg0) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x21) + } + + /* If strings are not of equal size, return error code */ + + If ((Local0 != Arg1)) + { + Return (0x22) + } + + Return (0x00) + } /* SAR0: SizeOf(Arg) test control method */ + + Method (SARG, 0, Serialized) + { + /* SARG: SizeOf(Arg) test control method */ + + Name (BUFR, Buffer (0x0C){}) /* uninitialized Buffer */ + Name (BUF1, Buffer (0x05) + { + 0x01, 0x02, 0x03, 0x04, 0x05 // ..... + }) + Name (PKG0, Package (0x04){}) /* uninitialized Package */ + Name (STR0, "String") + Name (PKG1, Package (0x04) + { + BUFR, + "String2", + STR0, + PKG0 + }) /* PKG1 */ + Name (PKG2, Package (0x04) + { + Buffer (0x0F){}, + "String 1", + Package (0x02){} + }) /* PKG2 */ + /* Namespace entry buffer reference */ + + Local0 = SAR0 (BUFR, 0x0C) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x23) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=BUFR) PASS" + /* Namespace entry package reference */ + + Local0 = SAR0 (PKG0, 0x04) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x24) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=PKG0) PASS" + /* Namespace entry string reference */ + + Local0 = SAR0 (STR0, 0x06) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x25) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=STR0) PASS" + /* direct string reference */ + + Local0 = SAR0 ("String", 0x06) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x26) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=String) PASS" + BUF1 [0x02] = 0x55 + /**************************************************** + // + // 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 */ + /* */ + Local0 = SAR0 (PKG1 [0x00], 0x0C) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x28) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=PackageBuffer NTE Reference Element) PASS" + /* Namespace StringPackageElement reference */ + + Local0 = SAR0 (PKG1 [0x01], 0x07) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x29) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=Package String Element) PASS" + /* Namespace StringPackageElement reference */ + + Local0 = SAR0 (PKG1 [0x02], 0x06) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x2A) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=Package String NTE Reference Element) PASS" + /* Namespace PackagePackageElement reference */ + + Local0 = SAR0 (PKG1 [0x03], 0x04) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x2B) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=Package Package NTE Reference Element) PASS" + /* Package Buffer Element */ + + Local0 = SAR0 (PKG2 [0x00], 0x0F) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x2B) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=Package Buffer Element) PASS" + /* Package String Element */ + + Local0 = SAR0 (PKG2 [0x01], 0x08) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x2B) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=Package String Element) PASS" + /* Package Package Element */ + + Local0 = SAR0 (PKG2 [0x02], 0x02) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x2B) + } + + If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */ + { + Return (Local0) + } + + Debug = "SizeOf(Arg=Package Package Element) PASS" + Debug = "SizeOf(Arg) PASS" + Return (0x00) + } /* SARG: SizeOf(Arg) test control method */ + + Method (SBUF, 0, Serialized) + { + /* SBUF: SizeOf(Buffer) test control method */ + + Name (BUFR, Buffer (0x0C){}) + /* store size of BUFR buffer into Local0 */ + + Local0 = SizeOf (BUFR) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x31) + } + + If ((Local0 != 0x0C)) /* BUFR size is 12 */ + { + Return (0x32) + } + + Debug = "SizeOf(BUFR) PASS" + Return (0x00) + } /* 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, 0, Serialized) + { + /* SLOC: SizeOf(Local) test control method */ + + Name (BUFR, Buffer (0x0C){}) /* uninitialized Buffer */ + Name (STR0, "String") + Name (PKG0, Package (0x04){}) /* uninitialized Package */ + /* store BUFR Buffer into Local2 */ + + Local2 = BUFR /* \SIZO.SLOC.BUFR */ + /* store size of BUFR buffer into Local0 */ + + Local0 = SizeOf (Local2) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x51) + } + + If ((Local0 != 0x0C)) /* BUFR size is 12 */ + { + Return (0x52) + } + + Debug = "SizeOf(Local2=Buffer) PASS" + /* store STR0 string into Local2 */ + + Local2 = STR0 /* \SIZO.SLOC.STR0 */ + /* store size of STR0 buffer into Local0 */ + + Local0 = SizeOf (Local2) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x53) + } + + If ((Local0 != 0x06)) /* STR0 size is 6 */ + { + Return (0x54) + } + + Debug = "SizeOf(Local2=String) PASS" + /* store PKG0 Package into Local2 */ + + Local2 = PKG0 /* \SIZO.SLOC.PKG0 */ + /* store size of PKG0 buffer into Local0 */ + + Local0 = SizeOf (Local2) + /* save Local0 object type value into Local1 */ + + Local1 = ObjectType (Local0) + /* validate Local0 is a Number */ + + If ((Local1 != 0x01)) /* Number type is 1 */ + { + Return (0x55) + } + + If ((Local0 != 0x04)) /* PKG0 size is 4 */ + { + Return (0x56) + } + + Debug = "SizeOf(Local2=Package) PASS" + Return (0x00) + } /* SLOC: SizeOf(Local) test control method */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ SizeOf Test" + /* Store current operating system string into Local0 */ + + Local0 = _OS /* \_OS_ */ + Local3 = SizeOf (_OS) + /* save Local3 object type value into Local4 */ + + Local4 = ObjectType (Local3) + /* validate Local3 is a Number */ + + If ((Local4 != 0x01)) /* Number type is 1 */ + { + /* failure */ + + Return (0x61) + } + + /* Store current operating system string into Local0 */ + /* This verifies above SizeOf(_OS) did not corrupt ACPI namespace */ + Local0 = _OS /* \_OS_ */ + /* Store SARG [Validate SizeOf(Arg)] return value into Local1 */ + + Local1 = SARG () + /* save Local1 object type value into Local2 */ + + Local2 = ObjectType (Local1) + /* validate Local1 is a Number */ + + If ((Local2 != 0x01)) /* Number type is 1 */ + { + /* failure */ + + Return (0x62) + } + + /* zero indicates pass, non-zero is an error code */ + + If ((Local1 != 0x00)) + { + /* return SARG error code */ + + Return (Local1) + } + + /* Store SBUF [Validate SizeOf(Buffer)] return value into Local1 */ + + Local1 = SBUF () + /* save Local1 object type value into Local2 */ + + Local2 = ObjectType (Local1) + /* validate Local1 is a Number */ + + If ((Local2 != 0x01)) /* Number type is 1 */ + { + /* failure */ + + Return (0x63) + } + + /* zero indicates pass, non-zero is an error code */ + + If ((Local1 != 0x00)) + { + /* 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 */ + Local1 = SLOC () + /* save Local1 object type value into Local2 */ + + Local2 = ObjectType (Local1) + /* validate Local1 is a Number */ + + If ((Local2 != 0x01)) /* Number type is 1 */ + { + /* failure */ + + Return (0x65) + } + + /* zero indicates pass, non-zero is an error code */ + + If ((Local1 != 0x00)) + { + /* return SLOC error code */ + + Return (Local1) + } + + /* TBD: SizeOf (METH) -- where METH control method returns */ + /* buffer, BufferField, string, package, package element */ + Return (0x00) + } /* 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, 0x00400000, 0x0A) + Field (RAM1, AnyAcc, NoLock, Preserve) + { + BI1T, /* Create some bits in memory to access */ 1, + 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, 0, NotSerialized) // _INI: Initialize + { + BI1T = 0x00 + BI2T = 0x03 + BI3T = 0x07 + LST2 = 0x00 + } /* End _INI Method */ + } /* End Device MBIT */ + + Device (MWRD) + { + Method (_INI, 0, NotSerialized) // _INI: Initialize + { + WRD = 0x00 + } /* End _INI Method */ + } /* End Device MWRD */ + + Device (MBYT) + { + Method (_INI, 0, NotSerialized) // _INI: Initialize + { + BYTE = 0x00 + SMIC = 0x0C + SMID = 0x0D + } /* 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, 0, NotSerialized) + { + Return (BYTE) /* \_SB_.BYTE */ + } /* End SMIX */ + + Method (EVNT, 0, NotSerialized) + { + Local0 = SMIX () + Notify (\_SB, 0x29) // Reserved + If ((Local0 & 0x01)) + { + Notify (\_SB.SMIS, 0x21) // Reserved + } + + If ((Local0 & 0x02)) + { + Notify (\_SB.SMIS, 0x22) // Reserved + } + + If ((Local0 & 0x04)) + { + Notify (\_SB.SMIS, 0x24) // Reserved + } + + If ((Local0 & 0x08)) + { + Notify (\_SB.SMIS, 0x28) // Reserved + } + } /* End Method EVNT */ + + Method (NTFY, 0, NotSerialized) + { + Notify (\_SB, 0x01) // Device Check + Notify (\_TZ.TZ1, 0x02) // Device Wake + Notify (\_PR.CPU0, 0x03) // Eject Request + Notify (\_SB, 0x81) // Information Change + Notify (\_TZ.TZ1, 0x82) // Thermal Device List Change + Notify (\_PR.CPU0, 0x83) // Guaranteed Change + } + + Device (SMIS) + { + Method (BINK, 0, NotSerialized) + { + Local0 = 0x00 /* Zero out Local0 */ + If ((SMID != 0x0D)) + { + Local0 |= 0x80 + } + + If ((SMIC != 0x0C)) + { + Local0 |= 0x40 + } + + If ((BYTE != 0x00)) + { + Local0 |= 0x20 + } + + If ((WRD != 0x00)) + { + Local0 |= 0x10 + } + + If ((LST2 != 0x00)) + { + Local0 |= 0x08 + } + + If ((BI3T != 0x07)) + { + Local0 |= 0x04 + } + + If ((BI2T != 0x03)) + { + Local0 |= 0x02 + } + + If ((BI1T != 0x00)) + { + Local0 |= 0x01 + } + + Return (Local0) + } /* End Method BINK */ + + Method (TEST, 0, NotSerialized) + { + Debug = "++++++++ SmiShare Test" + /* Expect EVNT to generate Notify value we just previously */ + /* stored in BYTE */ + BYTE = 0x20 + EVNT () + BYTE = 0x21 + EVNT () + BYTE = 0x22 + EVNT () + BYTE = 0x23 + EVNT () + NTFY () + Return (0x00) /* pass */ + } /* End Method TEST */ + } /* Device SMIS */ + + Device (CNDT) + { + Method (TEST, 0, NotSerialized) + { + If (ECOK ()) + { + Return ("Broken") + } + Else + { + Return ("Works") + } + } + + Method (ECOK, 0, NotSerialized) + { + Return (0x00) + } + } + } /* _SB system bus */ + + /* Test a very big buffer */ + + Name (WQAB, Buffer (0x1A64) + { + /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, // FOMB.... + /* 0008 */ 0x54, 0x1A, 0x00, 0x00, 0xBA, 0xAD, 0x00, 0x00, // T....... + /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, // DS...}.T + /* 0018 */ 0x98, 0xBD, 0x92, 0x00, 0x01, 0x06, 0x18, 0x42, // .......B + /* 0020 */ 0x10, 0x47, 0x10, 0x92, 0x46, 0x62, 0x02, 0x89, // .G..Fb.. + /* 0028 */ 0x80, 0x90, 0x18, 0x18, 0x14, 0x81, 0x85, 0x00, // ........ + /* 0030 */ 0x49, 0x02, 0x88, 0xC4, 0x41, 0xE1, 0x20, 0xD4, // I...A. . + /* 0038 */ 0x9F, 0x40, 0x7E, 0x05, 0x20, 0x74, 0x28, 0x40, // .@~. t(@ + /* 0040 */ 0xA6, 0x00, 0x83, 0x02, 0x9C, 0x22, 0x88, 0xA0, // .....".. + /* 0048 */ 0x57, 0x01, 0x36, 0x05, 0x98, 0x14, 0x60, 0x51, // W.6...`Q + /* 0050 */ 0x80, 0x76, 0x01, 0x96, 0x05, 0xE8, 0x16, 0x20, // .v..... + /* 0058 */ 0x1D, 0x96, 0x88, 0x04, 0x47, 0x89, 0x01, 0x47, // ....G..G + /* 0060 */ 0xE9, 0xC4, 0x16, 0x6E, 0xD8, 0xE0, 0x85, 0xA2, // ...n.... + /* 0068 */ 0x68, 0x06, 0x51, 0x12, 0x94, 0x8B, 0x20, 0x5D, // h.Q... ] + /* 0070 */ 0x10, 0x52, 0x2E, 0xC0, 0x37, 0x82, 0x06, 0x10, // .R..7... + /* 0078 */ 0xA5, 0x77, 0x01, 0xB6, 0x05, 0x98, 0x86, 0x27, // .w.....' + /* 0080 */ 0xD2, 0x20, 0xE4, 0x60, 0x08, 0x54, 0xCE, 0x80, // . .`.T.. + /* 0088 */ 0x20, 0x69, 0x44, 0x21, 0x1E, 0xA7, 0x44, 0x08, // iD!..D. + /* 0090 */ 0x0A, 0x84, 0x90, 0xD4, 0xF1, 0xA0, 0xA0, 0x71, // .......q + /* 0098 */ 0x88, 0xAD, 0xCE, 0x46, 0x93, 0xA9, 0x74, 0x7E, // ...F..t~ + /* 00A0 */ 0x48, 0x82, 0x70, 0xC6, 0x2A, 0x7E, 0x3A, 0x9A, // H.p.*~:. + /* 00A8 */ 0xD0, 0xD9, 0x9C, 0x60, 0xE7, 0x18, 0x72, 0x3C, // ...`..r< + /* 00B0 */ 0x48, 0xF4, 0x20, 0xB8, 0x00, 0x0F, 0x1C, 0x2C, // H. ...., + /* 00B8 */ 0x34, 0x84, 0x22, 0x6B, 0x80, 0xC1, 0x8C, 0xDD, // 4."k.... + /* 00C0 */ 0x63, 0xB1, 0x0B, 0x4E, 0x0A, 0xEC, 0x61, 0xB3, // c..N..a. + /* 00C8 */ 0x01, 0x19, 0xA2, 0x24, 0x38, 0xD4, 0x11, 0xC0, // ...$8... + /* 00D0 */ 0x12, 0x05, 0x98, 0x1F, 0x87, 0x0C, 0x0F, 0x95, // ........ + /* 00D8 */ 0x8C, 0x25, 0x24, 0x1B, 0xAB, 0x87, 0xC2, 0xA5, // .%$..... + /* 00E0 */ 0x40, 0x68, 0x6C, 0x27, 0xED, 0x19, 0x45, 0x2C, // @hl'..E, + /* 00E8 */ 0x79, 0x4A, 0x82, 0x49, 0xE0, 0x51, 0x44, 0x36, // yJ.I.QD6 + /* 00F0 */ 0x1A, 0x27, 0x28, 0x1B, 0x1A, 0x25, 0x03, 0x42, // .'(..%.B + /* 00F8 */ 0x9E, 0x05, 0x58, 0x07, 0x26, 0x04, 0x76, 0x2F, // ..X.&.v/ + /* 0100 */ 0xC0, 0x9A, 0x00, 0x73, 0xB3, 0x90, 0xB1, 0xB9, // ...s.... + /* 0108 */ 0xE8, 0xFF, 0x0F, 0x71, 0xB0, 0x31, 0xDA, 0x9A, // ...q.1.. + /* 0110 */ 0xAE, 0x90, 0xC2, 0xC4, 0x88, 0x12, 0x2C, 0x5E, // ......,^ + /* 0118 */ 0xC5, 0xC3, 0x10, 0xCA, 0x93, 0x42, 0xA8, 0x48, // .....B.H + /* 0120 */ 0x95, 0xA1, 0x68, 0xB4, 0x51, 0x2A, 0x14, 0xE0, // ..h.Q*.. + /* 0128 */ 0x4C, 0x80, 0x30, 0x5C, 0x1D, 0x03, 0x82, 0x46, // L.0\...F + /* 0130 */ 0x88, 0x15, 0x29, 0x56, 0xFB, 0x83, 0x20, 0xF1, // ..)V.. . + /* 0138 */ 0x2D, 0x40, 0x54, 0x01, 0xA2, 0x48, 0xA3, 0x41, // -@T..H.A + /* 0140 */ 0x9D, 0x03, 0x3C, 0x5C, 0x0F, 0xF5, 0xF0, 0x3D, // ..<\...= + /* 0148 */ 0xF6, 0x93, 0x0C, 0x72, 0x90, 0x67, 0xF1, 0xA8, // ...r.g.. + /* 0150 */ 0x70, 0x9C, 0x06, 0x49, 0xE0, 0x0B, 0x80, 0x4F, // p..I...O + /* 0158 */ 0x08, 0x1E, 0x38, 0xDE, 0x35, 0xA0, 0x66, 0x7C, // ..8.5.f| + /* 0160 */ 0xBC, 0x4C, 0x10, 0x1C, 0x6A, 0x88, 0x1E, 0x68, // .L..j..h + /* 0168 */ 0xB8, 0x13, 0x38, 0x44, 0x06, 0xE8, 0x49, 0x3D, // ..8D..I= + /* 0170 */ 0x52, 0x60, 0x07, 0x77, 0x32, 0xEF, 0x01, 0xAF, // R`.w2... + /* 0178 */ 0x0A, 0xCD, 0x5E, 0x12, 0x08, 0xC1, 0xF1, 0xF8, // ..^..... + /* 0180 */ 0x7E, 0xC0, 0x26, 0x9C, 0xC0, 0xF2, 0x07, 0x81, // ~.&..... + /* 0188 */ 0x1A, 0x99, 0xA1, 0x3D, 0xCA, 0xD3, 0x8A, 0x19, // ...=.... + /* 0190 */ 0xF2, 0x31, 0xC1, 0x04, 0x16, 0x0B, 0x21, 0x05, // .1....!. + /* 0198 */ 0x10, 0x1A, 0x0F, 0xF8, 0x6F, 0x00, 0x8F, 0x17, // ....o... + /* 01A0 */ 0xBE, 0x12, 0xC4, 0xF6, 0x80, 0x12, 0x0C, 0x0B, // ........ + /* 01A8 */ 0x21, 0x23, 0xAB, 0xF0, 0x78, 0xE8, 0x28, 0x7C, // !#..x.(| + /* 01B0 */ 0x95, 0x38, 0x9C, 0xD3, 0x8A, 0x67, 0x82, 0xE1, // .8...g.. + /* 01B8 */ 0x20, 0xF4, 0x05, 0x90, 0x00, 0x51, 0xE7, 0x0C, // ....Q.. + /* 01C0 */ 0xD4, 0x61, 0xC1, 0xE7, 0x04, 0x76, 0x33, 0x38, // .a...v38 + /* 01C8 */ 0x83, 0x47, 0x00, 0x8F, 0xE4, 0x84, 0xFC, 0x2B, // .G.....+ + /* 01D0 */ 0xF1, 0xC0, 0xE0, 0x03, 0xE2, 0xEF, 0x1F, 0xA7, // ........ + /* 01D8 */ 0xEC, 0x11, 0x9C, 0xA9, 0x01, 0x7D, 0x1C, 0xF0, // .....}.. + /* 01E0 */ 0xFF, 0x7F, 0x28, 0x7C, 0x88, 0x1E, 0xDF, 0x29, // ..(|...) + /* 01E8 */ 0x1F, 0xAF, 0x4F, 0x17, 0x96, 0x35, 0x4E, 0xE8, // ..O..5N. + /* 01F0 */ 0x77, 0x08, 0x9F, 0x38, 0x7C, 0x64, 0x71, 0x44, // w..8|dqD + /* 01F8 */ 0x08, 0x39, 0x39, 0x05, 0xA0, 0x81, 0x4F, 0xF7, // .99...O. + /* 0200 */ 0xEC, 0x22, 0x9C, 0xAE, 0x27, 0xE5, 0x40, 0xC3, // ."..'.@. + /* 0208 */ 0xA0, 0xE3, 0x04, 0xC7, 0x79, 0x00, 0x1C, 0xE3, // ....y... + /* 0210 */ 0x84, 0x7F, 0x2E, 0x80, 0x3F, 0x40, 0x7E, 0xCA, // ....?@~. + /* 0218 */ 0x78, 0xC5, 0x48, 0xE0, 0x98, 0x23, 0x44, 0x9F, // x.H..#D. + /* 0220 */ 0x6B, 0x3C, 0x42, 0x2C, 0xFC, 0x53, 0x45, 0xE1, // k... + /* 0250 */ 0x89, 0x46, 0xF3, 0xE2, 0xA7, 0x03, 0x7E, 0xF8, // .F....~. + /* 0258 */ 0x00, 0x0F, 0xA8, 0x87, 0x84, 0x03, 0xC5, 0x4C, // .......L + /* 0260 */ 0x9B, 0x83, 0x3E, 0xBB, 0x1C, 0x3A, 0x76, 0xB8, // ..>..:v. + /* 0268 */ 0xE0, 0x3F, 0x81, 0x80, 0x4B, 0xDE, 0x21, 0x0C, // .?..K.!. + /* 0270 */ 0x14, 0x23, 0xC6, 0x9F, 0x83, 0x7C, 0x0A, 0x03, // .#...|.. + /* 0278 */ 0xFF, 0xFF, 0xFF, 0x14, 0x06, 0xFE, 0xE1, 0xF0, // ........ + /* 0280 */ 0x20, 0x4F, 0x07, 0x9F, 0xB6, 0xA8, 0x74, 0x18, // O....t. + /* 0288 */ 0xD4, 0x81, 0x0B, 0xB0, 0x32, 0x89, 0x08, 0xCF, // ....2... + /* 0290 */ 0x12, 0xB5, 0x41, 0xE8, 0xD4, 0xF0, 0x36, 0xF1, // ..A...6. + /* 0298 */ 0xB6, 0xE5, 0x5B, 0x40, 0x9C, 0xD3, 0xEC, 0xED, // ..[@.... + /* 02A0 */ 0xC0, 0x45, 0x30, 0x22, 0xD4, 0x0C, 0x45, 0x4E, // .E0"..EN + /* 02A8 */ 0x5A, 0x11, 0x63, 0x44, 0x79, 0xDC, 0x32, 0xCA, // Z.cDy.2. + /* 02B0 */ 0xDB, 0xD6, 0x0B, 0x40, 0xBC, 0x13, 0x7B, 0xDE, // ...@..{. + /* 02B8 */ 0x32, 0x46, 0xF0, 0xC8, 0x0F, 0x5C, 0x2C, 0xC6, // 2F...\,. + /* 02C0 */ 0xEA, 0xF5, 0x5F, 0xF3, 0x81, 0x0B, 0x70, 0xF6, // .._...p. + /* 02C8 */ 0xFF, 0x3F, 0x70, 0x01, 0x1C, 0x0A, 0x7A, 0x18, // .?p...z. + /* 02D0 */ 0x42, 0x0F, 0xC3, 0x53, 0x39, 0x97, 0x87, 0xC8, // B..S9... + /* 02D8 */ 0x53, 0x89, 0x18, 0x35, 0x4C, 0xD4, 0x67, 0x28, // S..5L.g( + /* 02E0 */ 0xDF, 0x2D, 0x7C, 0x20, 0x02, 0xDF, 0x99, 0x0B, // .-| .... + /* 02E8 */ 0xF8, 0xFD, 0xFF, 0x0F, 0x44, 0x70, 0x8E, 0x29, // ....Dp.) + /* 02F0 */ 0xB8, 0x33, 0x0D, 0x78, 0x7C, 0xCE, 0x40, 0x20, // .3.x|.@ + /* 02F8 */ 0xA7, 0xE2, 0x43, 0x0D, 0x60, 0x41, 0xF4, 0x13, // ..C.`A.. + /* 0300 */ 0xC2, 0x27, 0x1A, 0x2A, 0x13, 0x06, 0x75, 0xA8, // .'.*..u. + /* 0308 */ 0x01, 0xAC, 0x5C, 0x61, 0x9E, 0x46, 0xCF, 0xF9, // ..\a.F.. + /* 0310 */ 0x59, 0xC6, 0xA7, 0x1A, 0x1F, 0x4A, 0x8D, 0x63, // Y....J.c + /* 0318 */ 0x88, 0x97, 0x99, 0x87, 0x1A, 0x1F, 0x0B, 0x5E, // .......^ + /* 0320 */ 0x49, 0x7D, 0xA8, 0x31, 0x54, 0x9C, 0x87, 0x1A, // I}.1T... + /* 0328 */ 0x0F, 0x37, 0x50, 0xD4, 0x37, 0x9B, 0x67, 0x1B, // .7P.7.g. + /* 0330 */ 0xA3, 0xC7, 0xF7, 0x0D, 0xD5, 0x10, 0x0F, 0x35, // .......5 + /* 0338 */ 0x4C, 0xF2, 0x4A, 0x35, 0x16, 0x1F, 0x6A, 0xC0, // L.J5..j. + /* 0340 */ 0xF1, 0xFF, 0x3F, 0xD4, 0x00, 0xFC, 0xFF, 0xFF, // ..?..... + /* 0348 */ 0x1F, 0x6A, 0x00, 0x47, 0x47, 0x03, 0x38, 0x47, // .j.GG.8G + /* 0350 */ 0x46, 0xDC, 0xD1, 0x00, 0x5C, 0x87, 0x52, 0xE0, // F...\.R. + /* 0358 */ 0x70, 0x34, 0x00, 0x1E, 0x47, 0x21, 0x30, 0x5F, // p4..G!0_ + /* 0360 */ 0x68, 0x7C, 0x14, 0x02, 0x16, 0xFF, 0xFF, 0xA3, // h|...... + /* 0368 */ 0x10, 0xF8, 0x65, 0x9F, 0x83, 0x50, 0x42, 0x8F, // ..e..PB. + /* 0370 */ 0x42, 0x80, 0xA0, 0xDB, 0xCF, 0x53, 0xC4, 0xB3, // B....S.. + /* 0378 */ 0x8F, 0x2F, 0x3F, 0x0F, 0x04, 0x11, 0x5E, 0xF3, // ./?...^. + /* 0380 */ 0x7D, 0x0A, 0xF2, 0x21, 0xDF, 0x47, 0x21, 0x06, // }..!.G!. + /* 0388 */ 0x63, 0x28, 0x5F, 0x83, 0x7C, 0x14, 0x62, 0x50, // c(_.|.bP + /* 0390 */ 0xAF, 0x41, 0xBE, 0xEF, 0x1B, 0xE4, 0xF1, 0x22, // .A....." + /* 0398 */ 0x48, 0xEC, 0x67, 0x02, 0x1F, 0x85, 0x98, 0xE8, // H.g..... + /* 03A0 */ 0xA3, 0x10, 0xA0, 0xF0, 0xFF, 0x7F, 0x14, 0x02, // ........ + /* 03A8 */ 0xF8, 0xFF, 0xFF, 0x3F, 0x0A, 0x01, 0xCE, 0x02, // ...?.... + /* 03B0 */ 0x1C, 0x0D, 0x40, 0x37, 0xAD, 0x47, 0x21, 0xF0, // ..@7.G!. + /* 03B8 */ 0xDE, 0x59, 0x4E, 0xFB, 0x04, 0x7C, 0x16, 0x02, // .YN..|.. + /* 03C0 */ 0xCC, 0xFE, 0xFF, 0xCF, 0x42, 0xC0, 0xEC, 0x28, // ....B..( + /* 03C8 */ 0x74, 0x14, 0x67, 0xF9, 0x2A, 0xF4, 0x04, 0xF0, // t.g.*... + /* 03D0 */ 0x02, 0x10, 0x23, 0xCC, 0x3B, 0xD0, 0x4B, 0x26, // ..#.;.K& + /* 03D8 */ 0xBB, 0x8B, 0x1B, 0xE7, 0xC9, 0xE5, 0x2C, 0x9E, // ......,. + /* 03E0 */ 0xC4, 0x7D, 0x09, 0xF2, 0x81, 0xE2, 0x59, 0xC8, // .}....Y. + /* 03E8 */ 0x50, 0xA7, 0x1B, 0xF4, 0x8D, 0xDC, 0x03, 0x8B, // P....... + /* 03F0 */ 0x19, 0x3F, 0xC4, 0xF3, 0x90, 0x21, 0x9E, 0x85, // .?...!.. + /* 03F8 */ 0x00, 0x76, 0xFD, 0xFF, 0xCF, 0x42, 0x00, 0xFF, // .v...B.. + /* 0400 */ 0xFF, 0xFF, 0x47, 0x03, 0xF8, 0x2F, 0x00, 0x9F, // ..G../.. + /* 0408 */ 0x85, 0x80, 0xE7, 0x09, 0xE0, 0x41, 0xDB, 0x67, // .....A.g + /* 0410 */ 0x21, 0x80, 0x33, 0x87, 0xCB, 0xF3, 0x7F, 0x05, // !.3..... + /* 0418 */ 0x3A, 0x96, 0xF7, 0x08, 0xCF, 0xFA, 0x24, 0x5F, // :.....$_ + /* 0420 */ 0x2F, 0x3D, 0xD3, 0x87, 0x82, 0x67, 0x21, 0x86, // /=...g!. + /* 0428 */ 0x75, 0x18, 0x3E, 0x0B, 0x31, 0x88, 0x17, 0x4D, // u.>.1..M + /* 0430 */ 0x43, 0xBC, 0x70, 0xFA, 0x30, 0xE0, 0xFF, 0x3F, // C.p.0..? + /* 0438 */ 0x5E, 0xE0, 0x57, 0x4E, 0x03, 0x05, 0x09, 0xF4, // ^.WN.... + /* 0440 */ 0x2C, 0x04, 0x30, 0xFE, 0xFF, 0x7F, 0x16, 0x02, // ,.0..... + /* 0448 */ 0xC8, 0xB8, 0x46, 0x9D, 0x85, 0x80, 0xE5, 0x6D, // ..F....m + /* 0450 */ 0xE5, 0x19, 0xDB, 0xA7, 0x95, 0x04, 0xFF, 0xFF, // ........ + /* 0458 */ 0x67, 0x21, 0xC0, 0x41, 0x2E, 0x23, 0x07, 0x21, // g!.A.#.! + /* 0460 */ 0x4C, 0xC4, 0x87, 0x83, 0x8F, 0x99, 0x80, 0x9E, // L....... + /* 0468 */ 0x29, 0xBE, 0xB8, 0x1B, 0xE3, 0x09, 0xE0, 0x45, // )......E + /* 0470 */ 0xE2, 0x31, 0x93, 0x1D, 0x35, 0x0D, 0xF3, 0x2C, // .1..5.., + /* 0478 */ 0x64, 0xBC, 0xB3, 0x78, 0x0D, 0x78, 0x82, 0xF7, // d..x.x.. + /* 0480 */ 0xE4, 0x9F, 0x85, 0x18, 0xD8, 0x61, 0x05, 0x7B, // .....a.{ + /* 0488 */ 0x14, 0x32, 0xA8, 0xC1, 0x63, 0x87, 0x08, 0x13, // .2..c... + /* 0490 */ 0xE8, 0x59, 0x88, 0xC5, 0x7D, 0xAE, 0xE8, 0x3C, // .Y..}..< + /* 0498 */ 0xE1, 0xB3, 0x10, 0xF0, 0xFE, 0xFF, 0x9F, 0x25, // .......% + /* 04A0 */ 0xE0, 0x5E, 0x0D, 0x9E, 0x85, 0x00, 0x13, 0x87, // .^...... + /* 04A8 */ 0x0D, 0x9F, 0x35, 0xC0, 0x33, 0x7C, 0x8F, 0xEA, // ..5.3|.. + /* 04B0 */ 0x1C, 0x1E, 0x8F, 0x81, 0x7F, 0x56, 0x1D, 0xE7, // .....V.. + /* 04B8 */ 0x04, 0x96, 0x7B, 0xD1, 0xB2, 0x71, 0xA0, 0xA1, // ..{..q.. + /* 04C0 */ 0x23, 0xB2, 0x3A, 0x20, 0x8D, 0x0D, 0x73, 0x29, // #.: ..s) + /* 04C8 */ 0x89, 0x7C, 0x72, 0x6C, 0xD4, 0x56, 0x04, 0xA7, // .|rl.V.. + /* 04D0 */ 0x33, 0x93, 0x4F, 0x00, 0xD6, 0x42, 0x21, 0x05, // 3.O..B!. + /* 04D8 */ 0x34, 0x1A, 0x8B, 0xE1, 0x9D, 0xF9, 0xE8, 0x44, // 4......D + /* 04E0 */ 0x41, 0x0C, 0xE8, 0xE3, 0x90, 0x6D, 0x1C, 0x0A, // A....m.. + /* 04E8 */ 0x50, 0x7B, 0xD1, 0x14, 0xC8, 0x39, 0x07, 0xA3, // P{...9.. + /* 04F0 */ 0x7F, 0x76, 0x74, 0x36, 0xBE, 0x13, 0x70, 0x0D, // .vt6..p. + /* 04F8 */ 0x10, 0x3A, 0x25, 0x18, 0xDA, 0x6A, 0x04, 0xFC, // .:%..j.. + /* 0500 */ 0xFF, 0x67, 0x89, 0x01, 0x33, 0xFE, 0x53, 0x8C, // .g..3.S. + /* 0508 */ 0x09, 0x7C, 0x8E, 0xC1, 0x1F, 0x0C, 0xF0, 0x03, // .|...... + /* 0510 */ 0x7F, 0x31, 0xA8, 0xFA, 0x5E, 0xA0, 0xFB, 0x82, // .1..^... + /* 0518 */ 0xD5, 0xDD, 0x64, 0x20, 0xCC, 0xC8, 0x04, 0xF5, // ..d .... + /* 0520 */ 0x9D, 0x0E, 0x40, 0x01, 0xE4, 0x0B, 0x81, 0xCF, // ..@..... + /* 0528 */ 0x51, 0x0F, 0x05, 0x6C, 0x22, 0x21, 0xC2, 0x44, // Q..l"!.D + /* 0530 */ 0x33, 0x3A, 0x62, 0xC2, 0xA8, 0xE8, 0x13, 0xA6, // 3:b..... + /* 0538 */ 0x20, 0x9E, 0xB0, 0x63, 0x4D, 0x18, 0x3D, 0x13, // ..cM.=. + /* 0540 */ 0x5F, 0x74, 0xD8, 0x88, 0x31, 0x21, 0xAE, 0x1E, // _t..1!.. + /* 0548 */ 0xD0, 0x26, 0x18, 0xD4, 0x97, 0x22, 0x58, 0x43, // .&..."XC + /* 0550 */ 0xE6, 0x63, 0xF1, 0x05, 0x02, 0x37, 0x65, 0x30, // .c...7e0 + /* 0558 */ 0xCE, 0x89, 0x5D, 0x13, 0x7C, 0xD9, 0xC1, 0xCD, // ..].|... + /* 0560 */ 0x19, 0x8C, 0xF0, 0x98, 0xBB, 0x18, 0xBF, 0x3A, // .......: + /* 0568 */ 0x79, 0x74, 0xFC, 0xA0, 0xE0, 0x1B, 0x0E, 0xC3, // yt...... + /* 0570 */ 0x7E, 0x32, 0xF3, 0x8C, 0xDE, 0xCB, 0x7C, 0x8D, // ~2....|. + /* 0578 */ 0xC3, 0xC0, 0x7A, 0xBC, 0x1C, 0xD6, 0x68, 0x61, // ..z...ha + /* 0580 */ 0x0F, 0xED, 0x3D, 0xC4, 0xFF, 0xFF, 0x43, 0x8C, // ..=...C. + /* 0588 */ 0xCF, 0x13, 0xC6, 0x08, 0xEB, 0xDB, 0x0B, 0x38, // .......8 + /* 0590 */ 0xEE, 0x59, 0xF0, 0xEF, 0x1A, 0xE0, 0xB9, 0x84, // .Y...... + /* 0598 */ 0xF8, 0xAE, 0x01, 0x30, 0xF0, 0xFF, 0x7F, 0xD7, // ...0.... + /* 05A0 */ 0x00, 0x4E, 0xD7, 0x04, 0xDF, 0x35, 0x80, 0xF7, // .N...5.. + /* 05A8 */ 0xD0, 0x7D, 0xD7, 0x00, 0xAE, 0xD9, 0xEF, 0x1A, // .}...... + /* 05B0 */ 0xA8, 0x63, 0x80, 0x15, 0xDE, 0x35, 0xA0, 0x5D, // .c...5.] + /* 05B8 */ 0xD9, 0xDE, 0xD7, 0x9E, 0xB0, 0xAC, 0xE9, 0xB2, // ........ + /* 05C0 */ 0x81, 0x52, 0x73, 0xD9, 0x00, 0x14, 0xFC, 0xFF, // .Rs..... + /* 05C8 */ 0x2F, 0x1B, 0x80, 0x01, 0x29, 0x13, 0x46, 0x85, // /...).F. + /* 05D0 */ 0x9F, 0x30, 0x05, 0xF1, 0x84, 0x1D, 0xEC, 0xB2, // .0...... + /* 05D8 */ 0x01, 0x8A, 0x18, 0x97, 0x0D, 0xD0, 0x8F, 0xED, // ........ + /* 05E0 */ 0x65, 0x03, 0x18, 0xDC, 0x13, 0xF8, 0x6D, 0x03, // e.....m. + /* 05E8 */ 0x78, 0x43, 0xFA, 0xB6, 0x01, 0xD6, 0xFF, 0xFF, // xC...... + /* 05F0 */ 0x6D, 0x03, 0xAC, 0xF9, 0x6F, 0x1B, 0x28, 0x0E, // m...o.(. + /* 05F8 */ 0xAB, 0xBC, 0x6D, 0x40, 0x3C, 0xC9, 0x33, 0x02, // ..m@<.3. + /* 0600 */ 0xAB, 0xBA, 0x6E, 0xA0, 0xF4, 0x5C, 0x37, 0x00, // ..n..\7. + /* 0608 */ 0x12, 0x88, 0x99, 0x30, 0x2A, 0xFE, 0x84, 0x29, // ...0*..) + /* 0610 */ 0x88, 0x27, 0xEC, 0x68, 0xD7, 0x0D, 0x50, 0x04, // .'.h..P. + /* 0618 */ 0xB9, 0x6E, 0x80, 0x7E, 0x5E, 0x09, 0xFE, 0xFF, // .n.~^... + /* 0620 */ 0xAF, 0x1B, 0xC0, 0xE0, 0xA2, 0x80, 0xB9, 0x6F, // .......o + /* 0628 */ 0x00, 0x6F, 0x58, 0x7E, 0xDF, 0x00, 0x7C, 0xDC, // .oX~..|. + /* 0630 */ 0xC4, 0x31, 0xF7, 0x0D, 0xC0, 0xCC, 0xFF, 0xFF, // .1...... + /* 0638 */ 0xBE, 0x01, 0xB0, 0xE7, 0xA2, 0x80, 0xBB, 0x6F, // .......o + /* 0640 */ 0x00, 0xEF, 0x8B, 0xB4, 0xEF, 0x1B, 0x60, 0xFE, // ......`. + /* 0648 */ 0xFF, 0xDF, 0x37, 0xC0, 0x28, 0x6D, 0xFD, 0x1E, // ..7.(m.. + /* 0650 */ 0x1C, 0x3D, 0x21, 0x78, 0x7C, 0xB8, 0xFB, 0xA5, // .=!x|... + /* 0658 */ 0xC7, 0xE7, 0xBB, 0x39, 0x38, 0x06, 0x79, 0x8C, // ...98.y. + /* 0660 */ 0x87, 0x76, 0xC0, 0xAF, 0xEF, 0x9E, 0x98, 0xEF, // .v...... + /* 0668 */ 0xE6, 0xC0, 0xFF, 0x4C, 0x70, 0x3C, 0x18, 0x68, // ...Lp<.h + /* 0670 */ 0x1C, 0x62, 0xAB, 0x97, 0x06, 0x72, 0x34, 0x38, // .b...r48 + /* 0678 */ 0x3F, 0xDC, 0x19, 0x81, 0x61, 0x15, 0x7F, 0xF2, // ?...a... + /* 0680 */ 0x47, 0x38, 0xC7, 0xD0, 0xD9, 0xE1, 0x20, 0xB1, // G8.... . + /* 0688 */ 0x83, 0xE0, 0xC1, 0x56, 0x6D, 0x02, 0x85, 0x86, // ...Vm... + /* 0690 */ 0x50, 0x14, 0x18, 0x14, 0x8B, 0x0F, 0x18, 0xF8, // P....... + /* 0698 */ 0x61, 0xB3, 0xB3, 0x00, 0x93, 0x04, 0x87, 0x3A, // a......: + /* 06A0 */ 0x02, 0xF8, 0x3E, 0xD1, 0xFC, 0x38, 0x74, 0x37, // ..>..8t7 + /* 06A8 */ 0x38, 0x54, 0x8F, 0xE5, 0xA1, 0x80, 0x9E, 0x01, // 8T...... + /* 06B0 */ 0x71, 0xC7, 0x0C, 0x32, 0x69, 0xCF, 0x28, 0xE2, // q..2i.(. + /* 06B8 */ 0x53, 0xC2, 0x29, 0x85, 0x49, 0xE0, 0xF3, 0x03, // S.).I... + /* 06C0 */ 0x43, 0xE3, 0x04, 0xAF, 0x0D, 0xA1, 0xF9, 0xFF, // C....... + /* 06C8 */ 0xFF, 0xA4, 0xC0, 0x3C, 0xDF, 0x31, 0x04, 0x6C, // ...<.1.l + /* 06D0 */ 0x02, 0xBB, 0xBF, 0x64, 0xC8, 0xDA, 0xC0, 0x75, // ...d...u + /* 06D8 */ 0x4B, 0x32, 0x44, 0x6F, 0x38, 0xB2, 0x85, 0xA2, // K2Do8... + /* 06E0 */ 0xE9, 0x44, 0x79, 0xDF, 0x88, 0x62, 0x67, 0x08, // .Dy..bg. + /* 06E8 */ 0xC2, 0x88, 0x12, 0x2C, 0xC8, 0xA3, 0x42, 0xAC, // ...,..B. + /* 06F0 */ 0x28, 0x2F, 0x05, 0x46, 0x88, 0x18, 0xE2, 0x95, // (/.F.... + /* 06F8 */ 0x23, 0xD0, 0x09, 0x87, 0x0F, 0xF2, 0xD8, 0x14, // #....... + /* 0700 */ 0xA7, 0xFD, 0x41, 0x90, 0x58, 0x4F, 0x02, 0x8D, // ..A.XO.. + /* 0708 */ 0xC5, 0x91, 0x46, 0x83, 0x3A, 0x07, 0x78, 0xB8, // ..F.:.x. + /* 0710 */ 0x3E, 0xC4, 0x78, 0xF8, 0x0F, 0x21, 0x06, 0x39, // >.x..!.9 + /* 0718 */ 0xC8, 0x73, 0x7B, 0x54, 0x38, 0x4E, 0x5F, 0x25, // .s{T8N_% + /* 0720 */ 0x4C, 0xF0, 0x02, 0xE0, 0x83, 0x0A, 0x1C, 0xD7, // L....... + /* 0728 */ 0x80, 0x9A, 0xF1, 0x33, 0x06, 0x58, 0x8E, 0xE3, // ...3.X.. + /* 0730 */ 0x3E, 0xA9, 0xC0, 0x1D, 0x8F, 0xEF, 0x07, 0x6C, // >......l + /* 0738 */ 0xC2, 0x09, 0x2C, 0x7F, 0x10, 0xA8, 0xE3, 0x0C, // ..,..... + /* 0740 */ 0x9F, 0xE7, 0x0B, 0x8B, 0x21, 0x1F, 0x13, 0x4C, // ....!..L + /* 0748 */ 0x60, 0xB1, 0x27, 0x1B, 0x3A, 0x1E, 0xF0, 0xDF, // `.'.:... + /* 0750 */ 0x63, 0x1E, 0x2F, 0x7C, 0x32, 0xF1, 0x7C, 0x4D, // c./|2.|M + /* 0758 */ 0x30, 0x22, 0x84, 0x9C, 0x8C, 0x07, 0x7D, 0x87, // 0"....}. + /* 0760 */ 0xC0, 0x5C, 0x6F, 0xD8, 0xB9, 0x85, 0x8B, 0x3A, // .\o....: + /* 0768 */ 0x68, 0xA0, 0x4E, 0x0B, 0x3E, 0x28, 0xB0, 0x9B, // h.N.>(.. + /* 0770 */ 0x11, 0xE6, 0xB8, 0xCE, 0xCF, 0x2A, 0x60, 0xF8, // .....*`. + /* 0778 */ 0xFF, 0x9F, 0x55, 0x60, 0x8F, 0x10, 0xFE, 0xED, // ..U`.... + /* 0780 */ 0xC1, 0xF3, 0xF2, 0x95, 0xE1, 0xD5, 0x21, 0x81, // ......!. + /* 0788 */ 0x43, 0x8E, 0x10, 0x3D, 0x2E, 0x8F, 0x10, 0x73, // C..=...s + /* 0790 */ 0x3E, 0xC2, 0x0C, 0x11, 0x5C, 0x67, 0x01, 0x70, // >...\g.p + /* 0798 */ 0x0C, 0x11, 0xF8, 0x1C, 0x70, 0xC0, 0x71, 0x69, // ....p.qi + /* 07A0 */ 0xE2, 0x03, 0xF5, 0x01, 0x07, 0x70, 0x70, 0x4D, // .....ppM + /* 07A8 */ 0xC3, 0x1D, 0x70, 0xC0, 0x71, 0x16, 0x60, 0xFF, // ..p.q.`. + /* 07B0 */ 0xFF, 0xC3, 0x0D, 0x2C, 0x49, 0x26, 0x0E, 0x23, // ...,I&.# + /* 07B8 */ 0x18, 0x11, 0x30, 0x28, 0x02, 0x02, 0xA4, 0xB3, // ..0(.... + /* 07C0 */ 0x80, 0x0F, 0x29, 0x00, 0x1F, 0xAE, 0x0C, 0x0F, // ..)..... + /* 07C8 */ 0x29, 0xD8, 0x93, 0x86, 0x07, 0x8E, 0x1B, 0x85, // )....... + /* 07D0 */ 0x07, 0x8D, 0x0B, 0x30, 0x68, 0x7A, 0xE2, 0x80, // ...0hz.. + /* 07D8 */ 0x7F, 0x4C, 0xF0, 0x19, 0x05, 0x1C, 0xE3, 0x06, // .L...... + /* 07E0 */ 0xDF, 0x2A, 0x0C, 0xFC, 0xFF, 0x3F, 0x30, 0xCC, // .*...?0. + /* 07E8 */ 0xE1, 0xC2, 0x63, 0x39, 0x8A, 0xA0, 0x07, 0x1E, // ..c9.... + /* 07F0 */ 0xD4, 0xF7, 0x8C, 0x33, 0xF7, 0x24, 0x8F, 0xD1, // ...3.$.. + /* 07F8 */ 0x51, 0x0F, 0x27, 0xF4, 0xE4, 0x85, 0x3B, 0x57, // Q.'...;W + /* 0800 */ 0xF9, 0x0A, 0x71, 0x14, 0x18, 0xB8, 0x77, 0x29, // ..q...w) + /* 0808 */ 0x8F, 0xCF, 0x17, 0x2B, 0xC3, 0x63, 0x46, 0xFB, // ...+.cF. + /* 0810 */ 0x1E, 0x72, 0xD6, 0x11, 0x02, 0xE2, 0x2F, 0x75, // .r..../u + /* 0818 */ 0x6C, 0xC0, 0x60, 0x39, 0x18, 0x00, 0x87, 0x01, // l.`9.... + /* 0820 */ 0xE3, 0x13, 0x0D, 0x58, 0x67, 0x1B, 0x3C, 0xF4, // ...Xg.<. + /* 0828 */ 0x69, 0x31, 0xC4, 0xE3, 0x0B, 0xFB, 0x56, 0x61, // i1....Va + /* 0830 */ 0x82, 0xEA, 0x41, 0x75, 0x12, 0xF4, 0xD0, 0xC0, // ..Au.... + /* 0838 */ 0x01, 0xE8, 0xA1, 0xC1, 0x3F, 0xB9, 0x90, 0xFB, // ....?... + /* 0840 */ 0x2B, 0x1D, 0x82, 0xB5, 0xE2, 0x69, 0xDE, 0x47, // +....i.G + /* 0848 */ 0x1E, 0xF3, 0xDC, 0xA2, 0xBC, 0x0D, 0x3C, 0x07, // ......<. + /* 0850 */ 0xF0, 0xD3, 0x82, 0x87, 0xE3, 0x63, 0x81, 0xC7, // .....c.. + /* 0858 */ 0xE9, 0x4B, 0x58, 0x82, 0xF7, 0x1A, 0x9F, 0x6C, // .KX....l + /* 0860 */ 0x1E, 0x5C, 0x58, 0xB2, 0x21, 0xA0, 0x06, 0xEB, // .\X.!... + /* 0868 */ 0x21, 0x60, 0xA6, 0x9A, 0xC0, 0x49, 0x46, 0x80, // !`...IF. + /* 0870 */ 0xCA, 0x00, 0xA1, 0x1B, 0xCB, 0xE9, 0x3E, 0x8B, // ......>. + /* 0878 */ 0x84, 0x38, 0xCD, 0x47, 0x99, 0xC7, 0x02, 0x8F, // .8.G.... + /* 0880 */ 0xF5, 0xC1, 0xC0, 0xFF, 0x7F, 0xCD, 0x23, 0xD4, // ......#. + /* 0888 */ 0x7D, 0xCD, 0x33, 0x7B, 0x3A, 0xC0, 0xAC, 0x22, // }.3{:.." + /* 0890 */ 0xDC, 0x7B, 0xCE, 0x1B, 0x86, 0xD1, 0x9E, 0x2D, // .{.....- + /* 0898 */ 0x7C, 0xCD, 0x78, 0xD6, 0x34, 0x42, 0x38, 0x76, // |.x.4B8v + /* 08A0 */ 0x83, 0xF3, 0x48, 0x8C, 0xF0, 0x82, 0xC0, 0x4E, // ..H....N + /* 08A8 */ 0x0C, 0x0F, 0x30, 0xC6, 0x39, 0x79, 0xC3, 0xFA, // ..0.9y.. + /* 08B0 */ 0xC2, 0xCB, 0x40, 0x83, 0x19, 0xDB, 0x97, 0x01, // ..@..... + /* 08B8 */ 0x36, 0x2A, 0xDF, 0x88, 0xC0, 0x97, 0xFC, 0x62, // 6*.....b + /* 08C0 */ 0x00, 0x65, 0x16, 0xBE, 0x9E, 0xF8, 0xA0, 0xC4, // .e...... + /* 08C8 */ 0x2E, 0x06, 0x2C, 0xE5, 0xC5, 0x00, 0x54, 0x37, // ..,...T7 + /* 08D0 */ 0x0C, 0x5F, 0x0C, 0xE0, 0x5F, 0x89, 0x5E, 0x0C, // ._.._.^. + /* 08D8 */ 0xC0, 0x70, 0x71, 0xF2, 0x3D, 0xC0, 0x1E, 0xEE, // .pq.=... + /* 08E0 */ 0xA3, 0x74, 0x9C, 0xBE, 0xFD, 0xBD, 0x19, 0xF8, // .t...... + /* 08E8 */ 0x6C, 0xC0, 0x60, 0x3C, 0xC3, 0x30, 0xC6, 0x08, // l.`<.0.. + /* 08F0 */ 0xE3, 0x51, 0x86, 0x31, 0xC1, 0xDC, 0xB7, 0x03, // .Q.1.... + /* 08F8 */ 0xE8, 0x39, 0x87, 0x81, 0x4A, 0x78, 0x3B, 0x80, // .9..Jx;. + /* 0900 */ 0x72, 0x0E, 0xE8, 0xF2, 0x68, 0x42, 0x4F, 0x01, // r...hBO. + /* 0908 */ 0x4F, 0x07, 0x3E, 0x29, 0x1A, 0xA2, 0xAF, 0xB1, // O.>).... + /* 0910 */ 0x0A, 0x26, 0x50, 0xC4, 0x07, 0x0D, 0x3E, 0xB5, // .&P...>. + /* 0918 */ 0x28, 0x3E, 0x15, 0x78, 0x2D, 0xCF, 0x4E, 0xE1, // (>.x-.N. + /* 0920 */ 0xE2, 0x9C, 0x89, 0xA7, 0x6A, 0x38, 0x03, 0xBD, // ....j8.. + /* 0928 */ 0xE6, 0x86, 0x63, 0xFF, 0x7F, 0x38, 0xFC, 0xA9, // ..c..8.. + /* 0930 */ 0xE0, 0x35, 0x80, 0x1D, 0x24, 0x3D, 0x2D, 0x23, // .5..$=-# + /* 0938 */ 0xC2, 0x38, 0xA4, 0x3C, 0x32, 0xF8, 0xB6, 0x18, // .8.<2... + /* 0940 */ 0xC7, 0x90, 0x0F, 0x91, 0xBE, 0x13, 0x18, 0xF2, // ........ + /* 0948 */ 0x21, 0xEF, 0x79, 0xC7, 0xC0, 0xAF, 0x08, 0x71, // !.y....q + /* 0950 */ 0x9E, 0xB2, 0x7C, 0x67, 0xF0, 0x65, 0x01, 0x7C, // ..|g.e.| + /* 0958 */ 0x91, 0x2E, 0x0B, 0x68, 0x68, 0x9F, 0x64, 0x7C, // ...hh.d| + /* 0960 */ 0x41, 0x30, 0xEC, 0x89, 0xB3, 0x00, 0x77, 0x05, // A0....w. + /* 0968 */ 0x50, 0x81, 0xFA, 0xAE, 0x00, 0xFF, 0x42, 0xF0, // P.....B. + /* 0970 */ 0xAE, 0x00, 0x86, 0x79, 0xF9, 0x56, 0xC0, 0x35, // ...y.V.5 + /* 0978 */ 0x1D, 0x4A, 0xD0, 0x67, 0x12, 0x5F, 0x17, 0x70, // .J.g._.p + /* 0980 */ 0x53, 0x64, 0xA9, 0x8E, 0x0A, 0xD0, 0x53, 0x4C, // Sd....SL + /* 0988 */ 0x02, 0x75, 0x47, 0xF7, 0x51, 0x01, 0xC6, 0x4D, // .uG.Q..M + /* 0990 */ 0xD9, 0x07, 0x54, 0x76, 0x5A, 0x60, 0x67, 0x21, // ..TvZ`g! + /* 0998 */ 0x76, 0x1D, 0xC1, 0x5D, 0x49, 0x18, 0xCA, 0xB3, // v..]I... + /* 09A0 */ 0x81, 0x2F, 0x59, 0xFC, 0x70, 0x00, 0x03, 0xDC, // ./Y.p... + /* 09A8 */ 0xB3, 0x38, 0xC4, 0x08, 0xB1, 0xD9, 0x81, 0xEB, // .8...... + /* 09B0 */ 0x75, 0xD2, 0x70, 0x2F, 0x44, 0xEC, 0xFF, 0x7F, // u.p/D... + /* 09B8 */ 0x32, 0x00, 0xE3, 0x51, 0x1B, 0x1C, 0x27, 0x9D, // 2..Q..'. + /* 09C0 */ 0xF0, 0x91, 0x9E, 0x59, 0xF8, 0x49, 0x19, 0x30, // ...Y.I.0 + /* 09C8 */ 0x71, 0xF2, 0x03, 0xE3, 0xC9, 0x1A, 0xC6, 0x00, // q....... + /* 09D0 */ 0xB8, 0xBC, 0x57, 0x95, 0x81, 0xFC, 0x43, 0x90, // ..W...C. + /* 09D8 */ 0x20, 0x18, 0xD4, 0x29, 0x19, 0x38, 0x1C, 0xC5, // ..).8.. + /* 09E0 */ 0x70, 0xA7, 0x64, 0x78, 0x50, 0xF8, 0xC3, 0x00, // p.dxP... + /* 09E8 */ 0xE6, 0x46, 0xE8, 0x7B, 0x82, 0xA1, 0xDE, 0x93, // .F.{.... + /* 09F0 */ 0x0E, 0xE3, 0x91, 0xD0, 0x04, 0x3E, 0x2D, 0xC3, // .....>-. + /* 09F8 */ 0xFA, 0xFF, 0x9F, 0x96, 0x81, 0xD5, 0xB1, 0xDD, // ........ + /* 0A00 */ 0x43, 0xF6, 0x59, 0x01, 0x77, 0x76, 0x80, 0x3B, // C.Y.wv.; + /* 0A08 */ 0x3D, 0x7E, 0x7A, 0x00, 0x9C, 0x00, 0x3D, 0x3D, // =~z...== + /* 0A10 */ 0x80, 0xED, 0xBC, 0x01, 0xF7, 0x40, 0x80, 0x38, // .....@.8 + /* 0A18 */ 0xFE, 0xA3, 0x82, 0x5F, 0x59, 0x28, 0x1C, 0x3F, // ..._Y(.? + /* 0A20 */ 0xB6, 0xF3, 0x63, 0x09, 0xEE, 0x70, 0xE0, 0x23, // ..c..p.# + /* 0A28 */ 0x83, 0x0F, 0x90, 0xB8, 0xA1, 0xF8, 0x50, 0x81, // ......P. + /* 0A30 */ 0x3C, 0x0B, 0x80, 0x62, 0xF4, 0x6C, 0x04, 0xEC, // <..b.l.. + /* 0A38 */ 0x06, 0xF3, 0xD2, 0x12, 0xE5, 0xFF, 0xFF, 0xDE, // ........ + /* 0A40 */ 0xC0, 0x4E, 0x29, 0xB8, 0x83, 0x00, 0xF8, 0x8E, // .N)..... + /* 0A48 */ 0x01, 0xE0, 0x1D, 0x0C, 0x97, 0x35, 0x66, 0x94, // .....5f. + /* 0A50 */ 0x10, 0x18, 0x8D, 0x19, 0x77, 0x08, 0xE1, 0x27, // ....w..' + /* 0A58 */ 0x02, 0xDC, 0x98, 0x3D, 0x6E, 0x8F, 0x19, 0x77, // ...=n..w + /* 0A60 */ 0x9C, 0xE5, 0xA3, 0x7A, 0xCA, 0x08, 0xE5, 0x03, // ...z.... + /* 0A68 */ 0x07, 0x3B, 0x67, 0xBC, 0x11, 0xF0, 0xA1, 0x03, // .;g..... + /* 0A70 */ 0x8F, 0x03, 0x0C, 0xEE, 0x48, 0x01, 0xC6, 0xCB, // ....H... + /* 0A78 */ 0x01, 0x1B, 0x3B, 0xB8, 0x83, 0x90, 0x53, 0x20, // ..;...S + /* 0A80 */ 0x4B, 0x87, 0xD1, 0xD8, 0x71, 0xB2, 0x81, 0x74, // K...q..t + /* 0A88 */ 0x8C, 0xF1, 0x21, 0xD7, 0x63, 0xC7, 0x0D, 0xD6, // ..!.c... + /* 0A90 */ 0x63, 0xC7, 0x1D, 0x5F, 0xB0, 0xFF, 0xFF, 0xE3, // c.._.... + /* 0A98 */ 0x0B, 0x18, 0xC6, 0xC0, 0xC5, 0x0F, 0x03, 0x7D, // .......} + /* 0AA0 */ 0xF3, 0xF3, 0xE8, 0x0C, 0xEE, 0x61, 0xFB, 0x04, // .....a.. + /* 0AA8 */ 0x13, 0xE3, 0xF9, 0x25, 0xC4, 0x23, 0xCC, 0x8B, // ...%.#.. + /* 0AB0 */ 0x4B, 0x84, 0xA3, 0x08, 0xF2, 0xE6, 0x12, 0xE7, // K....... + /* 0AB8 */ 0xD5, 0x20, 0xCC, 0x63, 0x4B, 0x94, 0x10, 0x11, // . .cK... + /* 0AC0 */ 0x0E, 0x26, 0xCE, 0x13, 0x8C, 0x11, 0x0E, 0x3C, // .&.....< + /* 0AC8 */ 0x8A, 0x21, 0x22, 0x9C, 0x40, 0x88, 0x93, 0x3E, // .!".@..> + /* 0AD0 */ 0xD9, 0x20, 0xE1, 0x63, 0x84, 0x8D, 0xF6, 0x04, // . .c.... + /* 0AD8 */ 0xC3, 0xC7, 0xC2, 0xCF, 0x2B, 0x1E, 0x3C, 0x3F, // ....+... + /* 0B38 */ 0x41, 0xC0, 0x87, 0x3A, 0x54, 0x0F, 0xF3, 0xA8, // A..:T... + /* 0B40 */ 0x5E, 0x0A, 0x19, 0xCE, 0xD9, 0xC1, 0x1D, 0x04, // ^....... + /* 0B48 */ 0xF6, 0xF8, 0xE1, 0x41, 0xF0, 0x9B, 0x25, 0x1F, // ...A..%. + /* 0B50 */ 0x04, 0x3B, 0xDF, 0xBC, 0xC1, 0x19, 0xE4, 0xFF, // .;...... + /* 0B58 */ 0x7F, 0x0C, 0xB0, 0xCF, 0x54, 0x3E, 0x9A, 0x20, // ....T>. + /* 0B60 */ 0x8E, 0x80, 0xE8, 0xF3, 0x87, 0xC7, 0xF0, 0x26, // .......& + /* 0B68 */ 0xC7, 0x87, 0x83, 0x3D, 0x7A, 0xE0, 0x4E, 0x22, // ...=z.N" + /* 0B70 */ 0x70, 0x8F, 0x5D, 0x07, 0xED, 0x6B, 0x9C, 0x2F, // p.]..k./ + /* 0B78 */ 0x5A, 0x30, 0xEE, 0x7B, 0xCF, 0x22, 0xE0, 0xC7, // Z0.{.".. + /* 0B80 */ 0x78, 0x6C, 0x01, 0xC7, 0xA1, 0x04, 0xDC, 0xC1, // xl...... + /* 0B88 */ 0x8E, 0x6B, 0x1C, 0x42, 0x51, 0x60, 0x74, 0x28, // .k.BQ`t( + /* 0B90 */ 0xC1, 0xC5, 0x00, 0x12, 0x8C, 0x63, 0x9C, 0xD1, // .....c.. + /* 0B98 */ 0xD0, 0x97, 0x48, 0x1F, 0xD2, 0xE0, 0x0C, 0x1A, // ..H..... + /* 0BA0 */ 0xF6, 0x3C, 0x9F, 0x50, 0xB8, 0x3D, 0x01, 0x8A, // .<.P.=.. + /* 0BA8 */ 0x4E, 0x28, 0x20, 0xC3, 0x7D, 0x06, 0xC1, 0x9E, // N( .}... + /* 0BB0 */ 0x10, 0xF8, 0x19, 0x84, 0xFD, 0xFF, 0x0F, 0x8E, // ........ + /* 0BB8 */ 0x1E, 0xF7, 0x7B, 0xA3, 0x4F, 0x8D, 0x6C, 0xEE, // ..{.O.l. + /* 0BC0 */ 0x0F, 0x01, 0x27, 0x70, 0xEE, 0xEC, 0xD4, 0x8C, // ..'p.... + /* 0BC8 */ 0x3B, 0x33, 0x60, 0xCF, 0x1F, 0x1E, 0x02, 0x3F, // ;3`....? + /* 0BD0 */ 0x17, 0x78, 0xF8, 0x1E, 0x02, 0x7E, 0xF0, 0x0F, // .x...~.. + /* 0BD8 */ 0xCC, 0x06, 0x07, 0xE3, 0x29, 0xC2, 0xD7, 0x0E, // ....)... + /* 0BE0 */ 0x0E, 0xCE, 0x4F, 0x03, 0x06, 0xE7, 0xAF, 0x50, // ..O....P + /* 0BE8 */ 0x9F, 0xE7, 0x19, 0x38, 0xF6, 0xD4, 0xEB, 0x7B, // ...8...{ + /* 0BF0 */ 0x87, 0xE7, 0xEB, 0x43, 0x05, 0xFE, 0xA6, 0xE7, // ...C.... + /* 0BF8 */ 0x43, 0x05, 0x38, 0x0E, 0x0F, 0xFC, 0xB0, 0xC2, // C.8..... + /* 0C00 */ 0x86, 0xF0, 0x28, 0x80, 0x3F, 0xB5, 0xF8, 0xF8, // ..(.?... + /* 0C08 */ 0x17, 0xE7, 0x29, 0x82, 0xDD, 0x46, 0xB0, 0x87, // ..)..F.. + /* 0C10 */ 0x0B, 0xC0, 0x51, 0xB4, 0xB3, 0x18, 0x2A, 0xCC, // ..Q...*. + /* 0C18 */ 0x59, 0x8C, 0xFC, 0xFF, 0xCF, 0x51, 0xA8, 0xB3, // Y....Q.. + /* 0C20 */ 0x18, 0x3D, 0x5C, 0x00, 0x2E, 0x04, 0x1F, 0x0F, // .=\..... + /* 0C28 */ 0x40, 0x73, 0x10, 0x78, 0x5C, 0xF0, 0x85, 0xE0, // @s.x\... + /* 0C30 */ 0x48, 0x0E, 0xE4, 0xE9, 0x00, 0xF0, 0x19, 0x4A, // H......J + /* 0C38 */ 0xC3, 0xA1, 0x09, 0x13, 0x03, 0x06, 0x75, 0x3E, // ......u> + /* 0C40 */ 0xF0, 0x09, 0xC5, 0xC7, 0x0E, 0x7E, 0x36, 0xF0, // .....~6. + /* 0C48 */ 0x8D, 0xDC, 0x43, 0xE5, 0xA7, 0x66, 0x5F, 0xF2, // ..C..f_. + /* 0C50 */ 0x11, 0xE0, 0x02, 0x75, 0xA0, 0x61, 0xA0, 0x46, // ...u.a.F + /* 0C58 */ 0xE4, 0x23, 0xD2, 0xFF, 0xFF, 0xB9, 0x0D, 0x1B, // .#...... + /* 0C60 */ 0x60, 0x68, 0xF4, 0x1C, 0x0E, 0xE3, 0x80, 0xEB, // `h...... + /* 0C68 */ 0x73, 0x38, 0x76, 0x40, 0x3E, 0x87, 0xC3, 0x3F, // s8v@>..? + /* 0C70 */ 0x47, 0xC3, 0x1F, 0x1B, 0x3B, 0xDD, 0xF3, 0x81, // G...;... + /* 0C78 */ 0xC1, 0xBA, 0x7E, 0x63, 0x06, 0x06, 0xB6, 0x6F, // ..~c...o + /* 0C80 */ 0x91, 0x07, 0x06, 0x1C, 0x51, 0xCF, 0xC6, 0x57, // ....Q..W + /* 0C88 */ 0x08, 0x0F, 0x0C, 0x6C, 0x80, 0x1E, 0x18, 0xF0, // ...l.... + /* 0C90 */ 0x89, 0x05, 0x21, 0x27, 0x03, 0x43, 0x9D, 0x32, // ..!'.C.2 + /* 0C98 */ 0x8C, 0x1C, 0xF3, 0x89, 0xC3, 0xC3, 0xF0, 0xA1, // ........ + /* 0CA0 */ 0x22, 0xEA, 0x33, 0xC0, 0x23, 0x1E, 0x1B, 0x1B, // ".3.#... + /* 0CA8 */ 0xFB, 0xFF, 0x8F, 0x0D, 0x2C, 0xC7, 0x16, 0x8F, // ....,... + /* 0CB0 */ 0x0D, 0xFC, 0x47, 0x78, 0xFC, 0xD8, 0xE0, 0x8C, // ..Gx.... + /* 0CB8 */ 0xE5, 0xD1, 0xC4, 0x97, 0x99, 0x23, 0x3B, 0x8D, // .....#;. + /* 0CC0 */ 0x33, 0x7B, 0x0D, 0xF1, 0xD1, 0xEE, 0xF1, 0xDB, // 3{...... + /* 0CC8 */ 0x63, 0x03, 0x97, 0x85, 0xB1, 0x01, 0xA5, 0x90, // c....... + /* 0CD0 */ 0x63, 0x43, 0x1F, 0x52, 0x7C, 0x0A, 0xB0, 0x71, // cC.R|..q + /* 0CD8 */ 0x54, 0x32, 0x0F, 0x1F, 0xAF, 0x7C, 0x62, 0x38, // T2...|b8 + /* 0CE0 */ 0xBA, 0x20, 0x6F, 0xE8, 0xBE, 0x5C, 0xF8, 0x48, // . o..\.H + /* 0CE8 */ 0x63, 0x30, 0x5F, 0x5A, 0x7C, 0x06, 0xE5, 0x43, // c0_Z|..C + /* 0CF0 */ 0x04, 0xD7, 0x57, 0xC5, 0x43, 0x04, 0x3E, 0xA1, // ..W.C.>. + /* 0CF8 */ 0x86, 0x88, 0x1E, 0xCF, 0xFF, 0xFF, 0x11, 0xCC, // ........ + /* 0D00 */ 0x43, 0x64, 0x43, 0x03, 0xAF, 0x87, 0xA1, 0x01, // CdC..... + /* 0D08 */ 0xA5, 0x98, 0xC0, 0x5E, 0x85, 0x87, 0x46, 0x4F, // ...^..FO + /* 0D10 */ 0x3F, 0x3E, 0x04, 0x30, 0x08, 0xDF, 0x06, 0xD8, // ?>.0.... + /* 0D18 */ 0x55, 0xC0, 0x57, 0x21, 0x83, 0x24, 0x18, 0xE7, // U.W!.$.. + /* 0D20 */ 0x64, 0x41, 0x07, 0x07, 0x8E, 0x21, 0x79, 0x70, // dA...!yp + /* 0D28 */ 0xF0, 0x07, 0xE3, 0x21, 0x70, 0x60, 0xCF, 0xE0, // ...!p`.. + /* 0D30 */ 0xB9, 0xE8, 0x31, 0xD8, 0xA7, 0x1D, 0x9F, 0x4A, // ..1....J + /* 0D38 */ 0xC0, 0x77, 0xE6, 0x04, 0xC7, 0xE9, 0x1D, 0x7B, // .w.....{ + /* 0D40 */ 0x29, 0xF0, 0x08, 0x1E, 0xAD, 0x3C, 0x02, 0x7E, // )....<.~ + /* 0D48 */ 0xB4, 0x02, 0x66, 0xFF, 0xFF, 0xA3, 0x15, 0x30, // ..f....0 + /* 0D50 */ 0x09, 0x7A, 0xE6, 0xA4, 0x03, 0x77, 0x34, 0x18, // .z...w4. + /* 0D58 */ 0xD4, 0xD1, 0x0A, 0x5C, 0x11, 0xC0, 0x75, 0xDC, // ...\..u. + /* 0D60 */ 0xF0, 0xD1, 0x02, 0xCE, 0x50, 0x0F, 0xDA, 0x07, // ....P... + /* 0D68 */ 0x65, 0xCF, 0xDA, 0x97, 0x21, 0x76, 0xB4, 0x00, // e...!v.. + /* 0D70 */ 0x97, 0x89, 0x43, 0x08, 0xD0, 0x04, 0x3E, 0x89, // ..C...>. + /* 0D78 */ 0x67, 0xEF, 0x43, 0x03, 0xB3, 0x8A, 0xA1, 0x01, // g.C..... + /* 0D80 */ 0xA5, 0xA3, 0x01, 0xEE, 0x44, 0x81, 0xFD, 0xFF, // ....D... + /* 0D88 */ 0x9F, 0x28, 0x60, 0xDE, 0x30, 0x70, 0x07, 0x0A, // .(`.0p.. + /* 0D90 */ 0xC0, 0xCD, 0xE9, 0xDB, 0xE3, 0xE2, 0xD0, 0x38, // .......8 + /* 0D98 */ 0xC4, 0xE7, 0xA7, 0x73, 0xF6, 0xD1, 0xE8, 0x4C, // ...s...L + /* 0DA0 */ 0x71, 0x67, 0x11, 0x30, 0x9C, 0x7D, 0x11, 0x8F, // qg.0.}.. + /* 0DA8 */ 0x18, 0x03, 0xF9, 0x81, 0x21, 0x59, 0x30, 0x28, // ....!Y0( + /* 0DB0 */ 0x16, 0x0F, 0xC5, 0x07, 0x03, 0x0E, 0xEC, 0x23, // .......# + /* 0DB8 */ 0x02, 0x3B, 0x17, 0xB0, 0x73, 0xAD, 0xE1, 0xF8, // .;..s... + /* 0DC0 */ 0x59, 0xC0, 0xA7, 0x84, 0xB7, 0xA6, 0x17, 0x7B, // Y......{ + /* 0DC8 */ 0x9F, 0xD7, 0x7D, 0xD6, 0x08, 0xC9, 0xCE, 0xF4, // ..}..... + /* 0DD0 */ 0x3E, 0x89, 0xE2, 0x0E, 0xA2, 0x70, 0x4E, 0x9F, // >....pN. + /* 0DD8 */ 0xE0, 0x22, 0xF0, 0x65, 0xDF, 0xA3, 0xE0, 0xA7, // .".e.... + /* 0DE0 */ 0x07, 0xCF, 0xF1, 0x8D, 0xC1, 0xA7, 0x07, 0xE6, // ........ + /* 0DE8 */ 0x7E, 0xF8, 0x9A, 0xF1, 0x33, 0xC3, 0xE3, 0x43, // ~...3..C + /* 0DF0 */ 0x88, 0x27, 0xE2, 0xDA, 0xA6, 0x20, 0x5B, 0x18, // .'... [. + /* 0DF8 */ 0x42, 0x09, 0xF4, 0xFF, 0x8F, 0x10, 0xE5, 0x6D, // B......m + /* 0E00 */ 0x20, 0xCA, 0x29, 0x44, 0x88, 0x12, 0xA4, 0xB1, // .)D.... + /* 0E08 */ 0xC9, 0x0B, 0x35, 0xCA, 0xD9, 0x45, 0x6E, 0x6D, // ..5..Enm + /* 0E10 */ 0xF6, 0x82, 0x0B, 0x14, 0x2A, 0x66, 0x9C, 0x28, // ....*f.( + /* 0E18 */ 0xEF, 0x10, 0xB1, 0xDA, 0x1F, 0x04, 0x91, 0xF4, // ........ + /* 0E20 */ 0x32, 0xD0, 0x71, 0xC9, 0x91, 0x0E, 0x7D, 0xE8, // 2.q...}. + /* 0E28 */ 0x61, 0xFB, 0x04, 0x8C, 0x3F, 0x48, 0xE2, 0xAE, // a...?H.. + /* 0E30 */ 0x2A, 0x3E, 0x28, 0xF8, 0x00, 0x80, 0x77, 0x09, // *>(...w. + /* 0E38 */ 0xA8, 0x5B, 0x9D, 0xC7, 0xED, 0xF3, 0x06, 0xF8, // .[...... + /* 0E40 */ 0xAF, 0x17, 0x58, 0x82, 0xF2, 0x07, 0x81, 0x1A, // ..X..... + /* 0E48 */ 0x99, 0xA1, 0x3D, 0xCC, 0xB7, 0x19, 0x43, 0xBE, // ..=...C. + /* 0E50 */ 0x07, 0x1C, 0x16, 0x3B, 0x27, 0xF9, 0xF0, 0x08, // ...;'... + /* 0E58 */ 0x1C, 0x8E, 0x01, 0x4F, 0x1B, 0xBE, 0x51, 0x7B, // ...O..Q{ + /* 0E60 */ 0xBE, 0x3E, 0x62, 0x01, 0x8E, 0xFE, 0xFF, 0x47, // .>b....G + /* 0E68 */ 0x2C, 0x30, 0x9D, 0xDF, 0x7D, 0x82, 0x01, 0xC7, // ,0..}... + /* 0E70 */ 0xCD, 0x82, 0x9F, 0x61, 0x00, 0x67, 0x40, 0xCF, // ...a.g@. + /* 0E78 */ 0x30, 0x60, 0x1F, 0x2A, 0x6E, 0x08, 0x5C, 0xEE, // 0`.*n.\. + /* 0E80 */ 0x8A, 0x28, 0x90, 0x05, 0xC2, 0xA0, 0x0E, 0xFD, // .(...... + /* 0E88 */ 0xE4, 0x08, 0x42, 0xCF, 0x9C, 0x70, 0x86, 0x72, // ..B..p.r + /* 0E90 */ 0xB2, 0xBD, 0x5F, 0x1D, 0xC8, 0x2D, 0xC2, 0x43, // .._..-.C + /* 0E98 */ 0x3D, 0x8B, 0xC7, 0x04, 0x76, 0xDA, 0x02, 0x36, // =...v..6 + /* 0EA0 */ 0xFF, 0xFF, 0xE3, 0x29, 0xB0, 0x98, 0xF7, 0xD3, // ...).... + /* 0EA8 */ 0x69, 0x84, 0x63, 0x03, 0xFB, 0x71, 0x0B, 0x38, // i.c..q.8 + /* 0EB0 */ 0x1D, 0xCC, 0xE0, 0xDC, 0x7F, 0xD8, 0x2D, 0x1A, // ......-. + /* 0EB8 */ 0x37, 0x34, 0xB0, 0x0D, 0xCC, 0x43, 0x03, 0x3E, // 74...C.> + /* 0EC0 */ 0x27, 0x47, 0x30, 0x9E, 0x98, 0xF8, 0x55, 0xE2, // 'G0...U. + /* 0EC8 */ 0xE1, 0x89, 0x1F, 0x43, 0xC0, 0xFA, 0xFF, 0x3F, // ...C...? + /* 0ED0 */ 0x99, 0x01, 0xF6, 0x84, 0x1E, 0xCB, 0x50, 0xD2, // ......P. + /* 0ED8 */ 0x4E, 0x66, 0x80, 0xC0, 0xFB, 0xD8, 0x3B, 0xC3, // Nf....;. + /* 0EE0 */ 0x4B, 0x83, 0xE7, 0x74, 0xD2, 0xCF, 0x62, 0x3E, // K..t..b> + /* 0EE8 */ 0x99, 0x19, 0x21, 0x0A, 0xBB, 0x8F, 0x19, 0xAD, // ..!..... + /* 0EF0 */ 0x37, 0x14, 0xCD, 0x3C, 0xE8, 0x3B, 0x99, 0x51, // 7..<.;.Q + /* 0EF8 */ 0x62, 0x46, 0x6A, 0x0E, 0x4C, 0x48, 0x11, 0x0F, // bFj.LH.. + /* 0F00 */ 0x27, 0x4A, 0x88, 0x60, 0xAF, 0x13, 0x6F, 0x67, // 'J.`..og + /* 0F08 */ 0x4F, 0x66, 0x4C, 0xD6, 0xC9, 0x0C, 0x24, 0xFF, // OfL...$. + /* 0F10 */ 0xFF, 0x93, 0x19, 0x98, 0x5C, 0x9F, 0xCC, 0x80, // ....\... + /* 0F18 */ 0xCA, 0x39, 0x0A, 0x7F, 0x32, 0x03, 0x78, 0x74, // .9..2.xt + /* 0F20 */ 0xC0, 0xC2, 0x9D, 0xCC, 0xC0, 0xF2, 0xFF, 0x3F, // .......? + /* 0F28 */ 0xC4, 0x00, 0xCE, 0xC7, 0x0A, 0x63, 0x0C, 0x3C, // .....c.< + /* 0F30 */ 0xDA, 0xC1, 0x0C, 0x15, 0xE6, 0x6C, 0x86, 0x0E, // .....l.. + /* 0F38 */ 0x72, 0x08, 0xA1, 0xC1, 0x0E, 0x21, 0x50, 0xE6, // r....!P. + /* 0F40 */ 0x72, 0xA0, 0xA7, 0xF0, 0x9A, 0xE0, 0x73, 0x14, // r.....s. + /* 0F48 */ 0xD8, 0x0F, 0x67, 0xC0, 0xE1, 0xD4, 0x80, 0x0F, // ..g..... + /* 0F50 */ 0x74, 0xE2, 0x42, 0x8F, 0xC2, 0x23, 0x0E, 0x58, // t.B..#.X + /* 0F58 */ 0xFD, 0xC0, 0xC8, 0xFF, 0xFF, 0x64, 0x06, 0x18, // .....d.. + /* 0F60 */ 0x78, 0x6A, 0xF8, 0x40, 0x82, 0x63, 0x31, 0xEA, // xj.@.c1. + /* 0F68 */ 0x1B, 0xC4, 0x21, 0xBE, 0x8D, 0xF8, 0xE8, 0xFE, // ..!..... + /* 0F70 */ 0x6A, 0xE2, 0x4B, 0x00, 0xE6, 0x42, 0xE2, 0xD3, // j.K..B.. + /* 0F78 */ 0x09, 0xB3, 0x70, 0x38, 0x03, 0x5A, 0x43, 0x60, // ..p8.ZC` + /* 0F80 */ 0x57, 0x26, 0xCF, 0x9C, 0x0F, 0xE1, 0x6C, 0x3C, // W&....l< + /* 0F88 */ 0x7A, 0xDC, 0xE9, 0x04, 0xDE, 0x38, 0x7C, 0x3A, // z....8|: + /* 0F90 */ 0x01, 0x5E, 0x07, 0x0C, 0xCC, 0x0C, 0xC2, 0x3F, // .^.....? + /* 0F98 */ 0x84, 0xB0, 0x21, 0x9C, 0xAA, 0xC7, 0x70, 0xEE, // ..!...p. + /* 0FA0 */ 0xAF, 0x38, 0x3E, 0x9D, 0x80, 0xF3, 0xFF, 0x7F, // .8>..... + /* 0FA8 */ 0x62, 0x03, 0x0C, 0x0A, 0x7E, 0x32, 0xF8, 0xB8, // b...~2.. + /* 0FB0 */ 0x46, 0x25, 0xC2, 0xA0, 0x8E, 0xE6, 0x80, 0x7B, // F%.....{ + /* 0FB8 */ 0x98, 0x27, 0x36, 0x26, 0x6F, 0xC5, 0x1A, 0x8B, // .'6&o... + /* 0FC0 */ 0x4F, 0x6C, 0x30, 0xFF, 0xFF, 0x27, 0x36, 0x80, // Ol0..'6. + /* 0FC8 */ 0xD1, 0x87, 0x20, 0xB0, 0xFD, 0xFF, 0x0F, 0x41, // .. ....A + /* 0FD0 */ 0x60, 0x1C, 0xA0, 0x0F, 0x41, 0x80, 0x9B, 0xD3, // `...A... + /* 0FD8 */ 0x09, 0xEE, 0xC4, 0x07, 0xB6, 0x63, 0x10, 0x60, // .....c.` + /* 0FE0 */ 0x6D, 0xE8, 0x3E, 0x06, 0x81, 0xF9, 0xFF, 0x3F, // m.>....? + /* 0FE8 */ 0x5A, 0x98, 0xA3, 0xE0, 0xC2, 0x8E, 0x7C, 0x28, // Z.....|( + /* 0FF0 */ 0x29, 0xA7, 0x3E, 0xB4, 0x0C, 0x20, 0x69, 0x38, // ).>.. i8 + /* 0FF8 */ 0xC9, 0x01, 0x9D, 0xD3, 0x3D, 0x70, 0x92, 0x75, // ....=p.u + /* 1000 */ 0xEA, 0x40, 0x8F, 0xC7, 0xA0, 0xAF, 0x1C, 0xBE, // .@...... + /* 1008 */ 0x12, 0xF0, 0x23, 0x07, 0x93, 0x00, 0xAA, 0x41, // ..#....A + /* 1010 */ 0xFA, 0xCC, 0x07, 0x9C, 0x8E, 0x1C, 0xE0, 0x38, // .......8 + /* 1018 */ 0x26, 0x05, 0xC6, 0xDE, 0x0E, 0xDE, 0x22, 0x3D, // &....."= + /* 1020 */ 0x89, 0xA7, 0xA1, 0xE3, 0x0C, 0x51, 0x38, 0x26, // .....Q8& + /* 1028 */ 0x39, 0x18, 0x44, 0x7A, 0x95, 0x62, 0x03, 0x7C, // 9.Dz.b.| + /* 1030 */ 0xAB, 0xF1, 0xD9, 0xC8, 0x07, 0x10, 0x78, 0xE3, // ......x. + /* 1038 */ 0xF6, 0xD8, 0x61, 0xFF, 0xFF, 0x0F, 0x75, 0xC0, // ..a...u. + /* 1040 */ 0x01, 0xE2, 0xA4, 0xF8, 0x21, 0xC3, 0x98, 0x67, // ....!..g + /* 1048 */ 0xC5, 0x0F, 0x75, 0x80, 0xF5, 0x18, 0x27, 0x3A, // ..u...': + /* 1050 */ 0x94, 0xF0, 0x43, 0x1D, 0x20, 0xE8, 0xFF, 0x7F, // ..C. ... + /* 1058 */ 0xA8, 0x03, 0x86, 0x38, 0x6F, 0x24, 0xD1, 0x1E, // ...8o$.. + /* 1060 */ 0xEA, 0x98, 0xE8, 0x43, 0x1D, 0x40, 0xC8, 0xFF, // ...C.@.. + /* 1068 */ 0xFF, 0xA1, 0x0E, 0x18, 0x9E, 0x87, 0x00, 0xAE, // ........ + /* 1070 */ 0x9C, 0xEF, 0xC0, 0x7C, 0x22, 0x02, 0xEF, 0xFF, // ...|"... + /* 1078 */ 0xFF, 0x7C, 0x07, 0xB8, 0x1B, 0x2D, 0xCC, 0x51, // .|...-.Q + /* 1080 */ 0x70, 0x41, 0xAF, 0x0E, 0x03, 0x51, 0x09, 0x30, // pA...Q.0 + /* 1088 */ 0x28, 0x02, 0xC7, 0x5F, 0x9B, 0x60, 0x1C, 0xEA, // (.._.`.. + /* 1090 */ 0x7C, 0x87, 0x3E, 0x2F, 0x78, 0xD8, 0x4F, 0x05, // |.>/x.O. + /* 1098 */ 0x9E, 0xC4, 0xA9, 0xFA, 0x5A, 0x70, 0x14, 0x4F, // ....Zp.O + /* 10A0 */ 0x00, 0x3E, 0xE1, 0x01, 0xFF, 0xA1, 0xC1, 0x9A, // .>...... + /* 10A8 */ 0x44, 0xF1, 0x43, 0x03, 0xF5, 0x11, 0xE4, 0xFF, // D.C..... + /* 10B0 */ 0x7F, 0x68, 0xC0, 0x28, 0xEA, 0xF9, 0x06, 0x7D, // .h.(...} + /* 10B8 */ 0xCC, 0xF2, 0xD9, 0x20, 0xE6, 0x0B, 0x48, 0x84, // ... ..H. + /* 10C0 */ 0x07, 0x10, 0x5F, 0x1F, 0xD8, 0x71, 0xD2, 0x67, // .._..q.g + /* 10C8 */ 0xA0, 0x40, 0x51, 0xDE, 0x37, 0xF8, 0x09, 0x07, // .@Q.7... + /* 10D0 */ 0x5C, 0x83, 0xF3, 0x09, 0x07, 0xBC, 0x87, 0x23, // \......# + /* 10D8 */ 0x1F, 0x4B, 0xC0, 0x77, 0xD0, 0x84, 0x73, 0x81, // .K.w..s. + /* 10E0 */ 0xF1, 0x8D, 0x8D, 0x9D, 0x06, 0xC0, 0x76, 0x00, // ......v. + /* 10E8 */ 0x06, 0xDF, 0x69, 0x00, 0x1C, 0xC7, 0x24, 0x7E, // ..i...$~ + /* 10F0 */ 0x3A, 0x04, 0x13, 0xCC, 0xC1, 0xBC, 0x34, 0xFB, // :.....4. + /* 10F8 */ 0xFF, 0xEF, 0xFD, 0x94, 0x43, 0xCF, 0x86, 0x80, // ....C... + /* 1100 */ 0x75, 0x49, 0x07, 0x43, 0x94, 0x88, 0xB3, 0x21, // uI.C...! + /* 1108 */ 0x20, 0xFD, 0xFF, 0x7F, 0x36, 0xC4, 0x20, 0xC4, // ...6. . + /* 1110 */ 0x09, 0xFC, 0x12, 0xD1, 0xDC, 0xD9, 0x90, 0xAE, // ........ + /* 1118 */ 0xD8, 0x67, 0x43, 0x80, 0xE1, 0xFF, 0xFF, 0x23, // .gC....# + /* 1120 */ 0x00, 0xF6, 0x7C, 0x04, 0x38, 0x3D, 0x64, 0x83, // ..|.8=d. + /* 1128 */ 0xE7, 0x14, 0x08, 0xE3, 0xE4, 0x03, 0x38, 0xFE, // ......8. + /* 1130 */ 0xFF, 0x8F, 0x15, 0xE6, 0x18, 0x78, 0xEA, 0x97, // .....x.. + /* 1138 */ 0x9B, 0x8F, 0x03, 0x54, 0xD4, 0x2B, 0xC2, 0x30, // ...T.+.0 + /* 1140 */ 0x94, 0xC5, 0x87, 0x05, 0x1F, 0x11, 0xF8, 0x61, // .......a + /* 1148 */ 0xC1, 0x23, 0xA8, 0x78, 0x9C, 0xF4, 0x74, 0xE3, // .#.x..t. + /* 1150 */ 0x33, 0x21, 0x3B, 0x24, 0x38, 0xFC, 0x20, 0xE9, // 3!;$8. . + /* 1158 */ 0x41, 0x13, 0x3C, 0xE7, 0x23, 0x78, 0xB7, 0x1E, // A.<.#x.. + /* 1160 */ 0x38, 0xA7, 0x02, 0xC0, 0x4D, 0xAE, 0x27, 0xA3, // 8...M.'. + /* 1168 */ 0x4E, 0x17, 0x0E, 0x70, 0x8E, 0x92, 0x8D, 0x63, // N..p...c + /* 1170 */ 0x08, 0xE5, 0x70, 0xCC, 0xB7, 0x87, 0xA6, 0xC9, // ..p..... + /* 1178 */ 0x4E, 0x56, 0x30, 0x63, 0x41, 0xEA, 0x24, 0xE0, // NV0cA.$. + /* 1180 */ 0x01, 0x38, 0x10, 0x8C, 0xB4, 0x93, 0x68, 0x34, // .8....h4 + /* 1188 */ 0x86, 0xB3, 0x5A, 0x18, 0xC1, 0x19, 0xC4, 0xC7, // ..Z..... + /* 1190 */ 0x11, 0xE7, 0x3A, 0x19, 0xA1, 0x3F, 0x07, 0x3E, // ..:..?.> + /* 1198 */ 0x15, 0x61, 0x82, 0xDC, 0x4B, 0xE8, 0xBC, 0x7D, // .a..K..} + /* 11A0 */ 0x37, 0xE0, 0x57, 0x61, 0x8F, 0xC5, 0xFF, 0x7F, // 7.Wa.... + /* 11A8 */ 0x60, 0xDF, 0x4E, 0xC0, 0x31, 0x17, 0xAB, 0x01, // `.N.1... + /* 11B0 */ 0x45, 0x0D, 0xC0, 0x68, 0x98, 0x53, 0xC0, 0x53, // E..h.S.S + /* 11B8 */ 0x09, 0xB8, 0x82, 0xCD, 0x0D, 0x7D, 0x61, 0xB1, // .....}a. + /* 11C0 */ 0xD6, 0xA9, 0xE8, 0x14, 0xF4, 0x3E, 0x70, 0x70, // .....>pp + /* 11C8 */ 0xC0, 0x63, 0xF6, 0x1E, 0x1C, 0x2C, 0x34, 0x0F, // .c...,4. + /* 11D0 */ 0x0E, 0x6C, 0xD9, 0x06, 0x87, 0x56, 0x72, 0x17, // .l...Vr. + /* 11D8 */ 0x21, 0x87, 0x0F, 0xFC, 0xEC, 0x80, 0x03, 0xA0, // !....... + /* 11E0 */ 0x67, 0x07, 0x0B, 0xC9, 0xB3, 0x03, 0x9B, 0xBE, // g....... + /* 11E8 */ 0xB3, 0x08, 0x28, 0x70, 0xFE, 0xFF, 0x11, 0xDE, // ..(p.... + /* 11F0 */ 0x3B, 0x7C, 0x6E, 0x79, 0xF6, 0x60, 0x63, 0x78, // ;|ny.`cx + /* 11F8 */ 0x74, 0x31, 0x9A, 0xD1, 0xB9, 0xA6, 0xDB, 0x04, // t1...... + /* 1200 */ 0x4A, 0xC5, 0x6D, 0x82, 0x82, 0xF8, 0x06, 0xE0, // J.m..... + /* 1208 */ 0x84, 0x34, 0xBA, 0x75, 0xE2, 0x66, 0x62, 0xFC, // .4.u.fb. + /* 1210 */ 0x47, 0x0C, 0x1F, 0x11, 0x0E, 0xE9, 0x6C, 0x4D, // G.....lM + /* 1218 */ 0x30, 0x0F, 0xA4, 0x9E, 0x81, 0xBE, 0xB3, 0xE1, // 0....... + /* 1220 */ 0x67, 0x1F, 0xF2, 0xC1, 0xC5, 0xD3, 0xF0, 0xF5, // g....... + /* 1228 */ 0x86, 0xDC, 0x3B, 0xE8, 0xB4, 0x7D, 0x66, 0xC0, // ..;..}f. + /* 1230 */ 0x1C, 0x74, 0x7D, 0x9D, 0x7A, 0x83, 0x27, 0x57, // .t}.z.'W + /* 1238 */ 0x09, 0xEA, 0xE1, 0x02, 0x42, 0x2F, 0x34, 0xBE, // ....B/4. + /* 1240 */ 0xDC, 0x25, 0x78, 0xE0, 0xF4, 0xE9, 0xEE, 0xBD, // .%x..... + /* 1248 */ 0x84, 0x9D, 0xF1, 0x12, 0xBC, 0xE0, 0x25, 0x98, // ......%. + /* 1250 */ 0x77, 0x10, 0xA8, 0x51, 0x79, 0x10, 0x98, 0xAB, // w..Qy... + /* 1258 */ 0x3C, 0xCB, 0x37, 0x06, 0x54, 0xB2, 0x8B, 0x16, // <.7.T... + /* 1260 */ 0x3D, 0xC3, 0xBC, 0xC3, 0xF8, 0x92, 0xE0, 0xEB, // =....... + /* 1268 */ 0x87, 0xCF, 0x2D, 0x5E, 0xC0, 0xEB, 0x16, 0x0C, // ..-^.... + /* 1270 */ 0x82, 0x67, 0xA0, 0x57, 0x17, 0xDF, 0xD9, 0x0D, // .g.W.... + /* 1278 */ 0xFC, 0x2A, 0xF0, 0x46, 0x13, 0x22, 0x98, 0x61, // .*.F.".a + /* 1280 */ 0x0F, 0xFF, 0xDD, 0xDD, 0xA8, 0xBE, 0xE9, 0x18, // ........ + /* 1288 */ 0xEB, 0x75, 0xC4, 0x23, 0xE5, 0xC7, 0x96, 0x03, // .u.#.... + /* 1290 */ 0x8A, 0xF4, 0xF2, 0xE6, 0x09, 0xF8, 0x2C, 0xE3, // ......,. + /* 1298 */ 0x53, 0xDD, 0x49, 0xF9, 0x7A, 0x68, 0xF4, 0x57, // S.I.zh.W + /* 12A0 */ 0x08, 0x1F, 0x7E, 0x8C, 0xEC, 0x73, 0x0E, 0x3B, // ..~..s.; + /* 12A8 */ 0xDF, 0xB1, 0x41, 0x71, 0xC4, 0x07, 0x86, 0x97, // ..Aq.... + /* 12B0 */ 0x1A, 0x4F, 0x85, 0x9D, 0xBB, 0x60, 0x1C, 0x1C, // .O...`.. + /* 12B8 */ 0xD8, 0xB1, 0x08, 0x73, 0x7C, 0x05, 0xD7, 0xC9, // ...s|... + /* 12C0 */ 0xE6, 0xFF, 0xFF, 0xE4, 0x00, 0x6E, 0x78, 0xCC, // .....nx. + /* 12C8 */ 0xC1, 0xD7, 0xE7, 0x0D, 0xDF, 0x0C, 0x3C, 0x2E, // ......<. + /* 12D0 */ 0x7E, 0xE4, 0xF0, 0x49, 0xE3, 0xA5, 0xD3, 0xD8, // ~..I.... + /* 12D8 */ 0xA7, 0xE9, 0xA3, 0xD1, 0xCB, 0x9B, 0x4F, 0x2F, // ......O/ + /* 12E0 */ 0x18, 0x58, 0x5F, 0x1A, 0x38, 0xAC, 0xD1, 0xC2, // .X_.8... + /* 12E8 */ 0x3E, 0x06, 0x9C, 0xB9, 0x2F, 0x44, 0xB8, 0xC3, // >.../D.. + /* 12F0 */ 0x23, 0x58, 0x00, 0xF1, 0xB7, 0x92, 0x47, 0x0E, // #X....G. + /* 12F8 */ 0x4F, 0xC0, 0x80, 0x4C, 0xD3, 0xBA, 0x74, 0x20, // O..L..t + /* 1300 */ 0xE2, 0xA7, 0x3C, 0x2B, 0x5F, 0x99, 0x2E, 0x43, // ..<+_..C + /* 1308 */ 0x0C, 0xE3, 0xA9, 0xF2, 0xF1, 0xC3, 0xB3, 0xF1, // ........ + /* 1310 */ 0x51, 0xC0, 0xC7, 0x28, 0xCF, 0xFC, 0x8C, 0x22, // Q..(..." + /* 1318 */ 0xBD, 0x32, 0x10, 0x50, 0x9D, 0x88, 0xB8, 0x42, // .2.P...B + /* 1320 */ 0x18, 0x89, 0xA1, 0xD1, 0x9D, 0x83, 0xC7, 0x1F, // ........ + /* 1328 */ 0x22, 0x05, 0x31, 0xA0, 0x6F, 0x2E, 0xC0, 0xF4, // ".1.o... + /* 1330 */ 0x4C, 0x04, 0x5C, 0xFE, 0xFF, 0x37, 0x17, 0x80, // L.\..7.. + /* 1338 */ 0xFF, 0xFF, 0xFF, 0x9B, 0x0B, 0xE0, 0xE6, 0xFE, // ........ + /* 1340 */ 0xE0, 0x9B, 0x0B, 0x70, 0x8D, 0xB4, 0x2A, 0x7A, // ...p..*z + /* 1348 */ 0x61, 0x77, 0x08, 0x18, 0xD4, 0x9D, 0x1D, 0x70, // aw.....p + /* 1350 */ 0x78, 0x2B, 0x78, 0x67, 0x87, 0xF5, 0xFF, 0xBF, // x+xg.... + /* 1358 */ 0xB3, 0xC3, 0xC3, 0x8C, 0x13, 0xE5, 0x85, 0x21, // .......! + /* 1360 */ 0xC6, 0x3B, 0x3B, 0x0B, 0xF0, 0x26, 0xD0, 0x51, // .;;..&.Q + /* 1368 */ 0xC6, 0x77, 0x76, 0x80, 0x1F, 0x67, 0xD8, 0x77, // .wv..g.w + /* 1370 */ 0x69, 0xF0, 0x5E, 0x75, 0x81, 0xF5, 0xFF, 0xFF, // i.^u.... + /* 1378 */ 0xAA, 0x0B, 0x3C, 0x04, 0xDF, 0xA7, 0x41, 0x3E, // ..<...A> + /* 1380 */ 0x5E, 0x30, 0x8C, 0x83, 0x2B, 0x27, 0xA1, 0xC7, // ^0..+'.. + /* 1388 */ 0x02, 0x6B, 0x85, 0x41, 0xDD, 0xA9, 0xC1, 0xA5, // .k.A.... + /* 1390 */ 0x09, 0x5C, 0x17, 0x5F, 0x1F, 0x6A, 0x7C, 0xA4, // .\._.j|. + /* 1398 */ 0xC5, 0x9F, 0x2F, 0x70, 0x01, 0x86, 0x4C, 0x4F, // ../p..LO + /* 13A0 */ 0x65, 0x30, 0xAE, 0x29, 0x3E, 0x95, 0x61, 0xEE, // e0.)>.a. + /* 13A8 */ 0x0E, 0x1E, 0x90, 0x8F, 0x18, 0xC0, 0x67, 0x15, // ......g. + /* 13B0 */ 0x1E, 0x18, 0xEE, 0xB4, 0xE0, 0x9B, 0x92, 0x41, // .......A + /* 13B8 */ 0xCF, 0x31, 0xA8, 0x8F, 0x3C, 0x27, 0xEF, 0x7B, // .1..<'.{ + /* 13C0 */ 0xC2, 0xE3, 0x84, 0xA3, 0x9E, 0x83, 0xE8, 0xD8, // ........ + /* 13C8 */ 0xC0, 0x71, 0xDC, 0xC0, 0xFD, 0xFF, 0xC7, 0x06, // .q...... + /* 13D0 */ 0xEF, 0x70, 0x83, 0x3B, 0xE8, 0xF8, 0x62, 0x70, // .p.;..bp + /* 13D8 */ 0x5C, 0x18, 0xB8, 0xE7, 0x02, 0x0F, 0xC3, 0x37, // \......7 + /* 13E0 */ 0x1D, 0x8F, 0x08, 0x33, 0xFE, 0xD7, 0x3F, 0x23, // ...3..?# + /* 13E8 */ 0x04, 0xC4, 0x5F, 0x8C, 0xD8, 0x80, 0xC1, 0x78, // .._....x + /* 13F0 */ 0x6B, 0xF3, 0xF5, 0x0D, 0x37, 0x60, 0x5F, 0x1D, // k...7`_. + /* 13F8 */ 0x7C, 0xC1, 0xF0, 0x09, 0xCC, 0xE8, 0x2F, 0x30, // |...../0 + /* 1400 */ 0x4F, 0x62, 0x3E, 0x36, 0x90, 0x0B, 0x1C, 0x1D, // Ob>6.... + /* 1408 */ 0x30, 0x38, 0x00, 0x3D, 0x60, 0xF8, 0x87, 0x8B, // 08.=`... + /* 1410 */ 0x77, 0x39, 0x30, 0x5C, 0x05, 0x7D, 0x5C, 0xF0, // w90\.}\. + /* 1418 */ 0xB1, 0xC7, 0x8A, 0xEE, 0x72, 0xE8, 0x9B, 0x9C, // ....r... + /* 1420 */ 0x61, 0xE2, 0x18, 0xE2, 0x0D, 0x8C, 0xDD, 0x25, // a......% + /* 1428 */ 0xC8, 0x61, 0x0E, 0xEA, 0x5D, 0xC2, 0x73, 0xE0, // .a..].s. + /* 1430 */ 0x67, 0x0B, 0x9F, 0xE0, 0x7C, 0xF3, 0x09, 0x71, // g...|..q + /* 1438 */ 0xAA, 0x8F, 0x56, 0xEF, 0x01, 0x3E, 0x7A, 0xBC, // ..V..>z. + /* 1440 */ 0x77, 0xF9, 0xEC, 0xC4, 0x2E, 0x02, 0x3E, 0x72, // w.....>r + /* 1448 */ 0x19, 0xC7, 0xD3, 0xF4, 0x15, 0xD0, 0x43, 0x36, // ......C6 + /* 1450 */ 0xD8, 0xAB, 0x86, 0x4F, 0x60, 0x3E, 0xBA, 0xE1, // ...O`>.. + /* 1458 */ 0x8E, 0x51, 0x9E, 0x89, 0xA7, 0xEF, 0x3B, 0x08, // .Q....;. + /* 1460 */ 0x3B, 0x92, 0x1C, 0x75, 0xA8, 0x6B, 0x7A, 0x44, // ;..u.kzD + /* 1468 */ 0xF9, 0xFF, 0x9F, 0xD0, 0x81, 0xF8, 0xD6, 0x06, // ........ + /* 1470 */ 0xCE, 0x68, 0xF7, 0x0F, 0xF4, 0x36, 0x3D, 0x32, // .h...6=2 + /* 1478 */ 0xCC, 0xD1, 0x00, 0xD6, 0x25, 0x04, 0x5C, 0x77, // ....%.\w + /* 1480 */ 0x0C, 0x5F, 0x42, 0x80, 0x4F, 0xD0, 0x4B, 0x04, // ._B.O.K. + /* 1488 */ 0xFA, 0x9A, 0xE1, 0xD1, 0x3D, 0x02, 0x60, 0xAE, // ....=.`. + /* 1490 */ 0x18, 0xEC, 0x58, 0xE0, 0xC3, 0x86, 0xAF, 0x01, // ..X..... + /* 1498 */ 0xEC, 0x5E, 0xE0, 0x30, 0xF7, 0x08, 0x50, 0x81, // .^.0..P. + /* 14A0 */ 0x7A, 0x78, 0xF0, 0xD5, 0xDE, 0x23, 0x40, 0x71, // zx...#@q + /* 14A8 */ 0xB2, 0xF4, 0xA1, 0xC1, 0x03, 0xB5, 0xAA, 0x33, // .......3 + /* 14B0 */ 0x26, 0x94, 0x23, 0x26, 0x3F, 0x9B, 0xF9, 0x26, // &.#&?..& + /* 14B8 */ 0x81, 0xB9, 0x5D, 0xFA, 0x26, 0x01, 0x37, 0xCF, // ..].&.7. + /* 14C0 */ 0x2C, 0x50, 0x49, 0x20, 0xF4, 0xFF, 0xBF, 0x49, // ,PI ...I + /* 14C8 */ 0xC0, 0x85, 0xE9, 0xF2, 0x32, 0x43, 0xE7, 0x7F, // ....2C.. + /* 14D0 */ 0xE0, 0xBE, 0xD5, 0x79, 0x84, 0x3E, 0x44, 0x30, // ...y.>D0 + /* 14D8 */ 0x94, 0xF7, 0x3C, 0x9F, 0xC2, 0xF8, 0x19, 0xC2, // ..<..... + /* 14E0 */ 0x07, 0x4C, 0x76, 0xA6, 0xE0, 0x67, 0x4D, 0xDC, // .Lv..gM. + /* 14E8 */ 0x1D, 0xC0, 0x28, 0x6F, 0x9E, 0x9E, 0x00, 0x3B, // ..(o...; + /* 14F0 */ 0x7F, 0x1A, 0xF9, 0xDD, 0xE0, 0x5D, 0xC0, 0xD3, // .....].. + /* 14F8 */ 0xF7, 0xBD, 0x88, 0x9F, 0x28, 0xC0, 0x17, 0xEC, // ....(... + /* 1500 */ 0x4E, 0x07, 0x05, 0xFA, 0x84, 0x3C, 0x22, 0xA3, // N....<". + /* 1508 */ 0xFA, 0x88, 0xC0, 0x2F, 0x49, 0x60, 0x3C, 0x92, // .../I`<. + /* 1510 */ 0xF8, 0x40, 0x01, 0x84, 0xEE, 0x05, 0xA8, 0xD3, // .@...... + /* 1518 */ 0x07, 0x47, 0x3D, 0xE3, 0x17, 0x54, 0x63, 0xBE, // .G=..Tc. + /* 1520 */ 0x5B, 0x3D, 0xC2, 0x79, 0x72, 0x98, 0xCB, 0x01, // [=.yr... + /* 1528 */ 0x8B, 0x73, 0x4D, 0x02, 0xD5, 0x71, 0x97, 0x8F, // .sM..q.. + /* 1530 */ 0x0E, 0xEE, 0xB5, 0x15, 0xFB, 0xFF, 0x27, 0x38, // ......'8 + /* 1538 */ 0xB8, 0x77, 0x96, 0x77, 0x3E, 0x43, 0x79, 0x90, // .w.w>Cy. + /* 1540 */ 0xE0, 0xBB, 0xB6, 0x82, 0xE3, 0xAA, 0x06, 0xE3, // ........ + /* 1548 */ 0xD8, 0xC2, 0x2F, 0x79, 0x80, 0x9D, 0x61, 0x71, // ../y..aq + /* 1550 */ 0xC1, 0x7F, 0x0F, 0x03, 0x51, 0x89, 0x30, 0x28, // ....Q.0( + /* 1558 */ 0x02, 0xCB, 0xBB, 0xB7, 0x52, 0xF8, 0x43, 0x06, // ....R.C. + /* 1560 */ 0xE3, 0x4D, 0x81, 0x4F, 0x1A, 0x3B, 0x6A, 0xE0, // .M.O.;j. + /* 1568 */ 0xFB, 0xFF, 0x1F, 0x35, 0xD8, 0x86, 0x8A, 0xBB, // ...5.... + /* 1570 */ 0x29, 0x82, 0x75, 0xAA, 0x98, 0x21, 0xF0, 0x60, // ).u..!.` + /* 1578 */ 0x0F, 0x00, 0x9F, 0xAF, 0x7C, 0x06, 0x50, 0x14, // ....|.P. + /* 1580 */ 0x18, 0xD4, 0xA1, 0x1D, 0xCE, 0x6D, 0x18, 0x70, // .....m.p + /* 1588 */ 0x30, 0x62, 0xDC, 0xA5, 0x10, 0xEE, 0x94, 0xDF, // 0b...... + /* 1590 */ 0x51, 0x62, 0x3F, 0x97, 0xB3, 0xE9, 0xE2, 0xAE, // Qb?..... + /* 1598 */ 0xE6, 0x3E, 0x9D, 0xB0, 0x0B, 0x32, 0x8C, 0xB3, // .>...2.. + /* 15A0 */ 0xC0, 0x23, 0xC0, 0xAB, 0x39, 0xBF, 0x20, 0x3F, // .#..9. ? + /* 15A8 */ 0x17, 0xBF, 0x10, 0x3C, 0x26, 0x85, 0x78, 0x53, // ...<&.xS + /* 15B0 */ 0x7A, 0x25, 0x36, 0xC6, 0x93, 0x71, 0x73, 0xB7, // z%6..qs. + /* 15B8 */ 0x62, 0x72, 0xDE, 0x79, 0x41, 0x36, 0xC6, 0xD1, // br.yA6.. + /* 15C0 */ 0x44, 0x8C, 0x72, 0x6E, 0x0F, 0x03, 0x91, 0x5F, // D.rn..._ + /* 15C8 */ 0x90, 0x7D, 0x3F, 0x79, 0x21, 0x88, 0x18, 0xCD, // .}?y!... + /* 15D0 */ 0x10, 0x41, 0x9F, 0x97, 0x8D, 0x15, 0x28, 0xDE, // .A....(. + /* 15D8 */ 0x0B, 0x32, 0x13, 0xF8, 0x56, 0xD0, 0xC1, 0xC5, // .2..V... + /* 15E0 */ 0x17, 0x64, 0xEC, 0xFF, 0xFF, 0x82, 0x0C, 0x30, // .d.....0 + /* 15E8 */ 0xE2, 0x64, 0x04, 0xF8, 0x3C, 0x71, 0xE0, 0xCE, // .d.. 0x11111111) +Warning 3144 - ^ Method Local is set but never used (Local2) + +grammar2.asl 1798: Local3 = (0xFFFFFFFF >= 0x11111111) +Warning 3144 - ^ Method Local is set but never used (Local3) + +grammar2.asl 1800: Local4 = (0xFFFFFFFF < 0x11111111) +Warning 3144 - ^ Method Local is set but never used (Local4) + +grammar2.asl 1802: Local5 = (0xFFFFFFFF <= 0x11111111) +Warning 3144 - ^ Method Local is set but never used (Local5) + +grammar2.asl 1827: Method (COND, 0, NotSerialized) +Warning 3115 - ^ Not all control paths return a value (COND) + +grammar2.asl 1937: Local5 = RefOf (MAIN) +Warning 3144 - ^ Method Local is set but never used (Local5) + +grammar2.asl 1999: Device (IFEL) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 2165: Device (NOSV) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 2604: Device (IDXF) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 2633: Local0 = IFE0 /* \IDXF.IFE0 */ +Warning 3144 - ^ Method Local is set but never used (Local0) + +grammar2.asl 2634: Local1 = IFE1 /* \IDXF.IFE1 */ +Warning 3144 - ^ Method Local is set but never used (Local1) + +grammar2.asl 2635: Local2 = IFE2 /* \IDXF.IFE2 */ +Warning 3144 - ^ Method Local is set but never used (Local2) + +grammar2.asl 2651: Device (NSTL) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 2681: Device (RTBF) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 2786: Device (GPE2) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 2801: Device (PRW2) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 2855: Device (PRW1) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 2936: Local0 = Arg0 +Warning 3144 - ^ Method Local is set but never used (Local0) + +grammar2.asl 2939: Device (RTLV) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 3052: Name (_CRS, 0x00) // _CRS: Current Resource Settings +Error 6105 - ^ Invalid object type for reserved name (_CRS: found Integer, Buffer required) + +grammar2.asl 3159: Device (RETP) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 3199: Device (WHLR) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 3255: Device (ANDO) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 3543: Device (BRKP) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 3581: Device (ADSU) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 3706: Device (INDC) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 3835: Device (LOPS) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 4269: Device (FDSO) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 4484: Device (MLDV) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 4664: Device (NBIT) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 4955: Device (SHFT) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 5194: Device (XORD) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 5571: Device (CRBF) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 5674: Device (IDX4) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 6604: Device (EVNT) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 6867: Device (SZLV) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 6952: Device (BYTF) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 6963: Device (C005) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 6967: Device (C013) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 7039: Name (_HID, "*PNP0A06") // _HID: Hardware ID +Error 6061 - Invalid leading asterisk ^ (*PNP0A06) + +grammar2.asl 7231: Name (C18C, Package (0x02) +Remark 2063 - ^ Initializer list shorter than declared package length + +grammar2.asl 7264: Device (C19B) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 7276: Divide (Local1, 0x0A, Local0, Local2) /* Local0 = Local1 / 10 */ +Warning 3144 - Method Local is set but never used ^ (Local0) + +grammar2.asl 7321: Device (DWDF) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 7345: Method (MKW, 2, NotSerialized) +Remark 2146 - ^ Method Argument is never used (Arg0) + +grammar2.asl 7345: Method (MKW, 2, NotSerialized) +Remark 2146 - ^ Method Argument is never used (Arg1) + +grammar2.asl 7354: Device (DVAX) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 7394: Device (IDX6) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 7420: Device (TST) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 7441: Local0 = IFE0 /* \IDX6.IFE0 */ +Warning 3144 - ^ Method Local is set but never used (Local0) + +grammar2.asl 7442: Local1 = IFE1 /* \IDX6.IFE1 */ +Warning 3144 - ^ Method Local is set but never used (Local1) + +grammar2.asl 7443: Local2 = IFE2 /* \IDX6.IFE2 */ +Warning 3144 - ^ Method Local is set but never used (Local2) + +grammar2.asl 7446: Local3 = \IDX6.IFE0 +Warning 3144 - ^ Method Local is set but never used (Local3) + +grammar2.asl 7447: Local4 = \IDX6.IFE1 +Warning 3144 - ^ Method Local is set but never used (Local4) + +grammar2.asl 7450: Local5 = \IDX6.TST.IFE0 +Warning 3144 - ^ Method Local is set but never used (Local5) + +grammar2.asl 7451: Local6 = \IDX6.TST.IFE1 +Warning 3144 - ^ Method Local is set but never used (Local6) + +grammar2.asl 7463: Device (IDX5) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 7852: Device (BITI) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 7960: Local0 &= 0x01 /* Local0 &= 1 */ +Error 6066 - ^ Method local variable is not initialized (Local0) + +grammar2.asl 8123: Name (_HID, "*PNP0C0A") /* Control Method Battey ID */ // _HID: Hardware ID +Error 6061 - Invalid leading asterisk ^ (*PNP0C0A) + +grammar2.asl 8133: Device (IDX3) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 8314: Device (IDX7) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 9020: Device (MTCH) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 9099: CreateDWordField (TMD0, 0x04, DMA0) +Remark 2089 - Object is not referenced ^ (Name [DMA0] is within a method [TEST]) + +grammar2.asl 9100: CreateDWordField (TMD0, 0x08, PIO1) +Remark 2089 - Object is not referenced ^ (Name [PIO1] is within a method [TEST]) + +grammar2.asl 9101: CreateDWordField (TMD0, 0x0C, DMA1) +Remark 2089 - Object is not referenced ^ (Name [DMA1] is within a method [TEST]) + +grammar2.asl 9102: CreateDWordField (TMD0, 0x10, CHNF) +Remark 2089 - Object is not referenced ^ (Name [CHNF] is within a method [TEST]) + +grammar2.asl 9295: Device (WHLB) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 9673: Device (IDX2) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 10054: Device (SIZO) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 10103: Name (PKG2, Package (0x04) +Remark 2063 - ^ Initializer list shorter than declared package length + +grammar2.asl 10489: Local0 = _OS /* \_OS_ */ +Warning 3144 - ^ Method Local is set but never used (Local0) + +grammar2.asl 10621: Device (MBIT) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 10632: Device (MWRD) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 10640: Device (MBYT) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 10714: Device (SMIS) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + +grammar2.asl 10780: Device (CNDT) +Warning 3141 - Missing dependency ^ (Device object requires a _HID or _ADR in same scope) + + +Intel ACPI Component Architecture +ASL+ Optimizing Compiler/Disassembler version 20180508 +Copyright (c) 2000 - 2018 Intel Corporation + +Ignoring all errors, forcing AML file generation + +ASL Input: grammar2.asl - 11654 lines, 378020 bytes, 4899 keywords +AML Output: grammar2.aml - 43758 bytes, 670 named objects, 4229 executable opcodes + +Compilation complete. 6 Errors, 86 Warnings, 27 Remarks, 1109 Optimizations diff --git a/tests/grammar2/runtest.sh b/tests/grammar2/runtest.sh new file mode 100755 index 0000000..8b6a52d --- /dev/null +++ b/tests/grammar2/runtest.sh @@ -0,0 +1,35 @@ +#!/bin/bash +# +# run the misc tests: we need to do this in a script since +# these are expected to fail which would normally cause %check +# to stop. however, this is expected behavior. we are running +# iasl precisely because we expect it to stop when presented with +# faulty ASL. +# +# this script assumes it is in the source 'tests' directory at +# start. +# + +PWD=$(pwd) +BINDIR="/usr/bin" +VERSION=$($BINDIR/iasl -v | grep Optimizing | cut -d" " -f5) + +# create file to compare against +pushd ./grammar2 > /dev/null +sed -e "s/VVVVVVVV/$VERSION/" \ + grammar2.asl.result > grammar2.asl.expected + +# see if grammar2.asl failed as expected +# NB: the -f option is required so we can see all of the errors +$BINDIR/iasl -f -of grammar2.asl > grammar2.asl.actual 2>&1 +diff grammar2.asl.actual grammar2.asl.expected >/dev/null 2>&1 +RET=$? +popd > /dev/null + +if [ $RET -eq 0 ] +then + echo PASS grammar2 +else + echo FAIL grammar2 +fi +exit $RET diff --git a/tests/test_badcode.yml b/tests/test_badcode.yml new file mode 100644 index 0000000..96663e9 --- /dev/null +++ b/tests/test_badcode.yml @@ -0,0 +1,28 @@ +- hosts: localhost + vars: + - artifacts: ./artifacts + tags: + - classic + remote_user: root + tasks: + - name: badcode + block: + - name: run the badcode test + shell: exec > /tmp/badcode.test.log 2>&1 && ./badcode/runtest.sh + + always: + - name: pull out logs + fetch: + dest: "{{ artifacts }}/" + src: "/tmp/badcode.test.log" + flat: yes + - name: pull out expected + fetch: + dest: "{{ artifacts }}/" + src: "./badcode/badcode.asl.expected" + flat: yes + - name: pull out actual + fetch: + dest: "{{ artifacts }}/" + src: "./badcode/badcode.asl.actual" + flat: yes diff --git a/tests/test_converterSample.yml b/tests/test_converterSample.yml new file mode 100644 index 0000000..c4b0036 --- /dev/null +++ b/tests/test_converterSample.yml @@ -0,0 +1,28 @@ +- hosts: localhost + vars: + - artifacts: ./artifacts + tags: + - classic + remote_user: root + tasks: + - name: converterSample + block: + - name: run the converterSample test + shell: exec > /tmp/converterSample.test.log 2>&1 && ./converterSample/runtest.sh + + always: + - name: pull out logs + fetch: + dest: "{{ artifacts }}/" + src: "/tmp/converterSample.test.log" + flat: yes + - name: pull out expected + fetch: + dest: "{{ artifacts }}/" + src: "./converterSample/converterSample.asl.expected" + flat: yes + - name: pull out actual + fetch: + dest: "{{ artifacts }}/" + src: "./converterSample/converterSample.asl.actual" + flat: yes diff --git a/tests/test_grammar.yml b/tests/test_grammar.yml new file mode 100644 index 0000000..3c149fc --- /dev/null +++ b/tests/test_grammar.yml @@ -0,0 +1,28 @@ +- hosts: localhost + vars: + - artifacts: ./artifacts + tags: + - classic + remote_user: root + tasks: + - name: grammar + block: + - name: run the grammar test + shell: exec > /tmp/grammar.test.log 2>&1 && ./grammar/runtest.sh + + always: + - name: pull out logs + fetch: + dest: "{{ artifacts }}/" + src: "/tmp/grammar.test.log" + flat: yes + - name: pull out expected + fetch: + dest: "{{ artifacts }}/" + src: "./grammar/grammar.asl.expected" + flat: yes + - name: pull out actual + fetch: + dest: "{{ artifacts }}/" + src: "./grammar/grammar.asl.actual" + flat: yes diff --git a/tests/test_grammar2.yml b/tests/test_grammar2.yml new file mode 100644 index 0000000..7d76f0a --- /dev/null +++ b/tests/test_grammar2.yml @@ -0,0 +1,28 @@ +- hosts: localhost + vars: + - artifacts: ./artifacts + tags: + - classic + remote_user: root + tasks: + - name: grammar2 + block: + - name: run the grammar2 test + shell: exec > /tmp/grammar2.test.log 2>&1 && ./grammar2/runtest.sh + + always: + - name: pull out logs + fetch: + dest: "{{ artifacts }}/" + src: "/tmp/grammar2.test.log" + flat: yes + - name: pull out expected + fetch: + dest: "{{ artifacts }}/" + src: "./grammar2/grammar2.asl.expected" + flat: yes + - name: pull out actual + fetch: + dest: "{{ artifacts }}/" + src: "./grammar2/grammar2.asl.actual" + flat: yes diff --git a/tests/tests.yml b/tests/tests.yml new file mode 100644 index 0000000..4a92e7c --- /dev/null +++ b/tests/tests.yml @@ -0,0 +1,4 @@ +- import_playbook: test_badcode.yml +- import_playbook: test_grammar.yml +- import_playbook: test_grammar2.yml +- import_playbook: test_converterSample.yml