XenOn/kolibrios-fun
1
1
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Wiki Activity
88b9ca48fa
kolibrios-fun/drivers/devman/acpica/tests/misc/grammar.asl
Sergey Semyonov (Serge) 0f1313efde acpica library 
git-svn-id: svn://kolibrios.org@1498 a494cfbc-eb01-0410-851d-a64ba20cac60
2010-06-18 14:39:07 +00:00

10267 lines
314 KiB
Plaintext
Raw Blame History

/*
* 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
View Git Blame Copy Permalink