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