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