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