11653 lines
369 KiB
Plaintext
11653 lines
369 KiB
Plaintext
/*
|
|
* Intel ACPI Component Architecture
|
|
* AML/ASL+ Disassembler version 20180313 (32-bit version)
|
|
* Copyright (c) 2000 - 2018 Intel Corporation
|
|
*
|
|
* Disassembling to symbolic ASL+ operators
|
|
*
|
|
* Disassembly of grammar.xxx, Thu Mar 22 09:44:49 2018
|
|
*
|
|
* Original Table Header:
|
|
* Signature "DSDT"
|
|
* Length 0x0002192B (137515)
|
|
* Revision 0x01 **** 32-bit table (V1), no 64-bit math support
|
|
* Checksum 0x2C **** Incorrect checksum, should be 0x5D
|
|
* OEM ID "Intel"
|
|
* OEM Table ID "GRMTEST"
|
|
* OEM Revision 0x20090511 (537462033)
|
|
* Compiler ID "INTL"
|
|
* Compiler Version 0x20180313 (538444563)
|
|
*/
|
|
/*
|
|
* Some or all of this work - Copyright (c) 2006 - 2018, Intel Corp.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* Neither the name of Intel Corporation nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
/* */
|
|
/* */
|
|
/* Grammar.asl - Minimally excercises most ASL constructs */
|
|
/* */
|
|
/* NOTE -- use: iasl -f -of grammar.asl to compile */
|
|
/* */
|
|
/* This 1) Ignores errors (checks compiler error handling) */
|
|
/* 2) Disables constant folding */
|
|
/* */
|
|
/* */
|
|
/*******************************************************************************
|
|
Compilation should look like this:
|
|
C:\acpica\tests\misc>iasl -f -of grammar.asl
|
|
Intel ACPI Component Architecture
|
|
ASL Optimizing Compiler version 20090422 [Apr 22 2009]
|
|
Copyright (C) 2000 - 2009 Intel Corporation
|
|
Supports ACPI Specification Revision 3.0a
|
|
grammar.asl 187: Name (_NPK, Package (8)
|
|
Warning 1098 - ^ Unknown reserved name (_NPK)
|
|
grammar.asl 510: NAME (ESC1, "abcdefg\x00hijklmn")
|
|
Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
|
|
grammar.asl 511: NAME (ESC2, "abcdefg\000hijklmn")
|
|
Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
|
|
grammar.asl 601: Method (RCIV, 1)
|
|
Warning 1087 - ^ Not all control paths return a value (RCIV)
|
|
grammar.asl 608: RCIV (Subtract (Arg0, 1))
|
|
Remark 5073 - ^ Recursive method call (RCIV)
|
|
grammar.asl 937: Method (_ERR, 2)
|
|
Warning 1077 - ^ Reserved method has too few arguments (_ERR requires 3)
|
|
grammar.asl 1377: Store (0x1234567887654321, QWD2)
|
|
Warning 1032 - ^ 64-bit integer in 32-bit table, truncating
|
|
grammar.asl 1379: if (LNotEqual (Local0, 0x1234567887654321))
|
|
Warning 1032 - 64-bit integer in 32-bit table, truncating ^
|
|
grammar.asl 1459: SizeOf (BUFO)
|
|
Warning 1105 - ^ Result is not used, operator has no effect
|
|
grammar.asl 1485: Acquire (MTX2, 1)
|
|
Warning 1104 - ^ Possible operator timeout is ignored
|
|
grammar.asl 1633: Add (Local0, Local1)
|
|
Warning 1105 - ^ Result is not used, operator has no effect
|
|
grammar.asl 1804: Method (COND)
|
|
Warning 1087 - ^ Not all control paths return a value (COND)
|
|
grammar.asl 6010: Name (_HID, "*PNP0A06")
|
|
Error 4001 - ^ String must be entirely alphanumeric (*PNP0A06)
|
|
grammar.asl 6461: Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})
|
|
Warning 1038 - Invalid or unknown escape sequence ^
|
|
grammar.asl 6800: And (Local0, 1, Local0) // Local0 &= 1
|
|
Error 4050 - ^ Method local variable is not initialized (Local0)
|
|
grammar.asl 6886: Name (_HID, "*PNP0C0A") // Control Method Battey ID
|
|
Error 4001 - ^ String must be entirely alphanumeric (*PNP0C0A)
|
|
ASL Input: grammar.asl - 10254 lines, 322162 bytes, 4810 keywords
|
|
AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes
|
|
Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations
|
|
***************************************************************************************************/
|
|
DefinitionBlock ("", "DSDT", 1, "Intel", "GRMTEST", 0x20090511)
|
|
{
|
|
External (\ABCD, UnknownObj)
|
|
/* Device with _STA and _INI */
|
|
|
|
Device (A1)
|
|
{
|
|
Method (_STA, 0, NotSerialized) // _STA: Status
|
|
{
|
|
Return (0x0F)
|
|
}
|
|
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize
|
|
{
|
|
Return (Zero)
|
|
}
|
|
}
|
|
|
|
/* Device with no _STA, has _INI */
|
|
|
|
Device (A2)
|
|
{
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize
|
|
{
|
|
Return (Zero)
|
|
}
|
|
}
|
|
|
|
/* Device with _STA, no _INI */
|
|
|
|
Device (A3)
|
|
{
|
|
Method (_STA, 0, NotSerialized) // _STA: Status
|
|
{
|
|
Return (0x0F)
|
|
}
|
|
}
|
|
|
|
/* Device with _STA and _INI, but not present */
|
|
|
|
Device (A4)
|
|
{
|
|
Method (_STA, 0, NotSerialized) // _STA: Status
|
|
{
|
|
Return (Zero)
|
|
}
|
|
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize
|
|
{
|
|
Return (Zero)
|
|
}
|
|
}
|
|
|
|
/* Resource descriptors */
|
|
|
|
Device (IRES)
|
|
{
|
|
Name (PRT0, ResourceTemplate ()
|
|
{
|
|
IRQ (Edge, ActiveHigh, Exclusive, )
|
|
{3,4,5,6,7,9,10,11,14,15}
|
|
StartDependentFn (0x01, 0x01)
|
|
{
|
|
IRQNoFlags ()
|
|
{0,1,2}
|
|
}
|
|
EndDependentFn ()
|
|
})
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
|
|
{
|
|
Debug = "_CRS:"
|
|
Debug = PRT0 /* \IRES.PRT0 */
|
|
Return (PRT0) /* \IRES.PRT0 */
|
|
}
|
|
|
|
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
|
|
{
|
|
Debug = "_SRS:"
|
|
Debug = Arg0
|
|
Return (Zero)
|
|
}
|
|
}
|
|
|
|
Name (_NPK, Package (0x04)
|
|
{
|
|
0x1111,
|
|
0x2222,
|
|
0x3333,
|
|
0x4444
|
|
})
|
|
Device (RES)
|
|
{
|
|
Name (_PRT, Package (0x04) // _PRT: PCI Routing Table
|
|
{
|
|
Package (0x04)
|
|
{
|
|
0x0002FFFF,
|
|
Zero,
|
|
Zero,
|
|
Zero
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0002FFFF,
|
|
One,
|
|
Zero,
|
|
Zero
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x000AFFFF,
|
|
Zero,
|
|
Zero,
|
|
Zero
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x000BFFFF,
|
|
Zero,
|
|
Zero,
|
|
Zero
|
|
}
|
|
})
|
|
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
|
|
{
|
|
Name (PRT0, ResourceTemplate ()
|
|
{
|
|
WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
|
|
0x0000, // Granularity
|
|
0xFFF2, // Range Minimum
|
|
0xFFF3, // Range Maximum
|
|
0x0032, // Translation Offset
|
|
0x0002, // Length
|
|
,, _Y00)
|
|
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
|
|
0x0000, // Granularity
|
|
0x0000, // Range Minimum
|
|
0x00FF, // Range Maximum
|
|
0x0000, // Translation Offset
|
|
0x0100, // Length
|
|
,, )
|
|
WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
|
|
0x0000, // Granularity
|
|
0xA000, // Range Minimum
|
|
0xBFFF, // Range Maximum
|
|
0x0000, // Translation Offset
|
|
0x2000, // Length
|
|
,, )
|
|
IO (Decode16,
|
|
0x0CF8, // Range Minimum
|
|
0x0CFF, // Range Maximum
|
|
0x01, // Alignment
|
|
0x08, // Length
|
|
)
|
|
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
|
|
0x0000, // Granularity
|
|
0x0000, // Range Minimum
|
|
0x0CF7, // Range Maximum
|
|
0x0000, // Translation Offset
|
|
0x0CF8, // Length
|
|
,, , TypeStatic, DenseTranslation)
|
|
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
|
|
0x0000, // Granularity
|
|
0x0D00, // Range Minimum
|
|
0xFFFF, // Range Maximum
|
|
0x0000, // Translation Offset
|
|
0xF300, // Length
|
|
,, , TypeStatic, DenseTranslation)
|
|
DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
|
|
0x00000000, // Granularity
|
|
0x00000000, // Range Minimum
|
|
0x00000CF7, // Range Maximum
|
|
0x00000000, // Translation Offset
|
|
0x00000CF8, // Length
|
|
,, , TypeStatic, DenseTranslation)
|
|
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
|
|
0x00000000, // Granularity
|
|
0x000C8000, // Range Minimum
|
|
0x000EFFFF, // Range Maximum
|
|
0x00000000, // Translation Offset
|
|
0x00028000, // Length
|
|
,, , AddressRangeMemory, TypeStatic)
|
|
DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
|
|
0x00000000, // Granularity
|
|
0x000C8000, // Range Minimum
|
|
0x000EFFFF, // Range Maximum
|
|
0x00000000, // Translation Offset
|
|
0x00028000, // Length
|
|
,, )
|
|
QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
|
|
0x0000000000000000, // Granularity
|
|
0x0000000000000000, // Range Minimum
|
|
0x0000000000000CF7, // Range Maximum
|
|
0x0000000000000000, // Translation Offset
|
|
0x0000000000000CF8, // Length
|
|
0x44, "This is a ResouceSource string", , TypeStatic, DenseTranslation)
|
|
QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
|
|
0x0000000000000000, // Granularity
|
|
0x0000000000000000, // Range Minimum
|
|
0x0000000000000CF7, // Range Maximum
|
|
0x0000000000000000, // Translation Offset
|
|
0x0000000000000CF8, // Length
|
|
,, , TypeStatic, DenseTranslation)
|
|
QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
|
|
0x0000000000000000, // Granularity
|
|
0x0000000000100000, // Range Minimum
|
|
0x00000000FFDFFFFF, // Range Maximum
|
|
0x0000000000000000, // Translation Offset
|
|
0x00000000FFD00000, // Length
|
|
,, , AddressRangeMemory, TypeStatic)
|
|
QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
|
|
0x0000000000000000, // Granularity
|
|
0x0000000000000000, // Range Minimum
|
|
0x0000000000000CF7, // Range Maximum
|
|
0x0000000000000000, // Translation Offset
|
|
0x0000000000000CF8, // Length
|
|
,, )
|
|
ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
|
|
0x0000000000000000, // Granularity
|
|
0x0000000000000000, // Range Minimum
|
|
0x0000000000000CF7, // Range Maximum
|
|
0x0000000000000000, // Translation Offset
|
|
0x0000000000000CF8, // Length
|
|
0x0000000000000000, // Type-Specific Attributes
|
|
, TypeStatic, DenseTranslation)
|
|
ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
|
|
0x0000000000000000, // Granularity
|
|
0x0000000000100000, // Range Minimum
|
|
0x00000000FFDFFFFF, // Range Maximum
|
|
0x0000000000000000, // Translation Offset
|
|
0x00000000FFD00000, // Length
|
|
0x0000000000000000, // Type-Specific Attributes
|
|
, AddressRangeMemory, TypeStatic)
|
|
ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,
|
|
0x0000000000000000, // Granularity
|
|
0x0000000000100000, // Range Minimum
|
|
0x00000000FFDFFFFF, // Range Maximum
|
|
0x0000000000000000, // Translation Offset
|
|
0x00000000FFD00000, // Length
|
|
0x0000000000000000, // Type-Specific Attributes
|
|
)
|
|
IO (Decode16,
|
|
0x0010, // Range Minimum
|
|
0x0020, // Range Maximum
|
|
0x01, // Alignment
|
|
0x10, // Length
|
|
)
|
|
IO (Decode16,
|
|
0x0090, // Range Minimum
|
|
0x00A0, // Range Maximum
|
|
0x01, // Alignment
|
|
0x10, // Length
|
|
)
|
|
FixedIO (
|
|
0x0061, // Address
|
|
0x01, // Length
|
|
)
|
|
IRQNoFlags ()
|
|
{2}
|
|
DMA (Compatibility, BusMaster, Transfer8_16, )
|
|
{4}
|
|
DMA (Compatibility, BusMaster, Transfer8, )
|
|
{2,5,7}
|
|
Memory32Fixed (ReadWrite,
|
|
0x00100000, // Address Base
|
|
0x00000000, // Address Length
|
|
)
|
|
Memory32Fixed (ReadOnly,
|
|
0xFFFE0000, // Address Base
|
|
0x00020000, // Address Length
|
|
)
|
|
Memory32 (ReadOnly,
|
|
0x00020000, // Range Minimum
|
|
0xFFFE0000, // Range Maximum
|
|
0x00000004, // Alignment
|
|
0x00000200, // Length
|
|
)
|
|
Memory24 (ReadOnly,
|
|
0x1111, // Range Minimum
|
|
0x2222, // Range Maximum
|
|
0x0004, // Alignment
|
|
0x0200, // Length
|
|
)
|
|
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0x0E, "\\_SB_.TEST", )
|
|
{
|
|
0x00000E01,
|
|
}
|
|
Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x06, "xxxx", )
|
|
{
|
|
0x00000601,
|
|
0x00000003,
|
|
0x00000002,
|
|
0x00000001,
|
|
}
|
|
Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive, ,, )
|
|
{
|
|
0xFFFF0000,
|
|
0x00000003,
|
|
0x00000002,
|
|
0x00000001,
|
|
0x00000005,
|
|
0x00000007,
|
|
0x00000009,
|
|
}
|
|
VendorShort () // Length = 0x03
|
|
{
|
|
0x01, 0x02, 0x03 // ...
|
|
}
|
|
VendorLong () // Length = 0x09
|
|
{
|
|
/* 0000 */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // ........
|
|
/* 0008 */ 0x09 // .
|
|
}
|
|
Register (SystemIO,
|
|
0x08, // Bit Width
|
|
0x00, // Bit Offset
|
|
0x00000000000000B2, // Address
|
|
,_Y01)
|
|
Register (SystemMemory,
|
|
0x08, // Bit Width
|
|
0x00, // Bit Offset
|
|
0x00000000000000B2, // Address
|
|
,)
|
|
StartDependentFnNoPri ()
|
|
{
|
|
IRQNoFlags ()
|
|
{0,1,2}
|
|
IRQ (Level, ActiveLow, Shared, )
|
|
{3,4,5,6,7,9,10,11,14,15}
|
|
}
|
|
EndDependentFn ()
|
|
})
|
|
CreateWordField (PRT0, \RES._CRS._Y00._MIN, BMIN) // _MIN: Minimum Base Address
|
|
CreateByteField (PRT0, \RES._CRS._Y01._ASZ, RSIZ) // _ASZ: Access Size
|
|
BMIN = 0x03
|
|
Return (PRT0) /* \RES_._CRS.PRT0 */
|
|
}
|
|
|
|
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings
|
|
{
|
|
Name (BUF0, ResourceTemplate ()
|
|
{
|
|
StartDependentFn (0x01, 0x02)
|
|
{
|
|
IO (Decode16,
|
|
0x03D8, // Range Minimum
|
|
0x03F8, // Range Maximum
|
|
0x01, // Alignment
|
|
0x08, // Length
|
|
)
|
|
IRQNoFlags ()
|
|
{4}
|
|
}
|
|
StartDependentFn (0x02, 0x01)
|
|
{
|
|
IO (Decode16,
|
|
0x03D8, // Range Minimum
|
|
0x03E8, // Range Maximum
|
|
0x01, // Alignment
|
|
0x08, // Length
|
|
)
|
|
IRQNoFlags ()
|
|
{4}
|
|
}
|
|
StartDependentFn (0x00, 0x02)
|
|
{
|
|
IO (Decode16,
|
|
0x02E8, // Range Minimum
|
|
0x02F8, // Range Maximum
|
|
0x01, // Alignment
|
|
0x08, // Length
|
|
)
|
|
IRQNoFlags ()
|
|
{3}
|
|
}
|
|
StartDependentFn (0x00, 0x02)
|
|
{
|
|
IO (Decode16,
|
|
0x02D8, // Range Minimum
|
|
0x02E8, // Range Maximum
|
|
0x01, // Alignment
|
|
0x08, // Length
|
|
)
|
|
IRQNoFlags ()
|
|
{3}
|
|
}
|
|
StartDependentFn (0x02, 0x00)
|
|
{
|
|
IO (Decode16,
|
|
0x0100, // Range Minimum
|
|
0x03F8, // Range Maximum
|
|
0x08, // Alignment
|
|
0x08, // Length
|
|
)
|
|
IRQNoFlags ()
|
|
{1,3,4,5,6,7,8,10,11,12,13,14,15}
|
|
}
|
|
EndDependentFn ()
|
|
})
|
|
Return (BUF0) /* \RES_._PRS.BUF0 */
|
|
}
|
|
|
|
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings
|
|
{
|
|
Return (Zero)
|
|
}
|
|
}
|
|
|
|
Name (\_S0, Package (0x04) // _S0_: S0 System State
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x00,
|
|
0x00
|
|
})
|
|
Name (\_S3, Package (0x04) // _S3_: S3 System State
|
|
{
|
|
0x05,
|
|
0x05,
|
|
0x00,
|
|
0x00
|
|
})
|
|
Name (\_S4, Package (0x04) // _S4_: S4 System State
|
|
{
|
|
0x06,
|
|
0x06,
|
|
0x00,
|
|
0x00
|
|
})
|
|
Name (\_S5, Package (0x04) // _S5_: S5 System State
|
|
{
|
|
0x07,
|
|
0x07,
|
|
0x00,
|
|
0x00
|
|
})
|
|
/* Examine this table header (DSDT) */
|
|
/*
|
|
DataTableRegion (HDR, "DSDT", "", "")
|
|
Field (HDR, AnyAcc, NoLock, Preserve)
|
|
{
|
|
SIG, 32,
|
|
LENG, 32,
|
|
REV, 8,
|
|
SUM, 8,
|
|
OID, 48,
|
|
OTID, 64,
|
|
OREV, 32,
|
|
CID, 32,
|
|
CREV, 32
|
|
}
|
|
Method (SIZE)
|
|
{
|
|
If (LLess (REV, 2))
|
|
{
|
|
Store ("32-bit table", Debug)
|
|
}
|
|
else
|
|
{
|
|
Store ("64-bit table", Debug)
|
|
}
|
|
Return (0)
|
|
}
|
|
*/
|
|
Name (SIZE, 0x00)
|
|
/* Custom operation region */
|
|
|
|
OperationRegion (MYOP, 0x80, 0xFD60, 0x06)
|
|
Field (MYOP, ByteAcc, NoLock, Preserve)
|
|
{
|
|
MFLD, 8
|
|
}
|
|
|
|
Method (TCOP, 0, Serialized)
|
|
{
|
|
Name (_STR, Unicode ("test")) // _STR: Description String
|
|
MFLD = 0x04
|
|
Local0 = MFLD /* \MFLD */
|
|
}
|
|
|
|
Name (ERRS, 0x00)
|
|
/* Warning should be issued for premature string termination */
|
|
|
|
Name (ESC1, "abcdefghijklmn")
|
|
Name (ESC2, "abcdefghijklmn")
|
|
Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\x1A")
|
|
Name (CRSA, ResourceTemplate ()
|
|
{
|
|
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
|
|
0x0000, // Granularity
|
|
0x0019, // Range Minimum
|
|
0x001D, // Range Maximum
|
|
0x0000, // Translation Offset
|
|
0x0005, // Length
|
|
,, )
|
|
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, NonISAOnlyRanges,
|
|
0x0000, // Granularity
|
|
0xC000, // Range Minimum
|
|
0xCFFF, // Range Maximum
|
|
0x0000, // Translation Offset
|
|
0x1000, // Length
|
|
,, , TypeStatic, DenseTranslation)
|
|
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
|
|
0x00000000, // Granularity
|
|
0xD8000000, // Range Minimum
|
|
0xDBFFFFFF, // Range Maximum
|
|
0x00000000, // Translation Offset
|
|
0x04000000, // Length
|
|
,, , AddressRangeMemory, TypeStatic)
|
|
})
|
|
Name (CRSB, ResourceTemplate ()
|
|
{
|
|
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
|
|
0x00000000, // Granularity
|
|
0xD8000000, // Range Minimum
|
|
0xDBFFFFFF, // Range Maximum
|
|
0x00000000, // Translation Offset
|
|
0x04000000, // Length
|
|
,, , AddressRangeMemory, TypeStatic)
|
|
})
|
|
Name (CRSC, ResourceTemplate ()
|
|
{
|
|
VendorShort () // Length = 0x03
|
|
{
|
|
0x01, 0x02, 0x03 // ...
|
|
}
|
|
})
|
|
Name (CRSD, ResourceTemplate ()
|
|
{
|
|
VendorLong () // Length = 0x09
|
|
{
|
|
/* 0000 */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // ........
|
|
/* 0008 */ 0x09 // .
|
|
}
|
|
})
|
|
Name (CRSE, ResourceTemplate ()
|
|
{
|
|
IRQNoFlags ()
|
|
{3,4,10,11}
|
|
IRQNoFlags ()
|
|
{3,4,10,11}
|
|
})
|
|
Name (CRSR, Buffer ((SizeOf (CRSA) + SizeOf (CRSB))){})
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
|
|
{
|
|
Return (CRSR) /* \CRSR */
|
|
}
|
|
|
|
/* */
|
|
/* Unnamed scope */
|
|
/* */
|
|
Scope (\)
|
|
{
|
|
Name (BXXX, 0xFFFFFFFF)
|
|
}
|
|
|
|
Name (LANS, 0x00)
|
|
PowerResource (LANP, 0x01, 0x0000)
|
|
{
|
|
Method (_STA, 0, NotSerialized) // _STA: Status
|
|
{
|
|
If (((LANS & 0x30) == 0x30))
|
|
{
|
|
Return (One)
|
|
}
|
|
Else
|
|
{
|
|
Return (Zero)
|
|
}
|
|
}
|
|
|
|
Method (_ON, 0, NotSerialized) // _ON_: Power On
|
|
{
|
|
If (!_STA ())
|
|
{
|
|
LANS = 0x30
|
|
}
|
|
}
|
|
|
|
Method (_OFF, 0, NotSerialized) // _OFF: Power Off
|
|
{
|
|
If (_STA ())
|
|
{
|
|
LANS = 0x00
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Can a method define another method? */
|
|
/**********************************
|
|
Method (TASK, 2, SERIALIZED)
|
|
{
|
|
Sleep (100)
|
|
Method (TAS2)
|
|
{
|
|
Sleep (100)
|
|
}
|
|
TAS2()
|
|
Return
|
|
}
|
|
************************************/
|
|
/* A recursive method */
|
|
Method (RCIV, 1, NotSerialized)
|
|
{
|
|
Debug = Arg0
|
|
If ((Arg0 == 0x00))
|
|
{
|
|
Return (Zero)
|
|
}
|
|
|
|
RCIV ((Arg0 - 0x01))
|
|
}
|
|
|
|
Method (RTOP, 0, NotSerialized)
|
|
{
|
|
RCIV (0x64)
|
|
}
|
|
|
|
Scope (\_PR)
|
|
{
|
|
Processor (CPU0, 0x00, 0xFFFFFFFF, 0x00){}
|
|
}
|
|
|
|
Name (B1TP, 0xFFFFFFFF)
|
|
Name (B2TP, 0xFFFFFFFF)
|
|
Name (ADPS, 0xFFFFFFFF)
|
|
Name (B1PS, 0xFFFFFFFF)
|
|
Name (B1RS, 0xFFFFFFFF)
|
|
Name (B1CS, 0xFFFFFFFF)
|
|
Name (B2PS, 0xFFFFFFFF)
|
|
Name (B2RS, 0xFFFFFFFF)
|
|
Name (B2CS, 0xFFFFFFFF)
|
|
Name (B1DC, 0x0BB8)
|
|
Name (B2DC, 0x0A28)
|
|
Name (B1LF, 0x0BB8)
|
|
Name (B2LF, 0x0A28)
|
|
Name (BPIF, 0x00)
|
|
Name (PBLL, 0x00)
|
|
Name (RBIF, Package (0x0D)
|
|
{
|
|
0x01,
|
|
0x0898,
|
|
0x0898,
|
|
0x01,
|
|
0x2A30,
|
|
0x00,
|
|
0x00,
|
|
0x01,
|
|
0x01,
|
|
"CA54200-5003/5",
|
|
"1",
|
|
"LION",
|
|
"Fujitsu"
|
|
})
|
|
Method (SMWE, 4, NotSerialized)
|
|
{
|
|
Return (Ones)
|
|
}
|
|
|
|
Method (SMRE, 4, NotSerialized)
|
|
{
|
|
Return (Ones)
|
|
}
|
|
|
|
/*
|
|
Method(RDBT,0,Serialized){
|
|
If(LNot(SMWE(0x09,0x15,1,1))){
|
|
Store(0x18,Local2)
|
|
}
|
|
}
|
|
*/
|
|
Scope (_SB)
|
|
{
|
|
Name (SBUF, Buffer (0x80){})
|
|
CreateBitField (SBUF, 0x03, BITY)
|
|
CreateByteField (SBUF, 0x01, BYTY)
|
|
CreateWordField (SBUF, 0x02, WRDZ)
|
|
CreateDWordField (SBUF, 0x04, DWDZ)
|
|
CreateQWordField (SBUF, 0x08, QWDZ)
|
|
CreateField (SBUF, 0x80, 0x0C, FLDZ)
|
|
CreateField (SBUF, 0x94, 0x60, FLDY)
|
|
CreateField (SBUF, 0x94, 0x60, \_SB.FLDW)
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize
|
|
{
|
|
CreateField (\_SB.SBUF, 0x94, 0x60, FLDV)
|
|
}
|
|
|
|
Device (PCI0)
|
|
{
|
|
Name (_HID, EisaId ("PNP0A03") /* PCI Bus */) // _HID: Hardware ID
|
|
Name (_ADR, 0x00) // _ADR: Address
|
|
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings
|
|
{
|
|
Name (PRT0, ResourceTemplate ()/* PRT0 */ /*Minimum bus number suported under this bridge. */
|
|
{
|
|
WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
|
|
0x0000, // Granularity
|
|
0xFFF1, // Range Minimum
|
|
0xFFF2, // Range Maximum
|
|
0x0032, // Translation Offset
|
|
0x0002, // Length
|
|
,, _Y02)
|
|
})
|
|
CreateWordField (PRT0, \_SB.PCI0._CRS._Y02._MIN, BMIN) // _MIN: Minimum Base Address
|
|
BMIN = 0x03
|
|
Return (PRT0) /* \_SB_.PCI0._CRS.PRT0 */
|
|
} /* _CRS */
|
|
|
|
Method (_SRS, 0, NotSerialized) // _SRS: Set Resource Settings
|
|
{
|
|
Return (Zero)
|
|
}
|
|
|
|
Device (EIO)
|
|
{
|
|
OperationRegion (FJIO, SystemIO, 0xFD60, 0x06)
|
|
Field (FJIO, ByteAcc, NoLock, Preserve)
|
|
{
|
|
GIDX, 8,
|
|
GDTA, 8,
|
|
PIDX, 8,
|
|
PDTA, 8,
|
|
SIDX, 8,
|
|
SDTA, 8
|
|
}
|
|
|
|
IndexField (GIDX, GDTA, ByteAcc, NoLock, Preserve)
|
|
{
|
|
Offset (0x02),
|
|
, 5,
|
|
VGAS, 2,
|
|
Offset (0x04),
|
|
, 4,
|
|
DCKE, 1,
|
|
Offset (0x05),
|
|
, 6,
|
|
ACPW, 1,
|
|
Offset (0x0A),
|
|
B1P, 1,
|
|
B2P, 1,
|
|
B1C, 1,
|
|
B2C, 1,
|
|
B1ER, 1,
|
|
B2ER, 1,
|
|
Offset (0x0B),
|
|
B1CP, 8,
|
|
B2CP, 8,
|
|
BCP, 8,
|
|
B1VH, 8,
|
|
B1VL, 8,
|
|
B2VH, 8,
|
|
B2VL, 8,
|
|
B1TM, 8,
|
|
B2TM, 8,
|
|
B1CH, 8,
|
|
B1CL, 8,
|
|
B2CH, 8,
|
|
B2CL, 8
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Method (RDBT, 3, Serialized)
|
|
{
|
|
Local1 = 0x1FFF
|
|
If (Arg0)
|
|
{
|
|
Local1 = 0x2FFF
|
|
}
|
|
|
|
Local2 = 0x18
|
|
If (Arg1)
|
|
{
|
|
Local2 = 0x10
|
|
}
|
|
|
|
If (!SMRE (0x09, 0x15, 0x01, RefOf (Local0)))
|
|
{
|
|
If (!SMWE (0x08, 0x14, 0x01, Local1))
|
|
{
|
|
If (!SMRE (0x09, 0x17, Local2, RefOf (Local3)))
|
|
{
|
|
Arg2 = Local1
|
|
}
|
|
}
|
|
|
|
Local0 |= 0x0FFF
|
|
SMWE (0x08, 0x14, 0x01, Local0)
|
|
}
|
|
}
|
|
|
|
Method (MKWD, 2, NotSerialized)
|
|
{
|
|
If ((Arg1 & 0x80))
|
|
{
|
|
Local0 = (0xFFFF0000 | Arg0)
|
|
Local0 |= (Arg1 << 0x08)
|
|
Local0 = (Zero - Local0)
|
|
}
|
|
Else
|
|
{
|
|
Local0 = Arg0
|
|
Local0 |= (Arg1 << 0x08)
|
|
}
|
|
|
|
Return (Local0)
|
|
}
|
|
|
|
Device (CMB1)
|
|
{
|
|
Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID
|
|
Name (_UID, 0x01) // _UID: Unique ID
|
|
Alias (\_SB.PCI0.EIO.B1P, \_SB.PCI0.XXXX)
|
|
Alias (\_SB.PCI0.EIO.B1P, B1P)
|
|
Alias (\_SB.PCI0.EIO.B1C, B1C)
|
|
Alias (\_SB.PCI0.EIO.B1CH, B1CH)
|
|
Alias (\_SB.PCI0.EIO.B1CL, B1CL)
|
|
Alias (\_SB.PCI0.EIO.B1VH, B1VH)
|
|
Alias (\_SB.PCI0.EIO.B1VL, B1VL)
|
|
Alias (\_SB.PCI0.EIO.B1CP, B1CP)
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize
|
|
{
|
|
B1PS = B1P /* \CMB1.B1P_ */
|
|
B1RS = B1CP /* \CMB1.B1CP */
|
|
B1CS = B1C /* \CMB1.B1C_ */
|
|
}
|
|
|
|
Method (_BIF, 0, NotSerialized) // _BIF: Battery Information
|
|
{
|
|
RDBT (Zero, Zero, RefOf (B1DC))
|
|
RDBT (Zero, One, RefOf (B1LF))
|
|
RBIF [0x01] = B1DC /* \B1DC */
|
|
RBIF [0x02] = B1LF /* \B1LF */
|
|
RBIF [0x09] = "CA54200-5003/5"
|
|
RBIF [0x0A] = "1"
|
|
Return (RBIF) /* \RBIF */
|
|
}
|
|
|
|
Method (_BST, 0, Serialized) // _BST: Battery Status
|
|
{
|
|
_INI ()
|
|
Local0 = Zero
|
|
If ((B1P && !B1C))
|
|
{
|
|
Local0 |= 0x01
|
|
}
|
|
|
|
If ((B1P && B1C))
|
|
{
|
|
Local0 |= 0x02
|
|
}
|
|
|
|
If ((B1CP <= 0x01))
|
|
{
|
|
Local0 |= 0x04
|
|
}
|
|
|
|
Local1 = MKWD (B1CL, B1CH)
|
|
Store ((((B1CP * B1LF) + 0x63) / 0x64), Local2)
|
|
Local3 = MKWD (B1VL, B1VH)
|
|
Name (STAT, Package (0x04){})
|
|
STAT [0x00] = Local0
|
|
STAT [0x01] = Local1
|
|
STAT [0x02] = Local2
|
|
STAT [0x03] = Local3
|
|
If (!BPIF)
|
|
{
|
|
/* \_SB.PCI0.EIO.EC0.IECT() */
|
|
/* \_SB.PCI0.EIO.EC0.SECT() */
|
|
BPIF = One
|
|
}
|
|
|
|
Return (STAT) /* \CMB1._BST.STAT */
|
|
}
|
|
}
|
|
|
|
Device (DEV1)
|
|
{
|
|
}
|
|
|
|
Scope (\_TZ)
|
|
{
|
|
ThermalZone (TZ1)
|
|
{
|
|
Name (_PSL, Package (0x01) // _PSL: Passive List
|
|
{
|
|
\_PR.CPU0
|
|
})
|
|
}
|
|
}
|
|
|
|
Method (TZ2, 0, Serialized)
|
|
{
|
|
Name (_PSL, Package (0x01) // _PSL: Passive List
|
|
{
|
|
\_PR.CPU0
|
|
})
|
|
Return (_PSL) /* \TZ2_._PSL */
|
|
}
|
|
|
|
ThermalZone (THM1)
|
|
{
|
|
}
|
|
|
|
Method (NOTI, 0, NotSerialized)
|
|
{
|
|
Notify (\DEV1, 0x00) // Bus Check
|
|
Notify (\THM1, 0x00) // Bus Check
|
|
Notify (\_PR.CPU0, 0x00) // Bus Check
|
|
}
|
|
|
|
Method (_ERR, 3, NotSerialized)
|
|
{
|
|
ERRS++
|
|
Debug = "Run-time exception:"
|
|
Debug = Arg0
|
|
Debug = Arg1
|
|
Return (0x00) /* Map error to AE_OK */
|
|
}
|
|
|
|
Method (DIV0, 0, NotSerialized)
|
|
{
|
|
Local0 = 0x01
|
|
Local1 = 0x00
|
|
Divide (Local0, Local1, Local3)
|
|
Debug = "DIV0 - noabort"
|
|
}
|
|
|
|
Method (ERR, 2, NotSerialized)
|
|
{
|
|
Local0 = ToDecimalString (Arg1)
|
|
If ((Arg0 == 0x00))
|
|
{
|
|
Debug = Concatenate (Concatenate ("+*+*+*+* MTHD_ERROR at line ", Local0), ": Results not equal!")
|
|
}
|
|
|
|
If ((Arg0 == 0x01))
|
|
{
|
|
Debug = Concatenate (Concatenate ("+*+*+*+* MTHD_ERROR at line ", Local0), ": Numeric result is incorrect!")
|
|
}
|
|
|
|
If ((Arg0 == 0x02))
|
|
{
|
|
Debug = Concatenate (Concatenate ("+*+*+*+* MTHD_ERROR at line ", Local0), ": Operand was clobbered!")
|
|
}
|
|
|
|
Notify (DEV1, Arg0)
|
|
ERRS++
|
|
}
|
|
|
|
Method (R226, 2, NotSerialized)
|
|
{
|
|
}
|
|
|
|
Method (R225, 2, NotSerialized)
|
|
{
|
|
R226 (Arg0, Arg1)
|
|
}
|
|
|
|
Method (R224, 2, NotSerialized)
|
|
{
|
|
R225 (Arg1, Arg0)
|
|
}
|
|
|
|
Method (R223, 2, NotSerialized)
|
|
{
|
|
R224 (Arg0, Arg1)
|
|
}
|
|
|
|
Method (R222, 2, NotSerialized)
|
|
{
|
|
R223 (Arg1, Arg0)
|
|
}
|
|
|
|
Method (R111, 0, NotSerialized)
|
|
{
|
|
Local0 = 0x01010101
|
|
R222 (0xABAB, Local0)
|
|
Local1 = Local0
|
|
}
|
|
|
|
Method (MAIN, 0, NotSerialized)
|
|
{
|
|
/* SIZE() */
|
|
|
|
Local0 = NUM1 ()
|
|
\CMB1._BST ()
|
|
RDBT (0x01, 0x02, 0x03)
|
|
OBJ1 (0x01)
|
|
OBJ2 (0x02)
|
|
CHEK ()
|
|
RETZ ()
|
|
BITZ ()
|
|
LOGS ()
|
|
REFS ()
|
|
COND ()
|
|
TZ2 ()
|
|
/* */
|
|
/* iPCO tests added */
|
|
/* */
|
|
Local0 = \IFEL.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x040D)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \NOSV.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0414)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \IDXF.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x041B)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \_SB.NSTL.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0422)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \RTBF.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0429)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \_SB.RTLV.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0430)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \_SB.RETP.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0437)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \WHLR.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x043E)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \ANDO.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0445)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \BRKP.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x044C)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \ADSU.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0453)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \INDC.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x045A)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \LOPS.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0461)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \FDSO.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0468)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \MLDV.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x046F)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \NBIT.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0476)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \SHFT.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x047D)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \XORD.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0484)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \CRBF.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x048B)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \IDX4.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0492)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \EVNT.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x0499)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \SZLV.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04A0)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \_SB.BYTF.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04A7)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \DWDF.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04AE)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \DVAX.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04B5)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \IDX6.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04BC)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \IDX5.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04C3)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \_SB.IDX0.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04CA)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \_SB.IDX3.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04D1)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \IDX7.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04D8)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \MTCH.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04DF)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \WHLB.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04E6)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \_SB.IDX2.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04ED)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \SIZO.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04F4)
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = \_SB.SMIS.TEST ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
ERR (0x01, 0x04FB)
|
|
Return (Local0)
|
|
}
|
|
|
|
If ((ERRS > 0x00))
|
|
{
|
|
Debug = "****** There were errors during the execution of the test ******"
|
|
}
|
|
|
|
/* Flush all notifies */
|
|
|
|
Sleep (0xFA)
|
|
/* */
|
|
/* Last Test */
|
|
/* */
|
|
Return (0x00) /* Success */
|
|
}
|
|
|
|
Method (OBJ1, 1, Serialized)
|
|
{
|
|
Local0 = 0x03
|
|
Name (BUFR, Buffer (Local0){})
|
|
Name (BUF1, Buffer (0x04)
|
|
{
|
|
0x01, 0x02, 0x03, 0x04 // ....
|
|
})
|
|
Name (BUF2, Buffer (0x04){})
|
|
BUF2 = BUF1 /* \OBJ1.BUF1 */
|
|
Mutex (MTX1, 0x04)
|
|
Alias (MTX1, MTX2)
|
|
}
|
|
|
|
Mutex (MTXT, 0x00)
|
|
Mutex (MTXX, 0x00)
|
|
/*
|
|
* Field Creation
|
|
*/
|
|
Method (FLDS, 0, Serialized)
|
|
{
|
|
Debug = "++++++++ Creating BufferFields"
|
|
Name (BUF2, Buffer (0x80){})
|
|
CreateBitField (BUF2, 0x03, BIT2)
|
|
CreateByteField (BUF2, 0x01, BYT2)
|
|
CreateWordField (BUF2, 0x02, WRD2)
|
|
CreateDWordField (BUF2, 0x04, DWD2)
|
|
CreateQWordField (BUF2, 0x08, QWD2)
|
|
CreateField (BUF2, 0x80, 0x0C, FLD2)
|
|
CreateField (BUF2, 0x94, 0x60, FLD3)
|
|
BIT2 = 0x01
|
|
Local0 = BIT2 /* \FLDS.BIT2 */
|
|
If ((Local0 != 0x01))
|
|
{
|
|
ERR (0x01, 0x0537)
|
|
}
|
|
Else
|
|
{
|
|
Local0 = DerefOf (BUF2 [0x00])
|
|
If ((Local0 != 0x08))
|
|
{
|
|
ERR (0x01, 0x053E)
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ Bit BufferField I/O PASS"
|
|
}
|
|
}
|
|
|
|
BYT2 = 0x1A
|
|
Local0 = BYT2 /* \FLDS.BYT2 */
|
|
If ((Local0 != 0x1A))
|
|
{
|
|
ERR (0x01, 0x054A)
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ Byte BufferField I/O PASS"
|
|
}
|
|
|
|
WRD2 = 0x1234
|
|
Local0 = WRD2 /* \FLDS.WRD2 */
|
|
If ((Local0 != 0x1234))
|
|
{
|
|
ERR (0x01, 0x0555)
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ Word BufferField I/O PASS"
|
|
}
|
|
|
|
FLD2 = 0x0123
|
|
Local0 = FLD2 /* \FLDS.FLD2 */
|
|
If ((Local0 != 0x0123))
|
|
{
|
|
ERR (0x01, 0x0560)
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ 12-bit BufferField I/O PASS"
|
|
}
|
|
|
|
DWD2 = 0x12345678
|
|
Local0 = DWD2 /* \FLDS.DWD2 */
|
|
If ((Local0 != 0x12345678))
|
|
{
|
|
ERR (0x01, 0x056B)
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ Dword BufferField I/O PASS"
|
|
}
|
|
|
|
QWD2 = 0x1234567887654321
|
|
Local0 = QWD2 /* \FLDS.QWD2 */
|
|
If ((Local0 != 0x1234567887654321))
|
|
{
|
|
ERR (0x01, 0x0576)
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ Qword BufferField I/O PASS"
|
|
}
|
|
}
|
|
|
|
/* Field execution */
|
|
|
|
Method (FLDX, 0, Serialized)
|
|
{
|
|
Field (\_SB.MEM.SMEM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
/* Field: SMEM overlay using 32-bit field elements */
|
|
|
|
SMD0, /* 32-bits */ 32,
|
|
SMD1, /* 32-bits */ 32,
|
|
SMD2, /* 32-bits */ 32,
|
|
SMD3, /* 32-bits */ 32
|
|
} /* Field: SMEM overlay using 32-bit field elements */
|
|
|
|
Field (\_SB.MEM.SMEM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
/* Field: SMEM overlay using greater than 32-bit field elements */
|
|
|
|
SME0, /* larger than an integer (32 or 64) */ 69,
|
|
SME1, /* larger than an integer */ 97
|
|
} /* Field: SMEM overlay using greater than 32-bit field elements */
|
|
}
|
|
|
|
Method (MTX, 0, NotSerialized)
|
|
{
|
|
/* Test "Force release" of mutex on method exit */
|
|
|
|
Acquire (MTXT, 0xFFFF)
|
|
Acquire (MTXX, 0xFFFF)
|
|
Debug = "++++++++ Acquiring Mutex MTX2"
|
|
Acquire (_GL, 0xFFFF)
|
|
Debug = "++++++++ Releasing Mutex MTX2"
|
|
Release (_GL)
|
|
}
|
|
|
|
Method (OBJ2, 1, Serialized)
|
|
{
|
|
Debug = "++++++++ Creating Buffer BUFO"
|
|
Name (BUFO, Buffer (0x20){})
|
|
Debug = "++++++++ Creating OpRegion OPR2"
|
|
OperationRegion (OPR2, SystemMemory, Arg0, 0x0100)
|
|
Debug = "++++++++ Creating Field(s) in OpRegion OPR2"
|
|
Field (OPR2, ByteAcc, NoLock, Preserve)
|
|
{
|
|
IDX2, 8,
|
|
DAT2, 8,
|
|
BNK2, 4
|
|
}
|
|
|
|
Debug = "++++++++ Creating BankField BNK2 in OpRegion OPR2"
|
|
/* */
|
|
/* mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1 */
|
|
/* */
|
|
BankField (OPR2, BNK2, 0x00, ByteAcc, NoLock, Preserve)
|
|
{
|
|
FET0, 4,
|
|
FET1, 3
|
|
}
|
|
|
|
Debug = "++++++++ Creating IndexField"
|
|
IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve)
|
|
{
|
|
FET2, 4,
|
|
FET3, 3
|
|
}
|
|
|
|
Debug = "++++++++ SizeOf (BUFO)"
|
|
SizeOf (BUFO)
|
|
Debug = "++++++++ Store (SizeOf (BUFO), Local0)"
|
|
Local0 = SizeOf (BUFO)
|
|
Debug = "++++++++ Concatenate (\"abd\", \"def\", Local0)"
|
|
Concatenate ("abd", "def", Local0)
|
|
Debug = Local0
|
|
Debug = "++++++++ Concatenate (\"abd\", 0x7B, Local0)"
|
|
Concatenate ("abd", 0x7B, Local0)
|
|
Debug = Local0
|
|
Debug = "++++++++ Creating Event EVT2"
|
|
Event (EVT2)
|
|
Debug = "++++++++ Creating Mutex MTX2"
|
|
Mutex (MTX2, 0x00)
|
|
Debug = "++++++++ Creating Alias MTXA to MTX2"
|
|
Alias (MTX2, MTXA)
|
|
Debug = "++++++++ Acquiring Mutex MTX2"
|
|
Acquire (MTX2, 0xFFFF)
|
|
Debug = "++++++++ Acquiring Mutex MTX2 (2nd acquire)"
|
|
Acquire (MTX2, 0x0001)
|
|
Debug = "++++++++ Releasing Mutex MTX2"
|
|
Release (MTX2)
|
|
/* Type 1 opcodes */
|
|
|
|
Debug = "++++++++ Signalling Event EVT2"
|
|
Signal (EVT2)
|
|
Debug = "++++++++ Resetting Event EVT2"
|
|
Reset (EVT2)
|
|
Debug = "++++++++ Signalling Event EVT2"
|
|
Signal (EVT2)
|
|
Debug = "++++++++ Waiting Event EVT2"
|
|
Wait (EVT2, 0xFFFF)
|
|
Debug = "++++++++ Sleep"
|
|
Sleep (0x64)
|
|
Debug = "++++++++ Stall"
|
|
Stall (0xFE)
|
|
Debug = "++++++++ NoOperation"
|
|
Noop
|
|
/* Type 2 Opcodes */
|
|
|
|
Debug = "++++++++ Return from Method OBJ2"
|
|
Return (0x04)
|
|
}
|
|
|
|
Method (NUM1, 0, NotSerialized)
|
|
{
|
|
/* ADD */
|
|
|
|
Debug = "++++++++ Add (0x12345678, 0x11111111, Local0)"
|
|
Local0 = (0x12345678 + 0x11111111)
|
|
Debug = "++++++++ Store (Add (0x12345678, 0x11111111), Local1)"
|
|
Store ((0x12345678 + 0x11111111), Local1)
|
|
Debug = "++++++++ Checking result from ADD"
|
|
If ((Local0 != Local1))
|
|
{
|
|
ERR (0x00, 0x060E)
|
|
}
|
|
|
|
/* SUBTRACT */
|
|
|
|
Debug = "++++++++ Subtract (0x87654321, 0x11111111, Local4)"
|
|
Local4 = (0x87654321 - 0x11111111)
|
|
Debug = "++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)"
|
|
Store ((0x87654321 - 0x11111111), Local5)
|
|
Debug = "++++++++ Checking result from SUBTRACT"
|
|
If ((Local4 != Local5))
|
|
{
|
|
ERR (0x00, 0x061D)
|
|
}
|
|
|
|
/* MULTIPLY */
|
|
|
|
Debug = "++++++++ Multiply (33, 10, Local6)"
|
|
Local6 = (0x21 * 0x0A)
|
|
Debug = "++++++++ Store (Multiply (33, 10), Local7)"
|
|
Store ((0x21 * 0x0A), Local7)
|
|
Debug = "++++++++ Checking result from MULTIPLY"
|
|
If ((Local6 != Local7))
|
|
{
|
|
ERR (0x00, 0x062D)
|
|
}
|
|
|
|
/* DIVIDE */
|
|
|
|
Debug = "++++++++ Divide (100, 9, Local1, Local2)"
|
|
Divide (0x64, 0x09, Local1, Local2)
|
|
Debug = "++++++++ Store (Divide (100, 9), Local3)"
|
|
Store ((0x64 / 0x09), Local3)
|
|
Debug = "++++++++ Checking (quotient) result from DIVIDE"
|
|
If ((Local2 != Local3))
|
|
{
|
|
ERR (0x00, 0x063C)
|
|
}
|
|
|
|
/* INCREMENT */
|
|
|
|
Debug = "++++++++ Increment (Local0)"
|
|
Local0 = 0x01
|
|
Local1 = 0x02
|
|
Local0++
|
|
Debug = "++++++++ Checking result from INCREMENT"
|
|
If ((Local0 != Local1))
|
|
{
|
|
ERR (0x00, 0x064A)
|
|
}
|
|
|
|
/* DECREMENT */
|
|
|
|
Debug = "++++++++ Decrement (Local0)"
|
|
Local0 = 0x02
|
|
Local1 = 0x01
|
|
Local0--
|
|
Debug = "++++++++ Checking result from DECREMENT"
|
|
If ((Local0 != Local1))
|
|
{
|
|
ERR (0x00, 0x0658)
|
|
}
|
|
|
|
/* TOBCD */
|
|
/* FROMBCD */
|
|
Debug = "++++++++ ToBCD (0x1234, Local5)"
|
|
ToBCD (0x1234, Local5)
|
|
Debug = "++++++++ FromBCD (Local5, Local6)"
|
|
FromBCD (Local5, Local6)
|
|
Debug = "++++++++ Return (Local6)"
|
|
Return (Local6)
|
|
}
|
|
|
|
Method (CHEK, 0, NotSerialized)
|
|
{
|
|
Local0 = 0x03
|
|
Debug = 0x03
|
|
Debug = Local0
|
|
Local1 = 0x07
|
|
(Local0 + Local1)
|
|
If ((Local0 != 0x03))
|
|
{
|
|
ERR (0x02, 0x0675)
|
|
}
|
|
|
|
If ((Local1 != 0x07))
|
|
{
|
|
ERR (0x02, 0x0679)
|
|
}
|
|
|
|
Local2 = (Local0 + Local1)
|
|
If ((Local0 != 0x03))
|
|
{
|
|
ERR (0x02, 0x0680)
|
|
}
|
|
|
|
If ((Local1 != 0x07))
|
|
{
|
|
ERR (0x02, 0x0684)
|
|
}
|
|
}
|
|
|
|
Method (RET1, 0, NotSerialized)
|
|
{
|
|
Local0 = 0x03
|
|
Return (Local0)
|
|
}
|
|
|
|
Method (RET2, 0, NotSerialized)
|
|
{
|
|
Return (RET1 ())
|
|
}
|
|
|
|
Method (RETZ, 0, NotSerialized)
|
|
{
|
|
RET2 ()
|
|
}
|
|
|
|
Method (BITZ, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ FindSetLeftBit (0x00100100, Local0)"
|
|
FindSetLeftBit (0x00100100, Local0)
|
|
If ((Local0 != 0x15))
|
|
{
|
|
ERR (0x01, 0x06A0)
|
|
}
|
|
|
|
Debug = "++++++++ FindSetRightBit (0x00100100, Local1)"
|
|
FindSetRightBit (0x00100100, Local1)
|
|
If ((Local1 != 0x09))
|
|
{
|
|
ERR (0x01, 0x06A7)
|
|
}
|
|
|
|
Debug = "++++++++ And (0xF0F0F0F0, 0x11111111, Local2)"
|
|
Local2 = (0xF0F0F0F0 & 0x11111111)
|
|
If ((Local2 != 0x10101010))
|
|
{
|
|
ERR (0x01, 0x06AE)
|
|
}
|
|
|
|
Debug = "++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)"
|
|
NAnd (0xF0F0F0F0, 0x11111111, Local3)
|
|
If ((Local3 != 0xEFEFEFEF))
|
|
{
|
|
ERR (0x01, 0x06B5)
|
|
}
|
|
|
|
Debug = "++++++++ Or (0x11111111, 0x22222222, Local4)"
|
|
Local4 = (0x11111111 | 0x22222222)
|
|
If ((Local4 != 0x33333333))
|
|
{
|
|
ERR (0x01, 0x06BC)
|
|
}
|
|
|
|
Debug = "++++++++ NOr (0x11111111, 0x22222222, Local5)"
|
|
NOr (0x11111111, 0x22222222, Local5)
|
|
If ((Local5 != 0xCCCCCCCC))
|
|
{
|
|
ERR (0x01, 0x06C3)
|
|
}
|
|
|
|
Debug = "++++++++ XOr (0x11113333, 0x22222222, Local6)"
|
|
Local6 = (0x11113333 ^ 0x22222222)
|
|
If ((Local6 != 0x33331111))
|
|
{
|
|
ERR (0x01, 0x06CA)
|
|
}
|
|
|
|
Debug = "++++++++ ShiftLeft (0x11112222, 2, Local7)"
|
|
Local7 = (0x11112222 << 0x02)
|
|
If ((Local7 != 0x44448888))
|
|
{
|
|
ERR (0x01, 0x06D1)
|
|
}
|
|
|
|
Debug = "++++++++ ShiftRight (Local7, 2, Local7)"
|
|
Local7 >>= 0x02
|
|
If ((Local7 != 0x11112222))
|
|
{
|
|
ERR (0x01, 0x06D8)
|
|
}
|
|
|
|
Debug = "++++++++ Not (Local0, Local1)"
|
|
Local0 = 0x22224444
|
|
Local1 = ~Local0
|
|
If ((Local0 != 0x22224444))
|
|
{
|
|
ERR (0x02, 0x06E1)
|
|
}
|
|
|
|
If ((Local1 != 0xDDDDBBBB))
|
|
{
|
|
ERR (0x01, 0x06E6)
|
|
}
|
|
|
|
Return (Local7)
|
|
}
|
|
|
|
Method (LOGS, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)"
|
|
Local0 = (0xFFFFFFFF && 0x11111111)
|
|
Debug = "++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)"
|
|
Local1 = (0xFFFFFFFF == 0x11111111)
|
|
Debug = "++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)"
|
|
Local2 = (0xFFFFFFFF > 0x11111111)
|
|
Debug = "++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)"
|
|
Local3 = (0xFFFFFFFF >= 0x11111111)
|
|
Debug = "++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)"
|
|
Local4 = (0xFFFFFFFF < 0x11111111)
|
|
Debug = "++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)"
|
|
Local5 = (0xFFFFFFFF <= 0x11111111)
|
|
Debug = "++++++++ Store (LNot (0x31313131), Local6)"
|
|
Local6 = 0x1111
|
|
Local7 = !Local6
|
|
If ((Local6 != 0x1111))
|
|
{
|
|
ERR (0x02, 0x0707)
|
|
}
|
|
|
|
If ((Local7 != 0x00))
|
|
{
|
|
ERR (0x01, 0x070C)
|
|
}
|
|
|
|
Debug = "++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)"
|
|
Local7 = (0xFFFFFFFF != 0x11111111)
|
|
Debug = "++++++++ Lor (0x0, 0x1)"
|
|
If ((0x00 || 0x01))
|
|
{
|
|
Debug = "+_+_+_+_+ Lor (0x0, 0x1) returned TRUE"
|
|
}
|
|
|
|
Return (Local7)
|
|
}
|
|
|
|
Method (COND, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ Store (0x4, Local0)"
|
|
Local0 = 0x04
|
|
Debug = "++++++++ While (Local0)"
|
|
While (Local0)
|
|
{
|
|
Debug = "++++++++ Decrement (Local0)"
|
|
Local0--
|
|
}
|
|
|
|
Debug = "++++++++ Store (0x3, Local6)"
|
|
Local6 = 0x03
|
|
Debug = "++++++++ While (Subtract (Local6, 1))"
|
|
While ((Local6 - 0x01))
|
|
{
|
|
Debug = "++++++++ Decrement (Local6)"
|
|
Local6--
|
|
}
|
|
|
|
Debug = "++++++++ [LVL1] If (LGreater (0x2, 0x1))"
|
|
If ((0x02 > 0x01))
|
|
{
|
|
Debug = "++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))"
|
|
If ((0x11111111 == 0x22222222))
|
|
{
|
|
Debug = "++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE"
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ [LVL3] If (LNot (0x0))"
|
|
If (!0x00)
|
|
{
|
|
Debug = "++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))"
|
|
If ((0xEEEEEEEE && 0x02))
|
|
{
|
|
Debug = "++++++++ [LVL5] If (LLess (0x44444444, 0x3))"
|
|
If ((0x44444444 < 0x03))
|
|
{
|
|
Debug = "++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE"
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ Exiting from nested IF/ELSE statements"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Debug = "++++++++ [LVL1] If (LGreater (0x2, 0x1))"
|
|
If ((0x02 > 0x01))
|
|
{
|
|
Debug = "++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))"
|
|
If ((0x11111111 == 0x22222222))
|
|
{
|
|
Debug = "++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE"
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ [LVL3] If (LNot (0x0))"
|
|
If (!0x00)
|
|
{
|
|
Debug = "++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))"
|
|
If ((0xEEEEEEEE && 0x02))
|
|
{
|
|
Debug = "++++++++ [LVL5] If (LLess (0x44444444, 0x3))"
|
|
If ((0x44444444 < 0x03))
|
|
{
|
|
Debug = "++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE"
|
|
}
|
|
Else
|
|
{
|
|
Debug = "++++++++ Returning from nested IF/ELSE statements"
|
|
Return (Local6)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Method (REFS, 0, Serialized)
|
|
{
|
|
Name (BBUF, Buffer (0x08)
|
|
{
|
|
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7 // ........
|
|
})
|
|
Name (NEST, Package (0x02)
|
|
{
|
|
Package (0x06)
|
|
{
|
|
0x01,
|
|
0x02,
|
|
0x03,
|
|
0x04,
|
|
0x05,
|
|
0x06
|
|
},
|
|
|
|
Package (0x06)
|
|
{
|
|
0x11,
|
|
0x12,
|
|
0x12,
|
|
0x14,
|
|
0x15,
|
|
0x16
|
|
}
|
|
})
|
|
Local5 = RefOf (MAIN)
|
|
/* For this to work, ABCD must NOT exist. */
|
|
|
|
Local1 = CondRefOf (ABCD, Local0)
|
|
If ((Local1 != 0x00))
|
|
{
|
|
ERR (0x02, 0x0791)
|
|
}
|
|
|
|
Local1 = CondRefOf (BBUF, Local0)
|
|
If ((Local1 != Ones))
|
|
{
|
|
ERR (0x02, 0x0797)
|
|
}
|
|
|
|
Local6 = DerefOf (BBUF [0x03])
|
|
If ((Local6 != 0xB3))
|
|
{
|
|
ERR (0x02, 0x079D)
|
|
}
|
|
|
|
Local0 = DerefOf (DerefOf (NEST [0x01]) [0x03])
|
|
If ((Local0 != 0x14))
|
|
{
|
|
ERR (0x02, 0x07A3)
|
|
}
|
|
|
|
Local0 = 0x11223344
|
|
Local1 = RefOf (Local0)
|
|
Local2 = DerefOf (Local1)
|
|
If ((Local2 != 0x11223344))
|
|
{
|
|
ERR (0x02, 0x07AD)
|
|
}
|
|
/* Parser thinks this is a method invocation!! */
|
|
/* RefOf (MAIN) */
|
|
/* RefOf (R___) */
|
|
/* RefOf (BBUF) */
|
|
/* Store (RefOf (Local0), Local1) */
|
|
/* CondRefOf (BBUF, Local2) */
|
|
/* CondRefOf (R___, Local3) */
|
|
/* Store (DerefOf (Local1), Local4) */
|
|
/* Return (Local4) */
|
|
}
|
|
|
|
Method (INDX, 0, Serialized)
|
|
{
|
|
Name (STAT, Package (0x04){})
|
|
STAT [0x00] = 0x44443333
|
|
}
|
|
|
|
/*================================================================= */
|
|
/*================================================================= */
|
|
/*===================== iPCO TESTS ================================ */
|
|
/*================================================================= */
|
|
/*================================================================= */
|
|
/* */
|
|
/* */
|
|
/* test IfElseOp.asl */
|
|
/* */
|
|
/* test for IfOp and ElseOp, including validation of object stack cleanup */
|
|
/* */
|
|
Device (IFEL)
|
|
{
|
|
Name (DWRD, 0x01)
|
|
Name (RSLT, 0x00)
|
|
/* IFNR control method executes IfOp branch with NO nested Return */
|
|
/* and no Else branch */
|
|
Method (IFNR, 0, NotSerialized)
|
|
{
|
|
RSLT = DWRD /* \IFEL.DWRD */
|
|
If ((DWRD == 0x01))
|
|
{
|
|
RSLT = 0x00
|
|
}
|
|
} /* IFNR */
|
|
|
|
/* NINR control method does not execute If branch and has no Else branch */
|
|
|
|
Method (NINR, 0, NotSerialized)
|
|
{
|
|
RSLT = 0x00
|
|
If ((DWRD != 0x01))
|
|
{
|
|
RSLT = DWRD /* \IFEL.DWRD */
|
|
}
|
|
} /* NINR */
|
|
|
|
/* IENR control method executes IfOp branch with NO nested Return */
|
|
|
|
Method (IENR, 0, NotSerialized)
|
|
{
|
|
If ((DWRD == 0x01))
|
|
{
|
|
RSLT = 0x00
|
|
}
|
|
Else
|
|
{
|
|
RSLT = DWRD /* \IFEL.DWRD */
|
|
}
|
|
} /* IENR */
|
|
|
|
/* ELNR control method executes ElseOp branch with NO nested Return */
|
|
|
|
Method (ELNR, 0, NotSerialized)
|
|
{
|
|
If ((DWRD != 0x01))
|
|
{
|
|
RSLT = DWRD /* \IFEL.DWRD */
|
|
}
|
|
Else
|
|
{
|
|
RSLT = 0x00
|
|
}
|
|
} /* ELNR */
|
|
|
|
/* IFRT control method executes IfOp branch with nested Return with */
|
|
/* no Else branch */
|
|
Method (IFRT, 0, NotSerialized)
|
|
{
|
|
If ((DWRD == 0x01))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
|
|
Return (DWRD) /* \IFEL.DWRD */
|
|
} /* IFRT */
|
|
|
|
/* IERT control method executes IfOp branch with nested Return with */
|
|
/* Else branch */
|
|
Method (IERT, 0, NotSerialized)
|
|
{
|
|
If ((DWRD == 0x01))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (DWRD) /* \IFEL.DWRD */
|
|
}
|
|
} /* IERT */
|
|
|
|
/* ELRT control method executes ElseOp branch with nested Return */
|
|
|
|
Method (ELRT, 0, NotSerialized)
|
|
{
|
|
If ((DWRD != 0x01))
|
|
{
|
|
Return (DWRD) /* \IFEL.DWRD */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x00)
|
|
}
|
|
} /* ELRT */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ IfElseOp Test"
|
|
/* IfOp with NO return value */
|
|
|
|
IFNR ()
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \IFEL.RSLT */
|
|
}
|
|
|
|
/* IfOp with NO return value */
|
|
|
|
NINR ()
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \IFEL.RSLT */
|
|
}
|
|
|
|
/* IfOp with NO return value */
|
|
|
|
IENR ()
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \IFEL.RSLT */
|
|
}
|
|
|
|
/* ElseOp with NO return value */
|
|
|
|
ELNR ()
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \IFEL.RSLT */
|
|
}
|
|
|
|
/* IfOp with return value */
|
|
|
|
RSLT = IFRT ()
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \IFEL.RSLT */
|
|
}
|
|
|
|
/* IfOp with return value */
|
|
|
|
RSLT = IERT ()
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \IFEL.RSLT */
|
|
}
|
|
|
|
/* ElseOp with return value */
|
|
|
|
RSLT = ELRT ()
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \IFEL.RSLT */
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* IFEL */
|
|
|
|
/* */
|
|
/* test NoSave.asl */
|
|
/* */
|
|
/* */
|
|
/* Internal test cases to validate IfOp (Operator (,,)) where Operator */
|
|
/* target is ZeroOp to throw away the results. */
|
|
/* Includes internal test cases for logical operators with no destination */
|
|
/* operands. */
|
|
/* */
|
|
Device (NOSV)
|
|
{
|
|
Method (TEST, 0, Serialized)
|
|
{
|
|
Debug = "++++++++ NoSave Test"
|
|
Name (WRD, 0x1234)
|
|
/* */
|
|
/* Begin test of nested operators without saving results */
|
|
/* */
|
|
/* Test If (And ()) with no save of And result */
|
|
If ((0x03 & 0x01))
|
|
{
|
|
WRD = 0x01 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x01) /* fail */
|
|
}
|
|
|
|
/* Test If (And ()) with no save of And result */
|
|
|
|
If ((0x04 & 0x01))
|
|
{
|
|
Return (0x02) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x02 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (NAnd ()) with no save of NAnd result */
|
|
|
|
If (NAnd (0x03, 0x01))
|
|
{
|
|
WRD = 0x03 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x03) /* fail */
|
|
}
|
|
|
|
/* Test If (NAnd ()) with no save of NAnd result */
|
|
|
|
If (NAnd (0xFFFFFFFF, 0xFFFFFFFF))
|
|
{
|
|
Return (0x04) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x04 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (NOr ()) with no save of NOr result */
|
|
|
|
If (NOr (0x00, 0x01))
|
|
{
|
|
WRD = 0x05 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x05) /* fail */
|
|
}
|
|
|
|
/* Test If (NOr ()) with no save of NOr result */
|
|
|
|
If (NOr (0xFFFFFFFE, 0x01))
|
|
{
|
|
Return (0x06) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x06 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (Not ()) with no save of Not result */
|
|
|
|
If (~0x01)
|
|
{
|
|
WRD = 0x07 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x07) /* fail */
|
|
}
|
|
|
|
/* Test If (Not ()) with no save of Not result */
|
|
|
|
If (~0xFFFFFFFF)
|
|
{
|
|
Return (0x08) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x08 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (Or ()) with no save of Or result */
|
|
|
|
If ((0x03 | 0x01))
|
|
{
|
|
WRD = 0x09 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x09) /* fail */
|
|
}
|
|
|
|
/* Test If (Or ()) with no save of Or result */
|
|
|
|
If ((0x00 | 0x00))
|
|
{
|
|
Return (0x0A) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x0A /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (XOr ()) with no save of XOr result */
|
|
|
|
If ((0x03 ^ 0x01))
|
|
{
|
|
WRD = 0x0B /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x0B) /* fail */
|
|
}
|
|
|
|
/* Test If (XOr ()) with no save of XOr result */
|
|
|
|
If ((0x03 ^ 0x03))
|
|
{
|
|
Return (0x0C) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x0C /* pass -- just do something */
|
|
}
|
|
|
|
/* */
|
|
/* Begin test of logical operators with no destination operands */
|
|
/* */
|
|
/* Test If (LAnd ()) with no save of LAnd result */
|
|
If ((0x03 && 0x03))
|
|
{
|
|
WRD = 0x15 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x15) /* fail */
|
|
}
|
|
|
|
/* Test If (LAnd ()) with no save of LAnd result */
|
|
|
|
If ((0x03 && 0x00))
|
|
{
|
|
Return (0x16) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x16 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LAnd ()) with no save of LAnd result */
|
|
|
|
If ((0x00 && 0x03))
|
|
{
|
|
Return (0x17) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x17 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LAnd ()) with no save of LAnd result */
|
|
|
|
If ((0x00 && 0x00))
|
|
{
|
|
Return (0x18) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x18 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LEqual ()) with no save of LEqual result */
|
|
|
|
If ((0x03 == 0x03))
|
|
{
|
|
WRD = 0x1F /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x1F) /* fail */
|
|
}
|
|
|
|
/* Test If (LEqual ()) with no save of LEqual result */
|
|
|
|
If ((0x01 == 0x03))
|
|
{
|
|
Return (0x20) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x20 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LGreater ()) with no save of LGreater result */
|
|
|
|
If ((0x03 > 0x01))
|
|
{
|
|
WRD = 0x29 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x29) /* fail */
|
|
}
|
|
|
|
/* Test If (LGreater ()) with no save of LGreater result */
|
|
|
|
If ((0x04 > 0x04))
|
|
{
|
|
Return (0x2A) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x2A /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LGreater ()) with no save of LGreater result */
|
|
|
|
If ((0x01 > 0x04))
|
|
{
|
|
Return (0x2B) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x2B /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LGreaterEqual ()) with no save of LGreaterEqual result */
|
|
|
|
If ((0x03 >= 0x01))
|
|
{
|
|
WRD = 0x2C /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x2C) /* fail */
|
|
}
|
|
|
|
/* Test If (LGreaterEqual ()) with no save of LGreaterEqual result */
|
|
|
|
If ((0x03 >= 0x03))
|
|
{
|
|
WRD = 0x2D /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x2D) /* fail */
|
|
}
|
|
|
|
/* Test If (LGreaterEqual ()) with no save of LGreaterEqual result */
|
|
|
|
If ((0x03 >= 0x04))
|
|
{
|
|
Return (0x2E) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x2E /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LLess ()) with no save of LLess result */
|
|
|
|
If ((0x01 < 0x03))
|
|
{
|
|
WRD = 0x33 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x33) /* fail */
|
|
}
|
|
|
|
/* Test If (LLess ()) with no save of LLess result */
|
|
|
|
If ((0x02 < 0x02))
|
|
{
|
|
Return (0x34) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x34 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LLess ()) with no save of LLess result */
|
|
|
|
If ((0x04 < 0x02))
|
|
{
|
|
Return (0x35) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x35 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LLessEqual ()) with no save of LLessEqual result */
|
|
|
|
If ((0x01 <= 0x03))
|
|
{
|
|
WRD = 0x36 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x36) /* fail */
|
|
}
|
|
|
|
/* Test If (LLessEqual ()) with no save of LLessEqual result */
|
|
|
|
If ((0x02 <= 0x02))
|
|
{
|
|
WRD = 0x37 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x37) /* fail */
|
|
}
|
|
|
|
/* Test If (LLessEqual ()) with no save of LLessEqual result */
|
|
|
|
If ((0x04 <= 0x02))
|
|
{
|
|
Return (0x38) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x38 /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LNot ()) with no save of LNot result */
|
|
|
|
If (!0x00)
|
|
{
|
|
WRD = 0x3D /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x3D) /* fail */
|
|
}
|
|
|
|
/* Test If (LNot ()) with no save of LNot result */
|
|
|
|
If (!0x01)
|
|
{
|
|
Return (0x3E) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x3E /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LNotEqual ()) with no save of LNotEqual result */
|
|
|
|
If ((0x03 != 0x03))
|
|
{
|
|
Return (0x3F) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x3F /* pass -- just do something */
|
|
}
|
|
|
|
/* Test If (LNotEqual ()) with no save of LNotEqual result */
|
|
|
|
If ((0x01 != 0x03))
|
|
{
|
|
WRD = 0x40 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x40) /* fail */
|
|
}
|
|
|
|
/* Test If (LOr ()) with no save of LOr result */
|
|
|
|
If ((0x03 || 0x01))
|
|
{
|
|
WRD = 0x47 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x47) /* fail */
|
|
}
|
|
|
|
/* Test If (LOr ()) with no save of LOr result */
|
|
|
|
If ((0x00 || 0x01))
|
|
{
|
|
WRD = 0x48 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x48) /* fail */
|
|
}
|
|
|
|
/* Test If (LOr ()) with no save of LOr result */
|
|
|
|
If ((0x03 || 0x00))
|
|
{
|
|
WRD = 0x49 /* pass -- just do something */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x49) /* fail */
|
|
}
|
|
|
|
/* Test If (LOr ()) with no save of LOr result */
|
|
|
|
If ((0x00 || 0x00))
|
|
{
|
|
Return (0x4A) /* fail */
|
|
}
|
|
Else
|
|
{
|
|
WRD = 0x4A /* pass -- just do something */
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* NOSV */
|
|
|
|
/* */
|
|
/* test IndxFld.asl */
|
|
/* */
|
|
/* IndexFld test */
|
|
/* This is just a subset of the many RegionOp/Index Field test cases. */
|
|
/* Tests index field element AccessAs macro. */
|
|
/* */
|
|
Device (IDXF)
|
|
{
|
|
/* Test device name */
|
|
|
|
OperationRegion (SIO, SystemIO, 0x0100, 0x02)
|
|
Field (SIO, ByteAcc, NoLock, Preserve)
|
|
{
|
|
INDX, 8,
|
|
DATA, 8
|
|
}
|
|
|
|
IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
|
|
{
|
|
AccessAs (ByteAcc, 0x00),
|
|
IFE0, 8,
|
|
IFE1, 8,
|
|
IFE2, 8,
|
|
IFE3, 8,
|
|
IFE4, 8,
|
|
IFE5, 8,
|
|
IFE6, 8,
|
|
IFE7, 8,
|
|
IFE8, 8,
|
|
IFE9, 8
|
|
}
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ IndxFld Test"
|
|
Local0 = IFE0 /* \IDXF.IFE0 */
|
|
Local1 = IFE1 /* \IDXF.IFE1 */
|
|
Local2 = IFE2 /* \IDXF.IFE2 */
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* IDXF */
|
|
|
|
/* */
|
|
/* test NestdLor.asl */
|
|
/* */
|
|
Scope (\_SB) /* System Bus */
|
|
{
|
|
/* _SB system bus */
|
|
|
|
Name (ZER0, 0x00)
|
|
Name (ZER1, 0x00)
|
|
Name (ZER2, 0x00)
|
|
Name (ONE0, 0x01)
|
|
Device (NSTL)
|
|
{
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ NestdLor Test"
|
|
If ((ZER0 || (ZER1 || (ZER2 || ONE0))))
|
|
{
|
|
/* Indicate Pass */
|
|
|
|
Local0 = 0x00
|
|
}
|
|
Else
|
|
{
|
|
/* Indicate Fail */
|
|
|
|
Local0 = 0x01
|
|
}
|
|
|
|
Return (Local0)
|
|
} /* End Method TEST */
|
|
} /* Device NSTL */
|
|
} /* _SB system bus */
|
|
|
|
/* */
|
|
/* test RetBuf.asl */
|
|
/* */
|
|
/* Test ReturnOp(Buffer) */
|
|
/* This is required to support Control Method Batteries on */
|
|
/* Dell Latitude Laptops (e.g., CP1-A) */
|
|
/* */
|
|
Device (RTBF)
|
|
{
|
|
Method (SUBR, 1, NotSerialized)
|
|
{
|
|
Return (Arg0)
|
|
}
|
|
|
|
Method (RBUF, 0, Serialized)
|
|
{
|
|
/* RBUF: Return Buffer from local variable */
|
|
|
|
Name (ABUF, Buffer (0x11)
|
|
{
|
|
"ARBITRARY_BUFFER"
|
|
})
|
|
/* store local buffer ABUF into Local0 */
|
|
|
|
Local0 = ABUF /* \RTBF.RBUF.ABUF */
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Buffer */
|
|
|
|
If ((Local1 != 0x03)) /* Buffer type is 3 */
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/* store value returned by control method SUBR into Local0 */
|
|
|
|
Local0 = SUBR (ABUF)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Buffer */
|
|
|
|
If ((Local1 != 0x03)) /* Buffer type is 3 */
|
|
{
|
|
Return (0x02) /* failure */
|
|
}
|
|
|
|
/* allocate buffer using Local1 as buffer size (run-time evaluation) */
|
|
|
|
Local1 = 0x05
|
|
Name (BUFR, Buffer (Local1){})
|
|
/* store value returned by control method SUBR into Local0 */
|
|
|
|
Local0 = SUBR (BUFR)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Buffer */
|
|
|
|
If ((Local1 != 0x03)) /* Buffer type is 3 */
|
|
{
|
|
Return (0x03) /* failure */
|
|
}
|
|
|
|
/* store BUFR Buffer into Local0 */
|
|
|
|
Local0 = BUFR /* \RTBF.RBUF.BUFR */
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Buffer */
|
|
|
|
If ((Local1 != 0x03)) /* Buffer type is 3 */
|
|
{
|
|
Return (0x04) /* failure */
|
|
}
|
|
|
|
/* return Local0 Buffer */
|
|
|
|
Return (Local0)
|
|
} /* RBUF */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ RetBuf Test"
|
|
/* store RBUF Buffer return value into Local0 */
|
|
|
|
Local0 = RBUF ()
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Buffer */
|
|
|
|
If ((Local1 != 0x03)) /* Buffer type is 3 */
|
|
{
|
|
Return (0x0A) /* failure */
|
|
}
|
|
Else
|
|
{
|
|
Return (0x00) /* success */
|
|
}
|
|
} /* TEST */
|
|
} /* RTBF */
|
|
|
|
/* */
|
|
/* test RetLVal.asl */
|
|
/* */
|
|
/* Test ReturnOp(Lvalue) */
|
|
/* This is required to support _PSR on IBM ThinkPad 560D and */
|
|
/* _DCK on Toshiba Tecra 8000. */
|
|
/* */
|
|
Device (GPE2)
|
|
{
|
|
Method (_L03, 0, NotSerialized) // _Lxx: Level-Triggered GPE
|
|
{
|
|
Debug = "Method GPE2._L03 invoked"
|
|
Return (Zero)
|
|
}
|
|
|
|
Method (_E05, 0, NotSerialized) // _Exx: Edge-Triggered GPE
|
|
{
|
|
Debug = "Method GPE2._E05 invoked"
|
|
Return (Zero)
|
|
}
|
|
}
|
|
|
|
Device (PRW2)
|
|
{
|
|
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
|
|
{
|
|
Package (0x02)
|
|
{
|
|
\GPE2,
|
|
0x05
|
|
},
|
|
|
|
0x03
|
|
})
|
|
}
|
|
|
|
Scope (\_GPE)
|
|
{
|
|
Name (ACST, 0xFF)
|
|
Method (_L08, 0, NotSerialized) // _Lxx: Level-Triggered GPE
|
|
{
|
|
Debug = "Method _GPE._L08 invoked"
|
|
Return (Zero)
|
|
}
|
|
|
|
Method (_E09, 0, NotSerialized) // _Exx: Edge-Triggered GPE
|
|
{
|
|
Debug = "Method _GPE._E09 invoked"
|
|
Return (Zero)
|
|
}
|
|
|
|
Method (_E11, 0, NotSerialized) // _Exx: Edge-Triggered GPE
|
|
{
|
|
Debug = "Method _GPE._E11 invoked"
|
|
Notify (\PRW1, 0x02) // Device Wake
|
|
}
|
|
|
|
Method (_L22, 0, NotSerialized) // _Lxx: Level-Triggered GPE
|
|
{
|
|
Debug = "Method _GPE._L22 invoked"
|
|
Return (Zero)
|
|
}
|
|
|
|
Method (_L33, 0, NotSerialized) // _Lxx: Level-Triggered GPE
|
|
{
|
|
Debug = "Method _GPE._L33 invoked"
|
|
Return (Zero)
|
|
}
|
|
|
|
Method (_E64, 0, NotSerialized) // _Exx: Edge-Triggered GPE
|
|
{
|
|
Debug = "Method _GPE._E64 invoked"
|
|
Return (Zero)
|
|
}
|
|
} /* _GPE */
|
|
|
|
Device (PRW1)
|
|
{
|
|
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
|
|
{
|
|
0x11,
|
|
0x03
|
|
})
|
|
}
|
|
|
|
Device (PWRB)
|
|
{
|
|
Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */) // _HID: Hardware ID
|
|
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
|
|
{
|
|
0x33,
|
|
0x03
|
|
})
|
|
}
|
|
|
|
Scope (\_SB) /* System Bus */
|
|
{
|
|
/* _SB system bus */
|
|
|
|
Device (ACAD)
|
|
{
|
|
/* ACAD: AC adapter device */
|
|
|
|
Name (_HID, "ACPI0003" /* Power Source Device */) /* AC adapter device */ // _HID: Hardware ID
|
|
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
|
|
{
|
|
\_SB
|
|
})
|
|
OperationRegion (AREG, SystemIO, 0x0372, 0x02)
|
|
Field (AREG, ByteAcc, NoLock, Preserve)
|
|
{
|
|
AIDX, 8,
|
|
ADAT, 8
|
|
}
|
|
|
|
IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve)
|
|
{
|
|
, 1,
|
|
ACIN, 1,
|
|
, 2,
|
|
CHAG, 1,
|
|
Offset (0x01),
|
|
, 7,
|
|
ABAT, 1
|
|
} /* IndexField */
|
|
|
|
Method (_PSR, 0, NotSerialized) // _PSR: Power Source
|
|
{
|
|
Local0 = \_GPE.ACST
|
|
Local1 = ACIN /* \_SB_.ACAD.ACIN */
|
|
If ((\_GPE.ACST != Local1))
|
|
{
|
|
\_GPE.ACST = Local1
|
|
/* This Notify is commented because it causes a */
|
|
/* method error when running on a system without the */
|
|
/* specific device. */
|
|
/* Notify (\_SB_.ACAD, 0) */
|
|
}
|
|
|
|
Return (Local0)
|
|
} /* _PSR */
|
|
|
|
Method (_STA, 0, NotSerialized) // _STA: Status
|
|
{
|
|
Return (0x0F)
|
|
}
|
|
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize
|
|
{
|
|
\_GPE.ACST = ACIN /* \_SB_.ACAD.ACIN */
|
|
}
|
|
} /* ACAD: AC adapter device */
|
|
|
|
/* test implicit return from control method */
|
|
|
|
Method (DIS, 1, NotSerialized)
|
|
{
|
|
Local0 = Arg0
|
|
}
|
|
|
|
Device (RTLV)
|
|
{
|
|
/* test implicit return inside nested if with explicit return of Lvalue */
|
|
|
|
Method (_DCK, 1, NotSerialized) // _DCK: Dock Present
|
|
{
|
|
If (Arg0)
|
|
{
|
|
/* dock */
|
|
|
|
Local0 = 0x87
|
|
If (Local0)
|
|
{
|
|
DIS (0x23)
|
|
Return (0x01)
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* dock */
|
|
Else
|
|
{
|
|
/* undock */
|
|
|
|
Local0 = Arg0
|
|
If (Local0)
|
|
{
|
|
DIS (0x23)
|
|
Return (0x01)
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* undock */
|
|
} /* _DCK control method */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ RetLVal Test"
|
|
/* store _PSR return value into Local0 */
|
|
|
|
Local0 = \_SB.ACAD._PSR ()
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number/Integer type is 1 */
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/* test implicit return inside nested if with explicit return of Lvalue */
|
|
|
|
Local2 = _DCK (0x01)
|
|
/* save Local2 object type value into Local3 */
|
|
|
|
Local3 = ObjectType (Local2)
|
|
/* validate Local2 is a Number */
|
|
|
|
If ((Local3 != 0x01)) /* Number/Integer type is 1 */
|
|
{
|
|
Return (0x02) /* failure */
|
|
}
|
|
|
|
If ((Local2 != 0x01))
|
|
{
|
|
Return (0x03) /* failure */
|
|
}
|
|
|
|
Return (0x00) /* success */
|
|
} /* TEST */
|
|
} /* RTLV */
|
|
} /* _SB system bus */
|
|
|
|
/* */
|
|
/* test RetPkg.asl */
|
|
/* */
|
|
/* Test ReturnOp(Package) */
|
|
/* This is required to support _PRT on Dell Optiplex Workstations (e.g. GX1) */
|
|
/* */
|
|
Scope (\_SB) /* System Bus */
|
|
{
|
|
/* _SB system bus */
|
|
|
|
Device (LNKA)
|
|
{
|
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID
|
|
Name (_UID, 0x01) // _UID: Unique ID
|
|
}
|
|
|
|
Device (LNKB)
|
|
{
|
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID
|
|
Name (_UID, 0x02) // _UID: Unique ID
|
|
}
|
|
|
|
Device (LNKC)
|
|
{
|
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID
|
|
Name (_UID, 0x03) // _UID: Unique ID
|
|
}
|
|
|
|
Device (LNKD)
|
|
{
|
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) /* PCI interrupt link */ // _HID: Hardware ID
|
|
Name (_UID, 0x04) // _UID: Unique ID
|
|
}
|
|
|
|
Device (PCI1)
|
|
{
|
|
/* PCI1: Root PCI Bus */
|
|
|
|
Name (_HID, "PNP0A03" /* PCI Bus */) /* Need _HID for root device (String format) */ // _HID: Hardware ID
|
|
Name (_ADR, 0x00) // _ADR: Address
|
|
Name (_CRS, 0x00) // _CRS: Current Resource Settings
|
|
Name (_PRT, Package (0x0C) // _PRT: PCI Routing Table
|
|
{
|
|
Package (0x04)
|
|
{
|
|
0x0004FFFF,
|
|
0x00,
|
|
LNKA,
|
|
0x00
|
|
}, /* Slot 1, INTA */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0004FFFF,
|
|
0x01,
|
|
LNKB,
|
|
0x00
|
|
}, /* Slot 1, INTB */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0004FFFF,
|
|
0x02,
|
|
LNKC,
|
|
0x00
|
|
}, /* Slot 1, INTC */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0004FFFF,
|
|
0x03,
|
|
LNKD,
|
|
0x00
|
|
}, /* Slot 1, INTD */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0005FFFF,
|
|
0x00,
|
|
\_SB.LNKB,
|
|
0x00
|
|
}, /* Slot 2, INTA */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0005FFFF,
|
|
0x01,
|
|
\_SB.LNKC,
|
|
0x00
|
|
}, /* Slot 2, INTB */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0005FFFF,
|
|
0x02,
|
|
\_SB.LNKD,
|
|
0x00
|
|
}, /* Slot 2, INTC */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0006FFFF,
|
|
0x03,
|
|
\_SB.LNKA,
|
|
0x00
|
|
}, /* Slot 2, INTD */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0006FFFF,
|
|
0x00,
|
|
LNKC,
|
|
0x00
|
|
}, /* Slot 3, INTA */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0006FFFF,
|
|
0x01,
|
|
LNKD,
|
|
0x00
|
|
}, /* Slot 3, INTB */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0006FFFF,
|
|
0x02,
|
|
LNKA,
|
|
0x00
|
|
}, /* Slot 3, INTC */
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0006FFFF,
|
|
0x03,
|
|
LNKB,
|
|
0x00
|
|
} /* Slot 3, INTD */
|
|
})
|
|
Device (PX40)
|
|
{
|
|
/* Map f0 space, Start PX40 */
|
|
|
|
Name (_ADR, 0x00070000) /* Address+function. */ // _ADR: Address
|
|
}
|
|
} /* PCI0: Root PCI Bus */
|
|
|
|
Device (RETP)
|
|
{
|
|
Method (RPKG, 0, NotSerialized)
|
|
{
|
|
/* RPKG: Return Package from local variable */
|
|
/* store _PRT package into Local0 */
|
|
Local0 = \_SB.PCI1._PRT
|
|
/* return Local0 Package */
|
|
|
|
Return (Local0)
|
|
} /* RPKG */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ RetPkg Test"
|
|
/* store RPKG package return value into Local0 */
|
|
|
|
Local0 = RPKG ()
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Package */
|
|
|
|
If ((Local1 != 0x04)) /* Package type is 4 */
|
|
{
|
|
Return (0x01)
|
|
} /* failure */
|
|
Else
|
|
{
|
|
Return (0x00)
|
|
} /* success */
|
|
} /* TEST */
|
|
} /* RETP */
|
|
} /* _SB_ */
|
|
|
|
/* */
|
|
/* test WhileRet.asl */
|
|
/* */
|
|
/* WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp. */
|
|
/* */
|
|
Device (WHLR)
|
|
{
|
|
Name (LCNT, 0x00)
|
|
Method (WIR, 0, NotSerialized)
|
|
{
|
|
/* WIR: control method that returns inside of IfOp inside of WhileOp */
|
|
|
|
While ((LCNT < 0x04))
|
|
{
|
|
If ((LCNT == 0x02))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
|
|
LCNT++
|
|
}
|
|
|
|
Return (LCNT) /* \WHLR.LCNT */
|
|
} /* WIR: control method that returns inside of IfOp inside of WhileOp */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ WhileRet Test"
|
|
Local0 = WIR ()
|
|
Return (Local0)
|
|
} /* TEST */
|
|
} /* WHLR */
|
|
|
|
/* */
|
|
/* test AndOrOp.asl */
|
|
/* */
|
|
/*This code tests the bitwise AndOp and OrOp Operator terms */
|
|
/* */
|
|
/*Syntax of Andop term */
|
|
/*And - Bitwise And */
|
|
/*AndTerm := And( */
|
|
/* Source1, //TermArg=>Integer */
|
|
/* Source2, //TermArg=>Integer */
|
|
/* Result //Nothing | SuperName */
|
|
/*) => Integer */
|
|
/*Source1 and Source2 are evaluated as integer data types, */
|
|
/* a bit-wise AND is performed, and the result is optionally */
|
|
/*stored into Result. */
|
|
/* */
|
|
/* */
|
|
/*Syntax of OrOp */
|
|
/*Or - Bit-wise Or */
|
|
/*OrTerm := Or( */
|
|
/* Source1, //TermArg=>Integer */
|
|
/* Source2 //TermArg=>Integer */
|
|
/* Result //Nothing | SuperName */
|
|
/*) => Integer */
|
|
/*Source1 and Source2 are evaluated as integer data types, */
|
|
/* a bit-wide OR is performed, and the result is optionally */
|
|
/*stored in Result */
|
|
/* */
|
|
Device (ANDO)
|
|
{
|
|
OperationRegion (TMEM, SystemMemory, 0xC4, 0x02)
|
|
Field (TMEM, ByteAcc, NoLock, Preserve)
|
|
{
|
|
, 3,
|
|
TOUD, 13
|
|
}
|
|
|
|
/*Create System Memory Operation Region and field overlays */
|
|
|
|
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
SMDW, /* 32-bit DWORD */ 32,
|
|
SMWD, /* 16-bit WORD */ 16,
|
|
SMBY, /* 8-bit BYTE */ 8
|
|
}/* Field(RAM) */
|
|
|
|
/*And with Byte Data */
|
|
|
|
Name (BYT1, 0xFF)
|
|
Name (BYT2, 0xFF)
|
|
Name (BRSL, 0x00)
|
|
/*And with Word Data */
|
|
|
|
Name (WRD1, 0xFFFF)
|
|
Name (WRD2, 0xFFFF)
|
|
Name (WRSL, 0x00)
|
|
/*And with DWord Data */
|
|
|
|
Name (DWD1, 0xFFFFFFFF)
|
|
Name (DWD2, 0xFFFFFFFF)
|
|
Name (DRSL, 0x00)
|
|
Method (ANDP, 0, NotSerialized)
|
|
{
|
|
/*Check with 1 And 1 on byte data */
|
|
|
|
BRSL = (BYT1 & BYT2) /* \ANDO.BYT2 */
|
|
If ((BRSL != 0xFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/*Check with 1 And 1 on Word data */
|
|
|
|
WRSL = (WRD1 & WRD2) /* \ANDO.WRD2 */
|
|
If ((WRSL != 0xFFFF))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 1 And 1 Dword */
|
|
|
|
DRSL = (DWD1 & DWD2) /* \ANDO.DWD2 */
|
|
If ((DRSL != 0xFFFFFFFF))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 0 And 0 on byte data */
|
|
|
|
BYT1 = 0x00
|
|
BYT2 = 0x00
|
|
BRSL = 0x00
|
|
BRSL = (BYT1 & BYT2) /* \ANDO.BYT2 */
|
|
If ((BRSL != 0x00))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 0 And 0 on Word data */
|
|
|
|
WRD1 = 0x00
|
|
WRD2 = 0x00
|
|
WRSL = 0x00
|
|
WRSL = (WRD1 & WRD2) /* \ANDO.WRD2 */
|
|
If ((WRSL != 0x00))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 0 And 0 Dword */
|
|
|
|
DWD1 = 0x00
|
|
DWD2 = 0x00
|
|
DRSL = 0x00
|
|
DRSL = (DWD1 & DWD2) /* \ANDO.DWD2 */
|
|
If ((DRSL != 0x00))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 1 And 0 on byte data */
|
|
|
|
BYT1 = 0x55
|
|
BYT2 = 0xAA
|
|
BRSL = 0x00
|
|
BRSL = (BYT1 & BYT2) /* \ANDO.BYT2 */
|
|
If ((BRSL != 0x00))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 1 And 0 on Word data */
|
|
|
|
WRD1 = 0x5555
|
|
WRD2 = 0xAAAA
|
|
WRSL = 0x00
|
|
WRSL = (WRD1 & WRD2) /* \ANDO.WRD2 */
|
|
If ((WRSL != 0x00))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 1 And 0 on Dword */
|
|
|
|
DWD1 = 0x55555555
|
|
DWD2 = 0xAAAAAAAA
|
|
DRSL = 0x00
|
|
DRSL = (DWD1 & DWD2) /* \ANDO.DWD2 */
|
|
If ((DRSL != 0x00))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
TOUD = 0x1FFF
|
|
Local0 = TOUD /* \ANDO.TOUD */
|
|
If ((Local0 != 0x1FFF))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*TBD- Do We need to check for system memory data also for each test case ?? */
|
|
|
|
Return (0x00)
|
|
}/*ANDP */
|
|
|
|
Method (OROP, 0, NotSerialized)
|
|
{
|
|
/*Check with 1 Ored with 1 on byte data */
|
|
|
|
BYT1 = 0xFF
|
|
BYT2 = 0xFF
|
|
BRSL = 0x00
|
|
BRSL = (BYT1 | BYT2) /* \ANDO.BYT2 */
|
|
If ((BRSL != 0xFF))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 1 Ored with 1 on Word data */
|
|
|
|
WRD1 = 0xFFFF
|
|
WRD2 = 0xFFFF
|
|
WRSL = 0x00
|
|
WRSL = (WRD1 | WRD2) /* \ANDO.WRD2 */
|
|
If ((WRSL != 0xFFFF))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 1 Ored with 1 on Dword data */
|
|
|
|
DWD1 = 0xFFFFFFFF
|
|
DWD2 = 0xFFFFFFFF
|
|
DRSL = 0x00
|
|
DRSL = (DWD1 | DWD2) /* \ANDO.DWD2 */
|
|
If ((DRSL != 0xFFFFFFFF))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 0 Ored with 0 on byte data */
|
|
|
|
BYT1 = 0x00
|
|
BYT2 = 0x00
|
|
BRSL = 0x00
|
|
BRSL = (BYT1 | BYT2) /* \ANDO.BYT2 */
|
|
If ((BRSL != 0x00))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 0 Ored with 0 on Word data */
|
|
|
|
WRD1 = 0x00
|
|
WRD2 = 0x00
|
|
WRSL = 0x00
|
|
WRSL = (WRD1 | WRD2) /* \ANDO.WRD2 */
|
|
If ((WRSL != 0x00))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 0 Ored with 0 Dword data */
|
|
|
|
DWD1 = 0x00
|
|
DWD2 = 0x00
|
|
DRSL = 0x00
|
|
DRSL = (DWD1 | DWD2) /* \ANDO.DWD2 */
|
|
If ((DRSL != 0x00))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 1 Ored with 0 on byte data */
|
|
|
|
BYT1 = 0x55
|
|
BYT2 = 0xAA
|
|
BRSL = 0x00
|
|
BRSL = (BYT1 | BYT2) /* \ANDO.BYT2 */
|
|
If ((BRSL != 0xFF))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 1 Ored with 0 on Word data */
|
|
|
|
WRD1 = 0x5555
|
|
WRD2 = 0xAAAA
|
|
WRSL = 0x00
|
|
WRSL = (WRD1 | WRD2) /* \ANDO.WRD2 */
|
|
If ((WRSL != 0xFFFF))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*Check with 1 Ored with 0 on Dword data */
|
|
|
|
DWD1 = 0x55555555
|
|
DWD2 = 0xAAAAAAAA
|
|
DRSL = 0x00
|
|
DRSL = (DWD1 | DWD2) /* \ANDO.DWD2 */
|
|
If ((DRSL != 0xFFFFFFFF))
|
|
{
|
|
Return (0x01) /* failure */
|
|
}
|
|
|
|
/*TBD - Do We need to check for system memory data also for each test case ?? */
|
|
|
|
Return (0x00)
|
|
}/*OROP */
|
|
|
|
Method (TEST, 0, Serialized)
|
|
{
|
|
Debug = "++++++++ AndOrOp Test"
|
|
Name (RSLT, 0x01)
|
|
/*Call Andop method */
|
|
|
|
RSLT = ANDP ()
|
|
If ((RSLT == 0x01))
|
|
{
|
|
Return (RSLT) /* \ANDO.TEST.RSLT */
|
|
}
|
|
|
|
/*Call OrOp Method */
|
|
|
|
RSLT = OROP ()
|
|
If ((RSLT == 0x01))
|
|
{
|
|
Return (RSLT) /* \ANDO.TEST.RSLT */
|
|
}
|
|
|
|
/* */
|
|
/* Return original conditions to allow iterative execution */
|
|
/* */
|
|
BYT1 = 0xFF
|
|
BYT2 = 0xFF
|
|
BRSL = 0x00
|
|
WRD1 = 0xFFFF
|
|
WRD2 = 0xFFFF
|
|
WRSL = 0x00
|
|
DWD1 = 0xFFFFFFFF
|
|
DWD2 = 0xFFFFFFFF
|
|
DRSL = 0x00
|
|
Return (0x00)
|
|
} /*TEST */
|
|
} /*ANDO */
|
|
|
|
/* */
|
|
/* test BreakPnt.asl */
|
|
/* */
|
|
/* This code tests the BreakPoint opcode term. The syntax of BreakPoint Term is */
|
|
/* BreakPointTerm := BreakPoint */
|
|
/* Used for debugging, the Breakpoint opcode stops the execution and enters the AML debugger. */
|
|
/* In the non-debug version of the interpreter, BreakPoint is equivalent to Noop. */
|
|
/* */
|
|
Device (BRKP)
|
|
{
|
|
Name (CNT0, 0x00)
|
|
Method (BK1, 0, NotSerialized)
|
|
{
|
|
BreakPoint
|
|
Return (0x00)
|
|
}
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ BreakPnt Test"
|
|
CNT0 = 0x00
|
|
/*Check BreakPoint statement */
|
|
|
|
While ((CNT0 < 0x0A))
|
|
{
|
|
CNT0++
|
|
}
|
|
|
|
/*Check the BreakPoint statement */
|
|
|
|
If ((CNT0 == 0x0A))
|
|
{
|
|
/* BreakPoint */
|
|
|
|
Return (0x00)
|
|
}
|
|
|
|
/*failed */
|
|
|
|
Return (0x01)
|
|
}
|
|
}
|
|
|
|
/* */
|
|
/* test AddSubOp.asl */
|
|
/* */
|
|
Device (ADSU)
|
|
{
|
|
/* create System Memory Operation Region and field overlays */
|
|
|
|
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
SMDW, /* 32-bit DWORD */ 32,
|
|
SMWD, /* 16-bit WORD */ 16,
|
|
SMBY, /* 8-bit BYTE */ 8
|
|
} /* Field(RAM) */
|
|
|
|
Method (TEST, 0, Serialized)
|
|
{
|
|
Debug = "++++++++ AddSubOp Test"
|
|
Name (DWRD, 0x12345678)
|
|
Name (WRD, 0x1234)
|
|
Name (BYT, 0x12)
|
|
/* Test AddOp with DWORD data */
|
|
|
|
DWRD = 0x12345678
|
|
DWRD += 0x07
|
|
If ((DWRD != 0x1234567F))
|
|
{
|
|
Return (DWRD) /* \ADSU.TEST.DWRD */
|
|
}
|
|
|
|
/* Test AddOp with WORD data */
|
|
|
|
WRD += 0x05
|
|
If ((WRD != 0x1239))
|
|
{
|
|
Return (WRD) /* \ADSU.TEST.WRD_ */
|
|
}
|
|
|
|
/* Test AddOp with BYTE data */
|
|
|
|
BYT += 0x03
|
|
If ((BYT != 0x15))
|
|
{
|
|
Return (BYT) /* \ADSU.TEST.BYT_ */
|
|
}
|
|
|
|
/* Test SubtractOp with DWORD data */
|
|
|
|
DWRD -= 0x07
|
|
If ((DWRD != 0x12345678))
|
|
{
|
|
Return (DWRD) /* \ADSU.TEST.DWRD */
|
|
}
|
|
|
|
/* Test SubtractOp with WORD data */
|
|
|
|
WRD -= 0x03
|
|
If ((WRD != 0x1236))
|
|
{
|
|
Return (WRD) /* \ADSU.TEST.WRD_ */
|
|
}
|
|
|
|
/* Test SubtractOp with BYTE data */
|
|
|
|
BYT -= 0x03
|
|
If ((BYT != 0x12))
|
|
{
|
|
Return (BYT) /* \ADSU.TEST.BYT_ */
|
|
}
|
|
|
|
/* test AddOp with DWORD SystemMemory OpRegion */
|
|
|
|
SMDW = 0x01234567
|
|
SMDW += 0x08
|
|
If ((SMDW != 0x0123456F))
|
|
{
|
|
Return (SMDW) /* \ADSU.SMDW */
|
|
}
|
|
|
|
/* test SubtractOp with DWORD SystemMemory OpRegion */
|
|
|
|
SMDW -= 0x07
|
|
If ((SMDW != 0x01234568))
|
|
{
|
|
Return (SMDW) /* \ADSU.SMDW */
|
|
}
|
|
|
|
/* test AddOp with WORD SystemMemory OpRegion */
|
|
|
|
SMWD = 0x0123
|
|
SMWD += 0x06
|
|
If ((SMWD != 0x0129))
|
|
{
|
|
Return (SMWD) /* \ADSU.SMWD */
|
|
}
|
|
|
|
/* test SubtractOp with WORD SystemMemory OpRegion */
|
|
|
|
SMWD -= 0x05
|
|
If ((SMWD != 0x0124))
|
|
{
|
|
Return (SMWD) /* \ADSU.SMWD */
|
|
}
|
|
|
|
/* test AddOp with BYTE SystemMemory OpRegion */
|
|
|
|
SMBY = 0x01
|
|
SMBY += 0x04
|
|
If ((SMBY != 0x05))
|
|
{
|
|
Return (SMBY) /* \ADSU.SMBY */
|
|
}
|
|
|
|
/* test SubtractOp with BYTE SystemMemory OpRegion */
|
|
|
|
SMBY -= 0x03
|
|
If ((SMBY != 0x02))
|
|
{
|
|
Return (SMBY) /* \ADSU.SMBY */
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* ADSU */
|
|
|
|
/* */
|
|
/* test IncDecOp.asl */
|
|
/* */
|
|
Device (INDC)
|
|
{
|
|
/* create System Memory Operation Region and field overlays */
|
|
|
|
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
SMDW, /* 32-bit DWORD */ 32,
|
|
SMWD, /* 16-bit WORD */ 16,
|
|
SMBY, /* 8-bit BYTE */ 8
|
|
} /* Field(RAM) */
|
|
|
|
Method (TEST, 0, Serialized)
|
|
{
|
|
Debug = "++++++++ IncDecOp Test"
|
|
Name (DWRD, 0x12345678)
|
|
Name (WRD, 0x1234)
|
|
Name (BYT, 0x12)
|
|
/* Test IncrementOp with DWORD data */
|
|
|
|
DWRD = 0x12345678
|
|
DWRD++
|
|
If ((DWRD != 0x12345679))
|
|
{
|
|
Return (DWRD) /* \INDC.TEST.DWRD */
|
|
}
|
|
|
|
/* Test IncrementOp with WORD data */
|
|
|
|
WRD++
|
|
If ((WRD != 0x1235))
|
|
{
|
|
Return (WRD) /* \INDC.TEST.WRD_ */
|
|
}
|
|
|
|
/* Test IncrementOp with BYTE data */
|
|
|
|
BYT++
|
|
If ((BYT != 0x13))
|
|
{
|
|
Return (BYT) /* \INDC.TEST.BYT_ */
|
|
}
|
|
|
|
/* Test DecrementOp with DWORD data */
|
|
|
|
DWRD--
|
|
If ((DWRD != 0x12345678))
|
|
{
|
|
Return (DWRD) /* \INDC.TEST.DWRD */
|
|
}
|
|
|
|
/* Test DecrementOp with WORD data */
|
|
|
|
WRD--
|
|
If ((WRD != 0x1234))
|
|
{
|
|
Return (WRD) /* \INDC.TEST.WRD_ */
|
|
}
|
|
|
|
/* Test DecrementOp with BYTE data */
|
|
|
|
BYT--
|
|
If ((BYT != 0x12))
|
|
{
|
|
Return (BYT) /* \INDC.TEST.BYT_ */
|
|
}
|
|
|
|
/* test IncrementOp with DWORD SystemMemory OpRegion */
|
|
|
|
SMDW = 0x01234567
|
|
SMDW++
|
|
If ((SMDW != 0x01234568))
|
|
{
|
|
Return (SMDW) /* \INDC.SMDW */
|
|
}
|
|
|
|
/* test DecrementOp with DWORD SystemMemory OpRegion */
|
|
|
|
SMDW--
|
|
If ((SMDW != 0x01234567))
|
|
{
|
|
Return (SMDW) /* \INDC.SMDW */
|
|
}
|
|
|
|
/* test IncrementOp with WORD SystemMemory OpRegion */
|
|
|
|
SMWD = 0x0123
|
|
SMWD++
|
|
If ((SMWD != 0x0124))
|
|
{
|
|
Return (SMWD) /* \INDC.SMWD */
|
|
}
|
|
|
|
/* test DecrementOp with WORD SystemMemory OpRegion */
|
|
|
|
SMWD--
|
|
If ((SMWD != 0x0123))
|
|
{
|
|
Return (SMWD) /* \INDC.SMWD */
|
|
}
|
|
|
|
/* test IncrementOp with BYTE SystemMemory OpRegion */
|
|
|
|
SMBY = 0x01
|
|
SMBY++
|
|
If ((SMBY != 0x02))
|
|
{
|
|
Return (SMBY) /* \INDC.SMBY */
|
|
}
|
|
|
|
/* test DecrementOp with BYTE SystemMemory OpRegion */
|
|
|
|
SMBY--
|
|
If ((SMBY != 0x01))
|
|
{
|
|
Return (SMBY) /* \INDC.SMBY */
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* INDC */
|
|
|
|
/* */
|
|
/* test LOps.asl */
|
|
/* */
|
|
/*This source tests all the logical operators. Logical operators in ASL are as follows. */
|
|
/*LAnd, LEqual, LGreater, LLess, LNot, LNotEqual, LOr. */
|
|
/* Success will return 0 and failure will return a non zero number. Check the source code for */
|
|
/* non zero number to find where the test failed */
|
|
Device (LOPS)
|
|
{
|
|
/*Create System Memory Operation Region and field overlays */
|
|
|
|
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
SMDW, /* 32-bit DWORD */ 32,
|
|
SMWD, /* 16-bit WORD */ 16,
|
|
SMBY, /* 8-bit BYTE */ 8
|
|
}/* Field(RAM) */
|
|
|
|
/*And with Byte Data */
|
|
|
|
Name (BYT1, 0xFF)
|
|
Name (BYT2, 0xFF)
|
|
Name (BRSL, 0x00)
|
|
/*And with Word Data */
|
|
|
|
Name (WRD1, 0xFFFF)
|
|
Name (WRD2, 0xFFFF)
|
|
Name (WRSL, 0x00)
|
|
/*And with DWord Data */
|
|
|
|
Name (DWD1, 0xFFFFFFFF)
|
|
Name (DWD2, 0xFFFFFFFF)
|
|
Name (DRSL, 0x00)
|
|
Name (RSLT, 0x01)
|
|
Method (ANDL, 2, NotSerialized)
|
|
{
|
|
/*test with the arguments passed */
|
|
|
|
If ((Arg0 == Arg1))
|
|
{
|
|
RSLT = (Arg0 && Arg1)
|
|
If ((Ones != RSLT))
|
|
{
|
|
Return (0x0B)
|
|
}
|
|
}
|
|
|
|
/*test with he locals */
|
|
|
|
Local0 = Arg0
|
|
Local1 = Arg1
|
|
If ((Local0 == Local1))
|
|
{
|
|
RSLT = (Local0 && Local1)
|
|
If ((Ones != RSLT))
|
|
{
|
|
Return (0x0C)
|
|
}
|
|
}
|
|
|
|
/*test with BYTE data */
|
|
|
|
If ((BYT1 == BYT2))
|
|
{
|
|
BRSL = (BYT1 && BYT2)
|
|
If ((Ones != BRSL))
|
|
{
|
|
Return (0x0D)
|
|
}
|
|
}
|
|
|
|
/*test with WORD data */
|
|
|
|
If ((WRD1 == WRD2))
|
|
{
|
|
WRSL = (WRD1 && WRD2)
|
|
If ((Ones != WRSL))
|
|
{
|
|
Return (0x0E)
|
|
}
|
|
}
|
|
|
|
/*test with DWORD data */
|
|
|
|
If ((DWD1 == DWD2))
|
|
{
|
|
DRSL = (DWD1 && DWD2)
|
|
If ((Ones != DRSL))
|
|
{
|
|
Return (0x0F)
|
|
}
|
|
}
|
|
|
|
/*Test for system memory data for each test case. */
|
|
|
|
BYT1 = 0xFF
|
|
SMBY = 0xFF
|
|
BRSL = 0x00
|
|
/*test with BYTE system memory data */
|
|
|
|
If ((BYT1 == SMBY))
|
|
{
|
|
BRSL = (BYT1 && SMBY)
|
|
If ((Ones != BRSL))
|
|
{
|
|
Return (0x10)
|
|
}
|
|
}
|
|
|
|
WRD1 = 0xFFFF
|
|
SMWD = 0xFFFF
|
|
WRSL = 0x00
|
|
/*test with WORD system memory data */
|
|
|
|
If ((WRD1 == SMWD))
|
|
{
|
|
WRSL = (WRD1 && SMWD)
|
|
If ((Ones != WRSL))
|
|
{
|
|
Return (0x11)
|
|
}
|
|
}
|
|
|
|
DRSL = 0x00
|
|
DWD1 = 0x00FFFFFF
|
|
SMDW = 0x00FFFFFF
|
|
/*test with DWORD system memory data */
|
|
|
|
If ((DWD1 == SMDW))
|
|
{
|
|
DRSL = (DWD1 && SMDW)
|
|
If ((Ones != DRSL))
|
|
{
|
|
Return (0x12)
|
|
}
|
|
}
|
|
|
|
Return (0x00)
|
|
}/*ANDL */
|
|
|
|
/*Test the LOr Operator */
|
|
|
|
Method (ORL, 2, NotSerialized)
|
|
{
|
|
/*ORL_ */
|
|
/*test with the arguments passed */
|
|
If ((Arg0 == Arg1))
|
|
{
|
|
RSLT = (Arg0 || Arg1)
|
|
If ((Ones != RSLT))
|
|
{
|
|
Return (0x15)
|
|
}
|
|
}
|
|
|
|
/*test with he locals */
|
|
|
|
Local0 = Arg0
|
|
Local1 = Arg1
|
|
If ((Local0 == Local1))
|
|
{
|
|
RSLT = (Local0 || Local1)
|
|
If ((Ones != RSLT))
|
|
{
|
|
Return (0x16)
|
|
}
|
|
}
|
|
|
|
/*Check with 1 LOred with 0 on byte data */
|
|
|
|
BYT1 = 0xFF
|
|
BYT2 = 0x00
|
|
BRSL = 0x00
|
|
If ((BYT1 != BYT2))
|
|
{
|
|
BRSL = (BYT1 || BYT2)
|
|
If ((Ones != BRSL))
|
|
{
|
|
Return (0x17)
|
|
}
|
|
}
|
|
|
|
/*Check with 1 LOred with 0 on WORD data */
|
|
|
|
WRD1 = 0xFFFF
|
|
WRD2 = 0x00
|
|
WRSL = 0x00
|
|
If ((WRD1 != WRD2))
|
|
{
|
|
WRSL = (WRD1 || WRD2)
|
|
If ((Ones != WRSL))
|
|
{
|
|
Return (0x18)
|
|
}
|
|
}
|
|
|
|
/*Check with 1 LOred with 0 on DWORD data */
|
|
|
|
DWD1 = 0xFFFFFFFF
|
|
DWD2 = 0x00
|
|
DRSL = 0x00
|
|
If ((DWD1 != DWD2))
|
|
{
|
|
DRSL = (DWD1 || DWD2)
|
|
If ((Ones != DRSL))
|
|
{
|
|
Return (0x19)
|
|
}
|
|
}
|
|
|
|
BYT1 = 0x00
|
|
SMBY = 0xFF
|
|
BRSL = 0x00
|
|
/*test with BYTE system memory data */
|
|
|
|
If ((BYT1 == SMBY))
|
|
{
|
|
BRSL = (BYT1 || SMBY)
|
|
If ((Ones != BRSL))
|
|
{
|
|
Return (0x1A)
|
|
}
|
|
}
|
|
|
|
WRD1 = 0x00
|
|
SMWD = 0xFFFF
|
|
WRSL = 0x00
|
|
/*test with WORD system memory data */
|
|
|
|
If ((WRD1 == SMWD))
|
|
{
|
|
WRSL = (WRD1 || SMWD)
|
|
If ((Ones != WRSL))
|
|
{
|
|
Return (0x1B)
|
|
}
|
|
}
|
|
|
|
DWD1 = 0x00
|
|
SMDW = 0xFFFFFFFF
|
|
DRSL = 0x00
|
|
/*test with DWORD system memory data */
|
|
|
|
If ((DWD1 == SMDW))
|
|
{
|
|
DRSL = (DWD1 && SMDW)
|
|
If ((Ones != DRSL))
|
|
{
|
|
Return (0x1C)
|
|
}
|
|
}
|
|
|
|
Return (0x00)
|
|
}/*ORL_ */
|
|
|
|
/*This method tests LGreater and LNot operator */
|
|
|
|
Method (LSGR, 2, NotSerialized)
|
|
{
|
|
/*LSGR */
|
|
/*Test on arguements passed */
|
|
/*in test data, Arg1 > Arg0 */
|
|
If ((Ones == (Arg1 <= Arg0)))
|
|
{
|
|
Return (0x1F)
|
|
}
|
|
|
|
/*test LLessEqual */
|
|
|
|
If ((Ones == !(Arg1 >= Arg0)))
|
|
{
|
|
Return (0x20)
|
|
}
|
|
|
|
If ((Ones == (Arg1 < Arg0)))
|
|
{
|
|
Return (0x21)
|
|
}
|
|
|
|
/*test LLessEqual */
|
|
|
|
If ((Ones == (Arg1 <= Arg0)))
|
|
{
|
|
Return (0x22)
|
|
}
|
|
|
|
Local0 = Arg0
|
|
Local1 = Arg1
|
|
/*test with the locals */
|
|
|
|
If ((Local1 <= Local0))
|
|
{
|
|
Return (0x23)
|
|
}
|
|
|
|
/*test on Byte data */
|
|
|
|
BYT1 = 0x12
|
|
BYT2 = 0x21
|
|
If ((BYT2 <= BYT1))
|
|
{
|
|
Return (0x24)
|
|
}
|
|
|
|
If ((BYT1 >= BYT2))
|
|
{
|
|
Return (0x25)
|
|
}
|
|
|
|
/*test LGreaterEqual with byte data */
|
|
|
|
If (!(BYT2 >= BYT1))
|
|
{
|
|
Return (0x26)
|
|
}
|
|
|
|
/*test LLessEqual byte data */
|
|
|
|
If (!(BYT1 <= BYT2))
|
|
{
|
|
Return (0x27)
|
|
}
|
|
|
|
/*test on Word data */
|
|
|
|
WRD1 = 0x1212
|
|
WRD2 = 0x2121
|
|
If ((WRD2 <= WRD1))
|
|
{
|
|
Return (0x0136)
|
|
}
|
|
|
|
If ((WRD1 >= WRD2))
|
|
{
|
|
Return (0x0137)
|
|
}
|
|
|
|
/*Test LGreaterEqual with Word Data */
|
|
|
|
If (!(WRD2 >= WRD1))
|
|
{
|
|
Return (0x0138)
|
|
}
|
|
|
|
/*Test LLessEqual with Word Data */
|
|
|
|
If (!(WRD1 <= WRD2))
|
|
{
|
|
Return (0x0139)
|
|
}
|
|
|
|
/*test on DWord data */
|
|
|
|
DWD1 = 0x12121212
|
|
DWD2 = 0x21212121
|
|
If ((DWD2 <= DWD1))
|
|
{
|
|
Return (0x013A)
|
|
}
|
|
|
|
If ((DWD1 >= DWD2))
|
|
{
|
|
Return (0x013B)
|
|
}
|
|
|
|
/*Test LGreaterEqual with Dword */
|
|
|
|
If (!(DWD2 >= DWD1))
|
|
{
|
|
Return (0x013C)
|
|
}
|
|
|
|
/*Test LLessEqual DWord */
|
|
|
|
If (!(DWD1 <= DWD2))
|
|
{
|
|
Return (0x013D)
|
|
}
|
|
|
|
Return (0x00)
|
|
}/*LSGR */
|
|
|
|
/*The test method */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ LOps Test"
|
|
RSLT = 0x00
|
|
/*Call LAndOp method */
|
|
|
|
RSLT = ANDL (0x02, 0x02)
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \LOPS.RSLT */
|
|
}
|
|
|
|
/*Call LOrOp Method */
|
|
|
|
RSLT = ORL (0x05, 0x05)
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \LOPS.RSLT */
|
|
}
|
|
|
|
/*Call LSGR Method */
|
|
|
|
RSLT = LSGR (0x05, 0x07)
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \LOPS.RSLT */
|
|
}
|
|
|
|
Return (0x00)
|
|
}/*TEST */
|
|
}/*LOPS */
|
|
|
|
/* */
|
|
/* test FdSetOps.asl */
|
|
/* */
|
|
/* FindSetLeftBit - Find Set Left Bit */
|
|
/* FindSetLeftBitTerm := FindSetLeftBit */
|
|
/* ( Source, //TermArg=>Integer */
|
|
/* Result //Nothing | SuperName */
|
|
/* ) => Integer */
|
|
/* Source is evaluated as integer data type, and the one-based bit location of */
|
|
/* the first MSb (most significant set bit) is optionally stored into Result. */
|
|
/* The result of 0 means no bit was set, 1 means the left-most bit set is the */
|
|
/* first bit, 2 means the left-most bit set is the second bit, and so on. */
|
|
/* FindSetRightBit - Find Set Right Bit */
|
|
/* FindSetRightBitTerm := FindSetRightBit */
|
|
/* ( Source, //TermArg=>Integer */
|
|
/* Result //Nothing | SuperName */
|
|
/* ) => Integer */
|
|
/* Source is evaluated as integer data type, and the one-based bit location of */
|
|
/* the most LSb (least significant set bit) is optionally stored in Result. */
|
|
/* The result of 0 means no bit was set, 32 means the first bit set is the */
|
|
/* 32nd bit, 31 means the first bit set is the 31st bit, and so on. */
|
|
/* If the Control method is success Zero is returned. Otherwise a non-zero */
|
|
/* number is returned. */
|
|
/* */
|
|
Device (FDSO)
|
|
{
|
|
/* FDSO */
|
|
/* Create System Memory Operation Region and field overlays */
|
|
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
SMDW, /* 32-bit DWORD */ 32,
|
|
SMWD, /* 16-bit WORD */ 16,
|
|
SMBY, /* 8-bit BYTE */ 8
|
|
} /* Field(RAM) */
|
|
|
|
/* Byte Data */
|
|
|
|
Name (BYT1, 0x01)
|
|
Name (BRSL, 0x00)
|
|
/* Word Data */
|
|
|
|
Name (WRD1, 0x0100)
|
|
Name (WRSL, 0x00)
|
|
/* DWord Data */
|
|
|
|
Name (DWD1, 0x00010000)
|
|
Name (DRSL, 0x00)
|
|
Name (RSLT, 0x01)
|
|
Name (CNTR, 0x01)
|
|
Method (SHFT, 2, NotSerialized)
|
|
{
|
|
/* SHFT */
|
|
|
|
Local0 = Arg0
|
|
Local1 = Arg1
|
|
FindSetLeftBit (Arg0, BRSL) /* \FDSO.BRSL */
|
|
If ((BRSL != Arg1))
|
|
{
|
|
Return (0x11)
|
|
}
|
|
|
|
If ((Arg0 != Local0))
|
|
{
|
|
Return (0x12)
|
|
}
|
|
|
|
FindSetLeftBit (Local0, BRSL) /* \FDSO.BRSL */
|
|
If ((BRSL != Local1))
|
|
{
|
|
Return (0x13)
|
|
}
|
|
|
|
If ((Arg0 != Local0))
|
|
{
|
|
Return (0x14)
|
|
}
|
|
|
|
/* test the byte value for SetLeftBit */
|
|
|
|
BYT1 = 0x07
|
|
FindSetLeftBit (BYT1, BRSL) /* \FDSO.BRSL */
|
|
If ((BRSL != 0x03))
|
|
{
|
|
Return (0x15)
|
|
}
|
|
|
|
If ((BYT1 != 0x07))
|
|
{
|
|
Return (0x16)
|
|
}
|
|
|
|
BYT1 = 0x01
|
|
CNTR = 0x01
|
|
While ((CNTR <= 0x08))
|
|
{
|
|
/* FindSetLeftBit check loop for byte data */
|
|
|
|
FindSetLeftBit (BYT1, BRSL) /* \FDSO.BRSL */
|
|
If ((BRSL != CNTR))
|
|
{
|
|
Return (0x17)
|
|
}
|
|
|
|
/* Shift the bits to check the same */
|
|
|
|
BYT1 <<= 0x01
|
|
CNTR++
|
|
} /* FindSetLeftBit check loop for byte data */
|
|
|
|
/* Check BYTE value for SetRightBit */
|
|
|
|
BYT1 = 0x07
|
|
FindSetRightBit (BYT1, BRSL) /* \FDSO.BRSL */
|
|
If ((BRSL != 0x01))
|
|
{
|
|
Return (0x21)
|
|
}
|
|
|
|
If ((BYT1 != 0x07))
|
|
{
|
|
Return (0x22)
|
|
}
|
|
|
|
CNTR = 0x01
|
|
BYT1 = 0xFF
|
|
While ((CNTR <= 0x08))
|
|
{
|
|
/* FindSetRightBit check loop for byte data */
|
|
|
|
FindSetRightBit (BYT1, BRSL) /* \FDSO.BRSL */
|
|
If ((BRSL != CNTR))
|
|
{
|
|
Return (0x23)
|
|
}
|
|
|
|
BYT1 <<= 0x01
|
|
CNTR++
|
|
} /* FindSetRightBit check loop for byte data */
|
|
|
|
/* Test Word value for SetLeftBit */
|
|
|
|
CNTR = 0x09
|
|
WRD1 = 0x0100
|
|
While ((CNTR <= 0x10))
|
|
{
|
|
/* FindSetLeftBit check loop for Word data */
|
|
|
|
FindSetLeftBit (WRD1, WRSL) /* \FDSO.WRSL */
|
|
If ((WRSL != CNTR))
|
|
{
|
|
Return (0x31)
|
|
}
|
|
|
|
/* Shift the bits to check the same */
|
|
|
|
WRD1 <<= 0x01
|
|
CNTR++
|
|
} /* FindSetLeftBit check loop for Word data */
|
|
|
|
/* Check Word value for SetRightBit */
|
|
|
|
CNTR = 0x09
|
|
WRD1 = 0xFF00
|
|
While ((CNTR <= 0x10))
|
|
{
|
|
/* FindSetRightBit check loop for Word data */
|
|
|
|
FindSetRightBit (WRD1, WRSL) /* \FDSO.WRSL */
|
|
If ((WRSL != CNTR))
|
|
{
|
|
Return (0x32)
|
|
}
|
|
|
|
WRD1 <<= 0x01
|
|
CNTR++
|
|
} /* FindSetRightBit check loop for Word data */
|
|
|
|
/* Test the DWord value for SetLeftBit */
|
|
|
|
CNTR = 0x11
|
|
DWD1 = 0x00010000
|
|
While ((CNTR <= 0x20))
|
|
{
|
|
/* FindSetLeftBit check loop for Dword */
|
|
|
|
FindSetLeftBit (DWD1, DRSL) /* \FDSO.DRSL */
|
|
If ((DRSL != CNTR))
|
|
{
|
|
Return (0x41)
|
|
}
|
|
|
|
/* Shift the bits to check the same */
|
|
|
|
DWD1 <<= 0x01
|
|
CNTR++
|
|
} /* FindSetLeftBit check loop for Dword */
|
|
|
|
/* Check DWord value for SetRightBit */
|
|
|
|
CNTR = 0x11
|
|
DWD1 = 0xFFFF0000
|
|
While ((CNTR <= 0x20))
|
|
{
|
|
/* FindSetRightBit Check loop for DWORD */
|
|
|
|
FindSetRightBit (DWD1, DRSL) /* \FDSO.DRSL */
|
|
If ((DRSL != CNTR))
|
|
{
|
|
Return (0x42)
|
|
}
|
|
|
|
DWD1 <<= 0x01
|
|
CNTR++
|
|
} /* FindSetRightBit Check loop for DWORD */
|
|
|
|
Return (0x00)
|
|
} /* SHFT */
|
|
|
|
/* Test method called from amlexec */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
/* TEST */
|
|
|
|
Debug = "++++++++ FdSetOps Test"
|
|
RSLT = SHFT (0x80, 0x08)
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \FDSO.RSLT */
|
|
}
|
|
|
|
Return (0x00) /* pass */
|
|
} /* TEST */
|
|
} /* Device FDSO */
|
|
|
|
/* */
|
|
/* test MulDivOp.asl */
|
|
/* */
|
|
Device (MLDV)
|
|
{
|
|
/* create System Memory Operation Region and field overlays */
|
|
|
|
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
SMDW, /* 32-bit DWORD */ 32,
|
|
SMWD, /* 16-bit WORD */ 16,
|
|
SMBY, /* 8-bit BYTE */ 8
|
|
} /* Field(RAM) */
|
|
|
|
Method (TEST, 0, Serialized)
|
|
{
|
|
Debug = "++++++++ MulDivOp Test"
|
|
Name (RMDR, 0x00)
|
|
Name (DWRD, 0x12345678)
|
|
Name (WRD, 0x1234)
|
|
Name (BYT, 0x12)
|
|
/* Test MultiplyOp with DWORD data */
|
|
|
|
DWRD = 0x12345678
|
|
DWRD *= 0x03
|
|
If ((DWRD != 0x369D0368))
|
|
{
|
|
Return (DWRD) /* \MLDV.TEST.DWRD */
|
|
}
|
|
|
|
/* Test MultiplyOp with WORD data */
|
|
|
|
WRD *= 0x04
|
|
If ((WRD != 0x48D0))
|
|
{
|
|
Return (WRD) /* \MLDV.TEST.WRD_ */
|
|
}
|
|
|
|
/* Test MultiplyOp with BYTE data */
|
|
|
|
BYT *= 0x05
|
|
If ((BYT != 0x5A))
|
|
{
|
|
Return (BYT) /* \MLDV.TEST.BYT_ */
|
|
}
|
|
|
|
/* Test DivideOp with DWORD data */
|
|
|
|
Divide (DWRD, 0x03, DWRD, RMDR) /* \MLDV.TEST.RMDR */
|
|
If ((DWRD != 0x12345678))
|
|
{
|
|
Return (DWRD) /* \MLDV.TEST.DWRD */
|
|
}
|
|
|
|
If ((RMDR != 0x00))
|
|
{
|
|
Return (RMDR) /* \MLDV.TEST.RMDR */
|
|
}
|
|
|
|
/* Test DivideOp with WORD data */
|
|
|
|
Divide (WRD, 0x04, WRD, RMDR) /* \MLDV.TEST.RMDR */
|
|
If ((WRD != 0x1234))
|
|
{
|
|
Return (WRD) /* \MLDV.TEST.WRD_ */
|
|
}
|
|
|
|
If ((RMDR != 0x00))
|
|
{
|
|
Return (RMDR) /* \MLDV.TEST.RMDR */
|
|
}
|
|
|
|
/* Test DivideOp with BYTE data */
|
|
|
|
Divide (BYT, 0x05, BYT, RMDR) /* \MLDV.TEST.RMDR */
|
|
If ((BYT != 0x12))
|
|
{
|
|
Return (BYT) /* \MLDV.TEST.BYT_ */
|
|
}
|
|
|
|
If ((RMDR != 0x00))
|
|
{
|
|
Return (RMDR) /* \MLDV.TEST.RMDR */
|
|
}
|
|
|
|
/* test MultiplyOp with DWORD SystemMemory OpRegion */
|
|
|
|
SMDW = 0x01234567
|
|
SMDW *= 0x02
|
|
If ((SMDW != 0x02468ACE))
|
|
{
|
|
Return (SMDW) /* \MLDV.SMDW */
|
|
}
|
|
|
|
/* test DivideOp with DWORD SystemMemory OpRegion */
|
|
|
|
Divide (SMDW, 0x03, SMDW, RMDR) /* \MLDV.TEST.RMDR */
|
|
If ((SMDW != 0x00C22E44))
|
|
{
|
|
Return (SMDW) /* \MLDV.SMDW */
|
|
}
|
|
|
|
If ((RMDR != 0x02))
|
|
{
|
|
Return (RMDR) /* \MLDV.TEST.RMDR */
|
|
}
|
|
|
|
/* test MultiplyOp with WORD SystemMemory OpRegion */
|
|
|
|
SMWD = 0x0123
|
|
SMWD *= 0x03
|
|
If ((SMWD != 0x0369))
|
|
{
|
|
Return (SMWD) /* \MLDV.SMWD */
|
|
}
|
|
|
|
/* test DivideOp with WORD SystemMemory OpRegion */
|
|
|
|
Divide (SMWD, 0x02, SMWD, RMDR) /* \MLDV.TEST.RMDR */
|
|
If ((SMWD != 0x01B4))
|
|
{
|
|
Return (SMWD) /* \MLDV.SMWD */
|
|
}
|
|
|
|
If ((RMDR != 0x01))
|
|
{
|
|
Return (RMDR) /* \MLDV.TEST.RMDR */
|
|
}
|
|
|
|
/* test MultiplyOp with BYTE SystemMemory OpRegion */
|
|
|
|
SMBY = 0x01
|
|
SMBY *= 0x07
|
|
If ((SMBY != 0x07))
|
|
{
|
|
Return (SMBY) /* \MLDV.SMBY */
|
|
}
|
|
|
|
/* test DivideOp with BYTE SystemMemory OpRegion */
|
|
|
|
Divide (SMBY, 0x04, SMBY, RMDR) /* \MLDV.TEST.RMDR */
|
|
If ((SMBY != 0x01))
|
|
{
|
|
Return (SMBY) /* \MLDV.SMBY */
|
|
}
|
|
|
|
If ((RMDR != 0x03))
|
|
{
|
|
Return (RMDR) /* \MLDV.TEST.RMDR */
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* MLDV */
|
|
|
|
/* */
|
|
/* test NBitOps.asl */
|
|
/* */
|
|
/*NAnd - Bit-wise NAnd */
|
|
/*NAndTerm := NAnd( */
|
|
/* Source1, //TermArg=>Integer */
|
|
/* Source2 //TermArg=>Integer */
|
|
/* Result //Nothing | SuperName */
|
|
/*) => Integer */
|
|
/*Source1 and Source2 are evaluated as integer data types, a bit-wise NAND is performed, and the result is optionally */
|
|
/*stored in Result. */
|
|
/*NOr - Bitwise NOr */
|
|
/*NOrTerm := NOr( */
|
|
/* Source1, //TermArg=>Integer */
|
|
/* Source2 //TermArg=>Integer */
|
|
/* Result //Nothing | SuperName */
|
|
/*) => Integer */
|
|
/*Source1 and Source2 are evaluated as integer data types, a bit-wise NOR is performed, and the result is optionally */
|
|
/*stored in Result. */
|
|
/* Not - Not */
|
|
/*NotTerm := Not( */
|
|
/* Source, //TermArg=>Integer */
|
|
/* Result //Nothing | SuperName */
|
|
/*) => Integer */
|
|
/*Source1 is evaluated as an integer data type, a bit-wise NOT is performed, and the result is optionally stored in */
|
|
/*Result. */
|
|
/*If the Control method is success Zero is returned else a non-zero number is returned */
|
|
Device (NBIT)
|
|
{
|
|
/*NBIT */
|
|
/*Create System Memory Operation Region and field overlays */
|
|
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
SMDW, /* 32-bit DWORD */ 32,
|
|
SMWD, /* 16-bit WORD */ 16,
|
|
SMBY, /* 8-bit BYTE */ 8
|
|
}/* Field(RAM) */
|
|
|
|
/*And with Byte Data */
|
|
|
|
Name (BYT1, 0xFF)
|
|
Name (BYT2, 0xFF)
|
|
Name (BRSL, 0x00)
|
|
/*And with Word Data */
|
|
|
|
Name (WRD1, 0xFFFF)
|
|
Name (WRD2, 0xFFFF)
|
|
Name (WRSL, 0x00)
|
|
/*And with DWord Data */
|
|
|
|
Name (DWD1, 0xFFFFFFFF)
|
|
Name (DWD2, 0xFFFFFFFF)
|
|
Name (DRSL, 0x00)
|
|
Name (RSLT, 0x01)
|
|
Name (ARSL, 0x00)
|
|
Name (LRSL, 0x00)
|
|
Method (NNDB, 2, NotSerialized)
|
|
{
|
|
/*NNDB */
|
|
|
|
SMDW = 0xFFFFFFFF
|
|
SMWD = 0xFFFF
|
|
SMBY = 0xFF
|
|
NAnd (Arg0, Arg1, ARSL) /* \NBIT.ARSL */
|
|
If ((ARSL != 0xFFFFFFFD))
|
|
{
|
|
Return (0x0B)
|
|
}
|
|
|
|
Local0 = Arg0
|
|
Local1 = Arg1
|
|
NAnd (Local0, Local1, LRSL) /* \NBIT.LRSL */
|
|
If ((LRSL != 0xFFFFFFFD))
|
|
{
|
|
Return (0x0C)
|
|
}
|
|
|
|
/*Byte data */
|
|
|
|
NAnd (BYT1, BYT2, BRSL) /* \NBIT.BRSL */
|
|
If ((BRSL != 0xFFFFFF00))
|
|
{
|
|
Return (0x0D)
|
|
}
|
|
|
|
/*Word Data */
|
|
|
|
NAnd (WRD1, WRD2, WRSL) /* \NBIT.WRSL */
|
|
If ((WRSL != 0xFFFF0000))
|
|
{
|
|
Return (0x0E)
|
|
}
|
|
|
|
/*DWord Data */
|
|
|
|
NAnd (DWD1, DWD2, DRSL) /* \NBIT.DRSL */
|
|
If ((DRSL != 0x00))
|
|
{
|
|
Return (0x0F)
|
|
}
|
|
|
|
/*Byte data */
|
|
|
|
NAnd (SMBY, 0xFF, BRSL) /* \NBIT.BRSL */
|
|
If ((BRSL != 0xFFFFFF00))
|
|
{
|
|
Return (0x10)
|
|
}
|
|
|
|
/*Word Data */
|
|
|
|
NAnd (SMWD, 0xFFFF, WRSL) /* \NBIT.WRSL */
|
|
If ((WRSL != 0xFFFF0000))
|
|
{
|
|
Return (0x11)
|
|
}
|
|
|
|
/*DWord Data */
|
|
|
|
NAnd (SMDW, 0xFFFFFFFF, DRSL) /* \NBIT.DRSL */
|
|
If ((DRSL != 0x00))
|
|
{
|
|
Return (0x12)
|
|
}
|
|
|
|
Return (0x00)
|
|
}/*NNDB */
|
|
|
|
Method (NNOR, 2, NotSerialized)
|
|
{
|
|
/*NNOR */
|
|
|
|
NOr (Arg0, Arg1, ARSL) /* \NBIT.ARSL */
|
|
If ((ARSL != 0xFFFFFFFD))
|
|
{
|
|
Return (0x15)
|
|
}
|
|
|
|
Local0 = Arg0
|
|
Local1 = Arg1
|
|
NOr (Local0, Local1, LRSL) /* \NBIT.LRSL */
|
|
If ((LRSL != 0xFFFFFFFD))
|
|
{
|
|
Return (0x16)
|
|
}
|
|
|
|
/*Byte data */
|
|
|
|
NOr (BYT1, BYT2, BRSL) /* \NBIT.BRSL */
|
|
If ((BRSL != 0xFFFFFF00))
|
|
{
|
|
Return (0x17)
|
|
}
|
|
|
|
/*Word Data */
|
|
|
|
NOr (WRD1, WRD2, WRSL) /* \NBIT.WRSL */
|
|
If ((WRSL != 0xFFFF0000))
|
|
{
|
|
Return (0x18)
|
|
}
|
|
|
|
/*DWord Data */
|
|
|
|
NOr (DWD1, DWD2, DRSL) /* \NBIT.DRSL */
|
|
If ((DRSL != 0x00))
|
|
{
|
|
Return (0x19)
|
|
}
|
|
|
|
/*System Memory Byte data */
|
|
|
|
NOr (SMBY, 0xFF, BRSL) /* \NBIT.BRSL */
|
|
If ((BRSL != 0xFFFFFF00))
|
|
{
|
|
Return (0x1A)
|
|
}
|
|
|
|
/*System Memory Word Data */
|
|
|
|
NOr (SMWD, 0xFFFF, WRSL) /* \NBIT.WRSL */
|
|
If ((WRSL != 0xFFFF0000))
|
|
{
|
|
Return (0x1B)
|
|
}
|
|
|
|
/*System Memory DWord Data */
|
|
|
|
NOr (SMDW, 0xFFFFFFFF, DRSL) /* \NBIT.DRSL */
|
|
If ((DRSL != 0x00))
|
|
{
|
|
Return (0x1C)
|
|
}
|
|
|
|
Return (0x00)
|
|
}/*NNOR */
|
|
|
|
Method (NNOT, 2, NotSerialized)
|
|
{
|
|
/*NNOT */
|
|
|
|
ARSL = (Arg0 | Arg1)
|
|
ARSL = ~ARSL /* \NBIT.ARSL */
|
|
If ((ARSL != 0xFFFFFFFD))
|
|
{
|
|
Return (0x1F)
|
|
}
|
|
|
|
Local0 = Arg0
|
|
Local1 = Arg1
|
|
LRSL = (Local0 | Local1)
|
|
LRSL = ~LRSL /* \NBIT.LRSL */
|
|
If ((LRSL != 0xFFFFFFFD))
|
|
{
|
|
Return (0x20)
|
|
}
|
|
|
|
/*Byte data */
|
|
|
|
BRSL = (BYT1 | BYT2) /* \NBIT.BYT2 */
|
|
BRSL = ~BRSL /* \NBIT.BRSL */
|
|
If ((BRSL != 0xFFFFFF00))
|
|
{
|
|
Return (0x21)
|
|
}
|
|
|
|
/*Word Data */
|
|
|
|
WRSL = (WRD1 | WRD2) /* \NBIT.WRD2 */
|
|
WRSL = ~WRSL /* \NBIT.WRSL */
|
|
If ((WRSL != 0xFFFF0000))
|
|
{
|
|
Return (0x22)
|
|
}
|
|
|
|
/*DWord Data */
|
|
|
|
DRSL = (DWD1 | DWD2) /* \NBIT.DWD2 */
|
|
DRSL = ~DRSL /* \NBIT.DRSL */
|
|
If ((DRSL != 0x00))
|
|
{
|
|
Return (0x23)
|
|
}
|
|
|
|
/*System Memory Byte data */
|
|
|
|
BRSL = (SMBY | 0xFF)
|
|
BRSL = ~BRSL /* \NBIT.BRSL */
|
|
If ((BRSL != 0xFFFFFF00))
|
|
{
|
|
Return (0x24)
|
|
}
|
|
|
|
/*System Memory Word Data */
|
|
|
|
WRSL = (SMWD | 0xFFFF)
|
|
WRSL = ~WRSL /* \NBIT.WRSL */
|
|
If ((WRSL != 0xFFFF0000))
|
|
{
|
|
Return (0x25)
|
|
}
|
|
|
|
/*System Memory DWord Data */
|
|
|
|
DRSL = (SMDW | 0xFFFFFFFF)
|
|
DRSL = ~DRSL /* \NBIT.DRSL */
|
|
If ((DRSL != 0x00))
|
|
{
|
|
Return (0x26)
|
|
}
|
|
|
|
Return (0x00)
|
|
}/*NNOT */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ NBitOps Test"
|
|
RSLT = NNDB (0x02, 0x02)
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \NBIT.RSLT */
|
|
}
|
|
|
|
RSLT = NNOR (0x02, 0x02)
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \NBIT.RSLT */
|
|
}
|
|
|
|
RSLT = NNOT (0x02, 0x02)
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \NBIT.RSLT */
|
|
}
|
|
|
|
Return (0x00)
|
|
}
|
|
}/*Device NBIT */
|
|
|
|
/* */
|
|
/* test ShftOp.asl */
|
|
/* */
|
|
/*ShiftRightTerm := ShiftRight( */
|
|
/* Source, //TermArg=>Integer */
|
|
/* ShiftCount //TermArg=>Integer */
|
|
/* Result //Nothing | SuperName */
|
|
/*) => Integer */
|
|
/*Source and ShiftCount are evaluated as integer data types. Source is shifted right with the most significant bit */
|
|
/*zeroed ShiftCount times. The result is optionally stored into Result. */
|
|
/*ShiftLeft( */
|
|
/* Source, //TermArg=>Integer */
|
|
/* ShiftCount //TermArg=>Integer */
|
|
/* Result //Nothing | SuperName */
|
|
/*) => Integer */
|
|
/*Source and ShiftCount are evaluated as integer data types. Source is shifted left with the least significant */
|
|
/*bit zeroed ShiftCount times. The result is optionally stored into Result. */
|
|
/*If the Control method is success Zero is returned else a non-zero number is returned */
|
|
Device (SHFT)
|
|
{
|
|
/*SHFT */
|
|
/*Create System Memory Operation Region and field overlays */
|
|
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
SMDW, /* 32-bit DWORD */ 32,
|
|
SMWD, /* 16-bit WORD */ 16,
|
|
SMBY, /* 8-bit BYTE */ 8
|
|
}/* Field(RAM) */
|
|
|
|
Name (SHFC, 0x00)
|
|
/*And with Byte Data */
|
|
|
|
Name (BYT1, 0xFF)
|
|
Name (BRSL, 0x00)
|
|
/*And with Word Data */
|
|
|
|
Name (WRD1, 0xFFFF)
|
|
Name (WRSL, 0x00)
|
|
/*And with DWord Data */
|
|
|
|
Name (DWD1, 0xFFFFFFFF)
|
|
Name (DRSL, 0x00)
|
|
Name (RSLT, 0x01)
|
|
Name (ARSL, 0x00)
|
|
Name (LRSL, 0x00)
|
|
Method (SLFT, 2, NotSerialized)
|
|
{
|
|
/*SLFT */
|
|
|
|
SMDW = 0xFFFFFFFF
|
|
SMWD = 0xFFFF
|
|
SMBY = 0xFF
|
|
/*Arg0-> 2 & Arg1->2 */
|
|
|
|
ARSL = (Arg0 << Arg1)
|
|
If ((ARSL != 0x08))
|
|
{
|
|
Return (0x0B)
|
|
}
|
|
|
|
Local0 = Arg0
|
|
Local1 = Arg1
|
|
/*Local0->8 and Local1->2 */
|
|
|
|
LRSL = (Local0 << Local1)
|
|
If ((LRSL != 0x08))
|
|
{
|
|
Return (0x0C)
|
|
}
|
|
|
|
SHFC = 0x02
|
|
/*Byte data */
|
|
|
|
BRSL = (BYT1 << SHFC) /* \SHFT.SHFC */
|
|
If ((BRSL != 0x03FC))
|
|
{
|
|
Return (0x0D)
|
|
}
|
|
|
|
SHFC = 0x04
|
|
/*Word Data */
|
|
|
|
WRSL = (WRD1 << SHFC) /* \SHFT.SHFC */
|
|
If ((WRSL != 0x000FFFF0))
|
|
{
|
|
Return (0x0E)
|
|
}
|
|
|
|
SHFC = 0x08
|
|
/*DWord Data */
|
|
|
|
DRSL = (DWD1 << SHFC) /* \SHFT.SHFC */
|
|
If ((DRSL != 0xFFFFFF00))
|
|
{
|
|
Return (0x0F)
|
|
}
|
|
|
|
/*System Memory Byte data */
|
|
|
|
SHFC = 0x04
|
|
BRSL = (SMBY << SHFC) /* \SHFT.SHFC */
|
|
If ((BRSL != 0x0FF0))
|
|
{
|
|
Return (0x10)
|
|
}
|
|
|
|
/*Word Data */
|
|
|
|
SHFC = 0x04
|
|
WRSL = (SMWD << SHFC) /* \SHFT.SHFC */
|
|
If ((WRSL != 0x000FFFF0))
|
|
{
|
|
Return (0x11)
|
|
}
|
|
|
|
/*DWord Data */
|
|
|
|
SHFC = 0x08
|
|
DRSL = (SMDW << SHFC) /* \SHFT.SHFC */
|
|
If ((DRSL != 0xFFFFFF00))
|
|
{
|
|
Return (0x12)
|
|
}
|
|
|
|
Return (0x00)
|
|
}/*SLFT */
|
|
|
|
Method (SRGT, 2, NotSerialized)
|
|
{
|
|
/*SRGT */
|
|
/*And with Byte Data */
|
|
BYT1 = 0xFF
|
|
BRSL = 0x00
|
|
/*And with Word Data */
|
|
|
|
WRD1 = 0xFFFF
|
|
WRSL = 0x00
|
|
/*And with DWord Data */
|
|
|
|
DWD1 = 0xFFFFFFFF
|
|
DRSL = 0x00
|
|
/*Reinitialize the result objects */
|
|
|
|
ARSL = 0x00
|
|
LRSL = 0x00
|
|
SMDW = 0xFFFFFFFF
|
|
SMWD = 0xFFFF
|
|
SMBY = 0xFF
|
|
/*Arg0-> 2 & Arg1->2 */
|
|
|
|
ARSL = (Arg0 >> Arg1)
|
|
If ((ARSL != 0x00))
|
|
{
|
|
Return (0x15)
|
|
}
|
|
|
|
Local0 = Arg0
|
|
Local1 = Arg1
|
|
/*Local0->8 and Local1->2 */
|
|
|
|
LRSL = (Local0 >> Local1)
|
|
If ((LRSL != 0x00))
|
|
{
|
|
Return (0x16)
|
|
}
|
|
|
|
SHFC = 0x02
|
|
/*Byte data */
|
|
|
|
BRSL = (BYT1 >> SHFC) /* \SHFT.SHFC */
|
|
If ((BRSL != 0x3F))
|
|
{
|
|
Return (0x17)
|
|
}
|
|
|
|
SHFC = 0x04
|
|
/*Word Data */
|
|
|
|
WRSL = (WRD1 >> SHFC) /* \SHFT.SHFC */
|
|
If ((WRSL != 0x0FFF))
|
|
{
|
|
Return (0x18)
|
|
}
|
|
|
|
SHFC = 0x08
|
|
/*DWord Data */
|
|
|
|
DRSL = (DWD1 >> SHFC) /* \SHFT.SHFC */
|
|
If ((DRSL != 0x00FFFFFF))
|
|
{
|
|
Return (0x19)
|
|
}
|
|
|
|
/*System Memory Byte data */
|
|
|
|
SHFC = 0x04
|
|
BRSL = (SMBY >> SHFC) /* \SHFT.SHFC */
|
|
If ((BRSL != 0x0F))
|
|
{
|
|
Return (0x1A)
|
|
}
|
|
|
|
/*Word Data */
|
|
|
|
SHFC = 0x04
|
|
WRSL = (SMWD >> SHFC) /* \SHFT.SHFC */
|
|
If ((WRSL != 0x0FFF))
|
|
{
|
|
Return (0x1B)
|
|
}
|
|
|
|
/*DWord Data */
|
|
|
|
SHFC = 0x08
|
|
DRSL = (SMDW >> SHFC) /* \SHFT.SHFC */
|
|
If ((DRSL != 0x00FFFFFF))
|
|
{
|
|
Return (0x1C)
|
|
}
|
|
|
|
Return (0x00)
|
|
}/*SRGT */
|
|
|
|
/*Test method called from amlexec */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ ShftOp Test"
|
|
RSLT = SLFT (0x02, 0x02)
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \SHFT.RSLT */
|
|
}
|
|
|
|
RSLT = SRGT (0x02, 0x02)
|
|
If ((RSLT != 0x00))
|
|
{
|
|
Return (RSLT) /* \SHFT.RSLT */
|
|
}
|
|
|
|
Return (0x00)
|
|
}
|
|
}/*Device SHFT */
|
|
|
|
/* */
|
|
/* test Xor.asl and slightly modified */
|
|
/* */
|
|
/*This code tests the XOR opcode term */
|
|
/*Syntax of XOR term */
|
|
/* XOr( */
|
|
/* Source1 //TermArg=>BufferTerm */
|
|
/* Source2 //TermArg=>Integer */
|
|
/* Result //NameString */
|
|
/* ) */
|
|
/*"Source1" and "Source2" are evaluated as integers, a bit-wise XOR is performed, and the result is optionally stored in */
|
|
/* Result */
|
|
Device (XORD)
|
|
{
|
|
/*This Method tests XOr operator for all the data types i.e. BYTE, WORD and DWORD */
|
|
|
|
Method (TEST, 0, Serialized)
|
|
{
|
|
Debug = "++++++++ Xor Test"
|
|
/*Overlay in system memory */
|
|
|
|
OperationRegion (RAM, SystemMemory, 0x00800000, 0x0100)
|
|
Field (RAM, ByteAcc, NoLock, Preserve)
|
|
{
|
|
RES1, /*Offset */ 1,
|
|
BYT1, /*First BYTE */ 8,
|
|
BYT2, /*Second BYTE */ 8,
|
|
RBYT, /*Result Byte */ 8,
|
|
RES2, /*Offset */ 1,
|
|
WRD1, /*First WORD field */ 16,
|
|
WRD2, /*Second WORD field */ 16,
|
|
RWRD, /*RSLT WORD field */ 16,
|
|
RES3, /*Offset */ 1,
|
|
DWD1, /*First Dword */ 32,
|
|
DWD2, /*Second Dword */ 32,
|
|
RDWD, /*Result Dword */ 32,
|
|
RES4, /*Offset */ 1
|
|
}
|
|
|
|
/* Store bits in the single bit fields for checking */
|
|
/* at the end */
|
|
RES1 = 0x01
|
|
RES2 = 0x01
|
|
RES3 = 0x01
|
|
RES4 = 0x01
|
|
/* Check the stored single bits */
|
|
|
|
If ((RES1 != 0x01))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RES2 != 0x01))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RES3 != 0x01))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RES4 != 0x01))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/************************************************* */
|
|
/* (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition */
|
|
BYT1 = 0x00
|
|
BYT2 = 0x00
|
|
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
|
|
RBYT = Local0
|
|
If ((RBYT != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition */
|
|
|
|
BYT1 = 0xFF
|
|
BYT2 = 0xFF
|
|
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
|
|
RBYT = Local0
|
|
If ((RBYT != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition */
|
|
|
|
BYT1 = 0x55
|
|
BYT2 = 0xAA
|
|
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
|
|
RBYT = Local0
|
|
If ((RBYT != 0xFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/*(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition */
|
|
|
|
BYT1 = 0xAA
|
|
BYT2 = 0x55
|
|
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
|
|
RBYT = Local0
|
|
If ((RBYT != 0xFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
BYT1 = 0x12
|
|
BYT2 = 0xED
|
|
Local0 = (BYT1 ^ BYT2) /* \XORD.TEST.BYT2 */
|
|
RBYT = Local0
|
|
If ((RBYT != 0xFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* Store known values for checking later */
|
|
|
|
BYT1 = 0x12
|
|
If ((BYT1 != 0x12))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
BYT2 = 0xFE
|
|
If ((BYT2 != 0xFE))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
RBYT = 0xAB
|
|
If ((RBYT != 0xAB))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/************************************************ */
|
|
/* (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition */
|
|
WRD1 = 0x00
|
|
WRD2 = 0x00
|
|
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
|
|
If ((RWRD != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition */
|
|
|
|
WRD1 = 0xFFFF
|
|
WRD2 = 0xFFFF
|
|
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
|
|
If ((RWRD != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition */
|
|
|
|
WRD1 = 0x5555
|
|
WRD2 = 0xAAAA
|
|
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
|
|
If ((RWRD != 0xFFFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/*(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition */
|
|
|
|
WRD1 = 0xAAAA
|
|
WRD2 = 0x5555
|
|
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
|
|
If ((RWRD != 0xFFFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
WRD1 = 0x1234
|
|
WRD2 = 0xEDCB
|
|
RWRD = (WRD1 ^ WRD2) /* \XORD.TEST.WRD2 */
|
|
If ((RWRD != 0xFFFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* Store known values for checking later */
|
|
|
|
WRD1 = 0x1234
|
|
If ((WRD1 != 0x1234))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
WRD2 = 0xFEDC
|
|
If ((WRD2 != 0xFEDC))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
RWRD = 0x87AB
|
|
If ((RWRD != 0x87AB))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/*************************************************** */
|
|
/* (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition */
|
|
DWD1 = 0x00
|
|
DWD2 = 0x00
|
|
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
|
|
If ((RDWD != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition */
|
|
|
|
DWD1 = 0xFFFFFFFF
|
|
DWD2 = 0xFFFFFFFF
|
|
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
|
|
If ((RDWD != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition */
|
|
|
|
DWD1 = 0x55555555
|
|
DWD2 = 0xAAAAAAAA
|
|
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
|
|
If ((RDWD != 0xFFFFFFFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/*(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition */
|
|
|
|
DWD1 = 0xAAAAAAAA
|
|
DWD2 = 0x55555555
|
|
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
|
|
If ((RDWD != 0xFFFFFFFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition */
|
|
|
|
DWD1 = 0x12345678
|
|
DWD2 = 0xEDCBA987
|
|
RDWD = (DWD1 ^ DWD2) /* \XORD.TEST.DWD2 */
|
|
If ((RDWD != 0xFFFFFFFF))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
DWD1 = 0x12345678
|
|
If ((DWD1 != 0x12345678))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
DWD2 = 0xFEDCBA98
|
|
If ((DWD2 != 0xFEDCBA98))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
RDWD = 0x91827364
|
|
If ((RDWD != 0x91827364))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/***************************************************** */
|
|
/* Check the stored single bits */
|
|
If ((RES1 != 0x01))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RES2 != 0x01))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RES3 != 0x01))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RES4 != 0x01))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* Change all of the single bit fields to zero */
|
|
|
|
RES1 = 0x00
|
|
RES2 = 0x00
|
|
RES3 = 0x00
|
|
RES4 = 0x00
|
|
/* Now, check all of the fields */
|
|
/* Byte */
|
|
If ((BYT1 != 0x12))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((BYT2 != 0xFE))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RBYT != 0xAB))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* Word */
|
|
|
|
If ((WRD1 != 0x1234))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((WRD2 != 0xFEDC))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RWRD != 0x87AB))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* Dword */
|
|
|
|
If ((DWD1 != 0x12345678))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((DWD2 != 0xFEDCBA98))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RDWD != 0x91827364))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* Bits */
|
|
|
|
If ((RES1 != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RES2 != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RES3 != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((RES4 != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* XORD */
|
|
|
|
/* */
|
|
/* test CrBytFld.asl */
|
|
/* */
|
|
/* CrBytFld test */
|
|
/* Test for CreateByteField. */
|
|
/* Tests creating byte field overlay of buffer stored in Local0. */
|
|
/* Tests need to be added for Arg0 and Name buffers. */
|
|
/* */
|
|
Device (CRBF)
|
|
{
|
|
/* Test device name */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ CrBytFld Test"
|
|
/* Local0 is unitialized buffer with 4 elements */
|
|
|
|
Local0 = Buffer (0x04){}
|
|
/* create Byte Field named BF0 based on Local0 element 0 */
|
|
|
|
CreateByteField (Local0, 0x00, BF0)
|
|
/* validate CreateByteField did not alter Local0 */
|
|
|
|
Local1 = ObjectType (Local0) /* Local1 = Local0 object type */
|
|
If ((Local1 != 0x03)) /* Buffer object type value is 3 */
|
|
{
|
|
Return (0x02)
|
|
}
|
|
|
|
/* store something into BF0 */
|
|
|
|
BF0 = 0x01
|
|
/* validate Store did not alter Local0 object type */
|
|
|
|
Local1 = ObjectType (Local0) /* Local1 = Local0 object type */
|
|
If ((Local1 != 0x03)) /* Buffer object type value is 3 */
|
|
{
|
|
Return (0x03)
|
|
}
|
|
|
|
/* verify that the Store into BF0 was successful */
|
|
|
|
If ((BF0 != 0x01))
|
|
{
|
|
Return (0x04)
|
|
}
|
|
|
|
/* create Byte Field named BF1 based on Local0 element 1 */
|
|
|
|
CreateByteField (Local0, 0x01, BF1)
|
|
/* validate CreateByteField did not alter Local0 */
|
|
|
|
Local1 = ObjectType (Local0) /* Local1 = Local0 object type */
|
|
If ((Local1 != 0x03)) /* Buffer object type value is 3 */
|
|
{
|
|
Return (0x0A)
|
|
}
|
|
|
|
/* store something into BF1 */
|
|
|
|
BF1 = 0x05
|
|
/* validate Store did not alter Local0 object type */
|
|
|
|
Local1 = ObjectType (Local0) /* Local1 = Local0 object type */
|
|
If ((Local1 != 0x03)) /* Buffer object type value is 3 */
|
|
{
|
|
Return (0x0B)
|
|
}
|
|
|
|
/* verify that the Store into BF1 was successful */
|
|
|
|
If ((BF1 != 0x05))
|
|
{
|
|
Return (0x0C)
|
|
}
|
|
|
|
/* verify that the Store into BF1 did not alter BF0 */
|
|
|
|
If ((BF0 != 0x01))
|
|
{
|
|
Return (0x0D)
|
|
}
|
|
|
|
/* store something into BF0 */
|
|
|
|
BF0 = 0xFFFF
|
|
/* verify that the Store into BF0 was successful */
|
|
|
|
If ((BF0 != 0xFF))
|
|
{
|
|
Return (0x14)
|
|
}
|
|
|
|
/* verify that the Store into BF0 did not alter BF1 */
|
|
|
|
If ((BF1 != 0x05))
|
|
{
|
|
Return (0x15)
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* CRBF */
|
|
|
|
/* */
|
|
/* test IndexOp4.asl */
|
|
/* */
|
|
/* IndexOp4 test */
|
|
/* This is just a subset of the many RegionOp/Index Field test cases. */
|
|
/* Tests access of index fields smaller than 8 bits. */
|
|
/* */
|
|
Device (IDX4)
|
|
{
|
|
/* Test device name */
|
|
/* MADM: Misaligned Dynamic RAM SystemMemory OperationRegion */
|
|
/* Tests OperationRegion memory access using misaligned BYTE, */
|
|
/* WORD, and DWORD field element accesses. Validation is performed */
|
|
/* using both misaligned field entries and aligned field entries. */
|
|
/* */
|
|
/* MADM returns 0 if all test cases pass or non-zero identifying */
|
|
/* the failing test case for debug purposes. This non-zero numbers */
|
|
/* are not guaranteed to be in perfect sequence (i.e., test case */
|
|
/* index), but are guaranteed to be unique so the failing test */
|
|
/* case can be uniquely identified. */
|
|
/* */
|
|
Method (MADM, 1, Serialized)
|
|
{
|
|
/* MADM: Misaligned Dynamic RAM SystemMemory OperationRegion */
|
|
|
|
OperationRegion (RAM, SystemMemory, Arg0, 0x0100)
|
|
Field (RAM, DWordAcc, NoLock, Preserve)
|
|
{
|
|
/* aligned field definition (for verification) */
|
|
|
|
DWD0, /* aligned DWORD field */ 32,
|
|
DWD1, /* aligned DWORD field */ 32
|
|
}
|
|
|
|
Field (RAM, ByteAcc, NoLock, Preserve)
|
|
{
|
|
/* bit access field definition */
|
|
|
|
BIT0, /* single bit field entry */ 1,
|
|
BIT1, /* single bit field entry */ 1,
|
|
BIT2, /* single bit field entry */ 1,
|
|
BIT3, /* single bit field entry */ 1,
|
|
BIT4, /* single bit field entry */ 1,
|
|
BIT5, /* single bit field entry */ 1,
|
|
BIT6, /* single bit field entry */ 1,
|
|
BIT7, /* single bit field entry */ 1,
|
|
BIT8, /* single bit field entry */ 1,
|
|
BIT9, /* single bit field entry */ 1,
|
|
BITA, /* single bit field entry */ 1,
|
|
BITB, /* single bit field entry */ 1,
|
|
BITC, /* single bit field entry */ 1,
|
|
BITD, /* single bit field entry */ 1,
|
|
BITE, /* single bit field entry */ 1,
|
|
BITF, /* single bit field entry */ 1,
|
|
BI10, /* single bit field entry */ 1,
|
|
BI11, /* single bit field entry */ 1,
|
|
BI12, /* single bit field entry */ 1,
|
|
BI13, /* single bit field entry */ 1,
|
|
BI14, /* single bit field entry */ 1,
|
|
BI15, /* single bit field entry */ 1,
|
|
BI16, /* single bit field entry */ 1,
|
|
BI17, /* single bit field entry */ 1,
|
|
BI18, /* single bit field entry */ 1,
|
|
BI19, /* single bit field entry */ 1,
|
|
BI1A, /* single bit field entry */ 1,
|
|
BI1B, /* single bit field entry */ 1,
|
|
BI1C, /* single bit field entry */ 1,
|
|
BI1D, /* single bit field entry */ 1,
|
|
BI1E, /* single bit field entry */ 1,
|
|
BI1F, /* single bit field entry */ 1
|
|
} /* bit access field definition */
|
|
|
|
Field (RAM, ByteAcc, NoLock, Preserve)
|
|
{
|
|
/* two-bit access field definition */
|
|
|
|
B2_0, /* single bit field entry */ 2,
|
|
B2_1, /* single bit field entry */ 2,
|
|
B2_2, /* single bit field entry */ 2,
|
|
B2_3, /* single bit field entry */ 2,
|
|
B2_4, /* single bit field entry */ 2,
|
|
B2_5, /* single bit field entry */ 2,
|
|
B2_6, /* single bit field entry */ 2,
|
|
B2_7, /* single bit field entry */ 2,
|
|
B2_8, /* single bit field entry */ 2,
|
|
B2_9, /* single bit field entry */ 2,
|
|
B2_A, /* single bit field entry */ 2,
|
|
B2_B, /* single bit field entry */ 2,
|
|
B2_C, /* single bit field entry */ 2,
|
|
B2_D, /* single bit field entry */ 2,
|
|
B2_E, /* single bit field entry */ 2,
|
|
B2_F, /* single bit field entry */ 2
|
|
} /* bit access field definition */
|
|
|
|
/* initialize memory contents using aligned field entries */
|
|
|
|
DWD0 = 0x5AA55AA5
|
|
DWD1 = 0x5AA55AA5
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT0 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT0 != 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55AA4))
|
|
{
|
|
Return (0x02)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT1 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT1 != 0x01))
|
|
{
|
|
Return (0x03)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55AA6))
|
|
{
|
|
Return (0x04)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT2 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT2 != 0x00))
|
|
{
|
|
Return (0x05)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55AA2))
|
|
{
|
|
Return (0x06)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT3 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT3 != 0x01))
|
|
{
|
|
Return (0x07)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55AAA))
|
|
{
|
|
Return (0x08)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT4 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT4 != 0x01))
|
|
{
|
|
Return (0x09)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55ABA))
|
|
{
|
|
Return (0x0A)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT5 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT5 != 0x00))
|
|
{
|
|
Return (0x0B)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55A9A))
|
|
{
|
|
Return (0x0C)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT6 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT6 != 0x01))
|
|
{
|
|
Return (0x0D)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55ADA))
|
|
{
|
|
Return (0x0E)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT7 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT7 != 0x00))
|
|
{
|
|
Return (0x0F)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55A5A))
|
|
{
|
|
Return (0x10)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT8 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT8 != 0x01))
|
|
{
|
|
Return (0x11)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55B5A))
|
|
{
|
|
Return (0x12)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BIT9 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BIT9 != 0x00))
|
|
{
|
|
Return (0x13)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA5595A))
|
|
{
|
|
Return (0x14)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BITA = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BITA != 0x01))
|
|
{
|
|
Return (0x15)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA55D5A))
|
|
{
|
|
Return (0x16)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BITB = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BITB != 0x00))
|
|
{
|
|
Return (0x17)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA5555A))
|
|
{
|
|
Return (0x18)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BITC = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BITC != 0x00))
|
|
{
|
|
Return (0x19)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA5455A))
|
|
{
|
|
Return (0x1A)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BITD = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BITD != 0x01))
|
|
{
|
|
Return (0x1B)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA5655A))
|
|
{
|
|
Return (0x1C)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BITE = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BITE != 0x00))
|
|
{
|
|
Return (0x1D)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA5255A))
|
|
{
|
|
Return (0x1E)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BITF = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BITF != 0x01))
|
|
{
|
|
Return (0x1F)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA5A55A))
|
|
{
|
|
Return (0x20)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI10 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI10 != 0x00))
|
|
{
|
|
Return (0x21)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA4A55A))
|
|
{
|
|
Return (0x22)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI11 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI11 != 0x01))
|
|
{
|
|
Return (0x23)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA6A55A))
|
|
{
|
|
Return (0x24)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI12 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI12 != 0x00))
|
|
{
|
|
Return (0x25)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AA2A55A))
|
|
{
|
|
Return (0x26)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI13 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI13 != 0x01))
|
|
{
|
|
Return (0x27)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5AAAA55A))
|
|
{
|
|
Return (0x28)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI14 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI14 != 0x01))
|
|
{
|
|
Return (0x29)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5ABAA55A))
|
|
{
|
|
Return (0x2A)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI15 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI15 != 0x00))
|
|
{
|
|
Return (0x2B)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5A9AA55A))
|
|
{
|
|
Return (0x2C)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI16 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI16 != 0x01))
|
|
{
|
|
Return (0x2D)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5ADAA55A))
|
|
{
|
|
Return (0x2E)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI17 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI17 != 0x00))
|
|
{
|
|
Return (0x2F)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5A5AA55A))
|
|
{
|
|
Return (0x30)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI18 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI18 != 0x01))
|
|
{
|
|
Return (0x31)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5B5AA55A))
|
|
{
|
|
Return (0x32)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI19 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI19 != 0x00))
|
|
{
|
|
Return (0x33)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x595AA55A))
|
|
{
|
|
Return (0x34)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI1A = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI1A != 0x01))
|
|
{
|
|
Return (0x35)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x5D5AA55A))
|
|
{
|
|
Return (0x36)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI1B = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI1B != 0x00))
|
|
{
|
|
Return (0x37)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x555AA55A))
|
|
{
|
|
Return (0x38)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI1C = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI1C != 0x00))
|
|
{
|
|
Return (0x39)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x455AA55A))
|
|
{
|
|
Return (0x3A)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI1D = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI1D != 0x01))
|
|
{
|
|
Return (0x3B)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x655AA55A))
|
|
{
|
|
Return (0x3C)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI1E = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI1E != 0x00))
|
|
{
|
|
Return (0x3D)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x255AA55A))
|
|
{
|
|
Return (0x3E)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
BI1F = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((BI1F != 0x01))
|
|
{
|
|
Return (0x3F)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55AA55A))
|
|
{
|
|
Return (0x40)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_0 = 0x03
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_0 != 0x03))
|
|
{
|
|
Return (0x41)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55AA55B))
|
|
{
|
|
Return (0x42)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_1 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_1 != 0x01))
|
|
{
|
|
Return (0x43)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55AA557))
|
|
{
|
|
Return (0x44)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_2 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_2 != 0x00))
|
|
{
|
|
Return (0x45)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55AA547))
|
|
{
|
|
Return (0x46)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_3 = 0x03
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_3 != 0x03))
|
|
{
|
|
Return (0x47)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55AA5C7))
|
|
{
|
|
Return (0x48)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_4 = 0x03
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_4 != 0x03))
|
|
{
|
|
Return (0x49)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55AA7C7))
|
|
{
|
|
Return (0x4A)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_5 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_5 != 0x00))
|
|
{
|
|
Return (0x4B)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55AA3C7))
|
|
{
|
|
Return (0x4C)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_6 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_6 != 0x01))
|
|
{
|
|
Return (0x4D)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55A93C7))
|
|
{
|
|
Return (0x4E)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_7 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_7 != 0x01))
|
|
{
|
|
Return (0x4F)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55A53C7))
|
|
{
|
|
Return (0x50)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_8 = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_8 != 0x00))
|
|
{
|
|
Return (0x51)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55853C7))
|
|
{
|
|
Return (0x52)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_9 = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_9 != 0x01))
|
|
{
|
|
Return (0x53)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA55453C7))
|
|
{
|
|
Return (0x54)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_A = 0x02
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_A != 0x02))
|
|
{
|
|
Return (0x55)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA56453C7))
|
|
{
|
|
Return (0x56)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_B = 0x02
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_B != 0x02))
|
|
{
|
|
Return (0x57)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA5A453C7))
|
|
{
|
|
Return (0x58)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_C = 0x03
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_C != 0x03))
|
|
{
|
|
Return (0x59)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xA7A453C7))
|
|
{
|
|
Return (0x5A)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_D = 0x03
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_D != 0x03))
|
|
{
|
|
Return (0x5B)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0xAFA453C7))
|
|
{
|
|
Return (0x5C)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_E = 0x01
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_E != 0x01))
|
|
{
|
|
Return (0x5D)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x9FA453C7))
|
|
{
|
|
Return (0x5E)
|
|
}
|
|
|
|
/* set memory contents to known values using misaligned field entries */
|
|
|
|
B2_F = 0x00
|
|
/* verify memory contents using misaligned field entries */
|
|
|
|
If ((B2_F != 0x00))
|
|
{
|
|
Return (0x5F)
|
|
}
|
|
|
|
/* verify memory contents using aligned field entries */
|
|
|
|
If ((DWD0 != 0x1FA453C7))
|
|
{
|
|
Return (0x60)
|
|
}
|
|
|
|
Return (0x00) /* pass */
|
|
} /* MADM: Misaligned Dynamic RAM SystemMemory OperationRegion */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ IndexOp4 Test"
|
|
/* MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments: */
|
|
/* Arg0 -- SystemMemory OperationRegion base address */
|
|
Local0 = MADM (0x00800000)
|
|
If ((Local0 != 0x00)) /* MADM returns zero if successful */
|
|
{
|
|
Return (Local0)
|
|
} /* failure: return MADM error code */
|
|
|
|
Return (Local0)
|
|
} /* TEST */
|
|
} /* IDX4 */
|
|
|
|
/* */
|
|
/* test Event.asl */
|
|
/* */
|
|
/* EventOp, ResetOp, SignalOp, and WaitOp test cases. */
|
|
/* */
|
|
Device (EVNT)
|
|
{
|
|
Event (EVNT) /* event synchronization object */
|
|
Method (TEVN, 1, NotSerialized)
|
|
{
|
|
/* TEVN control method to test ResetOp, SignalOp, and WaitOp */
|
|
/* reset EVNT to initialization (zero) state */
|
|
Reset (EVNT)
|
|
/* prime EVNT with two outstanding signals */
|
|
|
|
Signal (EVNT)
|
|
Signal (EVNT)
|
|
/* acquire existing signal */
|
|
|
|
Local0 = Wait (EVNT, Arg0)
|
|
/* validate Local0 is a Number */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 != 0x01)) /* Number is type 1 */
|
|
{
|
|
Return (0x21)
|
|
} /* Local1 indicates Local0 is not a Number */
|
|
|
|
If ((Local0 != 0x00)) /* Number is type 1 */
|
|
{
|
|
Return (0x22)
|
|
} /* timeout occurred without acquiring signal */
|
|
|
|
Debug = "Acquire 1st existing signal PASS"
|
|
/* acquire existing signal */
|
|
|
|
Local0 = Wait (EVNT, Arg0)
|
|
/* validate Local0 is a Number */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 != 0x01)) /* Number is type 1 */
|
|
{
|
|
Return (0x31)
|
|
} /* Local1 indicates Local0 is not a Number */
|
|
|
|
If ((Local0 != 0x00)) /* Number is type 1 */
|
|
{
|
|
Return (0x32)
|
|
} /* timeout occurred without acquiring signal */
|
|
|
|
Debug = "Acquire 2nd existing signal PASS"
|
|
/* ensure WaitOp timeout test cases do not hang */
|
|
|
|
If ((Arg0 == 0xFFFF))
|
|
{
|
|
Arg0 = 0xFFFE
|
|
}
|
|
|
|
/* acquire non-existing signal */
|
|
|
|
Local0 = Wait (EVNT, Arg0)
|
|
/* validate Local0 is a Number */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 != 0x01)) /* Number is type 1 */
|
|
{
|
|
Return (0x41)
|
|
} /* Local1 indicates Local0 is not a Number */
|
|
|
|
If ((Local0 == 0x00)) /* Number is type 1 */
|
|
{
|
|
Return (0x42)
|
|
} /* non-existant signal was acquired */
|
|
|
|
Debug = "Acquire signal timeout PASS"
|
|
/* prime EVNT with two outstanding signals */
|
|
|
|
Signal (EVNT)
|
|
Signal (EVNT)
|
|
/* reset EVNT to initialization (zero) state */
|
|
|
|
Reset (EVNT)
|
|
/* acquire non-existing signal */
|
|
|
|
Local0 = Wait (EVNT, Arg0)
|
|
/* validate Local0 is a Number */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 != 0x01)) /* Number is type 1 */
|
|
{
|
|
Return (0x51)
|
|
} /* Local1 indicates Local0 is not a Number */
|
|
|
|
If ((Local0 == 0x00)) /* Number is type 1 */
|
|
{
|
|
Return (0x52)
|
|
} /* non-existant signal was acquired */
|
|
|
|
Debug = "Reset signal PASS"
|
|
/* acquire non-existing signal using Lvalue timeout */
|
|
|
|
Local0 = Wait (EVNT, Zero)
|
|
/* validate Local0 is a Number */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 != 0x01)) /* Number is type 1 */
|
|
{
|
|
Return (0x61)
|
|
} /* Local1 indicates Local0 is not a Number */
|
|
|
|
If ((Local0 == 0x00)) /* Number is type 1 */
|
|
{
|
|
Return (0x62)
|
|
} /* non-existant signal was acquired */
|
|
|
|
Debug = "Zero Lvalue PASS"
|
|
/* acquire non-existing signal using Lvalue timeout */
|
|
|
|
Local0 = Wait (EVNT, One)
|
|
/* validate Local0 is a Number */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 != 0x01)) /* Number is type 1 */
|
|
{
|
|
Return (0x71)
|
|
} /* Local1 indicates Local0 is not a Number */
|
|
|
|
If ((Local0 == 0x00)) /* Number is type 1 */
|
|
{
|
|
Return (0x72)
|
|
} /* non-existant signal was acquired */
|
|
|
|
Debug = "One Lvalue PASS"
|
|
/* Lvalue Event test cases */
|
|
/* ILLEGAL SOURCE OPERAND Store (EVNT, Local2) */
|
|
/* validate Local2 is an Event */
|
|
Local1 = ObjectType (EVNT)
|
|
If ((Local1 != 0x07)) /* Event is type 7 */
|
|
{
|
|
Return (0x81)
|
|
} /* Local1 indicates Local0 is not a Number */
|
|
|
|
/* reset EVNT to initialization (zero) state */
|
|
|
|
Reset (EVNT)
|
|
/* prime EVNT with two outstanding signals */
|
|
|
|
Signal (EVNT)
|
|
/* acquire existing signal */
|
|
|
|
Local0 = Wait (EVNT, Arg0)
|
|
/* validate Local0 is a Number */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 != 0x01)) /* Number is type 1 */
|
|
{
|
|
Return (0x82)
|
|
} /* Local1 indicates Local0 is not a Number */
|
|
|
|
If ((Local0 != 0x00)) /* Number is type 1 */
|
|
{
|
|
Return (0x83)
|
|
} /* timeout occurred without acquiring signal */
|
|
|
|
Debug = "Acquire Lvalue existing signal PASS"
|
|
/* acquire non-existing signal */
|
|
|
|
Local0 = Wait (EVNT, Arg0)
|
|
/* validate Local0 is a Number */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 != 0x01)) /* Number is type 1 */
|
|
{
|
|
Return (0x84)
|
|
} /* Local1 indicates Local0 is not a Number */
|
|
|
|
If ((Local0 == 0x00)) /* Number is type 1 */
|
|
{
|
|
Return (0x85)
|
|
} /* non-existant signal was acquired */
|
|
|
|
Debug = "Acquire Lvalue signal timeout PASS"
|
|
Return (0x00) /* success */
|
|
} /* TEVN control method to test ResetOp, SignalOp, and WaitOp */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ Event Test"
|
|
Local0 = TEVN (0x64)
|
|
Return (Local0)
|
|
} /* TEST */
|
|
} /* EVNT */
|
|
|
|
/* */
|
|
/* test SizeOfLv.asl */
|
|
/* */
|
|
/* Test for SizeOf (Lvalue) */
|
|
/* */
|
|
/* This next section will contain the packages that the SizeOfOp will be */
|
|
/* exercised on. The first one, PKG0, is a regular package of 3 elements. */
|
|
/* The 2nd one, PKG1, is a nested package with 3 packages inside it, each */
|
|
/* with 3 elements. It is expected that SizeOf operator will return the */
|
|
/* same value for these two packages since they both have 3 elements. The */
|
|
/* final package, PKG2, has 4 elements and the SizeOf operator is expected */
|
|
/* to return different results for this package. */
|
|
Name (PKG0, Package (0x03)
|
|
{
|
|
0x0123,
|
|
0x4567,
|
|
0x89AB
|
|
}) /* PKG0 */
|
|
Name (PKG1, Package (0x03)
|
|
{
|
|
Package (0x03)
|
|
{
|
|
0x0123,
|
|
0x4567,
|
|
0x89AB
|
|
},
|
|
|
|
Package (0x03)
|
|
{
|
|
0xCDEF,
|
|
0xFEDC,
|
|
0xBA98
|
|
},
|
|
|
|
Package (0x03)
|
|
{
|
|
0x7654,
|
|
0x3210,
|
|
0x1234
|
|
}
|
|
}) /* PKG1 */
|
|
Name (PKG2, Package (0x04)
|
|
{
|
|
0x0123,
|
|
0x4567,
|
|
0x89AB,
|
|
0x8888
|
|
}) /* PKG2 */
|
|
Name (PKG3, Package (0x05)
|
|
{
|
|
0x0123,
|
|
0x4567,
|
|
0x89AB,
|
|
0x8888,
|
|
0x7777
|
|
}) /* PKG3 */
|
|
/* End Packages ********************************************************** */
|
|
/* The following section will declare the data strings that will be used to */
|
|
/* exercise the SizeOf operator. STR0 and STR1 are expected to be equal, */
|
|
/* STR2 is expected to have a different SizeOf value than STR0 and STR1. */
|
|
Name (STR0, "ACPI permits very flexible methods of expressing a system")
|
|
Name (STR1, "MIKE permits very flexible methods of expressing a system")
|
|
Name (STR2, "Needless to say, Mike and ACPI are frequently at odds")
|
|
/* This string is being made in case we want to do a SizeOf comparison */
|
|
/* between strings and packages or buffers */
|
|
Name (STR3, "12345")
|
|
/* End Strings ********************************************************** */
|
|
/* The following section will declare the buffers that will be used to exercise */
|
|
/* the SizeOf operator. */
|
|
Name (BUF0, Buffer (0x0A){})
|
|
Name (BUF1, Buffer (0x0A){})
|
|
Name (BUF2, Buffer (0x08){})
|
|
Name (BUF3, Buffer (0x05){})
|
|
/* End Buffers ********************************************************** */
|
|
|
|
Device (SZLV)
|
|
{
|
|
Method (CMPR, 2, NotSerialized)
|
|
{
|
|
/* CMPR is passed two arguments. If unequal, return 1 to indicate */
|
|
/* that, otherwise return 0 to indicate SizeOf each is equal. */
|
|
Local0 = 0x01
|
|
If ((SizeOf (Arg0) == SizeOf (Arg1)))
|
|
{
|
|
Local0 = 0x00
|
|
}
|
|
|
|
Return (Local0)
|
|
} /* CMPR */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ SizeOfLv Test"
|
|
/* TBD: SizeOf ("string") */
|
|
/* SizeOf (Buffer) */
|
|
/* SizeOf (Package) */
|
|
/* SizeOf (String) */
|
|
/* SizeOf (STR0) -- where Name (STR0,...) -- lot's of cases */
|
|
/* buffer, string, package, */
|
|
/* SizeOf (METH) -- where METH control method returns */
|
|
/* buffer, string, package, */
|
|
/* TBD: SLOC [SizeOf (Local0)] -- dup SARG */
|
|
/* Compare the elements that we expect to be the same. Exit out with an error */
|
|
/* code on the first failure. */
|
|
If ((0x00 != CMPR (STR0, STR1)))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
If ((0x00 != CMPR (STR3, BUF3)))
|
|
{
|
|
Return (0x02)
|
|
}
|
|
|
|
If ((0x00 != CMPR (STR3, PKG3)))
|
|
{
|
|
Return (0x03)
|
|
}
|
|
|
|
/* In the following section, this test will cover the SizeOf */
|
|
/* operator for Local values. */
|
|
/* In this case, both Local0 and Local1 should have the same Size */
|
|
Local0 = STR0 /* \STR0 */
|
|
Local1 = STR1 /* \STR1 */
|
|
If ((SizeOf (Local0) != SizeOf (Local1)))
|
|
{
|
|
Return (0x04)
|
|
}
|
|
|
|
/* Now create a case where Local0 and Local1 are different */
|
|
|
|
Local1 = STR2 /* \STR2 */
|
|
If ((SizeOf (Local0) == SizeOf (Local1)))
|
|
{
|
|
Return (0x05)
|
|
}
|
|
|
|
/* Finally, check for the return of SizeOf for a known Buffer. Just */
|
|
/* in case we magically pass above cases due to all Buffers being Zero */
|
|
/* bytes in size, or Infinity, etc. */
|
|
If ((0x05 != SizeOf (BUF3)))
|
|
{
|
|
Return (0x06)
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* SZLV */
|
|
|
|
/* */
|
|
/* test BytField.asl */
|
|
/* */
|
|
/* BytField test */
|
|
/* This is just a subset of the many RegionOp/Index Field test cases. */
|
|
/* Tests access of TBD. */
|
|
/* */
|
|
Scope (\_SB) /* System Bus */
|
|
{
|
|
/* _SB system bus */
|
|
|
|
Device (BYTF)
|
|
{
|
|
/* Test device name */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ BytField Test"
|
|
Return (\_TZ.C19B.RSLT)
|
|
} /* TEST */
|
|
} /* BYTF */
|
|
|
|
Device (C005)
|
|
{
|
|
/* Device C005 */
|
|
|
|
Device (C013)
|
|
{
|
|
/* Device C013 */
|
|
} /* Device C013 */
|
|
} /* Device C005 */
|
|
|
|
Method (C115, 0, NotSerialized)
|
|
{
|
|
/* C115 control method */
|
|
|
|
Acquire (\_GL, 0xFFFF)
|
|
Local0 = \_SB.C005.C013.C058.C07E
|
|
Release (\_GL)
|
|
Local0 &= 0x10
|
|
Store ((Local0 >> 0x04), Local1)
|
|
If ((Local1 == 0x00))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x00)
|
|
}
|
|
} /* C115 control method */
|
|
} /* _SB system bus */
|
|
|
|
OperationRegion (C018, SystemIO, 0x5028, 0x04)
|
|
Field (C018, AnyAcc, NoLock, Preserve)
|
|
{
|
|
/* Field overlaying C018 */
|
|
|
|
C019, 32
|
|
} /* Field overlaying C018 */
|
|
|
|
OperationRegion (C01A, SystemIO, 0x5030, 0x04)
|
|
Field (C01A, ByteAcc, NoLock, Preserve)
|
|
{
|
|
/* Field overlaying C01A */
|
|
|
|
C01B, 8,
|
|
C01C, 8,
|
|
C01D, 8,
|
|
C01E, 8
|
|
} /* Field overlaying C01A */
|
|
|
|
Mutex (\C01F, 0x00)
|
|
Name (\C020, 0x00)
|
|
Name (\C021, 0x00)
|
|
Method (\C022, 0, NotSerialized)
|
|
{
|
|
/* \C022 control method */
|
|
|
|
Acquire (\C01F, 0xFFFF)
|
|
If ((\C021 == 0x00))
|
|
{
|
|
Local0 = C019 /* \C019 */
|
|
Local0 &= 0xFFFEFFFE
|
|
C019 = Local0
|
|
\C021++
|
|
}
|
|
|
|
Release (\C01F)
|
|
} /* \C022 control method */
|
|
|
|
Scope (\_SB.C005.C013)
|
|
{
|
|
/* Scope \_SB.C005.C013 */
|
|
|
|
Device (C058)
|
|
{
|
|
/* Device C058 */
|
|
|
|
Name (_HID, "*PNP0A06") // _HID: Hardware ID
|
|
OperationRegion (C059, SystemIO, 0xE0, 0x02)
|
|
Field (C059, ByteAcc, NoLock, Preserve)
|
|
{
|
|
/* Field overlaying C059 */
|
|
|
|
C05A, 8,
|
|
C05B, 8
|
|
} /* Field overlaying C059 */
|
|
|
|
OperationRegion (C05C, SystemIO, 0xE2, 0x02)
|
|
Field (C05C, ByteAcc, NoLock, Preserve)
|
|
{
|
|
/* Field overlaying C05C */
|
|
|
|
C05D, 8,
|
|
C05E, 8
|
|
} /* Field overlaying C05C */
|
|
|
|
IndexField (C05D, C05E, ByteAcc, NoLock, Preserve)
|
|
{
|
|
Offset (0x82),
|
|
/* IndexField overlaying C05D/C05E */
|
|
|
|
C05F, 8,
|
|
C060, 8,
|
|
C061, 8,
|
|
C062, 8,
|
|
C063, 8,
|
|
C064, 8,
|
|
C065, 8,
|
|
C066, 8,
|
|
C067, 8,
|
|
C068, 8,
|
|
C069, 8,
|
|
C06A, 8,
|
|
C06B, 8,
|
|
C06C, 8,
|
|
C06D, 8,
|
|
C06E, 8,
|
|
Offset (0xA0),
|
|
C06F, 8,
|
|
C070, 8,
|
|
C071, 8,
|
|
C072, 8,
|
|
C073, 8,
|
|
C074, 8,
|
|
C075, 8,
|
|
C076, 8,
|
|
C077, 8,
|
|
C078, 8,
|
|
C079, 8,
|
|
C07A, 8,
|
|
C07B, 8,
|
|
C07C, 8,
|
|
C07D, 8,
|
|
C07E, 8
|
|
} /* IndexField overlaying C05D/C05E */
|
|
|
|
OperationRegion (C07F, SystemIO, 0xE4, 0x02)
|
|
Field (C07F, ByteAcc, NoLock, Preserve)
|
|
{
|
|
/* Field overlaying C07F */
|
|
|
|
C080, 8,
|
|
C081, 8
|
|
} /* Field overlaying C07F */
|
|
|
|
OperationRegion (C082, SystemIO, 0xE0, 0x01)
|
|
Field (C082, ByteAcc, NoLock, Preserve)
|
|
{
|
|
/* Field overlaying C082 */
|
|
|
|
C083, 8
|
|
} /* Field overlaying C082 */
|
|
|
|
OperationRegion (C084, SystemIO, 0xFF, 0x01)
|
|
Field (C084, ByteAcc, NoLock, Preserve)
|
|
{
|
|
/* Field overlaying C084 */
|
|
|
|
C085, 8
|
|
} /* Field overlaying C084 */
|
|
|
|
OperationRegion (C086, SystemIO, 0xFD, 0x01)
|
|
Field (C086, ByteAcc, NoLock, Preserve)
|
|
{
|
|
/* Field overlaying C086 */
|
|
|
|
C087, 8
|
|
} /* Field overlaying C086 */
|
|
|
|
Mutex (C088, 0x00)
|
|
Mutex (C089, 0x00)
|
|
Mutex (C08A, 0x00)
|
|
Mutex (C08B, 0x00)
|
|
Mutex (C08C, 0x00)
|
|
Mutex (C08D, 0x00)
|
|
Name (C08E, 0xFFFFFFFD)
|
|
Name (C08F, 0x00)
|
|
Method (C0AA, 4, NotSerialized)
|
|
{
|
|
/* C0AA control method */
|
|
|
|
Local7 = Buffer (0x04){}
|
|
CreateByteField (Local7, 0x00, C0AB)
|
|
CreateByteField (Local7, 0x01, C0AC)
|
|
CreateByteField (Local7, 0x02, C0AD)
|
|
CreateByteField (Local7, 0x03, C0AE)
|
|
Acquire (^C08B, 0xFFFF)
|
|
Acquire (\_GL, 0xFFFF)
|
|
\C022 ()
|
|
\_SB.C005.C013.C058.C06B = 0x01
|
|
While ((0x00 != \_SB.C005.C013.C058.C06B))
|
|
{
|
|
Stall (0x64)
|
|
}
|
|
|
|
\_SB.C005.C013.C058.C06E = Arg3
|
|
\_SB.C005.C013.C058.C06D = Arg2
|
|
\_SB.C005.C013.C058.C06C = Arg1
|
|
\_SB.C005.C013.C058.C06B = Arg0
|
|
While ((0x00 != \_SB.C005.C013.C058.C06B))
|
|
{
|
|
Stall (0x64)
|
|
}
|
|
|
|
C0AB = \_SB.C005.C013.C058.C06E
|
|
C0AC = \_SB.C005.C013.C058.C06D
|
|
C0AD = \_SB.C005.C013.C058.C06C
|
|
C0AE = \_SB.C005.C013.C058.C06B
|
|
If ((Arg0 != 0x17))
|
|
{
|
|
\_SB.C005.C013.C058.C06B = 0x02
|
|
Stall (0x64)
|
|
}
|
|
|
|
Release (\_GL)
|
|
Release (^C08B)
|
|
Return (Local7)
|
|
} /* C0AA control method */
|
|
} /* Device C058 */
|
|
} /* Scope \_SB.C005.C013 */
|
|
|
|
Scope (\_TZ)
|
|
{
|
|
/* \_TZ thermal zone scope */
|
|
|
|
Name (C18B, Package (0x02)
|
|
{
|
|
Package (0x02)
|
|
{
|
|
Package (0x05)
|
|
{
|
|
0x05AC,
|
|
0x0CD2,
|
|
0x0D68,
|
|
0x0DE0,
|
|
0x0E4E
|
|
},
|
|
|
|
Package (0x05)
|
|
{
|
|
0x0D04,
|
|
0x0D9A,
|
|
0x0DFE,
|
|
0x0E80,
|
|
0x0FA2
|
|
}
|
|
},
|
|
|
|
Package (0x02)
|
|
{
|
|
Package (0x05)
|
|
{
|
|
0x05AC,
|
|
0x0CD2,
|
|
0x0D68,
|
|
0x0DE0,
|
|
0x0E4E
|
|
},
|
|
|
|
Package (0x05)
|
|
{
|
|
0x0D04,
|
|
0x0D9A,
|
|
0x0DFE,
|
|
0x0E80,
|
|
0x0FA2
|
|
}
|
|
}
|
|
}) /* C18B */
|
|
Name (C18C, Package (0x02)
|
|
{
|
|
Package (0x02)
|
|
{
|
|
Package (0x03)
|
|
{
|
|
0x64,
|
|
0x4B,
|
|
0x32
|
|
},
|
|
|
|
Package (0x03)
|
|
{
|
|
0x64,
|
|
0x4B,
|
|
0x32
|
|
}
|
|
}
|
|
}) /* C81C */
|
|
Name (C18D, 0x00)
|
|
Name (C18E, 0x00)
|
|
Name (C18F, 0x00)
|
|
Name (C190, 0x00)
|
|
Name (C191, 0x03)
|
|
Name (C192, 0x00)
|
|
Name (C193, 0x01)
|
|
Name (C194, 0x02)
|
|
Mutex (C195, 0x00)
|
|
Name (C196, 0x01)
|
|
Name (C197, 0x0B9C)
|
|
Name (C198, 0x0B9C)
|
|
Name (C199, 0xFFFFFFFD)
|
|
Name (C19A, 0x00)
|
|
Device (C19B)
|
|
{
|
|
/* Device C19B */
|
|
|
|
Name (RSLT, 0x00) /* default to zero */
|
|
Method (XINI, 0, NotSerialized)
|
|
{
|
|
/* _INI control method (Uses Global Lock -- can't run under AcpiExec) */
|
|
|
|
C19A = \_SB.C115 ()
|
|
\_TZ.C19C._SCP (0x00)
|
|
Local1 = (0x0EB2 - 0x0AAC) /* Local1 = AACh - EB2h */
|
|
Divide (Local1, 0x0A, Local0, Local2) /* Local0 = Local1 / 10 */
|
|
/* Local2 = Local1 % 10 */
|
|
|
|
\_SB.C005.C013.C058.C0AA (0x0E, Local2, 0x00, 0x00)
|
|
C18D = DerefOf (DerefOf (\_TZ.C18C [C19A]) [0x00])
|
|
C18E = DerefOf (DerefOf (\_TZ.C18C [C19A]) [0x01])
|
|
C18F = DerefOf (DerefOf (\_TZ.C18C [C19A]) [0x02])
|
|
RSLT = 0x01 /* set RSLT to 1 if _INI control method completes */
|
|
} /* _INI control method */
|
|
/* PowerResource (C19D) {...} */
|
|
} /* Device C19B */
|
|
|
|
ThermalZone (C19C)
|
|
{
|
|
Method (_SCP, 1, NotSerialized) // _SCP: Set Cooling Policy
|
|
{
|
|
/* _SCP control method */
|
|
|
|
Local0 = Arg0
|
|
If ((Local0 == 0x00))
|
|
{
|
|
\_TZ.C192 = 0x00
|
|
\_TZ.C193 = 0x01
|
|
\_TZ.C194 = 0x02
|
|
\_TZ.C191 = 0x03
|
|
}
|
|
Else
|
|
{
|
|
\_TZ.C191 = 0x00
|
|
\_TZ.C192 = 0x01
|
|
\_TZ.C193 = 0x02
|
|
\_TZ.C194 = 0x03
|
|
}
|
|
} /* _SCP control method */
|
|
} /* ThermalZone C19C */
|
|
} /* \_TZ thermal zone scope */
|
|
|
|
/* */
|
|
/* test DwrdFld.asl */
|
|
/* */
|
|
Name (BUFR, Buffer (0x0A)
|
|
{
|
|
/* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........
|
|
/* 0008 */ 0x00, 0x00 // ..
|
|
})
|
|
Device (DWDF)
|
|
{
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ DwrdFld Test"
|
|
CreateByteField (BUFR, 0x00, BYTE)
|
|
BYTE = 0xAA
|
|
CreateWordField (BUFR, 0x01, WORD)
|
|
WORD = 0xBBCC
|
|
CreateDWordField (BUFR, 0x03, DWRD)
|
|
DWRD = 0xDDEEFF00
|
|
CreateByteField (BUFR, 0x07, BYT2)
|
|
BYT2 = 0x11
|
|
CreateWordField (BUFR, 0x08, WRD2)
|
|
WRD2 = 0x2233
|
|
Return (0x00)
|
|
} /* End Method TEST */
|
|
} /* Device DWDF */
|
|
|
|
/* */
|
|
/* test DivAddx.asl */
|
|
/* */
|
|
Name (B1LO, 0xAA)
|
|
Name (B1HI, 0xBB)
|
|
Method (MKW, 2, NotSerialized)
|
|
{
|
|
/* This control method will take two bytes and make them into a WORD */
|
|
|
|
Local0 = (B1HI * 0x0100) /* Make high byte.....high */
|
|
Local0 |= B1LO /* OR in the low byte */ /* \B1LO */
|
|
Return (Local0) /* Return the WORD */
|
|
} /* MKW_ */
|
|
|
|
Device (DVAX)
|
|
{
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ DivAddx Test"
|
|
B1LO = 0x19
|
|
B1HI = 0x00
|
|
/* We'll multiply 25 * 3 to get 75, add 99 to it then divide */
|
|
/* by 100. We expect to get 74 for the remainder and 1 for */
|
|
/* the quotient. */
|
|
Divide (((0x03 * MKW (B1LO, B1HI)) + 0x63), /* Dividend, */
|
|
|
|
0x64, /* Divisor */Local4, /* Remainder */
|
|
Local2) /* Quotient */
|
|
If (((0x4A == Local4) && (0x01 == Local2)))
|
|
{
|
|
/* Indicate Pass */
|
|
|
|
Local0 = 0x00
|
|
}
|
|
Else
|
|
{
|
|
/* Indicate Fail */
|
|
|
|
Local0 = 0x01
|
|
}
|
|
|
|
Return (Local0)
|
|
} /* End Method TEST */
|
|
} /* Device DVAX */
|
|
|
|
/* */
|
|
/* test IndexFld.asl (IndexOp6.asl) */
|
|
/* */
|
|
/* IndexFld test */
|
|
/* This is just a subset of the many RegionOp/Index Field test cases. */
|
|
/* Tests index field element AccessAs macro. */
|
|
/* Also tests name resolution of index field elements with same names */
|
|
/* but different namespace scopes. */
|
|
/* */
|
|
Device (IDX6)
|
|
{
|
|
/* Test device name */
|
|
|
|
OperationRegion (SIO, SystemIO, 0x0100, 0x02)
|
|
Field (SIO, ByteAcc, NoLock, Preserve)
|
|
{
|
|
INDX, 8,
|
|
DATA, 8
|
|
}
|
|
|
|
IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
|
|
{
|
|
AccessAs (ByteAcc, 0x00),
|
|
IFE0, 8,
|
|
IFE1, 8,
|
|
IFE2, 8,
|
|
IFE3, 8,
|
|
IFE4, 8,
|
|
IFE5, 8,
|
|
IFE6, 8,
|
|
IFE7, 8,
|
|
IFE8, 8,
|
|
IFE9, 8
|
|
}
|
|
|
|
Device (TST)
|
|
{
|
|
/* TST_: provides a different namespace scope for IFE0 and IFE1 */
|
|
|
|
OperationRegion (SIO2, SystemIO, 0x0100, 0x02)
|
|
Field (SIO2, ByteAcc, NoLock, Preserve)
|
|
{
|
|
IND2, 8,
|
|
DAT2, 8
|
|
}
|
|
|
|
IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes)
|
|
{
|
|
IFE0, /* duplicate IndexField name with different scope */ 8,
|
|
IFE1, 8
|
|
}
|
|
} /* TST_: provides a different namespace scope for IFE0 and IFE1 */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ IndexOp6 Test"
|
|
Local0 = IFE0 /* \IDX6.IFE0 */
|
|
Local1 = IFE1 /* \IDX6.IFE1 */
|
|
Local2 = IFE2 /* \IDX6.IFE2 */
|
|
/* validate name resolution of IndexFields with different scopes */
|
|
|
|
Local3 = \IDX6.IFE0
|
|
Local4 = \IDX6.IFE1
|
|
/* verioading of namespace can resolve following names */
|
|
|
|
Local5 = \IDX6.TST.IFE0
|
|
Local6 = \IDX6.TST.IFE1
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* IDX6 */
|
|
|
|
/* */
|
|
/* test IndexOp5.asl */
|
|
/* */
|
|
/* IndexOp5 test */
|
|
/* This is just a subset of the many RegionOp/Index Field test cases. */
|
|
/* Tests copying string into buffer then performing IndexOp on result. */
|
|
/* */
|
|
Device (IDX5)
|
|
{
|
|
/* Test device name */
|
|
|
|
Name (OSFL, 0x00) /* 0 == Windows 98, 1 == Windows NT */
|
|
/* MCTH is a control method to compare two strings. It returns */
|
|
/* zero if the strings mismatch, or 1 if the strings match. */
|
|
/* This exercises the test case of copying a string into a buffer */
|
|
/* and performing an IndexOp on the resulting buffer. */
|
|
Method (MCTH, 2, Serialized)
|
|
{
|
|
/* MCTH: Control Method to compare two strings */
|
|
/* Arg0: first string to compare */
|
|
/* Arg1: second string to compare */
|
|
/* Return: zero if strings mismatch, 1 if strings match */
|
|
/* check if first string's length is less than second string's length */
|
|
If ((SizeOf (Arg0) < SizeOf (Arg1)))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
|
|
/* increment length to include NULL termination character */
|
|
|
|
Local0 = (SizeOf (Arg0) + 0x01) /* Local0 = strlen(Arg0) + 1 */
|
|
/* create two buffers of size Local0 [strlen(Arg0)+1] */
|
|
|
|
Name (BUF0, Buffer (Local0){})
|
|
Name (BUF1, Buffer (Local0){})
|
|
/* copy strings into buffers */
|
|
|
|
BUF0 = Arg0
|
|
BUF1 = Arg1
|
|
/* validate BUF0 and BUF1 are still buffers */
|
|
|
|
Local1 = ObjectType (BUF0)
|
|
If ((Local1 != 0x03)) /* Buffer is type 3 */
|
|
{
|
|
Return (0x14)
|
|
}
|
|
|
|
Local1 = ObjectType (BUF1)
|
|
If ((Local1 != 0x03)) /* Buffer is type 3 */
|
|
{
|
|
Return (0x15)
|
|
}
|
|
|
|
/* Decrement because the Index base below is zero based */
|
|
/* while Local0 length is one based. */
|
|
Local0--
|
|
While (Local0)
|
|
{
|
|
/* loop through all BUF0 buffer elements */
|
|
|
|
Local0--
|
|
/* check if BUF0[n] == BUF1[n] */
|
|
|
|
If ((DerefOf (BUF0 [Local0]) == DerefOf (BUF1 [Local0]))){} /* this is how the code was really implemented */
|
|
Else
|
|
{
|
|
Return (Zero)
|
|
}
|
|
} /* loop through all BUF0 buffer elements */
|
|
|
|
Return (One) /* strings / buffers match */
|
|
} /* MCTH: Control Method to compare two strings */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ IndexOp5 Test"
|
|
If (MCTH (\_OS, "Microsoft Windows NT"))
|
|
{
|
|
OSFL = 0x01
|
|
}
|
|
|
|
If ((OSFL != 0x01))
|
|
{
|
|
Return (0x0B)
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* IDX5 */
|
|
|
|
/* */
|
|
/* test IndexOp.asl */
|
|
/* */
|
|
Scope (\_SB) /* System Bus */
|
|
{
|
|
/* _SB system bus */
|
|
|
|
Method (C097, 0, NotSerialized)
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
Device (PCI2)
|
|
{
|
|
/* Root PCI Bus */
|
|
|
|
Name (_HID, EisaId ("PNP0A03") /* PCI Bus */) // _HID: Hardware ID
|
|
Name (_ADR, 0x00) // _ADR: Address
|
|
Name (_CRS, Buffer (0x1A) // _CRS: Current Resource Settings
|
|
{
|
|
"_SB_.PCI2._CRS..........."
|
|
})
|
|
Method (_STA, 0, NotSerialized) // _STA: Status
|
|
{
|
|
Return (0x0F)
|
|
}
|
|
|
|
Device (ISA)
|
|
{
|
|
/* ISA bridge */
|
|
|
|
Name (_ADR, 0x00030000) /* ISA bus ID */ // _ADR: Address
|
|
Device (EC0)
|
|
{
|
|
/* Embedded Controller */
|
|
|
|
Name (_GPE, 0x00) /* EC use GPE0 */ // _GPE: General Purpose Events
|
|
Name (_ADR, 0x00030000) /* PCI address */ // _ADR: Address
|
|
Method (_STA, 0, NotSerialized) // _STA: Status
|
|
{
|
|
Return (0x0F)
|
|
} /* EC is functioning */
|
|
|
|
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
|
|
{
|
|
IO (Decode16,
|
|
0x0062, // Range Minimum
|
|
0x0062, // Range Maximum
|
|
0x01, // Alignment
|
|
0x01, // Length
|
|
)
|
|
IO (Decode16,
|
|
0x0066, // Range Minimum
|
|
0x0066, // Range Maximum
|
|
0x01, // Alignment
|
|
0x01, // Length
|
|
)
|
|
})
|
|
/* create EC's region and field */
|
|
|
|
OperationRegion (RAM, SystemMemory, 0x00400000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
/* AC information */
|
|
|
|
ADP, /* AC Adapter 1:On-line, 0:Off-line */ 1,
|
|
AFLT, /* AC Adapter Fault 1:Fault 0:Normal */ 1,
|
|
BAT0, /* BAT0 1:present, 0:not present */ 1,
|
|
, 1,
|
|
Offset (0x04),
|
|
/* CMBatt information */
|
|
|
|
BPU0, /* Power Unit */ 32,
|
|
BDC0, /* Designed Capacity */ 32,
|
|
BFC0, /* Last Full Charge Capacity */ 32,
|
|
BTC0, /* Battery Technology */ 32,
|
|
BDV0, /* Design Voltage */ 32,
|
|
BST0, /* Battery State */ 32,
|
|
BPR0, /* Battery Present Rate */ 32,
|
|
/* (Designed Capacity)x(%)/{(h)x100} */
|
|
|
|
BRC0, /* Battery Remaining Capacity */ 32,
|
|
/* (Designed Capacity)(%)^100 */
|
|
|
|
BPV0, /* Battery Present Voltage */ 32,
|
|
BTP0, /* Trip Point */ 32,
|
|
BCW0, /* Design capacity of Warning */ 32,
|
|
BCL0, /* Design capacity of Low */ 32,
|
|
BCG0, /* capacity granularity 1 */ 32,
|
|
BG20, /* capacity granularity 2 */ 32,
|
|
BMO0, /* Battery model number field */ 32,
|
|
BIF0, /* OEM Information(00h) */ 32,
|
|
BSN0, /* Battery Serial Number */ 32,
|
|
BTY0, /* Battery Type (e.g., "Li-Ion") */ 32,
|
|
BTY1, /* Battery Type (e.g., "Li-Ion") */ 32
|
|
} /* Field */
|
|
} /* EC0: Embedded Controller */
|
|
} /* ISA bridge */
|
|
} /* PCI2 Root PCI Bus */
|
|
|
|
Device (IDX0)
|
|
{
|
|
/* Test device name */
|
|
|
|
Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) /* Control Method Battey ID */ // _HID: Hardware ID
|
|
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
|
|
{
|
|
\_SB
|
|
})
|
|
Method (_STA, 0, NotSerialized) // _STA: Status
|
|
{
|
|
/* _STA bits 0-3 indicate existence of battery slot */
|
|
/* _STA bit 4 indicates battery (not) present */
|
|
If (\_SB.PCI2.ISA.EC0.BAT0)
|
|
{
|
|
Return (0x1F)
|
|
} /* Battery present */
|
|
Else
|
|
{
|
|
Return (0x0F)
|
|
} /* Battery not present */
|
|
} /* _STA */
|
|
|
|
Method (_BIF, 0, Serialized) // _BIF: Battery Information
|
|
{
|
|
Name (BUFR, Package (0x0D){})
|
|
BUFR [0x00] = \_SB.PCI2.ISA.EC0.BPU0 /* Power Unit */
|
|
BUFR [0x01] = \_SB.PCI2.ISA.EC0.BDC0 /* Designed Capacity */
|
|
BUFR [0x02] = \_SB.PCI2.ISA.EC0.BFC0 /* Last Full Charge Capa. */
|
|
BUFR [0x03] = \_SB.PCI2.ISA.EC0.BTC0 /* Battery Technology */
|
|
BUFR [0x04] = \_SB.PCI2.ISA.EC0.BDV0 /* Designed Voltage */
|
|
BUFR [0x05] = \_SB.PCI2.ISA.EC0.BCW0 /* Designed warning level */
|
|
BUFR [0x06] = \_SB.PCI2.ISA.EC0.BCL0 /* Designed Low level */
|
|
BUFR [0x07] = \_SB.PCI2.ISA.EC0.BCG0 /* Capacity granularity 1 */
|
|
BUFR [0x08] = \_SB.PCI2.ISA.EC0.BG20 /* Capacity granularity 2 */
|
|
BUFR [0x09] = "" /* Model Number */
|
|
BUFR [0x0A] = "" /* Serial Number */
|
|
BUFR [0x0B] = "LiOn" /* Battery Type */
|
|
BUFR [0x0C] = "Chicony" /* OEM Information */
|
|
Return (BUFR) /* \_SB_.IDX0._BIF.BUFR */
|
|
} /* _BIF */
|
|
|
|
Method (_BST, 0, Serialized) // _BST: Battery Status
|
|
{
|
|
Name (BUFR, Package (0x04)
|
|
{
|
|
0x01,
|
|
0x0100,
|
|
0x76543210,
|
|
0x0180
|
|
})
|
|
Return (BUFR) /* \_SB_.IDX0._BST.BUFR */
|
|
} /* _BST */
|
|
|
|
Method (_BTP, 1, NotSerialized) // _BTP: Battery Trip Point
|
|
{
|
|
\_SB.PCI2.ISA.EC0.BTP0 = Arg0 /* Set Battery Trip point */
|
|
}
|
|
|
|
Method (TEST, 0, Serialized)
|
|
{
|
|
Debug = "++++++++ IndexOp Test"
|
|
/* test storing into uninitialized package elements */
|
|
|
|
Name (PBUF, Package (0x04){}) /* leave unitialized */
|
|
PBUF [0x00] = 0x01234567
|
|
PBUF [0x01] = 0x89ABCDEF
|
|
PBUF [0x02] = 0xFEDCBA98
|
|
PBUF [0x03] = 0x76543210
|
|
/* verify values stored into uninitialized package elements */
|
|
|
|
If ((DerefOf (PBUF [0x00]) != 0x01234567))
|
|
{
|
|
Return (0x10)
|
|
}
|
|
|
|
If ((DerefOf (PBUF [0x01]) != 0x89ABCDEF))
|
|
{
|
|
Return (0x11)
|
|
}
|
|
|
|
If ((DerefOf (PBUF [0x02]) != 0xFEDCBA98))
|
|
{
|
|
Return (0x12)
|
|
}
|
|
|
|
If ((DerefOf (PBUF [0x03]) != 0x76543210))
|
|
{
|
|
Return (0x13)
|
|
}
|
|
|
|
/* store _BIF package return value into Local0 */
|
|
|
|
Local0 = _BIF ()
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Package */
|
|
|
|
If ((Local1 != 0x04)) /* Package type is 4 */
|
|
{
|
|
Return (0x21)
|
|
} /* failure */
|
|
|
|
/* test storing into buffer field elements */
|
|
|
|
Name (BUFR, Buffer (0x10)
|
|
{
|
|
/* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........
|
|
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........
|
|
}) /* BUFR */
|
|
/* test storing into buffer field elements */
|
|
|
|
BUFR [0x00] = 0x01234567 /* should only store 0x67 */
|
|
BUFR [0x04] = 0x89ABCDEF /* should only store 0xEF */
|
|
BUFR [0x08] = 0xFEDCBA98 /* should only store 0x98 */
|
|
BUFR [0x0C] = 0x76543210 /* should only store 0x10 */
|
|
/* verify storing into buffer field elements */
|
|
|
|
If ((DerefOf (BUFR [0x00]) != 0x67))
|
|
{
|
|
Return (0x30)
|
|
}
|
|
|
|
If ((DerefOf (BUFR [0x01]) != 0x00))
|
|
{
|
|
Return (0x31)
|
|
}
|
|
|
|
If ((DerefOf (BUFR [0x04]) != 0xEF))
|
|
{
|
|
Return (0x34)
|
|
}
|
|
|
|
If ((DerefOf (BUFR [0x08]) != 0x98))
|
|
{
|
|
Return (0x38)
|
|
}
|
|
|
|
If ((DerefOf (BUFR [0x0C]) != 0x10))
|
|
{
|
|
Return (0x3C)
|
|
}
|
|
|
|
Return (0x00) /* pass */
|
|
} /* TEST */
|
|
} /* IDX0 */
|
|
} /* _SB system bus */
|
|
|
|
/* */
|
|
/* test BitIndex.asl */
|
|
/* */
|
|
/* BitIndex test */
|
|
/* This is a test case for accessing fields defined as single bits in */
|
|
/* memory. This is done by creating two index fields that overlay the */
|
|
/* same DWORD in memory. One field accesses the DWORD as a DWORD, the */
|
|
/* other accesses individual bits of the same DWORD field in memory. */
|
|
/* */
|
|
Scope (\_SB) /* System Bus */
|
|
{
|
|
/* _SB system bus */
|
|
|
|
OperationRegion (RAM, SystemMemory, 0x00800000, 0x0100)
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
/* Any access */
|
|
|
|
TREE, 3,
|
|
WRD0, 16,
|
|
WRD1, 16,
|
|
WRD2, 16,
|
|
WRD3, 16,
|
|
WRD4, 16,
|
|
DWRD, /* DWORD field */ 32
|
|
}
|
|
|
|
Field (RAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
/* Any access */
|
|
|
|
THRE, 3,
|
|
WD00, 16,
|
|
WD01, 16,
|
|
WD02, 16,
|
|
WD03, 16,
|
|
WD04, 16,
|
|
BYT0, /* Start off with a BYTE */ 8,
|
|
BIT0, /* single-bit field */ 1,
|
|
BIT1, /* single-bit field */ 1,
|
|
BIT2, /* single-bit field */ 1,
|
|
BIT3, /* single-bit field */ 1,
|
|
BIT4, /* single-bit field */ 1,
|
|
BIT5, /* single-bit field */ 1,
|
|
BIT6, /* single-bit field */ 1,
|
|
BIT7, /* single-bit field */ 1,
|
|
BIT8, /* single-bit field */ 1,
|
|
BIT9, /* single-bit field */ 1,
|
|
BITA, /* single-bit field */ 1,
|
|
BITB, /* single-bit field */ 1,
|
|
BITC, /* single-bit field */ 1,
|
|
BITD, /* single-bit field */ 1,
|
|
BITE, /* single-bit field */ 1,
|
|
BITF, /* single-bit field */ 1,
|
|
BYTZ, /* End with a BYTE for a total of 32 bits */ 8
|
|
}
|
|
|
|
Device (BITI)
|
|
{
|
|
/* Test device name */
|
|
|
|
Method (MBIT, 0, NotSerialized)
|
|
{
|
|
If ((DWRD != 0x00))
|
|
{
|
|
Local0 = 0xFF00
|
|
}
|
|
Else
|
|
{
|
|
/* Prime Local0 with 0...assume passing condition */
|
|
|
|
Local0 = 0x00
|
|
/* set memory contents to known values using DWORD field */
|
|
|
|
DWRD = 0x5A5A5A5A
|
|
/* Given the value programmed into DWRD, only the odd bits */
|
|
/* of the lower nibble should be set. BIT1, BIT3 should be set. */
|
|
/* BIT0 and BIT2 should be clear */
|
|
If (BIT0)
|
|
{
|
|
Local0 |= 0x01
|
|
}
|
|
|
|
If (!BIT1)
|
|
{
|
|
Local0 |= 0x02
|
|
}
|
|
|
|
If (BIT2)
|
|
{
|
|
Local0 |= 0x04
|
|
}
|
|
|
|
If (!BIT3)
|
|
{
|
|
Local0 |= 0x08
|
|
}
|
|
|
|
/* Now check the upper nibble. Only the "even" bits should */
|
|
/* be set. BIT4, BIT6. BIT5 and BIT7 should be clear. */
|
|
If (!BIT4)
|
|
{
|
|
Local0 |= 0x10
|
|
}
|
|
|
|
If (BIT5)
|
|
{
|
|
Local0 |= 0x20
|
|
}
|
|
|
|
If (!BIT6)
|
|
{
|
|
Local0 |= 0x40
|
|
}
|
|
|
|
If (BIT7)
|
|
{
|
|
Local0 |= 0x80
|
|
}
|
|
} /* End Else DWRD zeroed out */
|
|
|
|
Return (Local0)
|
|
} /* MBIT: Test single bit memory accesses */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ BitIndex Test"
|
|
/* Zero out DWRD */
|
|
|
|
DWRD = 0x00
|
|
/* MBIT returns zero if successful */
|
|
/* This may be causing problems -- Return (MBIT) */
|
|
Local0 = MBIT ()
|
|
Return (Local0)
|
|
} /* TEST */
|
|
} /* BITI */
|
|
} /* _SB system bus */
|
|
|
|
/* */
|
|
/* test IndexOp3.asl */
|
|
/* */
|
|
/* Additional IndexOp test cases to support ACPICMB (control method battery */
|
|
/* test) on Compaq laptops. Test cases include storing a package into */
|
|
/* an IndexOp target and validating that changing source and destination */
|
|
/* package contents are independent of each other. */
|
|
/* */
|
|
Scope (\_SB) /* System Bus */
|
|
{
|
|
/* _SB system bus */
|
|
|
|
Name (C174, 0x0D)
|
|
Name (C175, 0x08)
|
|
Device (C158)
|
|
{
|
|
/* C158: AC Adapter device */
|
|
|
|
Name (_HID, "ACPI0003" /* Power Source Device */) /* AC Adapter device */ // _HID: Hardware ID
|
|
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
|
|
{
|
|
\_SB
|
|
})
|
|
Method (_PSR, 0, NotSerialized) // _PSR: Power Source
|
|
{
|
|
Acquire (\_GL, 0xFFFF)
|
|
Release (\_GL)
|
|
Local0 &= 0x01 /* Local0 &= 1 */
|
|
Return (Local0)
|
|
} /* _PSR */
|
|
} /* C158: AC Adapter device */
|
|
|
|
Name (C176, Package (0x04)
|
|
{
|
|
"Primary",
|
|
"MultiBay",
|
|
"DockRight",
|
|
"DockLeft"
|
|
})
|
|
Name (C177, Package (0x04)
|
|
{
|
|
0x99F5,
|
|
0x99F5,
|
|
0x995F,
|
|
0x995F
|
|
})
|
|
Name (C178, Package (0x04)
|
|
{
|
|
Package (0x04)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x966B,
|
|
0x4190
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x966B,
|
|
0x4190
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x966B,
|
|
0x4190
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x966B,
|
|
0x4190
|
|
}
|
|
}) /* C178 */
|
|
Name (C179, Package (0x04)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x966B,
|
|
0x4190
|
|
})
|
|
Name (C17A, Package (0x04)
|
|
{
|
|
Package (0x03)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x00
|
|
},
|
|
|
|
Package (0x03)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x00
|
|
},
|
|
|
|
Package (0x03)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x00
|
|
},
|
|
|
|
Package (0x03)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x00
|
|
}
|
|
}) /* C17A */
|
|
Method (C17B, 1, Serialized)
|
|
{
|
|
/* C17B: _BIF implementation */
|
|
|
|
Name (C17C, Package (0x0D)
|
|
{
|
|
/* C17C: _BIF control method return package */
|
|
|
|
0x00, /* Power Unit (0 ==> mWh and mW) */
|
|
0x99F5, /* Design Capacity */
|
|
0x99F5, /* Last Full Charge Capacity */
|
|
0x01, /* Battery Technology (1 ==> rechargeable) */
|
|
0x3840, /* Design Voltage */
|
|
0x1280, /* Design Capacity of Warning */
|
|
0x0AC7, /* Design Capacity of Low */
|
|
0x01, /* Battery Capacity Granularity 1 (Low -- Warning) */
|
|
0x01, /* Battery Capacity Granularity 2 (Warning -- Full) */
|
|
"2891", /* Model Number (ASCIIZ) */
|
|
"(-Unknown-)", /* Serial Number (ASCIIZ) */
|
|
"LIon", /* Battery Type (ASCIIZ) */
|
|
0x00 /* OEM Information (ASCIIZ) */
|
|
}) /* C17C: _BIF control method return package */
|
|
Local0 = (Arg0 & 0x07) /* Local0 = Arg0 & 7 */
|
|
Local4 = (Local0 >> 0x01) /* Local4 = Local0 >> 1 */
|
|
C178 [Local4] = C179 /* C178->Local4 = C179 */ /* \_SB_.C179 */
|
|
/* verify source and destination packages can be altered independent */
|
|
/* of each other (i.e., changing one's contents does NOT change other's */
|
|
/* contents) */
|
|
C179 [0x02] = 0x1234 /* C179[2] = 0x1234 */
|
|
Local2 = DerefOf (C179 [0x02]) /* Local2 = C179[2] */
|
|
If ((Local2 != 0x1234))
|
|
{
|
|
Return (0x1234)
|
|
}
|
|
|
|
/* Local2 = C178[0,2] */
|
|
|
|
Local2 = DerefOf (DerefOf (C178 [0x00]) [0x02])
|
|
If ((Local2 != 0x966B))
|
|
{
|
|
Return (0x1234)
|
|
}
|
|
|
|
/* Restore data to allow iterative execution */
|
|
|
|
C179 [0x02] = 0x966B /* C179[2] = 0x966B */
|
|
/* C178[0,3] = 0x5678 */
|
|
|
|
DerefOf (C178 [0x00]) [0x03] = 0x5678
|
|
/* Local2 = C178[0,3] */
|
|
|
|
Local2 = DerefOf (DerefOf (C178 [0x00]) [0x03])
|
|
If ((Local2 != 0x5678))
|
|
{
|
|
Return (0x5678)
|
|
}
|
|
|
|
Local2 = DerefOf (C179 [0x03]) /* Local2 = C179[3] */
|
|
If ((Local2 != 0x4190))
|
|
{
|
|
Return (0x5678)
|
|
}
|
|
|
|
/* Restore data to allow iterative execution */
|
|
|
|
DerefOf (C178 [0x00]) [0x03] = 0x4190 /* C179[2] = 0x4190 */
|
|
Return (C17C) /* \_SB_.C17B.C17C */
|
|
} /* C17B: _BIF implementation */
|
|
|
|
Device (C154)
|
|
{
|
|
/* C154: Battery 0 */
|
|
|
|
Name (_HID, "*PNP0C0A") /* Control Method Battey ID */ // _HID: Hardware ID
|
|
Name (_UID, 0x00) /* first instance */ // _UID: Unique ID
|
|
Method (_BIF, 0, NotSerialized) // _BIF: Battery Information
|
|
{
|
|
/* _BIF */
|
|
|
|
Return (C17B (0x30))
|
|
} /* _BIF */
|
|
} /* C154: Battery 0 */
|
|
|
|
Device (IDX3)
|
|
{
|
|
Method (LCLB, 0, Serialized)
|
|
{
|
|
/* LCLB control method: test Index(Local#) where Local# is buffer */
|
|
/* Local0 is index counter */
|
|
/* Local1 is buffer */
|
|
/* Local2 receives BUFR[Local0] via Deref(Index(Local1...)) */
|
|
/* Local3 is Local1 or Local2 object type */
|
|
/* Local4 is return error code */
|
|
Name (BUFR, Buffer (0x0A)
|
|
{
|
|
/* 0000 */ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, // ........
|
|
/* 0008 */ 0x08, 0x09 // ..
|
|
})
|
|
/* save PKG into Local1 */
|
|
|
|
Local1 = BUFR /* \_SB_.IDX3.LCLB.BUFR */
|
|
/* save Local2 object type value into Local3 */
|
|
|
|
Local3 = ObjectType (Local1)
|
|
/* validate Local1 is a Buffer */
|
|
|
|
If ((Local3 != 0x03)) /* Buffer type is 3 */
|
|
{
|
|
Return (0x9F)
|
|
}
|
|
|
|
Local0 = 0x00
|
|
While ((Local0 < 0x05))
|
|
{
|
|
/* While (Local0 < 5) */
|
|
/* Local2 = Local1[Local0] */
|
|
Local2 = DerefOf (Local1 [Local0])
|
|
/* save Local2 object type value into Local3 */
|
|
|
|
Local3 = ObjectType (Local2)
|
|
/* validate Local2 is a Number */
|
|
|
|
If ((Local3 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x9E)
|
|
}
|
|
|
|
/* validate Local1[Local0] value == Local0 */
|
|
|
|
If ((Local0 != Local2))
|
|
{
|
|
/* Local0 != Local2 == PKG[Local0] */
|
|
/* Local4 = 0x90 + loop index (Local0) */
|
|
Local4 = (0x90 + Local0)
|
|
/* return 0x90 + loop index */
|
|
|
|
Return (Local4)
|
|
}
|
|
|
|
Local0++
|
|
} /* While (Local0 < 5) */
|
|
|
|
Debug = "DerefOf(Index(LocalBuffer,,)) PASS"
|
|
Return (0x00) /* Pass */
|
|
} /* LCLB control method: test Index(Local#) where Local# is buffer */
|
|
|
|
Method (LCLP, 0, Serialized)
|
|
{
|
|
/* LCLP control method: test Index(Local#) where Local# is package */
|
|
/* Local0 is index counter */
|
|
/* Local1 is package */
|
|
/* Local2 receives PKG[Local0] via Deref(Index(Local1...)) */
|
|
/* Local3 is Local1 or Local2 object type */
|
|
/* Local4 is return error code */
|
|
Name (PKG, Package (0x0A)
|
|
{
|
|
0x00,
|
|
0x01,
|
|
0x02,
|
|
0x03,
|
|
0x04,
|
|
0x05,
|
|
0x06,
|
|
0x07,
|
|
0x08,
|
|
0x09
|
|
})
|
|
/* save PKG into Local1 */
|
|
|
|
Local1 = PKG /* \_SB_.IDX3.LCLP.PKG_ */
|
|
/* save Local2 object type value into Local3 */
|
|
|
|
Local3 = ObjectType (Local1)
|
|
/* validate Local1 is a Package */
|
|
|
|
If ((Local3 != 0x04)) /* Package type is 4 */
|
|
{
|
|
Return (0x8F)
|
|
}
|
|
|
|
Local0 = 0x00
|
|
While ((Local0 < 0x05))
|
|
{
|
|
/* While (Local0 < 5) */
|
|
/* Local2 = Local1[Local0] */
|
|
Local2 = DerefOf (Local1 [Local0])
|
|
/* save Local2 object type value into Local3 */
|
|
|
|
Local3 = ObjectType (Local2)
|
|
/* validate Local2 is a Number */
|
|
|
|
If ((Local3 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x8E)
|
|
}
|
|
|
|
/* validate Local1[Local0] value == Local0 */
|
|
|
|
If ((Local0 != Local2))
|
|
{
|
|
/* Local0 != Local2 == PKG[Local0] */
|
|
/* Local4 = 0x80 + loop index (Local0) */
|
|
Local4 = (0x80 + Local0)
|
|
/* return 0x80 + loop index */
|
|
|
|
Return (Local4)
|
|
}
|
|
|
|
Local0++
|
|
} /* While (Local0 < 5) */
|
|
|
|
Debug = "DerefOf(Index(LocalPackage,,)) PASS"
|
|
Return (0x00) /* Pass */
|
|
} /* LCLP control method: test Index(Local#) where Local# is package */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ IndexOp3 Test"
|
|
/* store _BIF package return value into Local0 */
|
|
|
|
Local0 = \_SB.C154._BIF ()
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Package */
|
|
|
|
If ((Local1 != 0x04)) /* Package type is 4 */
|
|
{
|
|
/* failure: did not return a Package (type 4) */
|
|
/* if Local0 is a Number, it contains an error code */
|
|
If ((Local1 == 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (Local0)
|
|
} /* return Local0 error code */
|
|
Else
|
|
{
|
|
Return (0x01)
|
|
} /* return default error code */
|
|
} /* failure: did not return a Package (type 4) */
|
|
|
|
/* save LCLB control method return value into Local2 */
|
|
|
|
Local2 = LCLB ()
|
|
If ((Local2 != 0x00))
|
|
{
|
|
Return (Local2)
|
|
} /* return failure code */
|
|
|
|
/* save LCLP control method return value into Local2 */
|
|
|
|
Local2 = LCLP ()
|
|
If ((Local2 != 0x00))
|
|
{
|
|
Return (Local2)
|
|
} /* return failure code */
|
|
|
|
Return (0x00) /* Pass */
|
|
} /* TEST */
|
|
} /* IDX3: Test device name */
|
|
} /* _SB system bus */
|
|
|
|
/* */
|
|
/* MTL developed test to exercise Indexes into buffers */
|
|
/* */
|
|
Device (IDX7)
|
|
{
|
|
Name (PKG4, Package (0x05)
|
|
{
|
|
0x02,
|
|
"A short string",
|
|
Buffer (0x04)
|
|
{
|
|
0x0A, 0x0B, 0x0C, 0x0D // ....
|
|
},
|
|
|
|
0x1234,
|
|
Package (0x02)
|
|
{
|
|
IDX7,
|
|
0x03
|
|
}
|
|
})
|
|
/* */
|
|
/* Generic Test method */
|
|
/* */
|
|
/* This test returns 0xE (14) - ObjectType = Buffer Field */
|
|
Method (TST1, 0, Serialized)
|
|
{
|
|
Name (DEST, Buffer (0x3F)
|
|
{
|
|
"Destination buffer that is longer than the short source buffer"
|
|
})
|
|
/* verify object type returned by Index(Buffer,Element,) */
|
|
|
|
Store (DEST [0x02], Local1)
|
|
Local2 = ObjectType (Local1)
|
|
If ((Local2 == 0x0E))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x01)
|
|
}
|
|
}
|
|
|
|
Method (TST2, 0, Serialized)
|
|
{
|
|
Name (BUF0, Buffer (0x05)
|
|
{
|
|
0x01, 0x02, 0x03, 0x04, 0x05 // .....
|
|
})
|
|
BUF0 [0x02] = 0x55
|
|
Local0 = DerefOf (BUF0 [0x02])
|
|
If ((Local0 == 0x55))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x02)
|
|
}
|
|
}
|
|
|
|
Method (TST3, 0, Serialized)
|
|
{
|
|
Name (BUF1, Buffer (0x05)
|
|
{
|
|
0x01, 0x02, 0x03, 0x04, 0x05 // .....
|
|
})
|
|
Store (BUF1 [0x01], Local0)
|
|
Local1 = DerefOf (Local0)
|
|
If ((Local1 == 0x02))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x03)
|
|
}
|
|
}
|
|
|
|
Method (TST4, 0, NotSerialized)
|
|
{
|
|
/* Index (PKG4, 0) is a Number */
|
|
|
|
Store (PKG4 [0x00], Local0)
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 == 0x01))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x04)
|
|
}
|
|
}
|
|
|
|
Method (TST5, 0, NotSerialized)
|
|
{
|
|
/* Index (PKG4, 1) is a String */
|
|
|
|
Store (PKG4 [0x01], Local0)
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 == 0x02))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x05)
|
|
}
|
|
}
|
|
|
|
Method (TST6, 0, NotSerialized)
|
|
{
|
|
/* Index (PKG4, 2) is a Buffer */
|
|
|
|
Store (PKG4 [0x02], Local0)
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 == 0x03))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x06)
|
|
}
|
|
}
|
|
|
|
Method (TST7, 0, NotSerialized)
|
|
{
|
|
/* Index (PKG4, 3) is a Number */
|
|
|
|
Store (PKG4 [0x03], Local0)
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 == 0x01))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x07)
|
|
}
|
|
}
|
|
|
|
Method (TST8, 0, NotSerialized)
|
|
{
|
|
/* Index (PKG4, 4) is a Package */
|
|
|
|
Store (PKG4 [0x04], Local0)
|
|
Local1 = ObjectType (Local0)
|
|
If ((Local1 == 0x04))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x08)
|
|
}
|
|
}
|
|
|
|
Method (TST9, 0, NotSerialized)
|
|
{
|
|
/* DerefOf (Index (PKG4, 0)) is a Number */
|
|
|
|
Local0 = DerefOf (PKG4 [0x00])
|
|
If ((Local0 == 0x02))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x09)
|
|
}
|
|
}
|
|
|
|
Method (TSTA, 0, NotSerialized)
|
|
{
|
|
/* DerefOf (Index (PKG4, 1)) is a String */
|
|
|
|
Local0 = DerefOf (PKG4 [0x01])
|
|
Local1 = SizeOf (Local0)
|
|
If ((Local1 == 0x0E))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x0A)
|
|
}
|
|
}
|
|
|
|
Method (TSTB, 0, NotSerialized)
|
|
{
|
|
/* DerefOf (Index (PKG4, 2)) is a Buffer */
|
|
|
|
Local0 = DerefOf (PKG4 [0x02])
|
|
Local1 = SizeOf (Local0)
|
|
If ((Local1 == 0x04))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x0B)
|
|
}
|
|
}
|
|
|
|
Method (TSTC, 0, NotSerialized)
|
|
{
|
|
/* DerefOf (Index (PKG4, 3)) is a Number */
|
|
|
|
Local0 = DerefOf (PKG4 [0x03])
|
|
If ((Local0 == 0x1234))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x0C)
|
|
}
|
|
}
|
|
|
|
Method (TSTD, 0, NotSerialized)
|
|
{
|
|
/* DerefOf (Index (PKG4, 4)) is a Package */
|
|
|
|
Local0 = DerefOf (PKG4 [0x04])
|
|
Local1 = SizeOf (Local0)
|
|
If ((Local1 == 0x02))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x0D)
|
|
}
|
|
}
|
|
|
|
Method (TSTE, 0, NotSerialized)
|
|
{
|
|
/* DerefOf (Index (PKG4, 2)) is a Buffer */
|
|
|
|
Local0 = DerefOf (PKG4 [0x02])
|
|
/* DerefOf (Index (Local0, 1)) is a Number */
|
|
|
|
Local1 = DerefOf (Local0 [0x01])
|
|
If ((Local1 == 0x0B))
|
|
{
|
|
Return (0x00)
|
|
}
|
|
Else
|
|
{
|
|
Return (0x0E)
|
|
}
|
|
}
|
|
|
|
Method (TSTF, 0, Serialized)
|
|
{
|
|
Name (SRCB, Buffer (0x0C){}) /* 12 characters */
|
|
SRCB = "Short Buffer"
|
|
Name (DEST, Buffer (0x3F)
|
|
{
|
|
"Destination buffer that is longer than the short source buffer"
|
|
})
|
|
/* overwrite DEST contents, starting at buffer position 2 */
|
|
|
|
DEST [0x02] = SRCB /* \IDX7.TSTF.SRCB */
|
|
/* */
|
|
/* The DEST buffer element should be replaced with the last element of */
|
|
/* the SRCB element (i.e. 's'->'r') */
|
|
Local0 = DerefOf (DEST [0x02])
|
|
If ((Local0 != 0x72)) /* 'r' */
|
|
{
|
|
/* DEST element does not match the value from SRCB */
|
|
|
|
Return ((Local0 | 0x1000))
|
|
}
|
|
|
|
Return (0x00)
|
|
}
|
|
|
|
Method (TSTG, 0, Serialized)
|
|
{
|
|
Name (SRCB, Buffer (0x0C){}) /* 12 characters */
|
|
SRCB = "Short Buffer"
|
|
Name (DEST, Buffer (0x3F)
|
|
{
|
|
"Destination buffer that is longer than the short source buffer"
|
|
})
|
|
/* overwrite DEST contents, starting at buffer position 2 */
|
|
|
|
DEST [0x02] = SRCB /* \IDX7.TSTG.SRCB */
|
|
/* */
|
|
/* The next element of DEST should be unchanged */
|
|
/* */
|
|
Local0 = DerefOf (DEST [0x03])
|
|
If ((Local0 != 0x74)) /* 't' */
|
|
{
|
|
/* DEST has been changed */
|
|
|
|
Return ((Local0 | 0x2000))
|
|
}
|
|
|
|
/* */
|
|
/* The next element of DEST should be unchanged */
|
|
/* */
|
|
Local0 = DerefOf (DEST [0x04])
|
|
If ((Local0 != 0x69)) /* 'i' */
|
|
{
|
|
/* DEST has been changed */
|
|
|
|
Return ((Local0 | 0x2100))
|
|
}
|
|
|
|
/* */
|
|
/* The next element of DEST should be unchanged */
|
|
/* */
|
|
Local0 = DerefOf (DEST [0x05])
|
|
If ((Local0 != 0x6E)) /* 'n' */
|
|
{
|
|
/* DEST has been changed */
|
|
|
|
Return ((Local0 | 0x2200))
|
|
}
|
|
|
|
/* */
|
|
/* The next element of DEST should be unchanged */
|
|
/* */
|
|
Local0 = DerefOf (DEST [0x06])
|
|
If ((Local0 != 0x61)) /* 'a' */
|
|
{
|
|
/* DEST has been changed */
|
|
|
|
Return ((Local0 | 0x2300))
|
|
}
|
|
|
|
/* */
|
|
/* The next element of DEST should be unchanged */
|
|
/* */
|
|
Local0 = DerefOf (DEST [0x07])
|
|
If ((Local0 != 0x74)) /* 't' */
|
|
{
|
|
/* DEST has been changed */
|
|
|
|
Return ((Local0 | 0x2400))
|
|
}
|
|
|
|
/* */
|
|
/* Verify DEST elements beyond end of SRCB buffer copy */
|
|
/* have not been changed */
|
|
Local0 = DerefOf (DEST [0x0E])
|
|
If ((Local0 != 0x66)) /* 'f' */
|
|
{
|
|
/* DEST has been changed */
|
|
|
|
Return ((Local0 | 0x2400))
|
|
}
|
|
|
|
Return (0x00)
|
|
}
|
|
|
|
/* */
|
|
/* This test shows that MS ACPI.SYS stores only the lower 8-bits of a 32-bit */
|
|
/* number into the index'ed buffer */
|
|
/* */
|
|
Method (TSTH, 0, Serialized)
|
|
{
|
|
/* Create a Destination Buffer */
|
|
|
|
Name (DBUF, Buffer (0x1B)
|
|
{
|
|
"abcdefghijklmnopqrstuvwxyz"
|
|
})
|
|
/* Store a number > UINT8 into an index of the buffer */
|
|
|
|
DBUF [0x02] = 0x12345678
|
|
/* Check the results */
|
|
|
|
Local0 = DerefOf (DBUF [0x02])
|
|
If ((Local0 != 0x78)) /* 0x78 */
|
|
{
|
|
Return ((Local0 | 0x3000))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x03])
|
|
If ((Local0 != 0x64)) /* 'd' */
|
|
{
|
|
Return ((Local0 | 0x3100))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x04])
|
|
If ((Local0 != 0x65)) /* 'e' */
|
|
{
|
|
Return ((Local0 | 0x3200))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x05])
|
|
If ((Local0 != 0x66)) /* 'f' */
|
|
{
|
|
Return ((Local0 | 0x3300))
|
|
}
|
|
|
|
Return (0x00)
|
|
}
|
|
|
|
Method (TSTI, 0, Serialized)
|
|
{
|
|
/* Create a Destination Buffer */
|
|
|
|
Name (DBUF, Buffer (0x1B)
|
|
{
|
|
"abcdefghijklmnopqrstuvwxyz"
|
|
})
|
|
/* Store a String into an index of the buffer */
|
|
|
|
DBUF [0x02] = "ABCDEFGH"
|
|
/* Check the results */
|
|
|
|
Local0 = DerefOf (DBUF [0x02])
|
|
If ((Local0 != 0x48)) /* 'H' */
|
|
{
|
|
Return ((Local0 | 0x4000))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x03])
|
|
If ((Local0 != 0x64)) /* 'd' */
|
|
{
|
|
Return ((Local0 | 0x4100))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x04])
|
|
If ((Local0 != 0x65)) /* 'e' */
|
|
{
|
|
Return ((Local0 | 0x4200))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x05])
|
|
If ((Local0 != 0x66)) /* 'f' */
|
|
{
|
|
Return ((Local0 | 0x4300))
|
|
}
|
|
|
|
Return (0x00)
|
|
}
|
|
|
|
Method (TSTJ, 0, Serialized)
|
|
{
|
|
/* Create a Destination Buffer */
|
|
|
|
Name (DBUF, Buffer (0x1B)
|
|
{
|
|
"abcdefghijklmnopqrstuvwxyz"
|
|
})
|
|
/* Store a number > UINT8 into an index of the buffer */
|
|
|
|
DBUF [0x02] = 0x1234
|
|
/* Check the results */
|
|
|
|
Local0 = DerefOf (DBUF [0x02])
|
|
If ((Local0 != 0x34)) /* 0x34 */
|
|
{
|
|
Return ((Local0 | 0x3000))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x03])
|
|
If ((Local0 != 0x64)) /* 'd' */
|
|
{
|
|
Return ((Local0 | 0x3100))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x04])
|
|
If ((Local0 != 0x65)) /* 'e' */
|
|
{
|
|
Return ((Local0 | 0x3200))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x05])
|
|
If ((Local0 != 0x66)) /* 'f' */
|
|
{
|
|
Return ((Local0 | 0x3300))
|
|
}
|
|
|
|
Return (0x00)
|
|
}
|
|
|
|
Method (TSTK, 0, Serialized)
|
|
{
|
|
/* Create a Destination Buffer */
|
|
|
|
Name (DBUF, Buffer (0x1B)
|
|
{
|
|
"abcdefghijklmnopqrstuvwxyz"
|
|
})
|
|
/* Store a number > UINT8 into an index of the buffer */
|
|
|
|
DBUF [0x02] = 0x00123456
|
|
/* Check the results */
|
|
|
|
Local0 = DerefOf (DBUF [0x02])
|
|
If ((Local0 != 0x56)) /* 0x56 */
|
|
{
|
|
Return ((Local0 | 0x3000))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x03])
|
|
If ((Local0 != 0x64)) /* 'd' */
|
|
{
|
|
Return ((Local0 | 0x3100))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x04])
|
|
If ((Local0 != 0x65)) /* 'e' */
|
|
{
|
|
Return ((Local0 | 0x3200))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x05])
|
|
If ((Local0 != 0x66)) /* 'f' */
|
|
{
|
|
Return ((Local0 | 0x3300))
|
|
}
|
|
|
|
Return (0x00)
|
|
}
|
|
|
|
Method (TSTL, 0, Serialized)
|
|
{
|
|
/* Create a Destination Buffer */
|
|
|
|
Name (DBUF, Buffer (0x1B)
|
|
{
|
|
"abcdefghijklmnopqrstuvwxyz"
|
|
})
|
|
/* Store a number > UINT8 into an index of the buffer */
|
|
|
|
DBUF [0x02] = 0x12
|
|
/* Check the results */
|
|
|
|
Local0 = DerefOf (DBUF [0x02])
|
|
If ((Local0 != 0x12)) /* 0x12 */
|
|
{
|
|
Return ((Local0 | 0x3000))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x03])
|
|
If ((Local0 != 0x64)) /* 'd' */
|
|
{
|
|
Return ((Local0 | 0x3100))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x04])
|
|
If ((Local0 != 0x65)) /* 'e' */
|
|
{
|
|
Return ((Local0 | 0x3200))
|
|
}
|
|
|
|
Local0 = DerefOf (DBUF [0x05])
|
|
If ((Local0 != 0x66)) /* 'f' */
|
|
{
|
|
Return ((Local0 | 0x3300))
|
|
}
|
|
|
|
Return (0x00)
|
|
}
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ IndexOp7 Test"
|
|
Local0 = TST1 ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TST2 ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TST3 ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TST4 ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TST5 ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TST6 ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TST7 ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TST8 ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TST9 ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TSTA ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TSTB ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TSTC ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TSTD ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TSTE ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
/* No longer ACPI compliant */
|
|
/*
|
|
Store(TSTF(), Local0)
|
|
if (LGreater (Local0, 0))
|
|
{
|
|
Return(Local0)
|
|
}
|
|
*/
|
|
Local0 = TSTG ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TSTH ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
/* No longer ACPI compliant */
|
|
/*
|
|
Store(TSTI(), Local0)
|
|
if (LGreater (Local0, 0))
|
|
{
|
|
Return(Local0)
|
|
}
|
|
*/
|
|
Local0 = TSTJ ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TSTK ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Local0 = TSTL ()
|
|
If ((Local0 > 0x00))
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Return (Local0)
|
|
}
|
|
} /* Device(IDX7) */
|
|
|
|
/* */
|
|
/* test MatchOp.asl */
|
|
/* */
|
|
/* MatchOp test cases that utilize nested DerefOf(Index(...)) to validate */
|
|
/* MatchOp, DerefOfOp, and IndexOp of nested packages. */
|
|
/* */
|
|
Device (MTCH)
|
|
{
|
|
Method (TEST, 0, Serialized)
|
|
{
|
|
Debug = "++++++++ MatchOp Test"
|
|
Name (TIM0, Package (0x08)
|
|
{
|
|
Package (0x04)
|
|
{
|
|
0x78,
|
|
0xB4,
|
|
0xF0,
|
|
0x0384
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x23,
|
|
0x21,
|
|
0x10,
|
|
0x00
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x0B,
|
|
0x09,
|
|
0x04,
|
|
0x00
|
|
},
|
|
|
|
Package (0x05)
|
|
{
|
|
0x70,
|
|
0x49,
|
|
0x36,
|
|
0x27,
|
|
0x19
|
|
},
|
|
|
|
Package (0x05)
|
|
{
|
|
0x00,
|
|
0x01,
|
|
0x02,
|
|
0x01,
|
|
0x02
|
|
},
|
|
|
|
Package (0x05)
|
|
{
|
|
0x00,
|
|
0x00,
|
|
0x00,
|
|
0x01,
|
|
0x01
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x04,
|
|
0x03,
|
|
0x02,
|
|
0x00
|
|
},
|
|
|
|
Package (0x04)
|
|
{
|
|
0x02,
|
|
0x01,
|
|
0x00,
|
|
0x00
|
|
}
|
|
}) /* TIM0 */
|
|
Name (TMD0, Buffer (0x14)
|
|
{
|
|
0xFF, 0xFF, 0xFF, 0xFF // ....
|
|
})
|
|
CreateDWordField (TMD0, 0x00, PIO0) /* 0xFFFFFFFF */
|
|
CreateDWordField (TMD0, 0x04, DMA0)
|
|
CreateDWordField (TMD0, 0x08, PIO1)
|
|
CreateDWordField (TMD0, 0x0C, DMA1)
|
|
CreateDWordField (TMD0, 0x10, CHNF)
|
|
/* validate PIO0 value */
|
|
|
|
Local3 = PIO0 /* \MTCH.TEST.PIO0 */
|
|
/* save Local3 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local3)
|
|
/* validate Local3 is a Number */
|
|
|
|
If ((Local2 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x02)
|
|
} /* failure */
|
|
|
|
/* validate Local3 Number value */
|
|
|
|
If ((Local3 != 0xFFFFFFFF)) /* Number value 0xFFFFFFFF */
|
|
{
|
|
Return (0x03)
|
|
} /* failure */
|
|
|
|
Debug = "DWordField PASS"
|
|
Local5 = 0x00
|
|
Local6 = Match (DerefOf (TIM0 [0x01]), MLE, Local5, MTR, 0x00,
|
|
0x00)
|
|
/* save Local6 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local6)
|
|
/* validate Local6 is a Number */
|
|
|
|
If ((Local2 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x04)
|
|
} /* failure */
|
|
|
|
Debug = "Match(DerefOf(Index(TIM0,1)),... PASS"
|
|
/* validate following produces a nested package to validate */
|
|
/* that MatchOp did not corrupt SearchPackage (TIM0) */
|
|
Local4 = DerefOf (TIM0 [0x01])
|
|
/* save Local4 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local4)
|
|
/* validate Local4 is a Package */
|
|
|
|
If ((Local2 != 0x04)) /* Package type is 4 */
|
|
{
|
|
Return (0x05)
|
|
} /* failure */
|
|
|
|
Debug = "DerefOf(Index(TIM0,1)),... PASS"
|
|
Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO0, MTR, 0x00,
|
|
0x00) & 0x03)
|
|
/* save Local0 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local2 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x06)
|
|
} /* failure */
|
|
|
|
/* validate Local0 Number value */
|
|
|
|
If ((Local0 != 0x03)) /* Number value 3 */
|
|
{
|
|
Return (0x07)
|
|
} /* failure */
|
|
|
|
Debug = "And(Match(DerefOf(Index(TIM0,0)),... PASS"
|
|
/* again, validate following produces a nested package */
|
|
|
|
Local4 = DerefOf (TIM0 [0x01])
|
|
/* save Local4 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local4)
|
|
/* validate Local4 is a Package */
|
|
|
|
If ((Local2 != 0x04)) /* Package type is 4 */
|
|
{
|
|
Return (0x08)
|
|
} /* failure */
|
|
|
|
Debug = "DerefOf(Index(TIM0,1)),... PASS again"
|
|
/* again, validate following produces a nested package */
|
|
|
|
Local4 = DerefOf (TIM0 [0x01])
|
|
/* save Local4 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local4)
|
|
/* validate Local4 is a Package */
|
|
|
|
If ((Local2 != 0x04)) /* Package type is 4 */
|
|
{
|
|
Return (0x09)
|
|
} /* failure */
|
|
|
|
Debug = "DerefOf(Index(TIM0,1)),... PASS again"
|
|
/* test nested DerefOf(Index) operators */
|
|
|
|
Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0])
|
|
/* save Local1 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local1)
|
|
/* validate Local1 is a Number */
|
|
|
|
If ((Local2 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x0A)
|
|
} /* failure */
|
|
|
|
/* zero indicates pass, non-zero is an error code */
|
|
|
|
If ((Local1 != 0x00))
|
|
{
|
|
Return (0x0B)
|
|
} /* failure */
|
|
|
|
Debug = "DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS"
|
|
/* again, validate following produces a nested package */
|
|
|
|
Local4 = DerefOf (TIM0 [0x01])
|
|
/* save Local4 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local4)
|
|
/* validate Local4 is a Package */
|
|
|
|
If ((Local2 != 0x04)) /* Package type is 4 */
|
|
{
|
|
Return (0x0C)
|
|
} /* failure */
|
|
|
|
Debug = "DerefOf(Index(TIM0,1)),... PASS again"
|
|
/* retest nested DerefOf(Index) operators */
|
|
|
|
Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0])
|
|
/* save Local1 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local1)
|
|
/* validate Local1 is a Number */
|
|
|
|
If ((Local2 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x0D)
|
|
} /* failure */
|
|
|
|
/* zero indicates pass, non-zero is an error code */
|
|
|
|
If ((Local1 != 0x00))
|
|
{
|
|
Return (0x0E)
|
|
} /* failure */
|
|
|
|
Debug = "DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again"
|
|
/* again, validate following produces a nested package */
|
|
|
|
Local4 = DerefOf (TIM0 [0x01])
|
|
/* save Local4 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local4)
|
|
/* validate Local4 is a Package */
|
|
|
|
If ((Local2 != 0x04)) /* Package type is 4 */
|
|
{
|
|
Return (0x0F)
|
|
} /* failure */
|
|
|
|
Debug = "DerefOf(Index(TIM0,1)),... PASS again"
|
|
Return (0x00) /* pass */
|
|
} /* TEST */
|
|
} /* MTCH */
|
|
|
|
/* */
|
|
/* test WhileBrk.asl */
|
|
/* */
|
|
/* This code tests the Break term and While term */
|
|
/* */
|
|
/* Syntax of Break term */
|
|
/* BreakTerm := Break */
|
|
/* The break operation causes the current package execution to complete. */
|
|
/* */
|
|
/* Syntax of While Term */
|
|
/* WhileTerm := While( */
|
|
/* Predicate //TermArg=>Integer */
|
|
/* ) {TermList} */
|
|
/* Predicate is evaluated as an integer. */
|
|
/* If the integer is non-zero, the list of terms in TermList is executed. */
|
|
/* The operation repeats until the Predicate evaluates to zero. */
|
|
/* */
|
|
/* MTL NOTE: This test has been modified to reflect ACPI 2.0 break */
|
|
/* NOTE: This test, when run under the MS ACPI.SYS grinds the system to */
|
|
/* a halt. */
|
|
/* */
|
|
Device (WHLB)
|
|
{
|
|
Name (CNT0, 0x00)
|
|
Name (CNT1, 0x00)
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
/* Check Break statement nested in If nested in While nested in */
|
|
/* While only exits inner-most While loop */
|
|
CNT0 = 0x00
|
|
While ((CNT0 < 0x04))
|
|
{
|
|
CNT1 = 0x00
|
|
While ((CNT1 < 0x0A))
|
|
{
|
|
If ((CNT1 == 0x01))
|
|
{
|
|
Break /* exit encompassing loop */
|
|
}
|
|
|
|
CNT1++
|
|
}
|
|
|
|
If ((CNT1 != 0x01))
|
|
{
|
|
/* failure */
|
|
|
|
Return (0x07)
|
|
}
|
|
|
|
CNT0++
|
|
}
|
|
|
|
/* Verify Break only exited inner-most While loop */
|
|
|
|
If ((CNT0 != 0x04))
|
|
{
|
|
/* failure */
|
|
|
|
Return (0x08)
|
|
}
|
|
|
|
Debug = "While/While/If/Break PASS"
|
|
Debug = "++++++++ WhileBrk Test"
|
|
/* Check Break statement nested in While */
|
|
|
|
CNT0 = 0x00
|
|
While ((CNT0 < 0x0A))
|
|
{
|
|
Break
|
|
CNT0++
|
|
}
|
|
|
|
If ((CNT0 != 0x00)) /* instruction after Break executed */
|
|
{
|
|
Return (0x04)
|
|
}
|
|
|
|
CNT0 = 0x00
|
|
/* Test While Term */
|
|
|
|
While ((CNT0 < 0x0A))
|
|
{
|
|
CNT0++
|
|
}
|
|
|
|
/* Check if the while loop was executed until the condition is satisfied. */
|
|
|
|
If ((CNT0 != 0x0A))
|
|
{
|
|
Return (0x01)
|
|
}
|
|
|
|
/* While loop in a reverse order */
|
|
|
|
While ((CNT0 > 0x00))
|
|
{
|
|
CNT0--
|
|
}
|
|
|
|
/* Check if the while loop was executed until the condition is satisfied. */
|
|
|
|
If ((CNT0 != 0x00))
|
|
{
|
|
Return (0x02)
|
|
}
|
|
|
|
Debug = "While/Break PASS"
|
|
/* Check Break statement nested in If nested in While */
|
|
|
|
CNT0 = 0x00
|
|
While ((CNT0 < 0x0A))
|
|
{
|
|
If ((CNT0 == 0x05))
|
|
{
|
|
Break
|
|
/* if we execute the next instruction, */
|
|
/* Break did not exit the loop */
|
|
CNT0 = 0x14 /* exit While loop with value larger */
|
|
/* than above */
|
|
}
|
|
|
|
CNT0++ /* check if Break exited both If and While */
|
|
} /* While */
|
|
|
|
If ((CNT0 > 0x13))
|
|
{
|
|
/* instruction after Break inside IfOp executed */
|
|
|
|
Return (0x05)
|
|
}
|
|
|
|
/* */
|
|
/* Break will exit out of the while loop, therefore */
|
|
/* the CNT0 counter should still Increment until 5 */
|
|
/* */
|
|
If ((CNT0 != 0x05))
|
|
{
|
|
/* instruction after Break inside WhileOp executed */
|
|
|
|
Return (0x06)
|
|
}
|
|
|
|
Debug = "While/If/Break PASS"
|
|
/* All the conditions passed */
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* WHLB */
|
|
|
|
/* */
|
|
/* test IndexOp2.asl */
|
|
/* */
|
|
/* Additional IndexOp test cases to support ACPICMB (control method battery */
|
|
/* test) on Toshiba Portege 7020CT. Test cases include appropriate bit */
|
|
/* shifting of Field elements and reading Field elements greater than 64 bits. */
|
|
/* */
|
|
/* MTL NOTE: This test has been modified slightly from the original test */
|
|
/* to take into account ACPI specification limitations. */
|
|
/* */
|
|
Scope (\_SB) /* System Bus */
|
|
{
|
|
/* _SB system bus */
|
|
|
|
Device (MEM)
|
|
{
|
|
/* MEM */
|
|
|
|
Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID
|
|
Name (_STA, 0x0F) // _STA: Status
|
|
OperationRegion (SMEM, SystemMemory, 0x00800000, 0x0100)
|
|
Field (SMEM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
/* Field: SMEM overlay using 32-bit field elements */
|
|
|
|
SMD0, /* 32-bits */ 32,
|
|
SMD1, /* 32-bits */ 32,
|
|
SMD2, /* 32-bits */ 32,
|
|
SMD3, /* 32-bits */ 32
|
|
} /* Field: SMEM overlay using 32-bit field elements */
|
|
|
|
Field (SMEM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
/* Field: SMEM overlay using greater than 32-bit field elements */
|
|
|
|
SME0, /* larger than an integer (32 or 64) */ 69,
|
|
SME1, /* larger than an integer */ 97
|
|
} /* Field: SMEM overlay using greater than 32-bit field elements */
|
|
|
|
OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000)
|
|
Field (SRAM, AnyAcc, NoLock, Preserve)
|
|
{
|
|
Offset (0x6800),
|
|
/* Field: SRAM overlay */
|
|
|
|
IEAX, 32,
|
|
IEBX, 32,
|
|
IECX, 32,
|
|
IEDX, 32,
|
|
IESI, 32,
|
|
IEDI, 32,
|
|
IEBP, 32,
|
|
Offset (0x6820),
|
|
OEAX, 32,
|
|
OEBX, 32,
|
|
OECX, 32,
|
|
OEDX, 32,
|
|
OESI, 32,
|
|
OEDI, 32,
|
|
OEBP, 32,
|
|
Offset (0x68FF),
|
|
ACST, 1,
|
|
BES1, 1,
|
|
BES2, 1,
|
|
Offset (0x6900),
|
|
BMN1, 104,
|
|
BSN1, 88,
|
|
BTP1, 72,
|
|
BPU1, 32,
|
|
BDC1, 32,
|
|
BLF1, 32,
|
|
BTC1, 32,
|
|
BDV1, 32,
|
|
BST1, 32,
|
|
BPR1, 32,
|
|
BRC1, 32,
|
|
BPV1, 32,
|
|
Offset (0x6949),
|
|
BCW1, 32,
|
|
BCL1, 32,
|
|
BG11, 32,
|
|
BG21, 32,
|
|
BOI1, 32,
|
|
Offset (0x6A03),
|
|
BMN2, 104,
|
|
BSN2, 88,
|
|
BTP2, 72,
|
|
BPU2, 32,
|
|
BDC2, 32,
|
|
BLF2, 32,
|
|
BTC2, 32,
|
|
BDV2, 32,
|
|
BST2, 32,
|
|
BPR2, 32,
|
|
BRC2, 32,
|
|
BPV2, 32,
|
|
Offset (0x6A4C),
|
|
BCW2, 32,
|
|
BCL2, 32,
|
|
BG12, 32,
|
|
BG22, 32,
|
|
BOI2, 32,
|
|
Offset (0x6B03),
|
|
AC01, 16,
|
|
AC11, 16,
|
|
PSV1, 16,
|
|
CRT1, 16,
|
|
TMP1, 16,
|
|
AST1, 16,
|
|
AC21, 16,
|
|
AC31, 16,
|
|
AC02, 16,
|
|
AC12, 16,
|
|
PSV2, 16,
|
|
CRT2, 16,
|
|
TMP2, 16,
|
|
AST2, 16,
|
|
AC22, 16,
|
|
AC32, 16,
|
|
AC03, 16,
|
|
AC13, 16,
|
|
PSV3, 16,
|
|
CRT3, 16,
|
|
TMP3, 16,
|
|
AST3, 16,
|
|
AC23, 16,
|
|
AC33, 16,
|
|
Offset (0x6B43),
|
|
TMPF, 16,
|
|
Offset (0x6BF3),
|
|
FANH, 1,
|
|
FANL, 7,
|
|
TF11, 1,
|
|
TF21, 1,
|
|
TF31, 1,
|
|
, 1,
|
|
TF10, 1,
|
|
TF20, 1,
|
|
TF30, 1,
|
|
Offset (0x6BF5),
|
|
TP11, 1,
|
|
TP21, 1,
|
|
TP31, 1,
|
|
Offset (0x6C03),
|
|
GP50, 1,
|
|
GP51, 1,
|
|
GP52, 1,
|
|
GP53, 1,
|
|
Offset (0x6C04),
|
|
GP60, 1,
|
|
GP61, 1,
|
|
GP62, 1,
|
|
GP63, 1,
|
|
GP64, 1,
|
|
GP65, 1,
|
|
GP66, 1,
|
|
Offset (0x6C05),
|
|
GP70, 1,
|
|
GP71, 1,
|
|
GP72, 1,
|
|
GP73, 1,
|
|
GP74, 1,
|
|
GP75, 1,
|
|
GP76, 1,
|
|
Offset (0x6C06),
|
|
WED0, 1,
|
|
WED1, 1,
|
|
WED2, 1,
|
|
WED3, 1,
|
|
WED4, 1,
|
|
Offset (0x6C07),
|
|
SBL0, 1,
|
|
SBL1, 1,
|
|
SBL2, 1,
|
|
SBL3, 1,
|
|
Offset (0x6C08),
|
|
LIDS, 1,
|
|
VALF, 1,
|
|
, 2,
|
|
DCKI, 1,
|
|
DCKF, 1,
|
|
BT1F, 1,
|
|
BT2F, 1,
|
|
Offset (0x6D03),
|
|
HKCD, 8,
|
|
Offset (0x6D05),
|
|
DLID, 32,
|
|
DSRN, 32,
|
|
Offset (0x6D11),
|
|
BDID, 32,
|
|
DSPW, 1,
|
|
VGAF, 1,
|
|
VWE0, 1,
|
|
VWE1, 1,
|
|
PPSC, 1,
|
|
SPSC, 1,
|
|
EWLD, 1,
|
|
EWPS, 1,
|
|
Offset (0x7003),
|
|
PRES, 32768
|
|
} /* Field: SRAM overlay */
|
|
} /* MEM */
|
|
|
|
Device (BAT1)
|
|
{
|
|
/* BAT1 */
|
|
|
|
Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) /* Control Method Battey ID */ // _HID: Hardware ID
|
|
Name (_UID, 0x01) // _UID: Unique ID
|
|
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
|
|
{
|
|
\_SB
|
|
})
|
|
Method (_STA, 0, NotSerialized) // _STA: Status
|
|
{
|
|
/* _STA */
|
|
|
|
If (\_SB.MEM.BES1)
|
|
{
|
|
Return (0x1F)
|
|
} /* battery present */
|
|
Else
|
|
{
|
|
Return (0x0F)
|
|
} /* battery not present */
|
|
} /* _STA */
|
|
|
|
Method (_BIF, 0, Serialized) // _BIF: Battery Information
|
|
{
|
|
/* _BIF */
|
|
|
|
Name (BUFR, Package (0x0D){})
|
|
BUFR [0x00] = \_SB.MEM.BPU1
|
|
BUFR [0x01] = \_SB.MEM.BDC1
|
|
BUFR [0x02] = \_SB.MEM.BLF1
|
|
BUFR [0x03] = \_SB.MEM.BTC1
|
|
BUFR [0x04] = \_SB.MEM.BDV1
|
|
BUFR [0x05] = \_SB.MEM.BCW1
|
|
BUFR [0x06] = \_SB.MEM.BCL1
|
|
BUFR [0x07] = \_SB.MEM.BG11
|
|
BUFR [0x08] = \_SB.MEM.BG21
|
|
BUFR [0x09] = \_SB.MEM.BMN1
|
|
BUFR [0x0A] = \_SB.MEM.BSN1
|
|
BUFR [0x0B] = \_SB.MEM.BTP1
|
|
BUFR [0x0C] = \_SB.MEM.BOI1
|
|
Return (BUFR) /* \_SB_.BAT1._BIF.BUFR */
|
|
} /* _BIF */
|
|
} /* BAT1 */
|
|
|
|
Device (IDX2)
|
|
{
|
|
Method (B2IB, 0, Serialized)
|
|
{
|
|
/* B2IB: store from Buffer into Index'ed Buffer */
|
|
|
|
Name (SRCB, Buffer (0x0D)
|
|
{
|
|
"Short Buffer"
|
|
}) /* 12 characters plus NULL */
|
|
Name (DEST, Buffer (0x3F)
|
|
{
|
|
"Destination buffer that is longer than the short source buffer"
|
|
})
|
|
/* verify object type returned by Index(Buffer,Element,) */
|
|
|
|
Store (DEST [0x02], Local1)
|
|
Local2 = ObjectType (Local1)
|
|
If ((Local2 != 0x0E)) /* Buffer Field is type 14 */
|
|
{
|
|
/* Local2 indicates Local1 is not a Buffer Field */
|
|
|
|
Return (0x61)
|
|
}
|
|
|
|
/* verify object type and value returned by DerefOf(Index(Buffer,Element,)) */
|
|
/* should return Number containing element value */
|
|
Local3 = DerefOf (Local1)
|
|
Local4 = ObjectType (Local3)
|
|
If ((Local4 != 0x01)) /* Number is type 1 */
|
|
{
|
|
/* Local2 indicates Local1 is not a Number */
|
|
|
|
Return (0x62)
|
|
}
|
|
ElseIf ((Local3 != 0x73)) /* expect 's' element from DEST */
|
|
{
|
|
Return (0x63)
|
|
}
|
|
|
|
Debug = "DerefOf(Index(Buffer,,)) PASS"
|
|
/* */
|
|
/* The following sections have been rewritten because storing into */
|
|
/* an Indexed buffer only changes one byte - the FIRST byte of the */
|
|
/* buffer is written to the source index. This is the ONLY byte */
|
|
/* written -- as per ACPI 2.0 */
|
|
/* */
|
|
/* Overwrite DEST contents, at buffer position 2 [only] */
|
|
DEST [0x02] = SRCB /* \_SB_.IDX2.B2IB.SRCB */
|
|
/* */
|
|
/* Check that the next byte is not changed */
|
|
/* */
|
|
Local0 = DerefOf (DEST [0x03])
|
|
If ((Local0 != 0x74)) /* 't' */
|
|
{
|
|
/* DEST element is not matching original value */
|
|
|
|
If ((Local0 == 0x68))
|
|
{
|
|
/* DEST element was altered to 'h' */
|
|
|
|
Return (0x68)
|
|
}
|
|
Else
|
|
{
|
|
/* DEST element is an unknown value */
|
|
|
|
Return (0x69)
|
|
}
|
|
}
|
|
|
|
/* */
|
|
/* Check that the elements beyond the SRCB buffer copy */
|
|
/* have not been altered. */
|
|
/* */
|
|
Local0 = DerefOf (DEST [0x0E])
|
|
/* */
|
|
/* This should be an 'f'. */
|
|
/* */
|
|
If ((Local0 != 0x66))
|
|
{
|
|
/* DEST element was zero'd by buffer copy */
|
|
|
|
If ((Local0 == 0x00))
|
|
{
|
|
/* DEST element is zero */
|
|
|
|
Return (0x6A)
|
|
}
|
|
Else
|
|
{
|
|
/* DEST element is unknown value */
|
|
|
|
Return (0x6B)
|
|
}
|
|
}
|
|
|
|
Debug = "Store(SRCB,Index(Buffer,,)) PASS"
|
|
/* */
|
|
/* verify altering SRCB does NOT alter DEST */
|
|
/* */
|
|
SRCB [0x01] = 0x6A /* SRCB = "Sjort Buffer" */
|
|
Local0 = DerefOf (SRCB [0x01])
|
|
If ((Local0 != 0x6A)) /* 'j' */
|
|
{
|
|
/* SRCB element is unaltered */
|
|
|
|
Return (0x71)
|
|
}
|
|
|
|
Local0 = DerefOf (DEST [0x03]) /* DEST = "Destination buffer that... */
|
|
If ((Local0 != 0x74)) /* 't' */
|
|
{
|
|
/* DEST element is altered */
|
|
|
|
If ((Local0 == 0x6A)) /* 'j' */
|
|
{
|
|
/* SRCB change altered DEST element */
|
|
|
|
Return (0x72)
|
|
}
|
|
Else
|
|
{
|
|
/* DEST element is unknown value */
|
|
|
|
Return (0x73)
|
|
}
|
|
}
|
|
|
|
/* verify altering DEST does NOT alter SRCB */
|
|
|
|
DEST [0x04] = 0x6B /* DEST = "DeSkination buffer..." */
|
|
Local0 = DerefOf (DEST [0x04])
|
|
If ((Local0 != 0x6B)) /* 'k' */
|
|
{
|
|
/* DEST element is unaltered */
|
|
|
|
Return (0x74)
|
|
}
|
|
|
|
Local0 = DerefOf (SRCB [0x02])
|
|
If ((Local0 != 0x6F)) /* 'o' */
|
|
{
|
|
/* SRC element is altered */
|
|
|
|
If ((Local0 == 0x6B)) /* 'k' */
|
|
{
|
|
/* DEST change altered SRCB element */
|
|
|
|
Return (0x75)
|
|
}
|
|
Else
|
|
{
|
|
/* SRCB element is unknown value */
|
|
|
|
Return (0x76)
|
|
}
|
|
}
|
|
|
|
Debug = "SRCB and DEST independent PASS"
|
|
/* verify string can be written to Index target/destination */
|
|
/* Only FIRST byte is written */
|
|
DEST [0x02] = "New Buff" /* DEST = "DeNkination buffer..." */
|
|
Local0 = DerefOf (DEST [0x02])
|
|
If ((Local0 != 0x4E)) /* 'N' */
|
|
{
|
|
/* DEST element is unaltered */
|
|
|
|
Return (0x81)
|
|
}
|
|
|
|
Local0 = DerefOf (DEST [0x06])
|
|
If ((Local0 != 0x61)) /* 'a' */
|
|
{
|
|
/* DEST element is unaltered */
|
|
|
|
Return (0x82)
|
|
}
|
|
|
|
Local0 = DerefOf (DEST [0x0A])
|
|
If ((Local0 != 0x6E)) /* 'n' */
|
|
{
|
|
/* DEST element is unaltered */
|
|
|
|
Return (0x83)
|
|
}
|
|
|
|
Debug = "Store(String,Index) PASS"
|
|
Return (0x00) /* pass */
|
|
} /* B2IB: store from Buffer into Index'ed Buffer */
|
|
|
|
Method (FB2P, 0, Serialized)
|
|
{
|
|
/* FB2P: store from Field Buffer into Index'ed Package */
|
|
|
|
Name (DEST, Package (0x02){})
|
|
/* initialize memory using 32-bit field elements */
|
|
|
|
\_SB.MEM.SMD0 = 0x01234567
|
|
\_SB.MEM.SMD1 = 0x89ABCDEF
|
|
\_SB.MEM.SMD2 = 0xFEDCBA98
|
|
\_SB.MEM.SMD3 = 0x76543210
|
|
/* move greater than 64-bit buffers into DEST package */
|
|
|
|
DEST [0x00] = \_SB.MEM.SME0
|
|
DEST [0x01] = \_SB.MEM.SME1
|
|
/* validate DEST contents */
|
|
|
|
Local0 = DerefOf (DEST [0x00])
|
|
Local1 = DerefOf (DEST [0x01])
|
|
/* verify Local0 and Local1 are Buffers */
|
|
|
|
Local2 = ObjectType (Local0)
|
|
If ((Local2 != 0x03)) /* Buffer type is 3 */
|
|
{
|
|
Return (0x11)
|
|
}
|
|
|
|
Local3 = ObjectType (Local1)
|
|
If ((Local3 != 0x03)) /* Buffer type is 3 */
|
|
{
|
|
Return (0x12)
|
|
}
|
|
|
|
/* validate DEST buffer contents */
|
|
|
|
Local4 = DerefOf (DerefOf (DEST [0x00]) [0x00])
|
|
If ((Local4 != 0x67))
|
|
{
|
|
Return (0x13)
|
|
}
|
|
|
|
Local4 = DerefOf (DerefOf (DEST [0x00]) [0x01])
|
|
If ((Local4 != 0x45))
|
|
{
|
|
Return (0x14)
|
|
}
|
|
|
|
Local4 = DerefOf (DerefOf (DEST [0x00]) [0x04])
|
|
If ((Local4 != 0xEF))
|
|
{
|
|
Return (0x15)
|
|
}
|
|
|
|
Local4 = DerefOf (DerefOf (DEST [0x00]) [0x05])
|
|
If ((Local4 != 0xCD))
|
|
{
|
|
Return (0x16)
|
|
}
|
|
|
|
Debug = "Store(Mem,PkgElement) PASS"
|
|
/* validate changing source \_SB.MEM.SMD* does not impact DEST */
|
|
|
|
\_SB.MEM.SMD0 = 0x12345678
|
|
Local5 = DerefOf (DerefOf (DEST [0x00]) [0x00])
|
|
If ((Local5 != 0x67))
|
|
{
|
|
Return (0x21)
|
|
}
|
|
|
|
Local5 = DerefOf (DerefOf (DEST [0x00]) [0x01])
|
|
If ((Local5 != 0x45))
|
|
{
|
|
Return (0x22)
|
|
}
|
|
|
|
/* validate changing DEST does not impact source \_SB.MEM.SMD* */
|
|
|
|
DerefOf (DEST [0x00]) [0x00] = 0x30
|
|
Local5 = DerefOf (DerefOf (DEST [0x00]) [0x00])
|
|
If ((Local5 != 0x30))
|
|
{
|
|
Return (0x23)
|
|
}
|
|
|
|
/* */
|
|
/* This section was modified from the original iPCO code because */
|
|
/* it attempted to compare two buffers. This is not allowed until */
|
|
/* ACPI v2.0, so the test has been modified to just check the */
|
|
/* changed \_SB.MEM.SMD0 */
|
|
/* */
|
|
Local5 = \_SB.MEM.SMD0
|
|
If ((Local5 != 0x12345678))
|
|
{
|
|
Return (0x24)
|
|
}
|
|
|
|
Debug = "Mem and Pkg independent PASS"
|
|
Return (0x00)
|
|
} /* FB2P: store from Field Buffer into Index'ed Package */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ IndexOp2 Test"
|
|
/* store _BIF package return value into Local0 */
|
|
|
|
Local0 = \_SB.BAT1._BIF ()
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Package */
|
|
|
|
If ((Local1 != 0x04)) /* Package type is 4 */
|
|
{
|
|
/* failure */
|
|
|
|
Return (0x02)
|
|
}
|
|
|
|
/* validate source and destination buffers are independent of each */
|
|
/* of each other (i.e., changing one's contents does not change */
|
|
/* other's contents) using B2IB (store from Buffer into Index'ed */
|
|
/* Buffer) and FB2P (store from Field Buffer into Index'ed Package) */
|
|
/* call B2IB (store from Buffer into Index'ed Buffer) */
|
|
Local2 = B2IB () /* Local2 is B2IB return value */
|
|
/* save Local2 object type value into Local3 */
|
|
|
|
Local3 = ObjectType (Local2)
|
|
/* validate Local2 is a Number */
|
|
|
|
If ((Local3 != 0x01)) /* Number type is 1 */
|
|
{
|
|
/* failure */
|
|
|
|
Return (0x04)
|
|
}
|
|
|
|
/* zero indicates pass, non-zero is an error code */
|
|
|
|
If ((Local2 != 0x00))
|
|
{
|
|
/* return B2IB error code */
|
|
|
|
Return (Local2)
|
|
}
|
|
|
|
/* call FB2P (store from Field Buffer into Index'ed Package) */
|
|
|
|
Local2 = FB2P () /* Local2 is FB2P return value */
|
|
/* save Local2 object type value into Local3 */
|
|
|
|
Local3 = ObjectType (Local2)
|
|
/* validate Local2 is a Number */
|
|
|
|
If ((Local3 != 0x01)) /* Number type is 1 */
|
|
{
|
|
/* failure */
|
|
|
|
Return (0x05)
|
|
}
|
|
|
|
/* zero indicates pass, non-zero is an error code */
|
|
|
|
If ((Local2 != 0x00))
|
|
{
|
|
/* return FB2P error code */
|
|
|
|
Return (Local2)
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* IDX2: Test device name */
|
|
} /* _SB system bus */
|
|
|
|
/* */
|
|
/* test SizeOf.asl */
|
|
/* */
|
|
/* Test for SizeOf */
|
|
/* test cases include following SizeOf arguments: */
|
|
/* buffer, buffer field; */
|
|
/* control method argument, control method local variable; */
|
|
/* control method return values; */
|
|
/* direct string, string; */
|
|
/* package; */
|
|
/* buffer, package, and string package elements */
|
|
/* */
|
|
/* MTL NOTE: This test has been modified to remove any SizeOf(Index(Buff,... */
|
|
/* calls because it is not legal to perform a SizeOf operation on a Buffer Field. */
|
|
/* This test has also been extended to test additional Package element sizes. */
|
|
/* */
|
|
Device (SIZO)
|
|
{
|
|
/* SAR0 control method validates SizeOf(Arg) */
|
|
/* SAR0 should only be called by SARG */
|
|
Method (SAR0, 2, NotSerialized)
|
|
{
|
|
/* SAR0: SizeOf(Arg) test control method */
|
|
/* Local0 Arg0 length */
|
|
/* Local1 Local0 object type */
|
|
/* Store first string size (Arg0) into Local7 */
|
|
Local0 = SizeOf (Arg0)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x21)
|
|
}
|
|
|
|
/* If strings are not of equal size, return error code */
|
|
|
|
If ((Local0 != Arg1))
|
|
{
|
|
Return (0x22)
|
|
}
|
|
|
|
Return (0x00)
|
|
} /* SAR0: SizeOf(Arg) test control method */
|
|
|
|
Method (SARG, 0, Serialized)
|
|
{
|
|
/* SARG: SizeOf(Arg) test control method */
|
|
|
|
Name (BUFR, Buffer (0x0C){}) /* uninitialized Buffer */
|
|
Name (BUF1, Buffer (0x05)
|
|
{
|
|
0x01, 0x02, 0x03, 0x04, 0x05 // .....
|
|
})
|
|
Name (PKG0, Package (0x04){}) /* uninitialized Package */
|
|
Name (STR0, "String")
|
|
Name (PKG1, Package (0x04)
|
|
{
|
|
BUFR,
|
|
"String2",
|
|
STR0,
|
|
PKG0
|
|
}) /* PKG1 */
|
|
Name (PKG2, Package (0x04)
|
|
{
|
|
Buffer (0x0F){},
|
|
"String 1",
|
|
Package (0x02){}
|
|
}) /* PKG2 */
|
|
/* Namespace entry buffer reference */
|
|
|
|
Local0 = SAR0 (BUFR, 0x0C)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x23)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=BUFR) PASS"
|
|
/* Namespace entry package reference */
|
|
|
|
Local0 = SAR0 (PKG0, 0x04)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x24)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=PKG0) PASS"
|
|
/* Namespace entry string reference */
|
|
|
|
Local0 = SAR0 (STR0, 0x06)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x25)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=STR0) PASS"
|
|
/* direct string reference */
|
|
|
|
Local0 = SAR0 ("String", 0x06)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x26)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=String) PASS"
|
|
BUF1 [0x02] = 0x55
|
|
/****************************************************
|
|
//
|
|
// This section is commented because it is illegal to
|
|
// perform a SizeOf operation on a Buffer Field
|
|
//
|
|
// Namespace BufferField reference
|
|
Store (SAR0 (Index (BUFR, 2, ), 10), Local0)
|
|
// save Local0 object type value into Local1
|
|
Store (ObjectType (Local0), Local1)
|
|
// validate Local0 is a Number
|
|
If (LNotEqual (Local1, 1)) // Number type is 1
|
|
{ Return (0x27) }
|
|
If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
|
|
{ Return (Local0) }
|
|
Store ("SizeOf(Arg=BufferField) PASS", Debug)
|
|
****************************************************/
|
|
/* Namespace BufferPackageElement reference */
|
|
/* */
|
|
Local0 = SAR0 (PKG1 [0x00], 0x0C)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x28)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=PackageBuffer NTE Reference Element) PASS"
|
|
/* Namespace StringPackageElement reference */
|
|
|
|
Local0 = SAR0 (PKG1 [0x01], 0x07)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x29)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=Package String Element) PASS"
|
|
/* Namespace StringPackageElement reference */
|
|
|
|
Local0 = SAR0 (PKG1 [0x02], 0x06)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x2A)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=Package String NTE Reference Element) PASS"
|
|
/* Namespace PackagePackageElement reference */
|
|
|
|
Local0 = SAR0 (PKG1 [0x03], 0x04)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x2B)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=Package Package NTE Reference Element) PASS"
|
|
/* Package Buffer Element */
|
|
|
|
Local0 = SAR0 (PKG2 [0x00], 0x0F)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x2B)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=Package Buffer Element) PASS"
|
|
/* Package String Element */
|
|
|
|
Local0 = SAR0 (PKG2 [0x01], 0x08)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x2B)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=Package String Element) PASS"
|
|
/* Package Package Element */
|
|
|
|
Local0 = SAR0 (PKG2 [0x02], 0x02)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x2B)
|
|
}
|
|
|
|
If ((Local0 != 0x00)) /* Local0 is SAR0 return error code */
|
|
{
|
|
Return (Local0)
|
|
}
|
|
|
|
Debug = "SizeOf(Arg=Package Package Element) PASS"
|
|
Debug = "SizeOf(Arg) PASS"
|
|
Return (0x00)
|
|
} /* SARG: SizeOf(Arg) test control method */
|
|
|
|
Method (SBUF, 0, Serialized)
|
|
{
|
|
/* SBUF: SizeOf(Buffer) test control method */
|
|
|
|
Name (BUFR, Buffer (0x0C){})
|
|
/* store size of BUFR buffer into Local0 */
|
|
|
|
Local0 = SizeOf (BUFR)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x31)
|
|
}
|
|
|
|
If ((Local0 != 0x0C)) /* BUFR size is 12 */
|
|
{
|
|
Return (0x32)
|
|
}
|
|
|
|
Debug = "SizeOf(BUFR) PASS"
|
|
Return (0x00)
|
|
} /* SBUF: SizeOf(Buffer) test control method */
|
|
|
|
/****************************************************
|
|
//
|
|
// This section is commented because it is illegal to
|
|
// perform a SizeOf operation on a Buffer Field
|
|
//
|
|
Method (SIND)
|
|
{ // SIND: SizeOf(Index(,,)) test control method
|
|
Name (BUFR, Buffer (12) {})
|
|
// store size of Index(BUFR,2,) buffer into Local0
|
|
Store (SizeOf (Index (BUFR, 2, )), Local0)
|
|
// save Local0 object type value into Local1
|
|
Store (ObjectType (Local0), Local1)
|
|
// validate Local0 is a Number
|
|
If (LNotEqual (Local1, 1)) // Number type is 1
|
|
{
|
|
Return (0x41)
|
|
}
|
|
If (LNotEqual (Local0, 10)) // 12 - 2 = 10
|
|
{
|
|
Return (0x42)
|
|
}
|
|
Store ("SizeOf(Index(BUFR,,)) PASS", Debug)
|
|
// TBD: strings and packages
|
|
Return (0)
|
|
} // SIND: SizeOf(Index(,,)) test control method
|
|
****************************************************/
|
|
Method (SLOC, 0, Serialized)
|
|
{
|
|
/* SLOC: SizeOf(Local) test control method */
|
|
|
|
Name (BUFR, Buffer (0x0C){}) /* uninitialized Buffer */
|
|
Name (STR0, "String")
|
|
Name (PKG0, Package (0x04){}) /* uninitialized Package */
|
|
/* store BUFR Buffer into Local2 */
|
|
|
|
Local2 = BUFR /* \SIZO.SLOC.BUFR */
|
|
/* store size of BUFR buffer into Local0 */
|
|
|
|
Local0 = SizeOf (Local2)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x51)
|
|
}
|
|
|
|
If ((Local0 != 0x0C)) /* BUFR size is 12 */
|
|
{
|
|
Return (0x52)
|
|
}
|
|
|
|
Debug = "SizeOf(Local2=Buffer) PASS"
|
|
/* store STR0 string into Local2 */
|
|
|
|
Local2 = STR0 /* \SIZO.SLOC.STR0 */
|
|
/* store size of STR0 buffer into Local0 */
|
|
|
|
Local0 = SizeOf (Local2)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x53)
|
|
}
|
|
|
|
If ((Local0 != 0x06)) /* STR0 size is 6 */
|
|
{
|
|
Return (0x54)
|
|
}
|
|
|
|
Debug = "SizeOf(Local2=String) PASS"
|
|
/* store PKG0 Package into Local2 */
|
|
|
|
Local2 = PKG0 /* \SIZO.SLOC.PKG0 */
|
|
/* store size of PKG0 buffer into Local0 */
|
|
|
|
Local0 = SizeOf (Local2)
|
|
/* save Local0 object type value into Local1 */
|
|
|
|
Local1 = ObjectType (Local0)
|
|
/* validate Local0 is a Number */
|
|
|
|
If ((Local1 != 0x01)) /* Number type is 1 */
|
|
{
|
|
Return (0x55)
|
|
}
|
|
|
|
If ((Local0 != 0x04)) /* PKG0 size is 4 */
|
|
{
|
|
Return (0x56)
|
|
}
|
|
|
|
Debug = "SizeOf(Local2=Package) PASS"
|
|
Return (0x00)
|
|
} /* SLOC: SizeOf(Local) test control method */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ SizeOf Test"
|
|
/* Store current operating system string into Local0 */
|
|
|
|
Local0 = _OS /* \_OS_ */
|
|
Local3 = SizeOf (_OS)
|
|
/* save Local3 object type value into Local4 */
|
|
|
|
Local4 = ObjectType (Local3)
|
|
/* validate Local3 is a Number */
|
|
|
|
If ((Local4 != 0x01)) /* Number type is 1 */
|
|
{
|
|
/* failure */
|
|
|
|
Return (0x61)
|
|
}
|
|
|
|
/* Store current operating system string into Local0 */
|
|
/* This verifies above SizeOf(_OS) did not corrupt ACPI namespace */
|
|
Local0 = _OS /* \_OS_ */
|
|
/* Store SARG [Validate SizeOf(Arg)] return value into Local1 */
|
|
|
|
Local1 = SARG ()
|
|
/* save Local1 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local1)
|
|
/* validate Local1 is a Number */
|
|
|
|
If ((Local2 != 0x01)) /* Number type is 1 */
|
|
{
|
|
/* failure */
|
|
|
|
Return (0x62)
|
|
}
|
|
|
|
/* zero indicates pass, non-zero is an error code */
|
|
|
|
If ((Local1 != 0x00))
|
|
{
|
|
/* return SARG error code */
|
|
|
|
Return (Local1)
|
|
}
|
|
|
|
/* Store SBUF [Validate SizeOf(Buffer)] return value into Local1 */
|
|
|
|
Local1 = SBUF ()
|
|
/* save Local1 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local1)
|
|
/* validate Local1 is a Number */
|
|
|
|
If ((Local2 != 0x01)) /* Number type is 1 */
|
|
{
|
|
/* failure */
|
|
|
|
Return (0x63)
|
|
}
|
|
|
|
/* zero indicates pass, non-zero is an error code */
|
|
|
|
If ((Local1 != 0x00))
|
|
{
|
|
/* return SBUF error code */
|
|
|
|
Return (Local1)
|
|
}
|
|
|
|
/****************************************************
|
|
//
|
|
// This section is commented because it is illegal to
|
|
// perform a SizeOf operation on a Buffer Field
|
|
//
|
|
// Store SIND [verify SizeOf(Index(,,))] return value into Local1
|
|
Store (SIND, Local1)
|
|
// save Local1 object type value into Local2
|
|
Store (ObjectType (Local1), Local2)
|
|
// validate Local1 is a Number
|
|
If (LNotEqual (Local2, 1)) // Number type is 1
|
|
{
|
|
// failure
|
|
Return (0x64)
|
|
}
|
|
// zero indicates pass, non-zero is an error code
|
|
If (LNotEqual (Local1, 0))
|
|
{
|
|
// return SARG error code
|
|
Return (Local1)
|
|
}
|
|
****************************************************/
|
|
/* Store SLOC [verify SizeOf(Local)] return value into Local1 */
|
|
Local1 = SLOC ()
|
|
/* save Local1 object type value into Local2 */
|
|
|
|
Local2 = ObjectType (Local1)
|
|
/* validate Local1 is a Number */
|
|
|
|
If ((Local2 != 0x01)) /* Number type is 1 */
|
|
{
|
|
/* failure */
|
|
|
|
Return (0x65)
|
|
}
|
|
|
|
/* zero indicates pass, non-zero is an error code */
|
|
|
|
If ((Local1 != 0x00))
|
|
{
|
|
/* return SLOC error code */
|
|
|
|
Return (Local1)
|
|
}
|
|
|
|
/* TBD: SizeOf (METH) -- where METH control method returns */
|
|
/* buffer, BufferField, string, package, package element */
|
|
Return (0x00)
|
|
} /* TEST */
|
|
} /* SIZO */
|
|
|
|
/* */
|
|
/* test SmiShare.asl */
|
|
/* */
|
|
Scope (\_SB) /* System Bus */
|
|
{
|
|
/* _SB system bus */
|
|
/* Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long */
|
|
OperationRegion (RAM1, SystemMemory, 0x00400000, 0x0A)
|
|
Field (RAM1, AnyAcc, NoLock, Preserve)
|
|
{
|
|
BI1T, /* Create some bits in memory to access */ 1,
|
|
BI2T, 2,
|
|
BI3T, 3,
|
|
LST2, 2
|
|
} /* End Field RAM1 */
|
|
|
|
Field (RAM1, WordAcc, NoLock, WriteAsZeros)
|
|
{
|
|
WRD, 16
|
|
} /* End 2nd Field RAM1 */
|
|
|
|
Field (RAM1, ByteAcc, NoLock, WriteAsOnes)
|
|
{
|
|
BYTE, 8
|
|
} /* End 3rd Field RAM1 */
|
|
|
|
Field (RAM1, ByteAcc, NoLock, Preserve)
|
|
{
|
|
SMIC, 8,
|
|
SMID, 8
|
|
}
|
|
|
|
Device (MBIT)
|
|
{
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize
|
|
{
|
|
BI1T = 0x00
|
|
BI2T = 0x03
|
|
BI3T = 0x07
|
|
LST2 = 0x00
|
|
} /* End _INI Method */
|
|
} /* End Device MBIT */
|
|
|
|
Device (MWRD)
|
|
{
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize
|
|
{
|
|
WRD = 0x00
|
|
} /* End _INI Method */
|
|
} /* End Device MWRD */
|
|
|
|
Device (MBYT)
|
|
{
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize
|
|
{
|
|
BYTE = 0x00
|
|
SMIC = 0x0C
|
|
SMID = 0x0D
|
|
} /* End _INI Method */
|
|
} /* End Device MBYT */
|
|
|
|
/*
|
|
// Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
|
|
OperationRegion(\RAM1, SystemMemory, 0x400000, 0xA)
|
|
Field (\RAM1, AnyAcc, NoLock, Preserve)
|
|
{
|
|
BI1T, 1, // Create some bits in memory to access
|
|
BI2T, 2,
|
|
BI3T, 3,
|
|
LST2, 2
|
|
} // End Field RAM1
|
|
Field (\RAM1, WordAcc, NoLock, WriteAsZeros)
|
|
{
|
|
WRD, 16
|
|
} // End 2nd Field RAM1
|
|
Field (\RAM1, ByteAcc, NoLock, WriteAsOnes)
|
|
{
|
|
BYTE, 8
|
|
} // End 3rd Field RAM1
|
|
Field (\RAM1, ByteAcc, NoLock, Preserve)
|
|
{
|
|
SMIC, 8,
|
|
SMID, 8
|
|
}
|
|
*/
|
|
Method (SMIX, 0, NotSerialized)
|
|
{
|
|
Return (BYTE) /* \_SB_.BYTE */
|
|
} /* End SMIX */
|
|
|
|
Method (EVNT, 0, NotSerialized)
|
|
{
|
|
Local0 = SMIX ()
|
|
Notify (\_SB, 0x29) // Reserved
|
|
If ((Local0 & 0x01))
|
|
{
|
|
Notify (\_SB.SMIS, 0x21) // Reserved
|
|
}
|
|
|
|
If ((Local0 & 0x02))
|
|
{
|
|
Notify (\_SB.SMIS, 0x22) // Reserved
|
|
}
|
|
|
|
If ((Local0 & 0x04))
|
|
{
|
|
Notify (\_SB.SMIS, 0x24) // Reserved
|
|
}
|
|
|
|
If ((Local0 & 0x08))
|
|
{
|
|
Notify (\_SB.SMIS, 0x28) // Reserved
|
|
}
|
|
} /* End Method EVNT */
|
|
|
|
Method (NTFY, 0, NotSerialized)
|
|
{
|
|
Notify (\_SB, 0x01) // Device Check
|
|
Notify (\_TZ.TZ1, 0x02) // Device Wake
|
|
Notify (\_PR.CPU0, 0x03) // Eject Request
|
|
Notify (\_SB, 0x81) // Information Change
|
|
Notify (\_TZ.TZ1, 0x82) // Thermal Device List Change
|
|
Notify (\_PR.CPU0, 0x83) // Guaranteed Change
|
|
}
|
|
|
|
Device (SMIS)
|
|
{
|
|
Method (BINK, 0, NotSerialized)
|
|
{
|
|
Local0 = 0x00 /* Zero out Local0 */
|
|
If ((SMID != 0x0D))
|
|
{
|
|
Local0 |= 0x80
|
|
}
|
|
|
|
If ((SMIC != 0x0C))
|
|
{
|
|
Local0 |= 0x40
|
|
}
|
|
|
|
If ((BYTE != 0x00))
|
|
{
|
|
Local0 |= 0x20
|
|
}
|
|
|
|
If ((WRD != 0x00))
|
|
{
|
|
Local0 |= 0x10
|
|
}
|
|
|
|
If ((LST2 != 0x00))
|
|
{
|
|
Local0 |= 0x08
|
|
}
|
|
|
|
If ((BI3T != 0x07))
|
|
{
|
|
Local0 |= 0x04
|
|
}
|
|
|
|
If ((BI2T != 0x03))
|
|
{
|
|
Local0 |= 0x02
|
|
}
|
|
|
|
If ((BI1T != 0x00))
|
|
{
|
|
Local0 |= 0x01
|
|
}
|
|
|
|
Return (Local0)
|
|
} /* End Method BINK */
|
|
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
Debug = "++++++++ SmiShare Test"
|
|
/* Expect EVNT to generate Notify value we just previously */
|
|
/* stored in BYTE */
|
|
BYTE = 0x20
|
|
EVNT ()
|
|
BYTE = 0x21
|
|
EVNT ()
|
|
BYTE = 0x22
|
|
EVNT ()
|
|
BYTE = 0x23
|
|
EVNT ()
|
|
NTFY ()
|
|
Return (0x00) /* pass */
|
|
} /* End Method TEST */
|
|
} /* Device SMIS */
|
|
|
|
Device (CNDT)
|
|
{
|
|
Method (TEST, 0, NotSerialized)
|
|
{
|
|
If (ECOK ())
|
|
{
|
|
Return ("Broken")
|
|
}
|
|
Else
|
|
{
|
|
Return ("Works")
|
|
}
|
|
}
|
|
|
|
Method (ECOK, 0, NotSerialized)
|
|
{
|
|
Return (0x00)
|
|
}
|
|
}
|
|
} /* _SB system bus */
|
|
|
|
/* Test a very big buffer */
|
|
|
|
Name (WQAB, Buffer (0x1A64)
|
|
{
|
|
/* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, // FOMB....
|
|
/* 0008 */ 0x54, 0x1A, 0x00, 0x00, 0xBA, 0xAD, 0x00, 0x00, // T.......
|
|
/* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, // DS...}.T
|
|
/* 0018 */ 0x98, 0xBD, 0x92, 0x00, 0x01, 0x06, 0x18, 0x42, // .......B
|
|
/* 0020 */ 0x10, 0x47, 0x10, 0x92, 0x46, 0x62, 0x02, 0x89, // .G..Fb..
|
|
/* 0028 */ 0x80, 0x90, 0x18, 0x18, 0x14, 0x81, 0x85, 0x00, // ........
|
|
/* 0030 */ 0x49, 0x02, 0x88, 0xC4, 0x41, 0xE1, 0x20, 0xD4, // I...A. .
|
|
/* 0038 */ 0x9F, 0x40, 0x7E, 0x05, 0x20, 0x74, 0x28, 0x40, // .@~. t(@
|
|
/* 0040 */ 0xA6, 0x00, 0x83, 0x02, 0x9C, 0x22, 0x88, 0xA0, // ....."..
|
|
/* 0048 */ 0x57, 0x01, 0x36, 0x05, 0x98, 0x14, 0x60, 0x51, // W.6...`Q
|
|
/* 0050 */ 0x80, 0x76, 0x01, 0x96, 0x05, 0xE8, 0x16, 0x20, // .v.....
|
|
/* 0058 */ 0x1D, 0x96, 0x88, 0x04, 0x47, 0x89, 0x01, 0x47, // ....G..G
|
|
/* 0060 */ 0xE9, 0xC4, 0x16, 0x6E, 0xD8, 0xE0, 0x85, 0xA2, // ...n....
|
|
/* 0068 */ 0x68, 0x06, 0x51, 0x12, 0x94, 0x8B, 0x20, 0x5D, // h.Q... ]
|
|
/* 0070 */ 0x10, 0x52, 0x2E, 0xC0, 0x37, 0x82, 0x06, 0x10, // .R..7...
|
|
/* 0078 */ 0xA5, 0x77, 0x01, 0xB6, 0x05, 0x98, 0x86, 0x27, // .w.....'
|
|
/* 0080 */ 0xD2, 0x20, 0xE4, 0x60, 0x08, 0x54, 0xCE, 0x80, // . .`.T..
|
|
/* 0088 */ 0x20, 0x69, 0x44, 0x21, 0x1E, 0xA7, 0x44, 0x08, // iD!..D.
|
|
/* 0090 */ 0x0A, 0x84, 0x90, 0xD4, 0xF1, 0xA0, 0xA0, 0x71, // .......q
|
|
/* 0098 */ 0x88, 0xAD, 0xCE, 0x46, 0x93, 0xA9, 0x74, 0x7E, // ...F..t~
|
|
/* 00A0 */ 0x48, 0x82, 0x70, 0xC6, 0x2A, 0x7E, 0x3A, 0x9A, // H.p.*~:.
|
|
/* 00A8 */ 0xD0, 0xD9, 0x9C, 0x60, 0xE7, 0x18, 0x72, 0x3C, // ...`..r<
|
|
/* 00B0 */ 0x48, 0xF4, 0x20, 0xB8, 0x00, 0x0F, 0x1C, 0x2C, // H. ....,
|
|
/* 00B8 */ 0x34, 0x84, 0x22, 0x6B, 0x80, 0xC1, 0x8C, 0xDD, // 4."k....
|
|
/* 00C0 */ 0x63, 0xB1, 0x0B, 0x4E, 0x0A, 0xEC, 0x61, 0xB3, // c..N..a.
|
|
/* 00C8 */ 0x01, 0x19, 0xA2, 0x24, 0x38, 0xD4, 0x11, 0xC0, // ...$8...
|
|
/* 00D0 */ 0x12, 0x05, 0x98, 0x1F, 0x87, 0x0C, 0x0F, 0x95, // ........
|
|
/* 00D8 */ 0x8C, 0x25, 0x24, 0x1B, 0xAB, 0x87, 0xC2, 0xA5, // .%$.....
|
|
/* 00E0 */ 0x40, 0x68, 0x6C, 0x27, 0xED, 0x19, 0x45, 0x2C, // @hl'..E,
|
|
/* 00E8 */ 0x79, 0x4A, 0x82, 0x49, 0xE0, 0x51, 0x44, 0x36, // yJ.I.QD6
|
|
/* 00F0 */ 0x1A, 0x27, 0x28, 0x1B, 0x1A, 0x25, 0x03, 0x42, // .'(..%.B
|
|
/* 00F8 */ 0x9E, 0x05, 0x58, 0x07, 0x26, 0x04, 0x76, 0x2F, // ..X.&.v/
|
|
/* 0100 */ 0xC0, 0x9A, 0x00, 0x73, 0xB3, 0x90, 0xB1, 0xB9, // ...s....
|
|
/* 0108 */ 0xE8, 0xFF, 0x0F, 0x71, 0xB0, 0x31, 0xDA, 0x9A, // ...q.1..
|
|
/* 0110 */ 0xAE, 0x90, 0xC2, 0xC4, 0x88, 0x12, 0x2C, 0x5E, // ......,^
|
|
/* 0118 */ 0xC5, 0xC3, 0x10, 0xCA, 0x93, 0x42, 0xA8, 0x48, // .....B.H
|
|
/* 0120 */ 0x95, 0xA1, 0x68, 0xB4, 0x51, 0x2A, 0x14, 0xE0, // ..h.Q*..
|
|
/* 0128 */ 0x4C, 0x80, 0x30, 0x5C, 0x1D, 0x03, 0x82, 0x46, // L.0\...F
|
|
/* 0130 */ 0x88, 0x15, 0x29, 0x56, 0xFB, 0x83, 0x20, 0xF1, // ..)V.. .
|
|
/* 0138 */ 0x2D, 0x40, 0x54, 0x01, 0xA2, 0x48, 0xA3, 0x41, // -@T..H.A
|
|
/* 0140 */ 0x9D, 0x03, 0x3C, 0x5C, 0x0F, 0xF5, 0xF0, 0x3D, // ..<\...=
|
|
/* 0148 */ 0xF6, 0x93, 0x0C, 0x72, 0x90, 0x67, 0xF1, 0xA8, // ...r.g..
|
|
/* 0150 */ 0x70, 0x9C, 0x06, 0x49, 0xE0, 0x0B, 0x80, 0x4F, // p..I...O
|
|
/* 0158 */ 0x08, 0x1E, 0x38, 0xDE, 0x35, 0xA0, 0x66, 0x7C, // ..8.5.f|
|
|
/* 0160 */ 0xBC, 0x4C, 0x10, 0x1C, 0x6A, 0x88, 0x1E, 0x68, // .L..j..h
|
|
/* 0168 */ 0xB8, 0x13, 0x38, 0x44, 0x06, 0xE8, 0x49, 0x3D, // ..8D..I=
|
|
/* 0170 */ 0x52, 0x60, 0x07, 0x77, 0x32, 0xEF, 0x01, 0xAF, // R`.w2...
|
|
/* 0178 */ 0x0A, 0xCD, 0x5E, 0x12, 0x08, 0xC1, 0xF1, 0xF8, // ..^.....
|
|
/* 0180 */ 0x7E, 0xC0, 0x26, 0x9C, 0xC0, 0xF2, 0x07, 0x81, // ~.&.....
|
|
/* 0188 */ 0x1A, 0x99, 0xA1, 0x3D, 0xCA, 0xD3, 0x8A, 0x19, // ...=....
|
|
/* 0190 */ 0xF2, 0x31, 0xC1, 0x04, 0x16, 0x0B, 0x21, 0x05, // .1....!.
|
|
/* 0198 */ 0x10, 0x1A, 0x0F, 0xF8, 0x6F, 0x00, 0x8F, 0x17, // ....o...
|
|
/* 01A0 */ 0xBE, 0x12, 0xC4, 0xF6, 0x80, 0x12, 0x0C, 0x0B, // ........
|
|
/* 01A8 */ 0x21, 0x23, 0xAB, 0xF0, 0x78, 0xE8, 0x28, 0x7C, // !#..x.(|
|
|
/* 01B0 */ 0x95, 0x38, 0x9C, 0xD3, 0x8A, 0x67, 0x82, 0xE1, // .8...g..
|
|
/* 01B8 */ 0x20, 0xF4, 0x05, 0x90, 0x00, 0x51, 0xE7, 0x0C, // ....Q..
|
|
/* 01C0 */ 0xD4, 0x61, 0xC1, 0xE7, 0x04, 0x76, 0x33, 0x38, // .a...v38
|
|
/* 01C8 */ 0x83, 0x47, 0x00, 0x8F, 0xE4, 0x84, 0xFC, 0x2B, // .G.....+
|
|
/* 01D0 */ 0xF1, 0xC0, 0xE0, 0x03, 0xE2, 0xEF, 0x1F, 0xA7, // ........
|
|
/* 01D8 */ 0xEC, 0x11, 0x9C, 0xA9, 0x01, 0x7D, 0x1C, 0xF0, // .....}..
|
|
/* 01E0 */ 0xFF, 0x7F, 0x28, 0x7C, 0x88, 0x1E, 0xDF, 0x29, // ..(|...)
|
|
/* 01E8 */ 0x1F, 0xAF, 0x4F, 0x17, 0x96, 0x35, 0x4E, 0xE8, // ..O..5N.
|
|
/* 01F0 */ 0x77, 0x08, 0x9F, 0x38, 0x7C, 0x64, 0x71, 0x44, // w..8|dqD
|
|
/* 01F8 */ 0x08, 0x39, 0x39, 0x05, 0xA0, 0x81, 0x4F, 0xF7, // .99...O.
|
|
/* 0200 */ 0xEC, 0x22, 0x9C, 0xAE, 0x27, 0xE5, 0x40, 0xC3, // ."..'.@.
|
|
/* 0208 */ 0xA0, 0xE3, 0x04, 0xC7, 0x79, 0x00, 0x1C, 0xE3, // ....y...
|
|
/* 0210 */ 0x84, 0x7F, 0x2E, 0x80, 0x3F, 0x40, 0x7E, 0xCA, // ....?@~.
|
|
/* 0218 */ 0x78, 0xC5, 0x48, 0xE0, 0x98, 0x23, 0x44, 0x9F, // x.H..#D.
|
|
/* 0220 */ 0x6B, 0x3C, 0x42, 0x2C, 0xFC, 0x53, 0x45, 0xE1, // k<B,.SE.
|
|
/* 0228 */ 0x03, 0x21, 0x63, 0x04, 0x17, 0xA0, 0xC7, 0x08, // .!c.....
|
|
/* 0230 */ 0x7C, 0x03, 0x8E, 0x11, 0x7D, 0x94, 0xE0, 0xEA, // |...}...
|
|
/* 0238 */ 0x0F, 0x1A, 0x74, 0x80, 0xB8, 0xFF, 0xFF, 0x00, // ..t.....
|
|
/* 0240 */ 0xE1, 0x83, 0x7A, 0x80, 0xC0, 0x37, 0xFA, 0xD1, // ..z..7..
|
|
/* 0248 */ 0x03, 0x3D, 0x2E, 0x8B, 0x3E, 0x0F, 0xC8, 0xF8, // .=..>...
|
|
/* 0250 */ 0x89, 0x46, 0xF3, 0xE2, 0xA7, 0x03, 0x7E, 0xF8, // .F....~.
|
|
/* 0258 */ 0x00, 0x0F, 0xA8, 0x87, 0x84, 0x03, 0xC5, 0x4C, // .......L
|
|
/* 0260 */ 0x9B, 0x83, 0x3E, 0xBB, 0x1C, 0x3A, 0x76, 0xB8, // ..>..:v.
|
|
/* 0268 */ 0xE0, 0x3F, 0x81, 0x80, 0x4B, 0xDE, 0x21, 0x0C, // .?..K.!.
|
|
/* 0270 */ 0x14, 0x23, 0xC6, 0x9F, 0x83, 0x7C, 0x0A, 0x03, // .#...|..
|
|
/* 0278 */ 0xFF, 0xFF, 0xFF, 0x14, 0x06, 0xFE, 0xE1, 0xF0, // ........
|
|
/* 0280 */ 0x20, 0x4F, 0x07, 0x9F, 0xB6, 0xA8, 0x74, 0x18, // O....t.
|
|
/* 0288 */ 0xD4, 0x81, 0x0B, 0xB0, 0x32, 0x89, 0x08, 0xCF, // ....2...
|
|
/* 0290 */ 0x12, 0xB5, 0x41, 0xE8, 0xD4, 0xF0, 0x36, 0xF1, // ..A...6.
|
|
/* 0298 */ 0xB6, 0xE5, 0x5B, 0x40, 0x9C, 0xD3, 0xEC, 0xED, // ..[@....
|
|
/* 02A0 */ 0xC0, 0x45, 0x30, 0x22, 0xD4, 0x0C, 0x45, 0x4E, // .E0"..EN
|
|
/* 02A8 */ 0x5A, 0x11, 0x63, 0x44, 0x79, 0xDC, 0x32, 0xCA, // Z.cDy.2.
|
|
/* 02B0 */ 0xDB, 0xD6, 0x0B, 0x40, 0xBC, 0x13, 0x7B, 0xDE, // ...@..{.
|
|
/* 02B8 */ 0x32, 0x46, 0xF0, 0xC8, 0x0F, 0x5C, 0x2C, 0xC6, // 2F...\,.
|
|
/* 02C0 */ 0xEA, 0xF5, 0x5F, 0xF3, 0x81, 0x0B, 0x70, 0xF6, // .._...p.
|
|
/* 02C8 */ 0xFF, 0x3F, 0x70, 0x01, 0x1C, 0x0A, 0x7A, 0x18, // .?p...z.
|
|
/* 02D0 */ 0x42, 0x0F, 0xC3, 0x53, 0x39, 0x97, 0x87, 0xC8, // B..S9...
|
|
/* 02D8 */ 0x53, 0x89, 0x18, 0x35, 0x4C, 0xD4, 0x67, 0x28, // S..5L.g(
|
|
/* 02E0 */ 0xDF, 0x2D, 0x7C, 0x20, 0x02, 0xDF, 0x99, 0x0B, // .-| ....
|
|
/* 02E8 */ 0xF8, 0xFD, 0xFF, 0x0F, 0x44, 0x70, 0x8E, 0x29, // ....Dp.)
|
|
/* 02F0 */ 0xB8, 0x33, 0x0D, 0x78, 0x7C, 0xCE, 0x40, 0x20, // .3.x|.@
|
|
/* 02F8 */ 0xA7, 0xE2, 0x43, 0x0D, 0x60, 0x41, 0xF4, 0x13, // ..C.`A..
|
|
/* 0300 */ 0xC2, 0x27, 0x1A, 0x2A, 0x13, 0x06, 0x75, 0xA8, // .'.*..u.
|
|
/* 0308 */ 0x01, 0xAC, 0x5C, 0x61, 0x9E, 0x46, 0xCF, 0xF9, // ..\a.F..
|
|
/* 0310 */ 0x59, 0xC6, 0xA7, 0x1A, 0x1F, 0x4A, 0x8D, 0x63, // Y....J.c
|
|
/* 0318 */ 0x88, 0x97, 0x99, 0x87, 0x1A, 0x1F, 0x0B, 0x5E, // .......^
|
|
/* 0320 */ 0x49, 0x7D, 0xA8, 0x31, 0x54, 0x9C, 0x87, 0x1A, // I}.1T...
|
|
/* 0328 */ 0x0F, 0x37, 0x50, 0xD4, 0x37, 0x9B, 0x67, 0x1B, // .7P.7.g.
|
|
/* 0330 */ 0xA3, 0xC7, 0xF7, 0x0D, 0xD5, 0x10, 0x0F, 0x35, // .......5
|
|
/* 0338 */ 0x4C, 0xF2, 0x4A, 0x35, 0x16, 0x1F, 0x6A, 0xC0, // L.J5..j.
|
|
/* 0340 */ 0xF1, 0xFF, 0x3F, 0xD4, 0x00, 0xFC, 0xFF, 0xFF, // ..?.....
|
|
/* 0348 */ 0x1F, 0x6A, 0x00, 0x47, 0x47, 0x03, 0x38, 0x47, // .j.GG.8G
|
|
/* 0350 */ 0x46, 0xDC, 0xD1, 0x00, 0x5C, 0x87, 0x52, 0xE0, // F...\.R.
|
|
/* 0358 */ 0x70, 0x34, 0x00, 0x1E, 0x47, 0x21, 0x30, 0x5F, // p4..G!0_
|
|
/* 0360 */ 0x68, 0x7C, 0x14, 0x02, 0x16, 0xFF, 0xFF, 0xA3, // h|......
|
|
/* 0368 */ 0x10, 0xF8, 0x65, 0x9F, 0x83, 0x50, 0x42, 0x8F, // ..e..PB.
|
|
/* 0370 */ 0x42, 0x80, 0xA0, 0xDB, 0xCF, 0x53, 0xC4, 0xB3, // B....S..
|
|
/* 0378 */ 0x8F, 0x2F, 0x3F, 0x0F, 0x04, 0x11, 0x5E, 0xF3, // ./?...^.
|
|
/* 0380 */ 0x7D, 0x0A, 0xF2, 0x21, 0xDF, 0x47, 0x21, 0x06, // }..!.G!.
|
|
/* 0388 */ 0x63, 0x28, 0x5F, 0x83, 0x7C, 0x14, 0x62, 0x50, // c(_.|.bP
|
|
/* 0390 */ 0xAF, 0x41, 0xBE, 0xEF, 0x1B, 0xE4, 0xF1, 0x22, // .A....."
|
|
/* 0398 */ 0x48, 0xEC, 0x67, 0x02, 0x1F, 0x85, 0x98, 0xE8, // H.g.....
|
|
/* 03A0 */ 0xA3, 0x10, 0xA0, 0xF0, 0xFF, 0x7F, 0x14, 0x02, // ........
|
|
/* 03A8 */ 0xF8, 0xFF, 0xFF, 0x3F, 0x0A, 0x01, 0xCE, 0x02, // ...?....
|
|
/* 03B0 */ 0x1C, 0x0D, 0x40, 0x37, 0xAD, 0x47, 0x21, 0xF0, // ..@7.G!.
|
|
/* 03B8 */ 0xDE, 0x59, 0x4E, 0xFB, 0x04, 0x7C, 0x16, 0x02, // .YN..|..
|
|
/* 03C0 */ 0xCC, 0xFE, 0xFF, 0xCF, 0x42, 0xC0, 0xEC, 0x28, // ....B..(
|
|
/* 03C8 */ 0x74, 0x14, 0x67, 0xF9, 0x2A, 0xF4, 0x04, 0xF0, // t.g.*...
|
|
/* 03D0 */ 0x02, 0x10, 0x23, 0xCC, 0x3B, 0xD0, 0x4B, 0x26, // ..#.;.K&
|
|
/* 03D8 */ 0xBB, 0x8B, 0x1B, 0xE7, 0xC9, 0xE5, 0x2C, 0x9E, // ......,.
|
|
/* 03E0 */ 0xC4, 0x7D, 0x09, 0xF2, 0x81, 0xE2, 0x59, 0xC8, // .}....Y.
|
|
/* 03E8 */ 0x50, 0xA7, 0x1B, 0xF4, 0x8D, 0xDC, 0x03, 0x8B, // P.......
|
|
/* 03F0 */ 0x19, 0x3F, 0xC4, 0xF3, 0x90, 0x21, 0x9E, 0x85, // .?...!..
|
|
/* 03F8 */ 0x00, 0x76, 0xFD, 0xFF, 0xCF, 0x42, 0x00, 0xFF, // .v...B..
|
|
/* 0400 */ 0xFF, 0xFF, 0x47, 0x03, 0xF8, 0x2F, 0x00, 0x9F, // ..G../..
|
|
/* 0408 */ 0x85, 0x80, 0xE7, 0x09, 0xE0, 0x41, 0xDB, 0x67, // .....A.g
|
|
/* 0410 */ 0x21, 0x80, 0x33, 0x87, 0xCB, 0xF3, 0x7F, 0x05, // !.3.....
|
|
/* 0418 */ 0x3A, 0x96, 0xF7, 0x08, 0xCF, 0xFA, 0x24, 0x5F, // :.....$_
|
|
/* 0420 */ 0x2F, 0x3D, 0xD3, 0x87, 0x82, 0x67, 0x21, 0x86, // /=...g!.
|
|
/* 0428 */ 0x75, 0x18, 0x3E, 0x0B, 0x31, 0x88, 0x17, 0x4D, // u.>.1..M
|
|
/* 0430 */ 0x43, 0xBC, 0x70, 0xFA, 0x30, 0xE0, 0xFF, 0x3F, // C.p.0..?
|
|
/* 0438 */ 0x5E, 0xE0, 0x57, 0x4E, 0x03, 0x05, 0x09, 0xF4, // ^.WN....
|
|
/* 0440 */ 0x2C, 0x04, 0x30, 0xFE, 0xFF, 0x7F, 0x16, 0x02, // ,.0.....
|
|
/* 0448 */ 0xC8, 0xB8, 0x46, 0x9D, 0x85, 0x80, 0xE5, 0x6D, // ..F....m
|
|
/* 0450 */ 0xE5, 0x19, 0xDB, 0xA7, 0x95, 0x04, 0xFF, 0xFF, // ........
|
|
/* 0458 */ 0x67, 0x21, 0xC0, 0x41, 0x2E, 0x23, 0x07, 0x21, // g!.A.#.!
|
|
/* 0460 */ 0x4C, 0xC4, 0x87, 0x83, 0x8F, 0x99, 0x80, 0x9E, // L.......
|
|
/* 0468 */ 0x29, 0xBE, 0xB8, 0x1B, 0xE3, 0x09, 0xE0, 0x45, // )......E
|
|
/* 0470 */ 0xE2, 0x31, 0x93, 0x1D, 0x35, 0x0D, 0xF3, 0x2C, // .1..5..,
|
|
/* 0478 */ 0x64, 0xBC, 0xB3, 0x78, 0x0D, 0x78, 0x82, 0xF7, // d..x.x..
|
|
/* 0480 */ 0xE4, 0x9F, 0x85, 0x18, 0xD8, 0x61, 0x05, 0x7B, // .....a.{
|
|
/* 0488 */ 0x14, 0x32, 0xA8, 0xC1, 0x63, 0x87, 0x08, 0x13, // .2..c...
|
|
/* 0490 */ 0xE8, 0x59, 0x88, 0xC5, 0x7D, 0xAE, 0xE8, 0x3C, // .Y..}..<
|
|
/* 0498 */ 0xE1, 0xB3, 0x10, 0xF0, 0xFE, 0xFF, 0x9F, 0x25, // .......%
|
|
/* 04A0 */ 0xE0, 0x5E, 0x0D, 0x9E, 0x85, 0x00, 0x13, 0x87, // .^......
|
|
/* 04A8 */ 0x0D, 0x9F, 0x35, 0xC0, 0x33, 0x7C, 0x8F, 0xEA, // ..5.3|..
|
|
/* 04B0 */ 0x1C, 0x1E, 0x8F, 0x81, 0x7F, 0x56, 0x1D, 0xE7, // .....V..
|
|
/* 04B8 */ 0x04, 0x96, 0x7B, 0xD1, 0xB2, 0x71, 0xA0, 0xA1, // ..{..q..
|
|
/* 04C0 */ 0x23, 0xB2, 0x3A, 0x20, 0x8D, 0x0D, 0x73, 0x29, // #.: ..s)
|
|
/* 04C8 */ 0x89, 0x7C, 0x72, 0x6C, 0xD4, 0x56, 0x04, 0xA7, // .|rl.V..
|
|
/* 04D0 */ 0x33, 0x93, 0x4F, 0x00, 0xD6, 0x42, 0x21, 0x05, // 3.O..B!.
|
|
/* 04D8 */ 0x34, 0x1A, 0x8B, 0xE1, 0x9D, 0xF9, 0xE8, 0x44, // 4......D
|
|
/* 04E0 */ 0x41, 0x0C, 0xE8, 0xE3, 0x90, 0x6D, 0x1C, 0x0A, // A....m..
|
|
/* 04E8 */ 0x50, 0x7B, 0xD1, 0x14, 0xC8, 0x39, 0x07, 0xA3, // P{...9..
|
|
/* 04F0 */ 0x7F, 0x76, 0x74, 0x36, 0xBE, 0x13, 0x70, 0x0D, // .vt6..p.
|
|
/* 04F8 */ 0x10, 0x3A, 0x25, 0x18, 0xDA, 0x6A, 0x04, 0xFC, // .:%..j..
|
|
/* 0500 */ 0xFF, 0x67, 0x89, 0x01, 0x33, 0xFE, 0x53, 0x8C, // .g..3.S.
|
|
/* 0508 */ 0x09, 0x7C, 0x8E, 0xC1, 0x1F, 0x0C, 0xF0, 0x03, // .|......
|
|
/* 0510 */ 0x7F, 0x31, 0xA8, 0xFA, 0x5E, 0xA0, 0xFB, 0x82, // .1..^...
|
|
/* 0518 */ 0xD5, 0xDD, 0x64, 0x20, 0xCC, 0xC8, 0x04, 0xF5, // ..d ....
|
|
/* 0520 */ 0x9D, 0x0E, 0x40, 0x01, 0xE4, 0x0B, 0x81, 0xCF, // ..@.....
|
|
/* 0528 */ 0x51, 0x0F, 0x05, 0x6C, 0x22, 0x21, 0xC2, 0x44, // Q..l"!.D
|
|
/* 0530 */ 0x33, 0x3A, 0x62, 0xC2, 0xA8, 0xE8, 0x13, 0xA6, // 3:b.....
|
|
/* 0538 */ 0x20, 0x9E, 0xB0, 0x63, 0x4D, 0x18, 0x3D, 0x13, // ..cM.=.
|
|
/* 0540 */ 0x5F, 0x74, 0xD8, 0x88, 0x31, 0x21, 0xAE, 0x1E, // _t..1!..
|
|
/* 0548 */ 0xD0, 0x26, 0x18, 0xD4, 0x97, 0x22, 0x58, 0x43, // .&..."XC
|
|
/* 0550 */ 0xE6, 0x63, 0xF1, 0x05, 0x02, 0x37, 0x65, 0x30, // .c...7e0
|
|
/* 0558 */ 0xCE, 0x89, 0x5D, 0x13, 0x7C, 0xD9, 0xC1, 0xCD, // ..].|...
|
|
/* 0560 */ 0x19, 0x8C, 0xF0, 0x98, 0xBB, 0x18, 0xBF, 0x3A, // .......:
|
|
/* 0568 */ 0x79, 0x74, 0xFC, 0xA0, 0xE0, 0x1B, 0x0E, 0xC3, // yt......
|
|
/* 0570 */ 0x7E, 0x32, 0xF3, 0x8C, 0xDE, 0xCB, 0x7C, 0x8D, // ~2....|.
|
|
/* 0578 */ 0xC3, 0xC0, 0x7A, 0xBC, 0x1C, 0xD6, 0x68, 0x61, // ..z...ha
|
|
/* 0580 */ 0x0F, 0xED, 0x3D, 0xC4, 0xFF, 0xFF, 0x43, 0x8C, // ..=...C.
|
|
/* 0588 */ 0xCF, 0x13, 0xC6, 0x08, 0xEB, 0xDB, 0x0B, 0x38, // .......8
|
|
/* 0590 */ 0xEE, 0x59, 0xF0, 0xEF, 0x1A, 0xE0, 0xB9, 0x84, // .Y......
|
|
/* 0598 */ 0xF8, 0xAE, 0x01, 0x30, 0xF0, 0xFF, 0x7F, 0xD7, // ...0....
|
|
/* 05A0 */ 0x00, 0x4E, 0xD7, 0x04, 0xDF, 0x35, 0x80, 0xF7, // .N...5..
|
|
/* 05A8 */ 0xD0, 0x7D, 0xD7, 0x00, 0xAE, 0xD9, 0xEF, 0x1A, // .}......
|
|
/* 05B0 */ 0xA8, 0x63, 0x80, 0x15, 0xDE, 0x35, 0xA0, 0x5D, // .c...5.]
|
|
/* 05B8 */ 0xD9, 0xDE, 0xD7, 0x9E, 0xB0, 0xAC, 0xE9, 0xB2, // ........
|
|
/* 05C0 */ 0x81, 0x52, 0x73, 0xD9, 0x00, 0x14, 0xFC, 0xFF, // .Rs.....
|
|
/* 05C8 */ 0x2F, 0x1B, 0x80, 0x01, 0x29, 0x13, 0x46, 0x85, // /...).F.
|
|
/* 05D0 */ 0x9F, 0x30, 0x05, 0xF1, 0x84, 0x1D, 0xEC, 0xB2, // .0......
|
|
/* 05D8 */ 0x01, 0x8A, 0x18, 0x97, 0x0D, 0xD0, 0x8F, 0xED, // ........
|
|
/* 05E0 */ 0x65, 0x03, 0x18, 0xDC, 0x13, 0xF8, 0x6D, 0x03, // e.....m.
|
|
/* 05E8 */ 0x78, 0x43, 0xFA, 0xB6, 0x01, 0xD6, 0xFF, 0xFF, // xC......
|
|
/* 05F0 */ 0x6D, 0x03, 0xAC, 0xF9, 0x6F, 0x1B, 0x28, 0x0E, // m...o.(.
|
|
/* 05F8 */ 0xAB, 0xBC, 0x6D, 0x40, 0x3C, 0xC9, 0x33, 0x02, // ..m@<.3.
|
|
/* 0600 */ 0xAB, 0xBA, 0x6E, 0xA0, 0xF4, 0x5C, 0x37, 0x00, // ..n..\7.
|
|
/* 0608 */ 0x12, 0x88, 0x99, 0x30, 0x2A, 0xFE, 0x84, 0x29, // ...0*..)
|
|
/* 0610 */ 0x88, 0x27, 0xEC, 0x68, 0xD7, 0x0D, 0x50, 0x04, // .'.h..P.
|
|
/* 0618 */ 0xB9, 0x6E, 0x80, 0x7E, 0x5E, 0x09, 0xFE, 0xFF, // .n.~^...
|
|
/* 0620 */ 0xAF, 0x1B, 0xC0, 0xE0, 0xA2, 0x80, 0xB9, 0x6F, // .......o
|
|
/* 0628 */ 0x00, 0x6F, 0x58, 0x7E, 0xDF, 0x00, 0x7C, 0xDC, // .oX~..|.
|
|
/* 0630 */ 0xC4, 0x31, 0xF7, 0x0D, 0xC0, 0xCC, 0xFF, 0xFF, // .1......
|
|
/* 0638 */ 0xBE, 0x01, 0xB0, 0xE7, 0xA2, 0x80, 0xBB, 0x6F, // .......o
|
|
/* 0640 */ 0x00, 0xEF, 0x8B, 0xB4, 0xEF, 0x1B, 0x60, 0xFE, // ......`.
|
|
/* 0648 */ 0xFF, 0xDF, 0x37, 0xC0, 0x28, 0x6D, 0xFD, 0x1E, // ..7.(m..
|
|
/* 0650 */ 0x1C, 0x3D, 0x21, 0x78, 0x7C, 0xB8, 0xFB, 0xA5, // .=!x|...
|
|
/* 0658 */ 0xC7, 0xE7, 0xBB, 0x39, 0x38, 0x06, 0x79, 0x8C, // ...98.y.
|
|
/* 0660 */ 0x87, 0x76, 0xC0, 0xAF, 0xEF, 0x9E, 0x98, 0xEF, // .v......
|
|
/* 0668 */ 0xE6, 0xC0, 0xFF, 0x4C, 0x70, 0x3C, 0x18, 0x68, // ...Lp<.h
|
|
/* 0670 */ 0x1C, 0x62, 0xAB, 0x97, 0x06, 0x72, 0x34, 0x38, // .b...r48
|
|
/* 0678 */ 0x3F, 0xDC, 0x19, 0x81, 0x61, 0x15, 0x7F, 0xF2, // ?...a...
|
|
/* 0680 */ 0x47, 0x38, 0xC7, 0xD0, 0xD9, 0xE1, 0x20, 0xB1, // G8.... .
|
|
/* 0688 */ 0x83, 0xE0, 0xC1, 0x56, 0x6D, 0x02, 0x85, 0x86, // ...Vm...
|
|
/* 0690 */ 0x50, 0x14, 0x18, 0x14, 0x8B, 0x0F, 0x18, 0xF8, // P.......
|
|
/* 0698 */ 0x61, 0xB3, 0xB3, 0x00, 0x93, 0x04, 0x87, 0x3A, // a......:
|
|
/* 06A0 */ 0x02, 0xF8, 0x3E, 0xD1, 0xFC, 0x38, 0x74, 0x37, // ..>..8t7
|
|
/* 06A8 */ 0x38, 0x54, 0x8F, 0xE5, 0xA1, 0x80, 0x9E, 0x01, // 8T......
|
|
/* 06B0 */ 0x71, 0xC7, 0x0C, 0x32, 0x69, 0xCF, 0x28, 0xE2, // q..2i.(.
|
|
/* 06B8 */ 0x53, 0xC2, 0x29, 0x85, 0x49, 0xE0, 0xF3, 0x03, // S.).I...
|
|
/* 06C0 */ 0x43, 0xE3, 0x04, 0xAF, 0x0D, 0xA1, 0xF9, 0xFF, // C.......
|
|
/* 06C8 */ 0xFF, 0xA4, 0xC0, 0x3C, 0xDF, 0x31, 0x04, 0x6C, // ...<.1.l
|
|
/* 06D0 */ 0x02, 0xBB, 0xBF, 0x64, 0xC8, 0xDA, 0xC0, 0x75, // ...d...u
|
|
/* 06D8 */ 0x4B, 0x32, 0x44, 0x6F, 0x38, 0xB2, 0x85, 0xA2, // K2Do8...
|
|
/* 06E0 */ 0xE9, 0x44, 0x79, 0xDF, 0x88, 0x62, 0x67, 0x08, // .Dy..bg.
|
|
/* 06E8 */ 0xC2, 0x88, 0x12, 0x2C, 0xC8, 0xA3, 0x42, 0xAC, // ...,..B.
|
|
/* 06F0 */ 0x28, 0x2F, 0x05, 0x46, 0x88, 0x18, 0xE2, 0x95, // (/.F....
|
|
/* 06F8 */ 0x23, 0xD0, 0x09, 0x87, 0x0F, 0xF2, 0xD8, 0x14, // #.......
|
|
/* 0700 */ 0xA7, 0xFD, 0x41, 0x90, 0x58, 0x4F, 0x02, 0x8D, // ..A.XO..
|
|
/* 0708 */ 0xC5, 0x91, 0x46, 0x83, 0x3A, 0x07, 0x78, 0xB8, // ..F.:.x.
|
|
/* 0710 */ 0x3E, 0xC4, 0x78, 0xF8, 0x0F, 0x21, 0x06, 0x39, // >.x..!.9
|
|
/* 0718 */ 0xC8, 0x73, 0x7B, 0x54, 0x38, 0x4E, 0x5F, 0x25, // .s{T8N_%
|
|
/* 0720 */ 0x4C, 0xF0, 0x02, 0xE0, 0x83, 0x0A, 0x1C, 0xD7, // L.......
|
|
/* 0728 */ 0x80, 0x9A, 0xF1, 0x33, 0x06, 0x58, 0x8E, 0xE3, // ...3.X..
|
|
/* 0730 */ 0x3E, 0xA9, 0xC0, 0x1D, 0x8F, 0xEF, 0x07, 0x6C, // >......l
|
|
/* 0738 */ 0xC2, 0x09, 0x2C, 0x7F, 0x10, 0xA8, 0xE3, 0x0C, // ..,.....
|
|
/* 0740 */ 0x9F, 0xE7, 0x0B, 0x8B, 0x21, 0x1F, 0x13, 0x4C, // ....!..L
|
|
/* 0748 */ 0x60, 0xB1, 0x27, 0x1B, 0x3A, 0x1E, 0xF0, 0xDF, // `.'.:...
|
|
/* 0750 */ 0x63, 0x1E, 0x2F, 0x7C, 0x32, 0xF1, 0x7C, 0x4D, // c./|2.|M
|
|
/* 0758 */ 0x30, 0x22, 0x84, 0x9C, 0x8C, 0x07, 0x7D, 0x87, // 0"....}.
|
|
/* 0760 */ 0xC0, 0x5C, 0x6F, 0xD8, 0xB9, 0x85, 0x8B, 0x3A, // .\o....:
|
|
/* 0768 */ 0x68, 0xA0, 0x4E, 0x0B, 0x3E, 0x28, 0xB0, 0x9B, // h.N.>(..
|
|
/* 0770 */ 0x11, 0xE6, 0xB8, 0xCE, 0xCF, 0x2A, 0x60, 0xF8, // .....*`.
|
|
/* 0778 */ 0xFF, 0x9F, 0x55, 0x60, 0x8F, 0x10, 0xFE, 0xED, // ..U`....
|
|
/* 0780 */ 0xC1, 0xF3, 0xF2, 0x95, 0xE1, 0xD5, 0x21, 0x81, // ......!.
|
|
/* 0788 */ 0x43, 0x8E, 0x10, 0x3D, 0x2E, 0x8F, 0x10, 0x73, // C..=...s
|
|
/* 0790 */ 0x3E, 0xC2, 0x0C, 0x11, 0x5C, 0x67, 0x01, 0x70, // >...\g.p
|
|
/* 0798 */ 0x0C, 0x11, 0xF8, 0x1C, 0x70, 0xC0, 0x71, 0x69, // ....p.qi
|
|
/* 07A0 */ 0xE2, 0x03, 0xF5, 0x01, 0x07, 0x70, 0x70, 0x4D, // .....ppM
|
|
/* 07A8 */ 0xC3, 0x1D, 0x70, 0xC0, 0x71, 0x16, 0x60, 0xFF, // ..p.q.`.
|
|
/* 07B0 */ 0xFF, 0xC3, 0x0D, 0x2C, 0x49, 0x26, 0x0E, 0x23, // ...,I&.#
|
|
/* 07B8 */ 0x18, 0x11, 0x30, 0x28, 0x02, 0x02, 0xA4, 0xB3, // ..0(....
|
|
/* 07C0 */ 0x80, 0x0F, 0x29, 0x00, 0x1F, 0xAE, 0x0C, 0x0F, // ..).....
|
|
/* 07C8 */ 0x29, 0xD8, 0x93, 0x86, 0x07, 0x8E, 0x1B, 0x85, // ).......
|
|
/* 07D0 */ 0x07, 0x8D, 0x0B, 0x30, 0x68, 0x7A, 0xE2, 0x80, // ...0hz..
|
|
/* 07D8 */ 0x7F, 0x4C, 0xF0, 0x19, 0x05, 0x1C, 0xE3, 0x06, // .L......
|
|
/* 07E0 */ 0xDF, 0x2A, 0x0C, 0xFC, 0xFF, 0x3F, 0x30, 0xCC, // .*...?0.
|
|
/* 07E8 */ 0xE1, 0xC2, 0x63, 0x39, 0x8A, 0xA0, 0x07, 0x1E, // ..c9....
|
|
/* 07F0 */ 0xD4, 0xF7, 0x8C, 0x33, 0xF7, 0x24, 0x8F, 0xD1, // ...3.$..
|
|
/* 07F8 */ 0x51, 0x0F, 0x27, 0xF4, 0xE4, 0x85, 0x3B, 0x57, // Q.'...;W
|
|
/* 0800 */ 0xF9, 0x0A, 0x71, 0x14, 0x18, 0xB8, 0x77, 0x29, // ..q...w)
|
|
/* 0808 */ 0x8F, 0xCF, 0x17, 0x2B, 0xC3, 0x63, 0x46, 0xFB, // ...+.cF.
|
|
/* 0810 */ 0x1E, 0x72, 0xD6, 0x11, 0x02, 0xE2, 0x2F, 0x75, // .r..../u
|
|
/* 0818 */ 0x6C, 0xC0, 0x60, 0x39, 0x18, 0x00, 0x87, 0x01, // l.`9....
|
|
/* 0820 */ 0xE3, 0x13, 0x0D, 0x58, 0x67, 0x1B, 0x3C, 0xF4, // ...Xg.<.
|
|
/* 0828 */ 0x69, 0x31, 0xC4, 0xE3, 0x0B, 0xFB, 0x56, 0x61, // i1....Va
|
|
/* 0830 */ 0x82, 0xEA, 0x41, 0x75, 0x12, 0xF4, 0xD0, 0xC0, // ..Au....
|
|
/* 0838 */ 0x01, 0xE8, 0xA1, 0xC1, 0x3F, 0xB9, 0x90, 0xFB, // ....?...
|
|
/* 0840 */ 0x2B, 0x1D, 0x82, 0xB5, 0xE2, 0x69, 0xDE, 0x47, // +....i.G
|
|
/* 0848 */ 0x1E, 0xF3, 0xDC, 0xA2, 0xBC, 0x0D, 0x3C, 0x07, // ......<.
|
|
/* 0850 */ 0xF0, 0xD3, 0x82, 0x87, 0xE3, 0x63, 0x81, 0xC7, // .....c..
|
|
/* 0858 */ 0xE9, 0x4B, 0x58, 0x82, 0xF7, 0x1A, 0x9F, 0x6C, // .KX....l
|
|
/* 0860 */ 0x1E, 0x5C, 0x58, 0xB2, 0x21, 0xA0, 0x06, 0xEB, // .\X.!...
|
|
/* 0868 */ 0x21, 0x60, 0xA6, 0x9A, 0xC0, 0x49, 0x46, 0x80, // !`...IF.
|
|
/* 0870 */ 0xCA, 0x00, 0xA1, 0x1B, 0xCB, 0xE9, 0x3E, 0x8B, // ......>.
|
|
/* 0878 */ 0x84, 0x38, 0xCD, 0x47, 0x99, 0xC7, 0x02, 0x8F, // .8.G....
|
|
/* 0880 */ 0xF5, 0xC1, 0xC0, 0xFF, 0x7F, 0xCD, 0x23, 0xD4, // ......#.
|
|
/* 0888 */ 0x7D, 0xCD, 0x33, 0x7B, 0x3A, 0xC0, 0xAC, 0x22, // }.3{:.."
|
|
/* 0890 */ 0xDC, 0x7B, 0xCE, 0x1B, 0x86, 0xD1, 0x9E, 0x2D, // .{.....-
|
|
/* 0898 */ 0x7C, 0xCD, 0x78, 0xD6, 0x34, 0x42, 0x38, 0x76, // |.x.4B8v
|
|
/* 08A0 */ 0x83, 0xF3, 0x48, 0x8C, 0xF0, 0x82, 0xC0, 0x4E, // ..H....N
|
|
/* 08A8 */ 0x0C, 0x0F, 0x30, 0xC6, 0x39, 0x79, 0xC3, 0xFA, // ..0.9y..
|
|
/* 08B0 */ 0xC2, 0xCB, 0x40, 0x83, 0x19, 0xDB, 0x97, 0x01, // ..@.....
|
|
/* 08B8 */ 0x36, 0x2A, 0xDF, 0x88, 0xC0, 0x97, 0xFC, 0x62, // 6*.....b
|
|
/* 08C0 */ 0x00, 0x65, 0x16, 0xBE, 0x9E, 0xF8, 0xA0, 0xC4, // .e......
|
|
/* 08C8 */ 0x2E, 0x06, 0x2C, 0xE5, 0xC5, 0x00, 0x54, 0x37, // ..,...T7
|
|
/* 08D0 */ 0x0C, 0x5F, 0x0C, 0xE0, 0x5F, 0x89, 0x5E, 0x0C, // ._.._.^.
|
|
/* 08D8 */ 0xC0, 0x70, 0x71, 0xF2, 0x3D, 0xC0, 0x1E, 0xEE, // .pq.=...
|
|
/* 08E0 */ 0xA3, 0x74, 0x9C, 0xBE, 0xFD, 0xBD, 0x19, 0xF8, // .t......
|
|
/* 08E8 */ 0x6C, 0xC0, 0x60, 0x3C, 0xC3, 0x30, 0xC6, 0x08, // l.`<.0..
|
|
/* 08F0 */ 0xE3, 0x51, 0x86, 0x31, 0xC1, 0xDC, 0xB7, 0x03, // .Q.1....
|
|
/* 08F8 */ 0xE8, 0x39, 0x87, 0x81, 0x4A, 0x78, 0x3B, 0x80, // .9..Jx;.
|
|
/* 0900 */ 0x72, 0x0E, 0xE8, 0xF2, 0x68, 0x42, 0x4F, 0x01, // r...hBO.
|
|
/* 0908 */ 0x4F, 0x07, 0x3E, 0x29, 0x1A, 0xA2, 0xAF, 0xB1, // O.>)....
|
|
/* 0910 */ 0x0A, 0x26, 0x50, 0xC4, 0x07, 0x0D, 0x3E, 0xB5, // .&P...>.
|
|
/* 0918 */ 0x28, 0x3E, 0x15, 0x78, 0x2D, 0xCF, 0x4E, 0xE1, // (>.x-.N.
|
|
/* 0920 */ 0xE2, 0x9C, 0x89, 0xA7, 0x6A, 0x38, 0x03, 0xBD, // ....j8..
|
|
/* 0928 */ 0xE6, 0x86, 0x63, 0xFF, 0x7F, 0x38, 0xFC, 0xA9, // ..c..8..
|
|
/* 0930 */ 0xE0, 0x35, 0x80, 0x1D, 0x24, 0x3D, 0x2D, 0x23, // .5..$=-#
|
|
/* 0938 */ 0xC2, 0x38, 0xA4, 0x3C, 0x32, 0xF8, 0xB6, 0x18, // .8.<2...
|
|
/* 0940 */ 0xC7, 0x90, 0x0F, 0x91, 0xBE, 0x13, 0x18, 0xF2, // ........
|
|
/* 0948 */ 0x21, 0xEF, 0x79, 0xC7, 0xC0, 0xAF, 0x08, 0x71, // !.y....q
|
|
/* 0950 */ 0x9E, 0xB2, 0x7C, 0x67, 0xF0, 0x65, 0x01, 0x7C, // ..|g.e.|
|
|
/* 0958 */ 0x91, 0x2E, 0x0B, 0x68, 0x68, 0x9F, 0x64, 0x7C, // ...hh.d|
|
|
/* 0960 */ 0x41, 0x30, 0xEC, 0x89, 0xB3, 0x00, 0x77, 0x05, // A0....w.
|
|
/* 0968 */ 0x50, 0x81, 0xFA, 0xAE, 0x00, 0xFF, 0x42, 0xF0, // P.....B.
|
|
/* 0970 */ 0xAE, 0x00, 0x86, 0x79, 0xF9, 0x56, 0xC0, 0x35, // ...y.V.5
|
|
/* 0978 */ 0x1D, 0x4A, 0xD0, 0x67, 0x12, 0x5F, 0x17, 0x70, // .J.g._.p
|
|
/* 0980 */ 0x53, 0x64, 0xA9, 0x8E, 0x0A, 0xD0, 0x53, 0x4C, // Sd....SL
|
|
/* 0988 */ 0x02, 0x75, 0x47, 0xF7, 0x51, 0x01, 0xC6, 0x4D, // .uG.Q..M
|
|
/* 0990 */ 0xD9, 0x07, 0x54, 0x76, 0x5A, 0x60, 0x67, 0x21, // ..TvZ`g!
|
|
/* 0998 */ 0x76, 0x1D, 0xC1, 0x5D, 0x49, 0x18, 0xCA, 0xB3, // v..]I...
|
|
/* 09A0 */ 0x81, 0x2F, 0x59, 0xFC, 0x70, 0x00, 0x03, 0xDC, // ./Y.p...
|
|
/* 09A8 */ 0xB3, 0x38, 0xC4, 0x08, 0xB1, 0xD9, 0x81, 0xEB, // .8......
|
|
/* 09B0 */ 0x75, 0xD2, 0x70, 0x2F, 0x44, 0xEC, 0xFF, 0x7F, // u.p/D...
|
|
/* 09B8 */ 0x32, 0x00, 0xE3, 0x51, 0x1B, 0x1C, 0x27, 0x9D, // 2..Q..'.
|
|
/* 09C0 */ 0xF0, 0x91, 0x9E, 0x59, 0xF8, 0x49, 0x19, 0x30, // ...Y.I.0
|
|
/* 09C8 */ 0x71, 0xF2, 0x03, 0xE3, 0xC9, 0x1A, 0xC6, 0x00, // q.......
|
|
/* 09D0 */ 0xB8, 0xBC, 0x57, 0x95, 0x81, 0xFC, 0x43, 0x90, // ..W...C.
|
|
/* 09D8 */ 0x20, 0x18, 0xD4, 0x29, 0x19, 0x38, 0x1C, 0xC5, // ..).8..
|
|
/* 09E0 */ 0x70, 0xA7, 0x64, 0x78, 0x50, 0xF8, 0xC3, 0x00, // p.dxP...
|
|
/* 09E8 */ 0xE6, 0x46, 0xE8, 0x7B, 0x82, 0xA1, 0xDE, 0x93, // .F.{....
|
|
/* 09F0 */ 0x0E, 0xE3, 0x91, 0xD0, 0x04, 0x3E, 0x2D, 0xC3, // .....>-.
|
|
/* 09F8 */ 0xFA, 0xFF, 0x9F, 0x96, 0x81, 0xD5, 0xB1, 0xDD, // ........
|
|
/* 0A00 */ 0x43, 0xF6, 0x59, 0x01, 0x77, 0x76, 0x80, 0x3B, // C.Y.wv.;
|
|
/* 0A08 */ 0x3D, 0x7E, 0x7A, 0x00, 0x9C, 0x00, 0x3D, 0x3D, // =~z...==
|
|
/* 0A10 */ 0x80, 0xED, 0xBC, 0x01, 0xF7, 0x40, 0x80, 0x38, // .....@.8
|
|
/* 0A18 */ 0xFE, 0xA3, 0x82, 0x5F, 0x59, 0x28, 0x1C, 0x3F, // ..._Y(.?
|
|
/* 0A20 */ 0xB6, 0xF3, 0x63, 0x09, 0xEE, 0x70, 0xE0, 0x23, // ..c..p.#
|
|
/* 0A28 */ 0x83, 0x0F, 0x90, 0xB8, 0xA1, 0xF8, 0x50, 0x81, // ......P.
|
|
/* 0A30 */ 0x3C, 0x0B, 0x80, 0x62, 0xF4, 0x6C, 0x04, 0xEC, // <..b.l..
|
|
/* 0A38 */ 0x06, 0xF3, 0xD2, 0x12, 0xE5, 0xFF, 0xFF, 0xDE, // ........
|
|
/* 0A40 */ 0xC0, 0x4E, 0x29, 0xB8, 0x83, 0x00, 0xF8, 0x8E, // .N).....
|
|
/* 0A48 */ 0x01, 0xE0, 0x1D, 0x0C, 0x97, 0x35, 0x66, 0x94, // .....5f.
|
|
/* 0A50 */ 0x10, 0x18, 0x8D, 0x19, 0x77, 0x08, 0xE1, 0x27, // ....w..'
|
|
/* 0A58 */ 0x02, 0xDC, 0x98, 0x3D, 0x6E, 0x8F, 0x19, 0x77, // ...=n..w
|
|
/* 0A60 */ 0x9C, 0xE5, 0xA3, 0x7A, 0xCA, 0x08, 0xE5, 0x03, // ...z....
|
|
/* 0A68 */ 0x07, 0x3B, 0x67, 0xBC, 0x11, 0xF0, 0xA1, 0x03, // .;g.....
|
|
/* 0A70 */ 0x8F, 0x03, 0x0C, 0xEE, 0x48, 0x01, 0xC6, 0xCB, // ....H...
|
|
/* 0A78 */ 0x01, 0x1B, 0x3B, 0xB8, 0x83, 0x90, 0x53, 0x20, // ..;...S
|
|
/* 0A80 */ 0x4B, 0x87, 0xD1, 0xD8, 0x71, 0xB2, 0x81, 0x74, // K...q..t
|
|
/* 0A88 */ 0x8C, 0xF1, 0x21, 0xD7, 0x63, 0xC7, 0x0D, 0xD6, // ..!.c...
|
|
/* 0A90 */ 0x63, 0xC7, 0x1D, 0x5F, 0xB0, 0xFF, 0xFF, 0xE3, // c.._....
|
|
/* 0A98 */ 0x0B, 0x18, 0xC6, 0xC0, 0xC5, 0x0F, 0x03, 0x7D, // .......}
|
|
/* 0AA0 */ 0xF3, 0xF3, 0xE8, 0x0C, 0xEE, 0x61, 0xFB, 0x04, // .....a..
|
|
/* 0AA8 */ 0x13, 0xE3, 0xF9, 0x25, 0xC4, 0x23, 0xCC, 0x8B, // ...%.#..
|
|
/* 0AB0 */ 0x4B, 0x84, 0xA3, 0x08, 0xF2, 0xE6, 0x12, 0xE7, // K.......
|
|
/* 0AB8 */ 0xD5, 0x20, 0xCC, 0x63, 0x4B, 0x94, 0x10, 0x11, // . .cK...
|
|
/* 0AC0 */ 0x0E, 0x26, 0xCE, 0x13, 0x8C, 0x11, 0x0E, 0x3C, // .&.....<
|
|
/* 0AC8 */ 0x8A, 0x21, 0x22, 0x9C, 0x40, 0x88, 0x93, 0x3E, // .!".@..>
|
|
/* 0AD0 */ 0xD9, 0x20, 0xE1, 0x63, 0x84, 0x8D, 0xF6, 0x04, // . .c....
|
|
/* 0AD8 */ 0xC3, 0xC7, 0xC2, 0xCF, 0x2B, 0x1E, 0x3C, 0x3F, // ....+.<?
|
|
/* 0AE0 */ 0xAD, 0xF9, 0x2E, 0xE8, 0xC9, 0x9C, 0xE3, 0x43, // .......C
|
|
/* 0AE8 */ 0x96, 0xA7, 0xF6, 0x38, 0xE9, 0xC3, 0x2C, 0x6E, // ...8..,n
|
|
/* 0AF0 */ 0x50, 0x0F, 0x8E, 0xEC, 0xAE, 0xE3, 0xE3, 0x35, // P......5
|
|
/* 0AF8 */ 0xF6, 0x14, 0xE4, 0x21, 0xF0, 0x13, 0x81, 0x2F, // ...!.../
|
|
/* 0B00 */ 0x88, 0x9E, 0xAC, 0xEF, 0x7A, 0xEC, 0x5E, 0x66, // ....z.^f
|
|
/* 0B08 */ 0x8C, 0xEA, 0xA7, 0x80, 0x3A, 0xA6, 0x9C, 0xC1, // ....:...
|
|
/* 0B10 */ 0x2B, 0x04, 0xBB, 0xE7, 0xF9, 0x90, 0xED, 0xBB, // +.......
|
|
/* 0B18 */ 0x24, 0x1B, 0x05, 0xEE, 0x90, 0xE0, 0x33, 0x12, // $.....3.
|
|
/* 0B20 */ 0x3F, 0x55, 0x78, 0x18, 0x1E, 0x05, 0x8C, 0x19, // ?Ux.....
|
|
/* 0B28 */ 0xBC, 0x23, 0x1C, 0x5A, 0x88, 0x03, 0x7E, 0xDF, // .#.Z..~.
|
|
/* 0B30 */ 0x65, 0x43, 0x8D, 0x71, 0x7A, 0x3E, 0x7F, 0xB0, // eC.qz>..
|
|
/* 0B38 */ 0x41, 0xC0, 0x87, 0x3A, 0x54, 0x0F, 0xF3, 0xA8, // A..:T...
|
|
/* 0B40 */ 0x5E, 0x0A, 0x19, 0xCE, 0xD9, 0xC1, 0x1D, 0x04, // ^.......
|
|
/* 0B48 */ 0xF6, 0xF8, 0xE1, 0x41, 0xF0, 0x9B, 0x25, 0x1F, // ...A..%.
|
|
/* 0B50 */ 0x04, 0x3B, 0xDF, 0xBC, 0xC1, 0x19, 0xE4, 0xFF, // .;......
|
|
/* 0B58 */ 0x7F, 0x0C, 0xB0, 0xCF, 0x54, 0x3E, 0x9A, 0x20, // ....T>.
|
|
/* 0B60 */ 0x8E, 0x80, 0xE8, 0xF3, 0x87, 0xC7, 0xF0, 0x26, // .......&
|
|
/* 0B68 */ 0xC7, 0x87, 0x83, 0x3D, 0x7A, 0xE0, 0x4E, 0x22, // ...=z.N"
|
|
/* 0B70 */ 0x70, 0x8F, 0x5D, 0x07, 0xED, 0x6B, 0x9C, 0x2F, // p.]..k./
|
|
/* 0B78 */ 0x5A, 0x30, 0xEE, 0x7B, 0xCF, 0x22, 0xE0, 0xC7, // Z0.{."..
|
|
/* 0B80 */ 0x78, 0x6C, 0x01, 0xC7, 0xA1, 0x04, 0xDC, 0xC1, // xl......
|
|
/* 0B88 */ 0x8E, 0x6B, 0x1C, 0x42, 0x51, 0x60, 0x74, 0x28, // .k.BQ`t(
|
|
/* 0B90 */ 0xC1, 0xC5, 0x00, 0x12, 0x8C, 0x63, 0x9C, 0xD1, // .....c..
|
|
/* 0B98 */ 0xD0, 0x97, 0x48, 0x1F, 0xD2, 0xE0, 0x0C, 0x1A, // ..H.....
|
|
/* 0BA0 */ 0xF6, 0x3C, 0x9F, 0x50, 0xB8, 0x3D, 0x01, 0x8A, // .<.P.=..
|
|
/* 0BA8 */ 0x4E, 0x28, 0x20, 0xC3, 0x7D, 0x06, 0xC1, 0x9E, // N( .}...
|
|
/* 0BB0 */ 0x10, 0xF8, 0x19, 0x84, 0xFD, 0xFF, 0x0F, 0x8E, // ........
|
|
/* 0BB8 */ 0x1E, 0xF7, 0x7B, 0xA3, 0x4F, 0x8D, 0x6C, 0xEE, // ..{.O.l.
|
|
/* 0BC0 */ 0x0F, 0x01, 0x27, 0x70, 0xEE, 0xEC, 0xD4, 0x8C, // ..'p....
|
|
/* 0BC8 */ 0x3B, 0x33, 0x60, 0xCF, 0x1F, 0x1E, 0x02, 0x3F, // ;3`....?
|
|
/* 0BD0 */ 0x17, 0x78, 0xF8, 0x1E, 0x02, 0x7E, 0xF0, 0x0F, // .x...~..
|
|
/* 0BD8 */ 0xCC, 0x06, 0x07, 0xE3, 0x29, 0xC2, 0xD7, 0x0E, // ....)...
|
|
/* 0BE0 */ 0x0E, 0xCE, 0x4F, 0x03, 0x06, 0xE7, 0xAF, 0x50, // ..O....P
|
|
/* 0BE8 */ 0x9F, 0xE7, 0x19, 0x38, 0xF6, 0xD4, 0xEB, 0x7B, // ...8...{
|
|
/* 0BF0 */ 0x87, 0xE7, 0xEB, 0x43, 0x05, 0xFE, 0xA6, 0xE7, // ...C....
|
|
/* 0BF8 */ 0x43, 0x05, 0x38, 0x0E, 0x0F, 0xFC, 0xB0, 0xC2, // C.8.....
|
|
/* 0C00 */ 0x86, 0xF0, 0x28, 0x80, 0x3F, 0xB5, 0xF8, 0xF8, // ..(.?...
|
|
/* 0C08 */ 0x17, 0xE7, 0x29, 0x82, 0xDD, 0x46, 0xB0, 0x87, // ..)..F..
|
|
/* 0C10 */ 0x0B, 0xC0, 0x51, 0xB4, 0xB3, 0x18, 0x2A, 0xCC, // ..Q...*.
|
|
/* 0C18 */ 0x59, 0x8C, 0xFC, 0xFF, 0xCF, 0x51, 0xA8, 0xB3, // Y....Q..
|
|
/* 0C20 */ 0x18, 0x3D, 0x5C, 0x00, 0x2E, 0x04, 0x1F, 0x0F, // .=\.....
|
|
/* 0C28 */ 0x40, 0x73, 0x10, 0x78, 0x5C, 0xF0, 0x85, 0xE0, // @s.x\...
|
|
/* 0C30 */ 0x48, 0x0E, 0xE4, 0xE9, 0x00, 0xF0, 0x19, 0x4A, // H......J
|
|
/* 0C38 */ 0xC3, 0xA1, 0x09, 0x13, 0x03, 0x06, 0x75, 0x3E, // ......u>
|
|
/* 0C40 */ 0xF0, 0x09, 0xC5, 0xC7, 0x0E, 0x7E, 0x36, 0xF0, // .....~6.
|
|
/* 0C48 */ 0x8D, 0xDC, 0x43, 0xE5, 0xA7, 0x66, 0x5F, 0xF2, // ..C..f_.
|
|
/* 0C50 */ 0x11, 0xE0, 0x02, 0x75, 0xA0, 0x61, 0xA0, 0x46, // ...u.a.F
|
|
/* 0C58 */ 0xE4, 0x23, 0xD2, 0xFF, 0xFF, 0xB9, 0x0D, 0x1B, // .#......
|
|
/* 0C60 */ 0x60, 0x68, 0xF4, 0x1C, 0x0E, 0xE3, 0x80, 0xEB, // `h......
|
|
/* 0C68 */ 0x73, 0x38, 0x76, 0x40, 0x3E, 0x87, 0xC3, 0x3F, // s8v@>..?
|
|
/* 0C70 */ 0x47, 0xC3, 0x1F, 0x1B, 0x3B, 0xDD, 0xF3, 0x81, // G...;...
|
|
/* 0C78 */ 0xC1, 0xBA, 0x7E, 0x63, 0x06, 0x06, 0xB6, 0x6F, // ..~c...o
|
|
/* 0C80 */ 0x91, 0x07, 0x06, 0x1C, 0x51, 0xCF, 0xC6, 0x57, // ....Q..W
|
|
/* 0C88 */ 0x08, 0x0F, 0x0C, 0x6C, 0x80, 0x1E, 0x18, 0xF0, // ...l....
|
|
/* 0C90 */ 0x89, 0x05, 0x21, 0x27, 0x03, 0x43, 0x9D, 0x32, // ..!'.C.2
|
|
/* 0C98 */ 0x8C, 0x1C, 0xF3, 0x89, 0xC3, 0xC3, 0xF0, 0xA1, // ........
|
|
/* 0CA0 */ 0x22, 0xEA, 0x33, 0xC0, 0x23, 0x1E, 0x1B, 0x1B, // ".3.#...
|
|
/* 0CA8 */ 0xFB, 0xFF, 0x8F, 0x0D, 0x2C, 0xC7, 0x16, 0x8F, // ....,...
|
|
/* 0CB0 */ 0x0D, 0xFC, 0x47, 0x78, 0xFC, 0xD8, 0xE0, 0x8C, // ..Gx....
|
|
/* 0CB8 */ 0xE5, 0xD1, 0xC4, 0x97, 0x99, 0x23, 0x3B, 0x8D, // .....#;.
|
|
/* 0CC0 */ 0x33, 0x7B, 0x0D, 0xF1, 0xD1, 0xEE, 0xF1, 0xDB, // 3{......
|
|
/* 0CC8 */ 0x63, 0x03, 0x97, 0x85, 0xB1, 0x01, 0xA5, 0x90, // c.......
|
|
/* 0CD0 */ 0x63, 0x43, 0x1F, 0x52, 0x7C, 0x0A, 0xB0, 0x71, // cC.R|..q
|
|
/* 0CD8 */ 0x54, 0x32, 0x0F, 0x1F, 0xAF, 0x7C, 0x62, 0x38, // T2...|b8
|
|
/* 0CE0 */ 0xBA, 0x20, 0x6F, 0xE8, 0xBE, 0x5C, 0xF8, 0x48, // . o..\.H
|
|
/* 0CE8 */ 0x63, 0x30, 0x5F, 0x5A, 0x7C, 0x06, 0xE5, 0x43, // c0_Z|..C
|
|
/* 0CF0 */ 0x04, 0xD7, 0x57, 0xC5, 0x43, 0x04, 0x3E, 0xA1, // ..W.C.>.
|
|
/* 0CF8 */ 0x86, 0x88, 0x1E, 0xCF, 0xFF, 0xFF, 0x11, 0xCC, // ........
|
|
/* 0D00 */ 0x43, 0x64, 0x43, 0x03, 0xAF, 0x87, 0xA1, 0x01, // CdC.....
|
|
/* 0D08 */ 0xA5, 0x98, 0xC0, 0x5E, 0x85, 0x87, 0x46, 0x4F, // ...^..FO
|
|
/* 0D10 */ 0x3F, 0x3E, 0x04, 0x30, 0x08, 0xDF, 0x06, 0xD8, // ?>.0....
|
|
/* 0D18 */ 0x55, 0xC0, 0x57, 0x21, 0x83, 0x24, 0x18, 0xE7, // U.W!.$..
|
|
/* 0D20 */ 0x64, 0x41, 0x07, 0x07, 0x8E, 0x21, 0x79, 0x70, // dA...!yp
|
|
/* 0D28 */ 0xF0, 0x07, 0xE3, 0x21, 0x70, 0x60, 0xCF, 0xE0, // ...!p`..
|
|
/* 0D30 */ 0xB9, 0xE8, 0x31, 0xD8, 0xA7, 0x1D, 0x9F, 0x4A, // ..1....J
|
|
/* 0D38 */ 0xC0, 0x77, 0xE6, 0x04, 0xC7, 0xE9, 0x1D, 0x7B, // .w.....{
|
|
/* 0D40 */ 0x29, 0xF0, 0x08, 0x1E, 0xAD, 0x3C, 0x02, 0x7E, // )....<.~
|
|
/* 0D48 */ 0xB4, 0x02, 0x66, 0xFF, 0xFF, 0xA3, 0x15, 0x30, // ..f....0
|
|
/* 0D50 */ 0x09, 0x7A, 0xE6, 0xA4, 0x03, 0x77, 0x34, 0x18, // .z...w4.
|
|
/* 0D58 */ 0xD4, 0xD1, 0x0A, 0x5C, 0x11, 0xC0, 0x75, 0xDC, // ...\..u.
|
|
/* 0D60 */ 0xF0, 0xD1, 0x02, 0xCE, 0x50, 0x0F, 0xDA, 0x07, // ....P...
|
|
/* 0D68 */ 0x65, 0xCF, 0xDA, 0x97, 0x21, 0x76, 0xB4, 0x00, // e...!v..
|
|
/* 0D70 */ 0x97, 0x89, 0x43, 0x08, 0xD0, 0x04, 0x3E, 0x89, // ..C...>.
|
|
/* 0D78 */ 0x67, 0xEF, 0x43, 0x03, 0xB3, 0x8A, 0xA1, 0x01, // g.C.....
|
|
/* 0D80 */ 0xA5, 0xA3, 0x01, 0xEE, 0x44, 0x81, 0xFD, 0xFF, // ....D...
|
|
/* 0D88 */ 0x9F, 0x28, 0x60, 0xDE, 0x30, 0x70, 0x07, 0x0A, // .(`.0p..
|
|
/* 0D90 */ 0xC0, 0xCD, 0xE9, 0xDB, 0xE3, 0xE2, 0xD0, 0x38, // .......8
|
|
/* 0D98 */ 0xC4, 0xE7, 0xA7, 0x73, 0xF6, 0xD1, 0xE8, 0x4C, // ...s...L
|
|
/* 0DA0 */ 0x71, 0x67, 0x11, 0x30, 0x9C, 0x7D, 0x11, 0x8F, // qg.0.}..
|
|
/* 0DA8 */ 0x18, 0x03, 0xF9, 0x81, 0x21, 0x59, 0x30, 0x28, // ....!Y0(
|
|
/* 0DB0 */ 0x16, 0x0F, 0xC5, 0x07, 0x03, 0x0E, 0xEC, 0x23, // .......#
|
|
/* 0DB8 */ 0x02, 0x3B, 0x17, 0xB0, 0x73, 0xAD, 0xE1, 0xF8, // .;..s...
|
|
/* 0DC0 */ 0x59, 0xC0, 0xA7, 0x84, 0xB7, 0xA6, 0x17, 0x7B, // Y......{
|
|
/* 0DC8 */ 0x9F, 0xD7, 0x7D, 0xD6, 0x08, 0xC9, 0xCE, 0xF4, // ..}.....
|
|
/* 0DD0 */ 0x3E, 0x89, 0xE2, 0x0E, 0xA2, 0x70, 0x4E, 0x9F, // >....pN.
|
|
/* 0DD8 */ 0xE0, 0x22, 0xF0, 0x65, 0xDF, 0xA3, 0xE0, 0xA7, // .".e....
|
|
/* 0DE0 */ 0x07, 0xCF, 0xF1, 0x8D, 0xC1, 0xA7, 0x07, 0xE6, // ........
|
|
/* 0DE8 */ 0x7E, 0xF8, 0x9A, 0xF1, 0x33, 0xC3, 0xE3, 0x43, // ~...3..C
|
|
/* 0DF0 */ 0x88, 0x27, 0xE2, 0xDA, 0xA6, 0x20, 0x5B, 0x18, // .'... [.
|
|
/* 0DF8 */ 0x42, 0x09, 0xF4, 0xFF, 0x8F, 0x10, 0xE5, 0x6D, // B......m
|
|
/* 0E00 */ 0x20, 0xCA, 0x29, 0x44, 0x88, 0x12, 0xA4, 0xB1, // .)D....
|
|
/* 0E08 */ 0xC9, 0x0B, 0x35, 0xCA, 0xD9, 0x45, 0x6E, 0x6D, // ..5..Enm
|
|
/* 0E10 */ 0xF6, 0x82, 0x0B, 0x14, 0x2A, 0x66, 0x9C, 0x28, // ....*f.(
|
|
/* 0E18 */ 0xEF, 0x10, 0xB1, 0xDA, 0x1F, 0x04, 0x91, 0xF4, // ........
|
|
/* 0E20 */ 0x32, 0xD0, 0x71, 0xC9, 0x91, 0x0E, 0x7D, 0xE8, // 2.q...}.
|
|
/* 0E28 */ 0x61, 0xFB, 0x04, 0x8C, 0x3F, 0x48, 0xE2, 0xAE, // a...?H..
|
|
/* 0E30 */ 0x2A, 0x3E, 0x28, 0xF8, 0x00, 0x80, 0x77, 0x09, // *>(...w.
|
|
/* 0E38 */ 0xA8, 0x5B, 0x9D, 0xC7, 0xED, 0xF3, 0x06, 0xF8, // .[......
|
|
/* 0E40 */ 0xAF, 0x17, 0x58, 0x82, 0xF2, 0x07, 0x81, 0x1A, // ..X.....
|
|
/* 0E48 */ 0x99, 0xA1, 0x3D, 0xCC, 0xB7, 0x19, 0x43, 0xBE, // ..=...C.
|
|
/* 0E50 */ 0x07, 0x1C, 0x16, 0x3B, 0x27, 0xF9, 0xF0, 0x08, // ...;'...
|
|
/* 0E58 */ 0x1C, 0x8E, 0x01, 0x4F, 0x1B, 0xBE, 0x51, 0x7B, // ...O..Q{
|
|
/* 0E60 */ 0xBE, 0x3E, 0x62, 0x01, 0x8E, 0xFE, 0xFF, 0x47, // .>b....G
|
|
/* 0E68 */ 0x2C, 0x30, 0x9D, 0xDF, 0x7D, 0x82, 0x01, 0xC7, // ,0..}...
|
|
/* 0E70 */ 0xCD, 0x82, 0x9F, 0x61, 0x00, 0x67, 0x40, 0xCF, // ...a.g@.
|
|
/* 0E78 */ 0x30, 0x60, 0x1F, 0x2A, 0x6E, 0x08, 0x5C, 0xEE, // 0`.*n.\.
|
|
/* 0E80 */ 0x8A, 0x28, 0x90, 0x05, 0xC2, 0xA0, 0x0E, 0xFD, // .(......
|
|
/* 0E88 */ 0xE4, 0x08, 0x42, 0xCF, 0x9C, 0x70, 0x86, 0x72, // ..B..p.r
|
|
/* 0E90 */ 0xB2, 0xBD, 0x5F, 0x1D, 0xC8, 0x2D, 0xC2, 0x43, // .._..-.C
|
|
/* 0E98 */ 0x3D, 0x8B, 0xC7, 0x04, 0x76, 0xDA, 0x02, 0x36, // =...v..6
|
|
/* 0EA0 */ 0xFF, 0xFF, 0xE3, 0x29, 0xB0, 0x98, 0xF7, 0xD3, // ...)....
|
|
/* 0EA8 */ 0x69, 0x84, 0x63, 0x03, 0xFB, 0x71, 0x0B, 0x38, // i.c..q.8
|
|
/* 0EB0 */ 0x1D, 0xCC, 0xE0, 0xDC, 0x7F, 0xD8, 0x2D, 0x1A, // ......-.
|
|
/* 0EB8 */ 0x37, 0x34, 0xB0, 0x0D, 0xCC, 0x43, 0x03, 0x3E, // 74...C.>
|
|
/* 0EC0 */ 0x27, 0x47, 0x30, 0x9E, 0x98, 0xF8, 0x55, 0xE2, // 'G0...U.
|
|
/* 0EC8 */ 0xE1, 0x89, 0x1F, 0x43, 0xC0, 0xFA, 0xFF, 0x3F, // ...C...?
|
|
/* 0ED0 */ 0x99, 0x01, 0xF6, 0x84, 0x1E, 0xCB, 0x50, 0xD2, // ......P.
|
|
/* 0ED8 */ 0x4E, 0x66, 0x80, 0xC0, 0xFB, 0xD8, 0x3B, 0xC3, // Nf....;.
|
|
/* 0EE0 */ 0x4B, 0x83, 0xE7, 0x74, 0xD2, 0xCF, 0x62, 0x3E, // K..t..b>
|
|
/* 0EE8 */ 0x99, 0x19, 0x21, 0x0A, 0xBB, 0x8F, 0x19, 0xAD, // ..!.....
|
|
/* 0EF0 */ 0x37, 0x14, 0xCD, 0x3C, 0xE8, 0x3B, 0x99, 0x51, // 7..<.;.Q
|
|
/* 0EF8 */ 0x62, 0x46, 0x6A, 0x0E, 0x4C, 0x48, 0x11, 0x0F, // bFj.LH..
|
|
/* 0F00 */ 0x27, 0x4A, 0x88, 0x60, 0xAF, 0x13, 0x6F, 0x67, // 'J.`..og
|
|
/* 0F08 */ 0x4F, 0x66, 0x4C, 0xD6, 0xC9, 0x0C, 0x24, 0xFF, // OfL...$.
|
|
/* 0F10 */ 0xFF, 0x93, 0x19, 0x98, 0x5C, 0x9F, 0xCC, 0x80, // ....\...
|
|
/* 0F18 */ 0xCA, 0x39, 0x0A, 0x7F, 0x32, 0x03, 0x78, 0x74, // .9..2.xt
|
|
/* 0F20 */ 0xC0, 0xC2, 0x9D, 0xCC, 0xC0, 0xF2, 0xFF, 0x3F, // .......?
|
|
/* 0F28 */ 0xC4, 0x00, 0xCE, 0xC7, 0x0A, 0x63, 0x0C, 0x3C, // .....c.<
|
|
/* 0F30 */ 0xDA, 0xC1, 0x0C, 0x15, 0xE6, 0x6C, 0x86, 0x0E, // .....l..
|
|
/* 0F38 */ 0x72, 0x08, 0xA1, 0xC1, 0x0E, 0x21, 0x50, 0xE6, // r....!P.
|
|
/* 0F40 */ 0x72, 0xA0, 0xA7, 0xF0, 0x9A, 0xE0, 0x73, 0x14, // r.....s.
|
|
/* 0F48 */ 0xD8, 0x0F, 0x67, 0xC0, 0xE1, 0xD4, 0x80, 0x0F, // ..g.....
|
|
/* 0F50 */ 0x74, 0xE2, 0x42, 0x8F, 0xC2, 0x23, 0x0E, 0x58, // t.B..#.X
|
|
/* 0F58 */ 0xFD, 0xC0, 0xC8, 0xFF, 0xFF, 0x64, 0x06, 0x18, // .....d..
|
|
/* 0F60 */ 0x78, 0x6A, 0xF8, 0x40, 0x82, 0x63, 0x31, 0xEA, // xj.@.c1.
|
|
/* 0F68 */ 0x1B, 0xC4, 0x21, 0xBE, 0x8D, 0xF8, 0xE8, 0xFE, // ..!.....
|
|
/* 0F70 */ 0x6A, 0xE2, 0x4B, 0x00, 0xE6, 0x42, 0xE2, 0xD3, // j.K..B..
|
|
/* 0F78 */ 0x09, 0xB3, 0x70, 0x38, 0x03, 0x5A, 0x43, 0x60, // ..p8.ZC`
|
|
/* 0F80 */ 0x57, 0x26, 0xCF, 0x9C, 0x0F, 0xE1, 0x6C, 0x3C, // W&....l<
|
|
/* 0F88 */ 0x7A, 0xDC, 0xE9, 0x04, 0xDE, 0x38, 0x7C, 0x3A, // z....8|:
|
|
/* 0F90 */ 0x01, 0x5E, 0x07, 0x0C, 0xCC, 0x0C, 0xC2, 0x3F, // .^.....?
|
|
/* 0F98 */ 0x84, 0xB0, 0x21, 0x9C, 0xAA, 0xC7, 0x70, 0xEE, // ..!...p.
|
|
/* 0FA0 */ 0xAF, 0x38, 0x3E, 0x9D, 0x80, 0xF3, 0xFF, 0x7F, // .8>.....
|
|
/* 0FA8 */ 0x62, 0x03, 0x0C, 0x0A, 0x7E, 0x32, 0xF8, 0xB8, // b...~2..
|
|
/* 0FB0 */ 0x46, 0x25, 0xC2, 0xA0, 0x8E, 0xE6, 0x80, 0x7B, // F%.....{
|
|
/* 0FB8 */ 0x98, 0x27, 0x36, 0x26, 0x6F, 0xC5, 0x1A, 0x8B, // .'6&o...
|
|
/* 0FC0 */ 0x4F, 0x6C, 0x30, 0xFF, 0xFF, 0x27, 0x36, 0x80, // Ol0..'6.
|
|
/* 0FC8 */ 0xD1, 0x87, 0x20, 0xB0, 0xFD, 0xFF, 0x0F, 0x41, // .. ....A
|
|
/* 0FD0 */ 0x60, 0x1C, 0xA0, 0x0F, 0x41, 0x80, 0x9B, 0xD3, // `...A...
|
|
/* 0FD8 */ 0x09, 0xEE, 0xC4, 0x07, 0xB6, 0x63, 0x10, 0x60, // .....c.`
|
|
/* 0FE0 */ 0x6D, 0xE8, 0x3E, 0x06, 0x81, 0xF9, 0xFF, 0x3F, // m.>....?
|
|
/* 0FE8 */ 0x5A, 0x98, 0xA3, 0xE0, 0xC2, 0x8E, 0x7C, 0x28, // Z.....|(
|
|
/* 0FF0 */ 0x29, 0xA7, 0x3E, 0xB4, 0x0C, 0x20, 0x69, 0x38, // ).>.. i8
|
|
/* 0FF8 */ 0xC9, 0x01, 0x9D, 0xD3, 0x3D, 0x70, 0x92, 0x75, // ....=p.u
|
|
/* 1000 */ 0xEA, 0x40, 0x8F, 0xC7, 0xA0, 0xAF, 0x1C, 0xBE, // .@......
|
|
/* 1008 */ 0x12, 0xF0, 0x23, 0x07, 0x93, 0x00, 0xAA, 0x41, // ..#....A
|
|
/* 1010 */ 0xFA, 0xCC, 0x07, 0x9C, 0x8E, 0x1C, 0xE0, 0x38, // .......8
|
|
/* 1018 */ 0x26, 0x05, 0xC6, 0xDE, 0x0E, 0xDE, 0x22, 0x3D, // &....."=
|
|
/* 1020 */ 0x89, 0xA7, 0xA1, 0xE3, 0x0C, 0x51, 0x38, 0x26, // .....Q8&
|
|
/* 1028 */ 0x39, 0x18, 0x44, 0x7A, 0x95, 0x62, 0x03, 0x7C, // 9.Dz.b.|
|
|
/* 1030 */ 0xAB, 0xF1, 0xD9, 0xC8, 0x07, 0x10, 0x78, 0xE3, // ......x.
|
|
/* 1038 */ 0xF6, 0xD8, 0x61, 0xFF, 0xFF, 0x0F, 0x75, 0xC0, // ..a...u.
|
|
/* 1040 */ 0x01, 0xE2, 0xA4, 0xF8, 0x21, 0xC3, 0x98, 0x67, // ....!..g
|
|
/* 1048 */ 0xC5, 0x0F, 0x75, 0x80, 0xF5, 0x18, 0x27, 0x3A, // ..u...':
|
|
/* 1050 */ 0x94, 0xF0, 0x43, 0x1D, 0x20, 0xE8, 0xFF, 0x7F, // ..C. ...
|
|
/* 1058 */ 0xA8, 0x03, 0x86, 0x38, 0x6F, 0x24, 0xD1, 0x1E, // ...8o$..
|
|
/* 1060 */ 0xEA, 0x98, 0xE8, 0x43, 0x1D, 0x40, 0xC8, 0xFF, // ...C.@..
|
|
/* 1068 */ 0xFF, 0xA1, 0x0E, 0x18, 0x9E, 0x87, 0x00, 0xAE, // ........
|
|
/* 1070 */ 0x9C, 0xEF, 0xC0, 0x7C, 0x22, 0x02, 0xEF, 0xFF, // ...|"...
|
|
/* 1078 */ 0xFF, 0x7C, 0x07, 0xB8, 0x1B, 0x2D, 0xCC, 0x51, // .|...-.Q
|
|
/* 1080 */ 0x70, 0x41, 0xAF, 0x0E, 0x03, 0x51, 0x09, 0x30, // pA...Q.0
|
|
/* 1088 */ 0x28, 0x02, 0xC7, 0x5F, 0x9B, 0x60, 0x1C, 0xEA, // (.._.`..
|
|
/* 1090 */ 0x7C, 0x87, 0x3E, 0x2F, 0x78, 0xD8, 0x4F, 0x05, // |.>/x.O.
|
|
/* 1098 */ 0x9E, 0xC4, 0xA9, 0xFA, 0x5A, 0x70, 0x14, 0x4F, // ....Zp.O
|
|
/* 10A0 */ 0x00, 0x3E, 0xE1, 0x01, 0xFF, 0xA1, 0xC1, 0x9A, // .>......
|
|
/* 10A8 */ 0x44, 0xF1, 0x43, 0x03, 0xF5, 0x11, 0xE4, 0xFF, // D.C.....
|
|
/* 10B0 */ 0x7F, 0x68, 0xC0, 0x28, 0xEA, 0xF9, 0x06, 0x7D, // .h.(...}
|
|
/* 10B8 */ 0xCC, 0xF2, 0xD9, 0x20, 0xE6, 0x0B, 0x48, 0x84, // ... ..H.
|
|
/* 10C0 */ 0x07, 0x10, 0x5F, 0x1F, 0xD8, 0x71, 0xD2, 0x67, // .._..q.g
|
|
/* 10C8 */ 0xA0, 0x40, 0x51, 0xDE, 0x37, 0xF8, 0x09, 0x07, // .@Q.7...
|
|
/* 10D0 */ 0x5C, 0x83, 0xF3, 0x09, 0x07, 0xBC, 0x87, 0x23, // \......#
|
|
/* 10D8 */ 0x1F, 0x4B, 0xC0, 0x77, 0xD0, 0x84, 0x73, 0x81, // .K.w..s.
|
|
/* 10E0 */ 0xF1, 0x8D, 0x8D, 0x9D, 0x06, 0xC0, 0x76, 0x00, // ......v.
|
|
/* 10E8 */ 0x06, 0xDF, 0x69, 0x00, 0x1C, 0xC7, 0x24, 0x7E, // ..i...$~
|
|
/* 10F0 */ 0x3A, 0x04, 0x13, 0xCC, 0xC1, 0xBC, 0x34, 0xFB, // :.....4.
|
|
/* 10F8 */ 0xFF, 0xEF, 0xFD, 0x94, 0x43, 0xCF, 0x86, 0x80, // ....C...
|
|
/* 1100 */ 0x75, 0x49, 0x07, 0x43, 0x94, 0x88, 0xB3, 0x21, // uI.C...!
|
|
/* 1108 */ 0x20, 0xFD, 0xFF, 0x7F, 0x36, 0xC4, 0x20, 0xC4, // ...6. .
|
|
/* 1110 */ 0x09, 0xFC, 0x12, 0xD1, 0xDC, 0xD9, 0x90, 0xAE, // ........
|
|
/* 1118 */ 0xD8, 0x67, 0x43, 0x80, 0xE1, 0xFF, 0xFF, 0x23, // .gC....#
|
|
/* 1120 */ 0x00, 0xF6, 0x7C, 0x04, 0x38, 0x3D, 0x64, 0x83, // ..|.8=d.
|
|
/* 1128 */ 0xE7, 0x14, 0x08, 0xE3, 0xE4, 0x03, 0x38, 0xFE, // ......8.
|
|
/* 1130 */ 0xFF, 0x8F, 0x15, 0xE6, 0x18, 0x78, 0xEA, 0x97, // .....x..
|
|
/* 1138 */ 0x9B, 0x8F, 0x03, 0x54, 0xD4, 0x2B, 0xC2, 0x30, // ...T.+.0
|
|
/* 1140 */ 0x94, 0xC5, 0x87, 0x05, 0x1F, 0x11, 0xF8, 0x61, // .......a
|
|
/* 1148 */ 0xC1, 0x23, 0xA8, 0x78, 0x9C, 0xF4, 0x74, 0xE3, // .#.x..t.
|
|
/* 1150 */ 0x33, 0x21, 0x3B, 0x24, 0x38, 0xFC, 0x20, 0xE9, // 3!;$8. .
|
|
/* 1158 */ 0x41, 0x13, 0x3C, 0xE7, 0x23, 0x78, 0xB7, 0x1E, // A.<.#x..
|
|
/* 1160 */ 0x38, 0xA7, 0x02, 0xC0, 0x4D, 0xAE, 0x27, 0xA3, // 8...M.'.
|
|
/* 1168 */ 0x4E, 0x17, 0x0E, 0x70, 0x8E, 0x92, 0x8D, 0x63, // N..p...c
|
|
/* 1170 */ 0x08, 0xE5, 0x70, 0xCC, 0xB7, 0x87, 0xA6, 0xC9, // ..p.....
|
|
/* 1178 */ 0x4E, 0x56, 0x30, 0x63, 0x41, 0xEA, 0x24, 0xE0, // NV0cA.$.
|
|
/* 1180 */ 0x01, 0x38, 0x10, 0x8C, 0xB4, 0x93, 0x68, 0x34, // .8....h4
|
|
/* 1188 */ 0x86, 0xB3, 0x5A, 0x18, 0xC1, 0x19, 0xC4, 0xC7, // ..Z.....
|
|
/* 1190 */ 0x11, 0xE7, 0x3A, 0x19, 0xA1, 0x3F, 0x07, 0x3E, // ..:..?.>
|
|
/* 1198 */ 0x15, 0x61, 0x82, 0xDC, 0x4B, 0xE8, 0xBC, 0x7D, // .a..K..}
|
|
/* 11A0 */ 0x37, 0xE0, 0x57, 0x61, 0x8F, 0xC5, 0xFF, 0x7F, // 7.Wa....
|
|
/* 11A8 */ 0x60, 0xDF, 0x4E, 0xC0, 0x31, 0x17, 0xAB, 0x01, // `.N.1...
|
|
/* 11B0 */ 0x45, 0x0D, 0xC0, 0x68, 0x98, 0x53, 0xC0, 0x53, // E..h.S.S
|
|
/* 11B8 */ 0x09, 0xB8, 0x82, 0xCD, 0x0D, 0x7D, 0x61, 0xB1, // .....}a.
|
|
/* 11C0 */ 0xD6, 0xA9, 0xE8, 0x14, 0xF4, 0x3E, 0x70, 0x70, // .....>pp
|
|
/* 11C8 */ 0xC0, 0x63, 0xF6, 0x1E, 0x1C, 0x2C, 0x34, 0x0F, // .c...,4.
|
|
/* 11D0 */ 0x0E, 0x6C, 0xD9, 0x06, 0x87, 0x56, 0x72, 0x17, // .l...Vr.
|
|
/* 11D8 */ 0x21, 0x87, 0x0F, 0xFC, 0xEC, 0x80, 0x03, 0xA0, // !.......
|
|
/* 11E0 */ 0x67, 0x07, 0x0B, 0xC9, 0xB3, 0x03, 0x9B, 0xBE, // g.......
|
|
/* 11E8 */ 0xB3, 0x08, 0x28, 0x70, 0xFE, 0xFF, 0x11, 0xDE, // ..(p....
|
|
/* 11F0 */ 0x3B, 0x7C, 0x6E, 0x79, 0xF6, 0x60, 0x63, 0x78, // ;|ny.`cx
|
|
/* 11F8 */ 0x74, 0x31, 0x9A, 0xD1, 0xB9, 0xA6, 0xDB, 0x04, // t1......
|
|
/* 1200 */ 0x4A, 0xC5, 0x6D, 0x82, 0x82, 0xF8, 0x06, 0xE0, // J.m.....
|
|
/* 1208 */ 0x84, 0x34, 0xBA, 0x75, 0xE2, 0x66, 0x62, 0xFC, // .4.u.fb.
|
|
/* 1210 */ 0x47, 0x0C, 0x1F, 0x11, 0x0E, 0xE9, 0x6C, 0x4D, // G.....lM
|
|
/* 1218 */ 0x30, 0x0F, 0xA4, 0x9E, 0x81, 0xBE, 0xB3, 0xE1, // 0.......
|
|
/* 1220 */ 0x67, 0x1F, 0xF2, 0xC1, 0xC5, 0xD3, 0xF0, 0xF5, // g.......
|
|
/* 1228 */ 0x86, 0xDC, 0x3B, 0xE8, 0xB4, 0x7D, 0x66, 0xC0, // ..;..}f.
|
|
/* 1230 */ 0x1C, 0x74, 0x7D, 0x9D, 0x7A, 0x83, 0x27, 0x57, // .t}.z.'W
|
|
/* 1238 */ 0x09, 0xEA, 0xE1, 0x02, 0x42, 0x2F, 0x34, 0xBE, // ....B/4.
|
|
/* 1240 */ 0xDC, 0x25, 0x78, 0xE0, 0xF4, 0xE9, 0xEE, 0xBD, // .%x.....
|
|
/* 1248 */ 0x84, 0x9D, 0xF1, 0x12, 0xBC, 0xE0, 0x25, 0x98, // ......%.
|
|
/* 1250 */ 0x77, 0x10, 0xA8, 0x51, 0x79, 0x10, 0x98, 0xAB, // w..Qy...
|
|
/* 1258 */ 0x3C, 0xCB, 0x37, 0x06, 0x54, 0xB2, 0x8B, 0x16, // <.7.T...
|
|
/* 1260 */ 0x3D, 0xC3, 0xBC, 0xC3, 0xF8, 0x92, 0xE0, 0xEB, // =.......
|
|
/* 1268 */ 0x87, 0xCF, 0x2D, 0x5E, 0xC0, 0xEB, 0x16, 0x0C, // ..-^....
|
|
/* 1270 */ 0x82, 0x67, 0xA0, 0x57, 0x17, 0xDF, 0xD9, 0x0D, // .g.W....
|
|
/* 1278 */ 0xFC, 0x2A, 0xF0, 0x46, 0x13, 0x22, 0x98, 0x61, // .*.F.".a
|
|
/* 1280 */ 0x0F, 0xFF, 0xDD, 0xDD, 0xA8, 0xBE, 0xE9, 0x18, // ........
|
|
/* 1288 */ 0xEB, 0x75, 0xC4, 0x23, 0xE5, 0xC7, 0x96, 0x03, // .u.#....
|
|
/* 1290 */ 0x8A, 0xF4, 0xF2, 0xE6, 0x09, 0xF8, 0x2C, 0xE3, // ......,.
|
|
/* 1298 */ 0x53, 0xDD, 0x49, 0xF9, 0x7A, 0x68, 0xF4, 0x57, // S.I.zh.W
|
|
/* 12A0 */ 0x08, 0x1F, 0x7E, 0x8C, 0xEC, 0x73, 0x0E, 0x3B, // ..~..s.;
|
|
/* 12A8 */ 0xDF, 0xB1, 0x41, 0x71, 0xC4, 0x07, 0x86, 0x97, // ..Aq....
|
|
/* 12B0 */ 0x1A, 0x4F, 0x85, 0x9D, 0xBB, 0x60, 0x1C, 0x1C, // .O...`..
|
|
/* 12B8 */ 0xD8, 0xB1, 0x08, 0x73, 0x7C, 0x05, 0xD7, 0xC9, // ...s|...
|
|
/* 12C0 */ 0xE6, 0xFF, 0xFF, 0xE4, 0x00, 0x6E, 0x78, 0xCC, // .....nx.
|
|
/* 12C8 */ 0xC1, 0xD7, 0xE7, 0x0D, 0xDF, 0x0C, 0x3C, 0x2E, // ......<.
|
|
/* 12D0 */ 0x7E, 0xE4, 0xF0, 0x49, 0xE3, 0xA5, 0xD3, 0xD8, // ~..I....
|
|
/* 12D8 */ 0xA7, 0xE9, 0xA3, 0xD1, 0xCB, 0x9B, 0x4F, 0x2F, // ......O/
|
|
/* 12E0 */ 0x18, 0x58, 0x5F, 0x1A, 0x38, 0xAC, 0xD1, 0xC2, // .X_.8...
|
|
/* 12E8 */ 0x3E, 0x06, 0x9C, 0xB9, 0x2F, 0x44, 0xB8, 0xC3, // >.../D..
|
|
/* 12F0 */ 0x23, 0x58, 0x00, 0xF1, 0xB7, 0x92, 0x47, 0x0E, // #X....G.
|
|
/* 12F8 */ 0x4F, 0xC0, 0x80, 0x4C, 0xD3, 0xBA, 0x74, 0x20, // O..L..t
|
|
/* 1300 */ 0xE2, 0xA7, 0x3C, 0x2B, 0x5F, 0x99, 0x2E, 0x43, // ..<+_..C
|
|
/* 1308 */ 0x0C, 0xE3, 0xA9, 0xF2, 0xF1, 0xC3, 0xB3, 0xF1, // ........
|
|
/* 1310 */ 0x51, 0xC0, 0xC7, 0x28, 0xCF, 0xFC, 0x8C, 0x22, // Q..(..."
|
|
/* 1318 */ 0xBD, 0x32, 0x10, 0x50, 0x9D, 0x88, 0xB8, 0x42, // .2.P...B
|
|
/* 1320 */ 0x18, 0x89, 0xA1, 0xD1, 0x9D, 0x83, 0xC7, 0x1F, // ........
|
|
/* 1328 */ 0x22, 0x05, 0x31, 0xA0, 0x6F, 0x2E, 0xC0, 0xF4, // ".1.o...
|
|
/* 1330 */ 0x4C, 0x04, 0x5C, 0xFE, 0xFF, 0x37, 0x17, 0x80, // L.\..7..
|
|
/* 1338 */ 0xFF, 0xFF, 0xFF, 0x9B, 0x0B, 0xE0, 0xE6, 0xFE, // ........
|
|
/* 1340 */ 0xE0, 0x9B, 0x0B, 0x70, 0x8D, 0xB4, 0x2A, 0x7A, // ...p..*z
|
|
/* 1348 */ 0x61, 0x77, 0x08, 0x18, 0xD4, 0x9D, 0x1D, 0x70, // aw.....p
|
|
/* 1350 */ 0x78, 0x2B, 0x78, 0x67, 0x87, 0xF5, 0xFF, 0xBF, // x+xg....
|
|
/* 1358 */ 0xB3, 0xC3, 0xC3, 0x8C, 0x13, 0xE5, 0x85, 0x21, // .......!
|
|
/* 1360 */ 0xC6, 0x3B, 0x3B, 0x0B, 0xF0, 0x26, 0xD0, 0x51, // .;;..&.Q
|
|
/* 1368 */ 0xC6, 0x77, 0x76, 0x80, 0x1F, 0x67, 0xD8, 0x77, // .wv..g.w
|
|
/* 1370 */ 0x69, 0xF0, 0x5E, 0x75, 0x81, 0xF5, 0xFF, 0xFF, // i.^u....
|
|
/* 1378 */ 0xAA, 0x0B, 0x3C, 0x04, 0xDF, 0xA7, 0x41, 0x3E, // ..<...A>
|
|
/* 1380 */ 0x5E, 0x30, 0x8C, 0x83, 0x2B, 0x27, 0xA1, 0xC7, // ^0..+'..
|
|
/* 1388 */ 0x02, 0x6B, 0x85, 0x41, 0xDD, 0xA9, 0xC1, 0xA5, // .k.A....
|
|
/* 1390 */ 0x09, 0x5C, 0x17, 0x5F, 0x1F, 0x6A, 0x7C, 0xA4, // .\._.j|.
|
|
/* 1398 */ 0xC5, 0x9F, 0x2F, 0x70, 0x01, 0x86, 0x4C, 0x4F, // ../p..LO
|
|
/* 13A0 */ 0x65, 0x30, 0xAE, 0x29, 0x3E, 0x95, 0x61, 0xEE, // e0.)>.a.
|
|
/* 13A8 */ 0x0E, 0x1E, 0x90, 0x8F, 0x18, 0xC0, 0x67, 0x15, // ......g.
|
|
/* 13B0 */ 0x1E, 0x18, 0xEE, 0xB4, 0xE0, 0x9B, 0x92, 0x41, // .......A
|
|
/* 13B8 */ 0xCF, 0x31, 0xA8, 0x8F, 0x3C, 0x27, 0xEF, 0x7B, // .1..<'.{
|
|
/* 13C0 */ 0xC2, 0xE3, 0x84, 0xA3, 0x9E, 0x83, 0xE8, 0xD8, // ........
|
|
/* 13C8 */ 0xC0, 0x71, 0xDC, 0xC0, 0xFD, 0xFF, 0xC7, 0x06, // .q......
|
|
/* 13D0 */ 0xEF, 0x70, 0x83, 0x3B, 0xE8, 0xF8, 0x62, 0x70, // .p.;..bp
|
|
/* 13D8 */ 0x5C, 0x18, 0xB8, 0xE7, 0x02, 0x0F, 0xC3, 0x37, // \......7
|
|
/* 13E0 */ 0x1D, 0x8F, 0x08, 0x33, 0xFE, 0xD7, 0x3F, 0x23, // ...3..?#
|
|
/* 13E8 */ 0x04, 0xC4, 0x5F, 0x8C, 0xD8, 0x80, 0xC1, 0x78, // .._....x
|
|
/* 13F0 */ 0x6B, 0xF3, 0xF5, 0x0D, 0x37, 0x60, 0x5F, 0x1D, // k...7`_.
|
|
/* 13F8 */ 0x7C, 0xC1, 0xF0, 0x09, 0xCC, 0xE8, 0x2F, 0x30, // |...../0
|
|
/* 1400 */ 0x4F, 0x62, 0x3E, 0x36, 0x90, 0x0B, 0x1C, 0x1D, // Ob>6....
|
|
/* 1408 */ 0x30, 0x38, 0x00, 0x3D, 0x60, 0xF8, 0x87, 0x8B, // 08.=`...
|
|
/* 1410 */ 0x77, 0x39, 0x30, 0x5C, 0x05, 0x7D, 0x5C, 0xF0, // w90\.}\.
|
|
/* 1418 */ 0xB1, 0xC7, 0x8A, 0xEE, 0x72, 0xE8, 0x9B, 0x9C, // ....r...
|
|
/* 1420 */ 0x61, 0xE2, 0x18, 0xE2, 0x0D, 0x8C, 0xDD, 0x25, // a......%
|
|
/* 1428 */ 0xC8, 0x61, 0x0E, 0xEA, 0x5D, 0xC2, 0x73, 0xE0, // .a..].s.
|
|
/* 1430 */ 0x67, 0x0B, 0x9F, 0xE0, 0x7C, 0xF3, 0x09, 0x71, // g...|..q
|
|
/* 1438 */ 0xAA, 0x8F, 0x56, 0xEF, 0x01, 0x3E, 0x7A, 0xBC, // ..V..>z.
|
|
/* 1440 */ 0x77, 0xF9, 0xEC, 0xC4, 0x2E, 0x02, 0x3E, 0x72, // w.....>r
|
|
/* 1448 */ 0x19, 0xC7, 0xD3, 0xF4, 0x15, 0xD0, 0x43, 0x36, // ......C6
|
|
/* 1450 */ 0xD8, 0xAB, 0x86, 0x4F, 0x60, 0x3E, 0xBA, 0xE1, // ...O`>..
|
|
/* 1458 */ 0x8E, 0x51, 0x9E, 0x89, 0xA7, 0xEF, 0x3B, 0x08, // .Q....;.
|
|
/* 1460 */ 0x3B, 0x92, 0x1C, 0x75, 0xA8, 0x6B, 0x7A, 0x44, // ;..u.kzD
|
|
/* 1468 */ 0xF9, 0xFF, 0x9F, 0xD0, 0x81, 0xF8, 0xD6, 0x06, // ........
|
|
/* 1470 */ 0xCE, 0x68, 0xF7, 0x0F, 0xF4, 0x36, 0x3D, 0x32, // .h...6=2
|
|
/* 1478 */ 0xCC, 0xD1, 0x00, 0xD6, 0x25, 0x04, 0x5C, 0x77, // ....%.\w
|
|
/* 1480 */ 0x0C, 0x5F, 0x42, 0x80, 0x4F, 0xD0, 0x4B, 0x04, // ._B.O.K.
|
|
/* 1488 */ 0xFA, 0x9A, 0xE1, 0xD1, 0x3D, 0x02, 0x60, 0xAE, // ....=.`.
|
|
/* 1490 */ 0x18, 0xEC, 0x58, 0xE0, 0xC3, 0x86, 0xAF, 0x01, // ..X.....
|
|
/* 1498 */ 0xEC, 0x5E, 0xE0, 0x30, 0xF7, 0x08, 0x50, 0x81, // .^.0..P.
|
|
/* 14A0 */ 0x7A, 0x78, 0xF0, 0xD5, 0xDE, 0x23, 0x40, 0x71, // zx...#@q
|
|
/* 14A8 */ 0xB2, 0xF4, 0xA1, 0xC1, 0x03, 0xB5, 0xAA, 0x33, // .......3
|
|
/* 14B0 */ 0x26, 0x94, 0x23, 0x26, 0x3F, 0x9B, 0xF9, 0x26, // &.#&?..&
|
|
/* 14B8 */ 0x81, 0xB9, 0x5D, 0xFA, 0x26, 0x01, 0x37, 0xCF, // ..].&.7.
|
|
/* 14C0 */ 0x2C, 0x50, 0x49, 0x20, 0xF4, 0xFF, 0xBF, 0x49, // ,PI ...I
|
|
/* 14C8 */ 0xC0, 0x85, 0xE9, 0xF2, 0x32, 0x43, 0xE7, 0x7F, // ....2C..
|
|
/* 14D0 */ 0xE0, 0xBE, 0xD5, 0x79, 0x84, 0x3E, 0x44, 0x30, // ...y.>D0
|
|
/* 14D8 */ 0x94, 0xF7, 0x3C, 0x9F, 0xC2, 0xF8, 0x19, 0xC2, // ..<.....
|
|
/* 14E0 */ 0x07, 0x4C, 0x76, 0xA6, 0xE0, 0x67, 0x4D, 0xDC, // .Lv..gM.
|
|
/* 14E8 */ 0x1D, 0xC0, 0x28, 0x6F, 0x9E, 0x9E, 0x00, 0x3B, // ..(o...;
|
|
/* 14F0 */ 0x7F, 0x1A, 0xF9, 0xDD, 0xE0, 0x5D, 0xC0, 0xD3, // .....]..
|
|
/* 14F8 */ 0xF7, 0xBD, 0x88, 0x9F, 0x28, 0xC0, 0x17, 0xEC, // ....(...
|
|
/* 1500 */ 0x4E, 0x07, 0x05, 0xFA, 0x84, 0x3C, 0x22, 0xA3, // N....<".
|
|
/* 1508 */ 0xFA, 0x88, 0xC0, 0x2F, 0x49, 0x60, 0x3C, 0x92, // .../I`<.
|
|
/* 1510 */ 0xF8, 0x40, 0x01, 0x84, 0xEE, 0x05, 0xA8, 0xD3, // .@......
|
|
/* 1518 */ 0x07, 0x47, 0x3D, 0xE3, 0x17, 0x54, 0x63, 0xBE, // .G=..Tc.
|
|
/* 1520 */ 0x5B, 0x3D, 0xC2, 0x79, 0x72, 0x98, 0xCB, 0x01, // [=.yr...
|
|
/* 1528 */ 0x8B, 0x73, 0x4D, 0x02, 0xD5, 0x71, 0x97, 0x8F, // .sM..q..
|
|
/* 1530 */ 0x0E, 0xEE, 0xB5, 0x15, 0xFB, 0xFF, 0x27, 0x38, // ......'8
|
|
/* 1538 */ 0xB8, 0x77, 0x96, 0x77, 0x3E, 0x43, 0x79, 0x90, // .w.w>Cy.
|
|
/* 1540 */ 0xE0, 0xBB, 0xB6, 0x82, 0xE3, 0xAA, 0x06, 0xE3, // ........
|
|
/* 1548 */ 0xD8, 0xC2, 0x2F, 0x79, 0x80, 0x9D, 0x61, 0x71, // ../y..aq
|
|
/* 1550 */ 0xC1, 0x7F, 0x0F, 0x03, 0x51, 0x89, 0x30, 0x28, // ....Q.0(
|
|
/* 1558 */ 0x02, 0xCB, 0xBB, 0xB7, 0x52, 0xF8, 0x43, 0x06, // ....R.C.
|
|
/* 1560 */ 0xE3, 0x4D, 0x81, 0x4F, 0x1A, 0x3B, 0x6A, 0xE0, // .M.O.;j.
|
|
/* 1568 */ 0xFB, 0xFF, 0x1F, 0x35, 0xD8, 0x86, 0x8A, 0xBB, // ...5....
|
|
/* 1570 */ 0x29, 0x82, 0x75, 0xAA, 0x98, 0x21, 0xF0, 0x60, // ).u..!.`
|
|
/* 1578 */ 0x0F, 0x00, 0x9F, 0xAF, 0x7C, 0x06, 0x50, 0x14, // ....|.P.
|
|
/* 1580 */ 0x18, 0xD4, 0xA1, 0x1D, 0xCE, 0x6D, 0x18, 0x70, // .....m.p
|
|
/* 1588 */ 0x30, 0x62, 0xDC, 0xA5, 0x10, 0xEE, 0x94, 0xDF, // 0b......
|
|
/* 1590 */ 0x51, 0x62, 0x3F, 0x97, 0xB3, 0xE9, 0xE2, 0xAE, // Qb?.....
|
|
/* 1598 */ 0xE6, 0x3E, 0x9D, 0xB0, 0x0B, 0x32, 0x8C, 0xB3, // .>...2..
|
|
/* 15A0 */ 0xC0, 0x23, 0xC0, 0xAB, 0x39, 0xBF, 0x20, 0x3F, // .#..9. ?
|
|
/* 15A8 */ 0x17, 0xBF, 0x10, 0x3C, 0x26, 0x85, 0x78, 0x53, // ...<&.xS
|
|
/* 15B0 */ 0x7A, 0x25, 0x36, 0xC6, 0x93, 0x71, 0x73, 0xB7, // z%6..qs.
|
|
/* 15B8 */ 0x62, 0x72, 0xDE, 0x79, 0x41, 0x36, 0xC6, 0xD1, // br.yA6..
|
|
/* 15C0 */ 0x44, 0x8C, 0x72, 0x6E, 0x0F, 0x03, 0x91, 0x5F, // D.rn..._
|
|
/* 15C8 */ 0x90, 0x7D, 0x3F, 0x79, 0x21, 0x88, 0x18, 0xCD, // .}?y!...
|
|
/* 15D0 */ 0x10, 0x41, 0x9F, 0x97, 0x8D, 0x15, 0x28, 0xDE, // .A....(.
|
|
/* 15D8 */ 0x0B, 0x32, 0x13, 0xF8, 0x56, 0xD0, 0xC1, 0xC5, // .2..V...
|
|
/* 15E0 */ 0x17, 0x64, 0xEC, 0xFF, 0xFF, 0x82, 0x0C, 0x30, // .d.....0
|
|
/* 15E8 */ 0xE2, 0x64, 0x04, 0xF8, 0x3C, 0x71, 0xE0, 0xCE, // .d..<q..
|
|
/* 15F0 */ 0x35, 0x30, 0xFE, 0xFF, 0x97, 0x6A, 0xD8, 0x27, // 50...j.'
|
|
/* 15F8 */ 0x1B, 0xC0, 0xD9, 0xD0, 0x7D, 0xB2, 0x01, 0xF7, // ....}...
|
|
/* 1600 */ 0x68, 0xE1, 0x1D, 0x4D, 0x10, 0x27, 0x1B, 0x0A, // h..M.'..
|
|
/* 1608 */ 0xE4, 0xE0, 0xEB, 0xA2, 0x70, 0x3C, 0xF4, 0x49, // ....p<.I
|
|
/* 1610 */ 0x84, 0x1E, 0x9D, 0x7C, 0x94, 0xC4, 0x9D, 0x19, // ...|....
|
|
/* 1618 */ 0x3C, 0x91, 0x77, 0x16, 0x8F, 0xE2, 0x65, 0xD0, // <.w...e.
|
|
/* 1620 */ 0xF7, 0x82, 0x13, 0x79, 0x7D, 0xB0, 0x9C, 0x63, // ...y}..c
|
|
/* 1628 */ 0x24, 0xA8, 0x46, 0xE2, 0xE3, 0x03, 0xFC, 0xEB, // $.F.....
|
|
/* 1630 */ 0x8B, 0x8F, 0x91, 0xF0, 0xF9, 0xFC, 0xC3, 0xF2, // ........
|
|
/* 1638 */ 0x60, 0x0C, 0xF9, 0xFF, 0x7F, 0x8A, 0xC4, 0x80, // `.......
|
|
/* 1640 */ 0x3C, 0xBB, 0x3C, 0x86, 0xF0, 0x0B, 0x24, 0xDC, // <.<...$.
|
|
/* 1648 */ 0xD3, 0xCC, 0x01, 0x60, 0x64, 0x5D, 0x1E, 0xD1, // ...`d]..
|
|
/* 1650 */ 0x67, 0x47, 0x8E, 0x11, 0xD7, 0x17, 0x45, 0x5F, // gG....E_
|
|
/* 1658 */ 0x81, 0x7D, 0x10, 0x38, 0x9F, 0xE7, 0x44, 0xB0, // .}.8..D.
|
|
/* 1660 */ 0x8E, 0x9A, 0x1F, 0x6D, 0xF8, 0xF8, 0x39, 0xF8, // ...m..9.
|
|
/* 1668 */ 0x5B, 0xC1, 0x03, 0xA5, 0x8F, 0x45, 0x21, 0x1E, // [....E!.
|
|
/* 1670 */ 0x91, 0xF8, 0x39, 0x11, 0x5C, 0x26, 0xCE, 0x89, // ..9.\&..
|
|
/* 1678 */ 0x40, 0xE2, 0xD0, 0x0B, 0xE3, 0xB4, 0x80, 0x1B, // @.......
|
|
/* 1680 */ 0x88, 0xCF, 0x94, 0xD8, 0x29, 0x9F, 0x08, 0x3B, // ....)..;
|
|
/* 1688 */ 0x97, 0x60, 0x46, 0x07, 0xAE, 0xCB, 0xBD, 0x47, // .`F....G
|
|
/* 1690 */ 0x07, 0xFE, 0x93, 0x00, 0x1E, 0xEB, 0xFF, 0xFF, // ........
|
|
/* 1698 */ 0x78, 0x07, 0xBE, 0x93, 0xBA, 0xEF, 0x26, 0xBE, // x.....&.
|
|
/* 16A0 */ 0xC8, 0xF8, 0x50, 0xF4, 0x7C, 0x07, 0xF8, 0x0F, // ..P.|...
|
|
/* 16A8 */ 0x77, 0xB8, 0x43, 0xC5, 0x39, 0xDF, 0x01, 0xD2, // w.C.9...
|
|
/* 16B0 */ 0xFE, 0xFF, 0xE7, 0x3B, 0x60, 0x79, 0xB6, 0x7E, // ...;`y.~
|
|
/* 16B8 */ 0xBE, 0x03, 0xBB, 0xC8, 0xF3, 0x1D, 0x40, 0xAC, // ......@.
|
|
/* 16C0 */ 0xFF, 0xFF, 0xF9, 0x0E, 0xB0, 0x73, 0x46, 0xC3, // .....sF.
|
|
/* 16C8 */ 0x9D, 0xEF, 0xC0, 0x76, 0xB4, 0x01, 0xCC, 0x4D, // ...v...M
|
|
/* 16D0 */ 0xE3, 0xD1, 0x06, 0xDC, 0xC3, 0x85, 0x3D, 0x0C, // ......=.
|
|
/* 16D8 */ 0xAE, 0xD0, 0xA6, 0x4F, 0x8D, 0x46, 0xAD, 0x1A, // ...O.F..
|
|
/* 16E0 */ 0x94, 0xA9, 0x51, 0xE6, 0xFF, 0xDF, 0xA0, 0x56, // ..Q....V
|
|
/* 16E8 */ 0x9F, 0x4A, 0x8D, 0x19, 0xCB, 0x0E, 0xA5, 0x80, // .J......
|
|
/* 16F0 */ 0x8F, 0x0A, 0x8D, 0xCD, 0xF2, 0x28, 0x04, 0x62, // .....(.b
|
|
/* 16F8 */ 0x31, 0xAF, 0x06, 0x81, 0x38, 0x2C, 0x08, 0x8D, // 1...8,..
|
|
/* 1700 */ 0xF4, 0xCA, 0x11, 0x88, 0x25, 0x3F, 0xFB, 0x05, // ....%?..
|
|
/* 1708 */ 0x62, 0xB9, 0x6F, 0x06, 0x81, 0x38, 0xE0, 0x1B, // b.o..8..
|
|
/* 1710 */ 0x4C, 0xE0, 0xE4, 0x61, 0x25, 0x70, 0xF2, 0x6E, // L..a%p.n
|
|
/* 1718 */ 0x10, 0x88, 0x23, 0x83, 0x50, 0xA1, 0x3A, 0x40, // ..#.P.:@
|
|
/* 1720 */ 0x58, 0x4C, 0x10, 0x1A, 0xCA, 0x07, 0x08, 0x93, // XL......
|
|
/* 1728 */ 0xFE, 0x48, 0x10, 0x20, 0x31, 0x02, 0xC2, 0xC2, // .H. 1...
|
|
/* 1730 */ 0xBD, 0xBF, 0x04, 0x62, 0x69, 0xEF, 0x09, 0x81, // ...bi...
|
|
/* 1738 */ 0x58, 0x88, 0x15, 0x10, 0x16, 0x17, 0x84, 0x86, // X.......
|
|
/* 1740 */ 0xD3, 0x02, 0xC2, 0x24, 0x99, 0x01, 0x61, 0x81, // ...$..a.
|
|
/* 1748 */ 0x40, 0xA8, 0x7C, 0x35, 0x20, 0x4C, 0xA4, 0x1B, // @.|5 L..
|
|
/* 1750 */ 0x40, 0xBA, 0x7A, 0x81, 0x38, 0x88, 0x1E, 0x10, // @.z.8...
|
|
/* 1758 */ 0x26, 0xC3, 0x0F, 0x08, 0x0B, 0x0D, 0x42, 0xA3, // &.....B.
|
|
/* 1760 */ 0x3D, 0x30, 0x04, 0x48, 0x0C, 0x81, 0xB0, 0xF8, // =0.H....
|
|
/* 1768 */ 0x8E, 0x40, 0x98, 0xF8, 0x57, 0x91, 0x40, 0x9C, // .@..W.@.
|
|
/* 1770 */ 0xDF, 0x12, 0xC4, 0x4D, 0x69, 0x88, 0x35, 0x01, // ...Mi.5.
|
|
/* 1778 */ 0x31, 0x0D, 0x9E, 0x80, 0x98, 0x22, 0x10, 0x01, // 1...."..
|
|
/* 1780 */ 0x39, 0xF6, 0xD3, 0x43, 0x40, 0xD6, 0x60, 0x0A, // 9..C@.`.
|
|
/* 1788 */ 0x88, 0x45, 0x07, 0x11, 0x90, 0x85, 0xA8, 0x02, // .E......
|
|
/* 1790 */ 0x62, 0x79, 0x5D, 0x01, 0xB1, 0xF0, 0x20, 0x02, // by]... .
|
|
/* 1798 */ 0x72, 0xE6, 0x97, 0x9F, 0x80, 0xAC, 0xE0, 0xA5, // r.......
|
|
/* 17A0 */ 0xF3, 0x10, 0xC0, 0xDE, 0x10, 0x81, 0x48, 0x72, // ......Hr
|
|
/* 17A8 */ 0x10, 0x01, 0x39, 0xB0, 0x2F, 0x20, 0x16, 0x1F, // ..9./ ..
|
|
/* 17B0 */ 0x44, 0x40, 0xCE, 0xFA, 0x28, 0x14, 0x90, 0x83, // D@..(...
|
|
/* 17B8 */ 0x83, 0x68, 0x10, 0xE4, 0x6B, 0x26, 0x20, 0xA7, // .h..k& .
|
|
/* 17C0 */ 0x07, 0x11, 0x10, 0xF9, 0x04, 0x05, 0x21, 0x6A, // ......!j
|
|
/* 17C8 */ 0xBD, 0x81, 0x30, 0x3D, 0x8F, 0x42, 0x0D, 0x85, // ..0=.B..
|
|
/* 17D0 */ 0x80, 0x50, 0xE5, 0xEA, 0xCE, 0x31, 0x2C, 0x07, // .P...1,.
|
|
/* 17D8 */ 0x08, 0xCD, 0x05, 0x22, 0x30, 0xAB, 0x70, 0x07, // ..."0.p.
|
|
/* 17E0 */ 0xC4, 0x54, 0x81, 0x08, 0xC8, 0x09, 0x80, 0xC8, // .T......
|
|
/* 17E8 */ 0xFF, 0x9F, 0x60, 0x2A, 0x10, 0x9A, 0x12, 0x8C, // ..`*....
|
|
/* 17F0 */ 0xEA, 0x92, 0x07, 0xC4, 0x12, 0x80, 0xD0, 0x54, // .......T
|
|
/* 17F8 */ 0x20, 0x34, 0x25, 0x88, 0x00, 0xAD, 0xCA, 0x1E, // 4%.....
|
|
/* 1800 */ 0x10, 0x53, 0x0A, 0x42, 0x95, 0x83, 0xD0, 0x74, // .S.B...t
|
|
/* 1808 */ 0x20, 0x54, 0xB6, 0xBE, 0xC3, 0x02, 0x05, 0x11, // T......
|
|
/* 1810 */ 0x90, 0xA3, 0x83, 0x50, 0xE1, 0xFE, 0x40, 0x98, // ...P..@.
|
|
/* 1818 */ 0xDE, 0x97, 0x86, 0x00, 0x9D, 0x0E, 0x44, 0x40, // ......D@
|
|
/* 1820 */ 0x4E, 0x0C, 0x42, 0x15, 0x7C, 0x32, 0x82, 0x10, // N.B.|2..
|
|
/* 1828 */ 0xB1, 0x20, 0x54, 0xC1, 0x27, 0x23, 0x28, 0xD1, // . T.'#(.
|
|
/* 1830 */ 0xF2, 0xB2, 0x13, 0x90, 0xF5, 0x81, 0x50, 0xBD, // ......P.
|
|
/* 1838 */ 0x20, 0x02, 0x73, 0x36, 0x20, 0x9A, 0x17, 0x84, // .s6 ...
|
|
/* 1840 */ 0xE6, 0x07, 0xA3, 0x5A, 0x8D, 0x02, 0x31, 0xFD, // ...Z..1.
|
|
/* 1848 */ 0x20, 0x34, 0x0F, 0x88, 0xC0, 0xAC, 0xE0, 0xF9, // 4......
|
|
/* 1850 */ 0x71, 0xC0, 0x0C, 0x84, 0xAA, 0x04, 0x11, 0x98, // q.......
|
|
/* 1858 */ 0x73, 0x01, 0xD1, 0xAC, 0x20, 0x34, 0x3B, 0x18, // s... 4;.
|
|
/* 1860 */ 0xD5, 0xFE, 0x0F, 0xD1, 0x00, 0x08, 0x08, 0xCD, // ........
|
|
/* 1868 */ 0x07, 0xA2, 0xC3, 0x00, 0x79, 0x96, 0x09, 0xC8, // ....y...
|
|
/* 1870 */ 0x1A, 0x41, 0xA8, 0x66, 0x10, 0x81, 0x39, 0x27, // .A.f..9'
|
|
/* 1878 */ 0x10, 0xCD, 0x0E, 0x42, 0x95, 0xFD, 0x4D, 0x82, // ...B..M.
|
|
/* 1880 */ 0x91, 0x8C, 0x0F, 0xD0, 0x40, 0x24, 0x37, 0x08, // ....@$7.
|
|
/* 1888 */ 0xD5, 0xF1, 0x0C, 0x0A, 0x46, 0x74, 0x83, 0x08, // ....Ft..
|
|
/* 1890 */ 0xC8, 0x59, 0x40, 0x68, 0x36, 0x30, 0x9A, 0x4C, // .Y@h60.L
|
|
/* 1898 */ 0xED, 0x91, 0x80, 0xBA, 0x05, 0x61, 0xE9, 0x41, // .....a.A
|
|
/* 18A0 */ 0x68, 0x3A, 0xBB, 0x83, 0xA7, 0x20, 0x54, 0x81, // h:... T.
|
|
/* 18A8 */ 0x5E, 0x30, 0xA6, 0x19, 0x44, 0x87, 0x05, 0x02, // ^0..D...
|
|
/* 18B0 */ 0x42, 0x73, 0x81, 0x51, 0x1D, 0xAF, 0x96, 0x40, // Bs.Q...@
|
|
/* 18B8 */ 0x44, 0x1B, 0x08, 0xD5, 0x0A, 0xA2, 0x81, 0x93, // D.......
|
|
/* 18C0 */ 0x1F, 0x53, 0x10, 0x92, 0x14, 0x84, 0xFC, 0xFF, // .S......
|
|
/* 18C8 */ 0x07, 0xAA, 0xC7, 0x9C, 0x40, 0xAC, 0xFA, 0x5B, // ....@..[
|
|
/* 18D0 */ 0x25, 0x50, 0x27, 0x01, 0xA1, 0xC9, 0x40, 0x74, // %P'...@t
|
|
/* 18D8 */ 0x7C, 0x20, 0x0F, 0xB8, 0x83, 0x64, 0x20, 0x54, // | ...d T
|
|
/* 18E0 */ 0x29, 0x88, 0xC0, 0xAC, 0xF4, 0x63, 0xA4, 0x23, // )....c.#
|
|
/* 18E8 */ 0x05, 0x51, 0x7D, 0xBC, 0xA0, 0x20, 0x34, 0xD1, // .Q}.. 4.
|
|
/* 18F0 */ 0x3B, 0x2C, 0x08, 0x7B, 0xB8, 0x69, 0xA8, 0xE4, // ;,.{.i..
|
|
/* 18F8 */ 0x59, 0xA5, 0xA1, 0x12, 0x10, 0x9A, 0x0D, 0x44, // Y......D
|
|
/* 1900 */ 0xC7, 0x04, 0xF2, 0xAA, 0x79, 0x4C, 0x60, 0x20, // ....yL`
|
|
/* 1908 */ 0x54, 0x2F, 0x08, 0xCD, 0x01, 0x42, 0x13, 0x83, // T/...B..
|
|
/* 1910 */ 0x08, 0xD4, 0xA9, 0xBF, 0x37, 0x1A, 0x2A, 0xF9, // ....7.*.
|
|
/* 1918 */ 0x5B, 0x09, 0xC4, 0xCA, 0x5E, 0x69, 0x02, 0xB1, // [...^i..
|
|
/* 1920 */ 0xDE, 0xA7, 0x4E, 0x20, 0xE6, 0x1D, 0x98, 0xA9, // ..N ....
|
|
/* 1928 */ 0x05, 0xA1, 0xEA, 0x41, 0x04, 0xE6, 0xB4, 0x40, // ...A...@
|
|
/* 1930 */ 0x54, 0x81, 0x78, 0x10, 0xA6, 0x08, 0x44, 0x60, // T.x...D`
|
|
/* 1938 */ 0x4E, 0x02, 0x44, 0xD3, 0x81, 0xD0, 0xEC, 0x60, // N.D....`
|
|
/* 1940 */ 0x54, 0xE7, 0xA3, 0x4D, 0x40, 0xD6, 0x0E, 0x42, // T..M@..B
|
|
/* 1948 */ 0xB3, 0x80, 0x08, 0xCC, 0x59, 0x1E, 0x69, 0x02, // ....Y.i.
|
|
/* 1950 */ 0xB1, 0x92, 0x2F, 0x9D, 0x0E, 0x24, 0x04, 0x84, // ../..$..
|
|
/* 1958 */ 0x26, 0xD3, 0x7F, 0x68, 0xA1, 0x05, 0x80, 0x99, // &..h....
|
|
/* 1960 */ 0x84, 0x04, 0x20, 0x4C, 0x16, 0x88, 0x0E, 0x27, // .. L...'
|
|
/* 1968 */ 0xD6, 0x08, 0x22, 0x40, 0xC7, 0x01, 0xA3, 0xD1, // .."@....
|
|
/* 1970 */ 0x40, 0x68, 0x5C, 0x40, 0x9A, 0x1D, 0x90, 0x2A, // @h\@...*
|
|
/* 1978 */ 0x6D, 0x00, 0xC6, 0x54, 0x83, 0xD0, 0x24, 0x20, // m..T..$
|
|
/* 1980 */ 0x02, 0x74, 0x2C, 0x10, 0x01, 0x5A, 0x74, 0x04, // .t,..Zt.
|
|
/* 1988 */ 0x30, 0x16, 0x01, 0x84, 0x46, 0x05, 0xA1, 0xC9, // 0...F...
|
|
/* 1990 */ 0x2A, 0x80, 0xB2, 0x9C, 0x20, 0x1A, 0x20, 0xC9, // *... . .
|
|
/* 1998 */ 0x30, 0x60, 0x0A, 0x42, 0x33, 0x81, 0xD0, 0x8C, // 0`.B3...
|
|
/* 19A0 */ 0x20, 0x54, 0x7C, 0x07, 0x10, 0x16, 0x04, 0x84, // T|.....
|
|
/* 19A8 */ 0x86, 0x03, 0xD1, 0x00, 0xFE, 0xFF, 0x8F, 0x0C, // ........
|
|
/* 19B0 */ 0x02, 0xD1, 0x00, 0x9C, 0x23, 0xC4, 0x61, 0x85, // ....#.a.
|
|
/* 19B8 */ 0x82, 0xD0, 0xF4, 0x20, 0x34, 0x6C, 0x09, 0x50, // ... 4l.P
|
|
/* 19C0 */ 0x16, 0x1D, 0x44, 0xC7, 0x23, 0x92, 0x02, 0x8C, // ..D.#...
|
|
/* 19C8 */ 0x05, 0x02, 0xA1, 0x31, 0x41, 0x68, 0x6C, 0x10, // ...1Ahl.
|
|
/* 19D0 */ 0x1A, 0x29, 0x06, 0x28, 0x13, 0x54, 0xE3, 0x50, // .).(.T.P
|
|
/* 19D8 */ 0x44, 0x7B, 0x80, 0x31, 0x99, 0x20, 0x54, 0x36, // D{.1. T6
|
|
/* 19E0 */ 0x88, 0xC0, 0x1C, 0x14, 0x88, 0x86, 0x07, 0xA1, // ........
|
|
/* 19E8 */ 0x62, 0x82, 0x00, 0x52, 0x10, 0x01, 0x12, 0x20, // b..R...
|
|
/* 19F0 */ 0x1A, 0x1E, 0x84, 0x8A, 0x29, 0x32, 0x74, 0x0A, // ....)2t.
|
|
/* 19F8 */ 0x42, 0x55, 0x24, 0x39, 0x9A, 0x50, 0x10, 0x1D, // BU$9.P..
|
|
/* 1A00 */ 0x4D, 0x08, 0x08, 0xCD, 0x07, 0x46, 0x75, 0x35, // M....Fu5
|
|
/* 1A08 */ 0x39, 0x6E, 0x50, 0x10, 0xAA, 0x1D, 0x84, 0x06, // 9nP.....
|
|
/* 1A10 */ 0x05, 0xA1, 0x39, 0xA2, 0x80, 0xB2, 0xEC, 0x20, // ..9....
|
|
/* 1A18 */ 0x02, 0xB2, 0x9E, 0x2A, 0x87, 0x0A, 0x0A, 0x22, // ...*..."
|
|
/* 1A20 */ 0x30, 0xA7, 0x02, 0xA2, 0x49, 0x41, 0xA8, 0x8E, // 0...IA..
|
|
/* 1A28 */ 0x2C, 0x47, 0x0A, 0x9A, 0x06, 0x84, 0x25, 0x06, // ,G....%.
|
|
/* 1A30 */ 0xA1, 0xC9, 0xDA, 0x80, 0xB0, 0x0C, 0x75, 0x0E, // ......u.
|
|
/* 1A38 */ 0x24, 0x14, 0x84, 0xE6, 0x04, 0xA1, 0x4A, 0xF2, // $.....J.
|
|
/* 1A40 */ 0x0C, 0x8F, 0x82, 0xE8, 0x38, 0x42, 0x80, 0x68, // ....8B.h
|
|
/* 1A48 */ 0x7A, 0x10, 0xAA, 0xA6, 0xCF, 0x00, 0x28, 0x88, // z.....(.
|
|
/* 1A50 */ 0x06, 0x40, 0x40, 0x68, 0x4E, 0x30, 0xAA, 0xA8, // .@@hN0..
|
|
/* 1A58 */ 0xD1, 0xD1, 0x84, 0x82, 0x50, 0xDD, 0x2F, 0x4E, // ....P./N
|
|
/* 1A60 */ 0x81, 0xF8, 0xFF, 0x0F // ....
|
|
}) /* END MBUF */
|
|
} /*end DefinitionBlock */
|
|
|