2 * Some or all of this work - Copyright (c) 2006 - 2018, Intel Corp.
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
8 * Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * Neither the name of Intel Corporation nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
26 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 // Grammar.asl - Minimally excercises most ASL constructs
33 // NOTE -- use: iasl -f -of grammar.asl to compile
35 // This 1) Ignores errors (checks compiler error handling)
36 // 2) Disables constant folding
40 /*******************************************************************************
41 Compilation should look like this:
43 C:\acpica\tests\misc>iasl -f -of grammar.asl
45 Intel ACPI Component Architecture
46 ASL Optimizing Compiler version 20090422 [Apr 22 2009]
47 Copyright (C) 2000 - 2009 Intel Corporation
48 Supports ACPI Specification Revision 3.0a
50 grammar.asl 187: Name (_NPK, Package (8)
51 Warning 1098 - ^ Unknown reserved name (_NPK)
53 grammar.asl 510: NAME (ESC1, "abcdefg\x00hijklmn")
54 Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
56 grammar.asl 511: NAME (ESC2, "abcdefg\000hijklmn")
57 Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
59 grammar.asl 601: Method (RCIV, 1)
60 Warning 1087 - ^ Not all control paths return a value (RCIV)
62 grammar.asl 608: RCIV (Subtract (Arg0, 1))
63 Remark 5073 - ^ Recursive method call (RCIV)
65 grammar.asl 937: Method (_ERR, 2)
66 Warning 1077 - ^ Reserved method has too few arguments (_ERR requires 3)
68 grammar.asl 1377: Store (0x1234567887654321, QWD2)
69 Warning 1032 - ^ 64-bit integer in 32-bit table, truncating
71 grammar.asl 1379: if (LNotEqual (Local0, 0x1234567887654321))
72 Warning 1032 - 64-bit integer in 32-bit table, truncating ^
74 grammar.asl 1459: SizeOf (BUFO)
75 Warning 1105 - ^ Result is not used, operator has no effect
77 grammar.asl 1485: Acquire (MTX2, 1)
78 Warning 1104 - ^ Possible operator timeout is ignored
80 grammar.asl 1633: Add (Local0, Local1)
81 Warning 1105 - ^ Result is not used, operator has no effect
83 grammar.asl 1804: Method (COND)
84 Warning 1087 - ^ Not all control paths return a value (COND)
86 grammar.asl 6010: Name (_HID, "*PNP0A06")
87 Error 4001 - ^ String must be entirely alphanumeric (*PNP0A06)
89 grammar.asl 6461: Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})
90 Warning 1038 - Invalid or unknown escape sequence ^
92 grammar.asl 6800: And (Local0, 1, Local0) // Local0 &= 1
93 Error 4050 - ^ Method local variable is not initialized (Local0)
95 grammar.asl 6886: Name (_HID, "*PNP0C0A") // Control Method Battey ID
96 Error 4001 - ^ String must be entirely alphanumeric (*PNP0C0A)
98 ASL Input: grammar.asl - 10254 lines, 322162 bytes, 4810 keywords
99 AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes
101 Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations
103 ***************************************************************************************************/
106 "grammar.aml", //Output filename
108 0x01, //DSDT Revision ---> 32-bit table
110 "GRMTEST", //TABLE ID
111 0x20090511 //OEM Revision
115 External (\ABCD, UnknownObj)
118 /* Device with _STA and _INI */
133 /* Device with no _STA, has _INI */
143 /* Device with _STA, no _INI */
153 /* Device with _STA and _INI, but not present */
169 /* Resource descriptors */
173 Name (PRT0, ResourceTemplate ()
175 IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15}
177 StartDependentFn (1,1)
179 IRQNoFlags () {0,1,2}
184 Method (_CRS, 0, NotSerialized)
186 Store ("_CRS:", Debug)
191 Method (_SRS, 1, Serialized)
193 Store ("_SRS:", Debug)
199 Name (_NPK, Package ()
210 Name (_PRT, Package (0x04)
245 Method (_CRS, 0, Serialized)
247 Name (PRT0, ResourceTemplate ()
249 WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
250 0x0000, // Address Space Granularity
251 0xFFF2, // Address Range Minimum
252 0xFFF3, // Address Range Maximum
253 0x0032, // Address Translation Offset
255 WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
256 0x0000, // Address Space Granularity
257 0x0000, // Address Range Minimum
258 0x00FF, // Address Range Maximum
259 0x0000, // Address Translation Offset
261 WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
262 0x0000, // Address Space Granularity
263 0xA000, // Address Range Minimum
264 0xBFFF, // Address Range Maximum
265 0x0000, // Address Translation Offset
267 IO (Decode16, 0x0CF8, 0x0CFF, 0x01, 0x08)
268 WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
269 0x0000, // Address Space Granularity
270 0x0000, // Address Range Minimum
271 0x0CF7, // Address Range Maximum
272 0x0000, // Address Translation Offset
275 WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
276 0x0000, // Address Space Granularity
277 0x0D00, // Address Range Minimum
278 0xFFFF, // Address Range Maximum
279 0x0000, // Address Translation Offset
282 DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
283 0x00000000, // Address Space Granularity
284 0x00000000, // Address Range Minimum
285 0x00000CF7, // Address Range Maximum
286 0x00000000, // Address Translation Offset
289 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
290 0x00000000, // Address Space Granularity
291 0x000C8000, // Address Range Minimum
292 0x000EFFFF, // Address Range Maximum
293 0x00000000, // Address Translation Offset
295 , AddressRangeMemory, TypeStatic)
296 DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
297 0x00000000, // Address Space Granularity
298 0x000C8000, // Address Range Minimum
299 0x000EFFFF, // Address Range Maximum
300 0x00000000, // Address Translation Offset
302 QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
303 0x0000000000000000, // Address Space Granularity
304 0x0000000000000000, // Address Range Minimum
305 0x0000000000000CF7, // Address Range Maximum
306 0x0000000000000000, // Address Translation Offset
307 0x0000000000000CF8, 0x44, "This is a ResouceSource string",
309 QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
310 0x0000000000000000, // Address Space Granularity
311 0x0000000000000000, // Address Range Minimum
312 0x0000000000000CF7, // Address Range Maximum
313 0x0000000000000000, // Address Translation Offset
314 0x0000000000000CF8,,,
316 QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
317 0x0000000000000000, // Address Space Granularity
318 0x0000000000100000, // Address Range Minimum
319 0x00000000FFDFFFFF, // Address Range Maximum
320 0x0000000000000000, // Address Translation Offset
321 0x00000000FFD00000,,,
322 , AddressRangeMemory, TypeStatic)
323 QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
324 0x0000000000000000, // Address Space Granularity
325 0x0000000000000000, // Address Range Minimum
326 0x0000000000000CF7, // Address Range Maximum
327 0x0000000000000000, // Address Translation Offset
328 0x0000000000000CF8,,,)
329 ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
330 0x0000000000000000, // Address Space Granularity
331 0x0000000000000000, // Address Range Minimum
332 0x0000000000000CF7, // Address Range Maximum
333 0x0000000000000000, // Address Translation Offset
334 0x0000000000000CF8, // Address Length
335 0x0000000000000000, // Type Specific Attributes
337 ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
338 0x0000000000000000, // Address Space Granularity
339 0x0000000000100000, // Address Range Minimum
340 0x00000000FFDFFFFF, // Address Range Maximum
341 0x0000000000000000, // Address Translation Offset
342 0x00000000FFD00000, // Address Length
343 0x0000000000000000, // Type Specific Attributes
344 , AddressRangeMemory, TypeStatic)
345 ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,
346 0x0000000000000000, // Address Space Granularity
347 0x0000000000100000, // Address Range Minimum
348 0x00000000FFDFFFFF, // Address Range Maximum
349 0x0000000000000000, // Address Translation Offset
350 0x00000000FFD00000, // Address Length
351 0x0000000000000000) // Type Specific Attributes
352 IO (Decode16, 0x0010, 0x0020, 0x01, 0x10)
353 IO (Decode16, 0x0090, 0x00A0, 0x01, 0x10)
354 FixedIO (0x0061, 0x01)
356 DMA (Compatibility, BusMaster, Transfer8_16) {4}
357 DMA (Compatibility, BusMaster, Transfer8) {2,5,7}
358 Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)
359 Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000)
360 Memory32 (ReadOnly, 0x00020000, 0xFFFE0000, 0x00000004, 0x00000200)
361 Memory24 (ReadOnly, 0x1111, 0x2222, 0x0004, 0x0200)
362 Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0xE, "\\_SB_.TEST")
366 Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx")
373 Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive)
383 VendorShort () {0x01, 0x02, 0x03}
386 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
389 Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000)
390 Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2)
391 StartDependentFnNoPri ()
393 IRQNoFlags () {0,1,2}
394 IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15}
398 CreateWordField (PRT0, 0x08, BMIN)
399 CreateByteField (PRT0, R000._ASZ, RSIZ)
404 Method (_PRS, 0, Serialized)
406 Name (BUF0, ResourceTemplate ()
408 StartDependentFn (0x01, 0x02)
410 IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08)
413 StartDependentFn (0x02, 0x01)
415 IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08)
418 StartDependentFn (0x00, 0x02)
420 IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08)
423 StartDependentFn (0x00, 0x02)
425 IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08)
428 StartDependentFn (0x02, 0x00)
430 IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08)
431 IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15}
438 Method (_SRS, 1, Serialized)
445 Name(\_S0,Package(0x04){
451 Name(\_S3,Package(0x04){
457 Name(\_S4,Package(0x04){
463 Name(\_S5,Package(0x04){
470 /* Examine this table header (DSDT) */
473 DataTableRegion (HDR, "DSDT", "", "")
474 Field (HDR, AnyAcc, NoLock, Preserve)
491 Store ("32-bit table", Debug)
495 Store ("64-bit table", Debug)
503 /* Custom operation region */
505 OperationRegion(MYOP,0x80,0xFD60,0x6)
506 Field(MYOP,ByteAcc,NoLock,Preserve)
511 Method (TCOP,, Serialized)
513 Name (_STR, Unicode ("test"))
520 /* Warning should be issued for premature string termination */
522 NAME (ESC1, "abcdefg\x00hijklmn")
523 NAME (ESC2, "abcdefg\000hijklmn")
524 Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\432")
527 Name(CRSA,ResourceTemplate()
529 WORDBusNumber(ResourceProducer,MinFixed,MaxFixed,PosDecode,0x0000,0x0019,0x001D,0x0000,0x0005)
530 WORDIO(ResourceProducer,MinFixed,MaxFixed,PosDecode,NonISAOnlyRanges,0x0000,0xC000,0xCFFF,0x0000,0x1000)
531 DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
534 Name(CRSB,ResourceTemplate()
536 DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
540 Name(CRSC,ResourceTemplate()
542 VendorShort () {0x1, 0x2, 0x3}
544 Name(CRSD,ResourceTemplate()
546 VendorLong (VNDL) {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}
549 Name(CRSE,ResourceTemplate()
551 IRQNoFlags(){3,4,10,11}
552 IRQNoFlags(xxxt){3,4,10,11}
554 Name(CRSR, Buffer (Add (SizeOf(CRSA),SizeOf(CRSB))){})
555 Method(_CRS,0,NotSerialized)
566 Name(Bxxx,0xFFFFFFFF)
571 PowerResource(LANP,1,0)
574 If(LEqual(And(LANS,0x30),0x30)){
593 /* Can a method define another method? */
595 /**********************************
596 Method (TASK, 2, SERIALIZED)
609 ************************************/
611 /* A recursive method */
616 If (Lequal (Arg0, 0))
620 RCIV (Subtract (Arg0, 1))
631 Processor(CPU0,0x0,0xFFFFFFFF,0x0) {}
634 Name(B1TP,0xFFFFFFFF)
636 Name(B2TP,0xFFFFFFFF)
637 Name(ADPS,0xFFFFFFFF)
638 Name(B1PS,0xFFFFFFFF)
639 Name(B1RS,0xFFFFFFFF)
640 Name(B1CS,0xFFFFFFFF)
641 Name(B2PS,0xFFFFFFFF)
642 Name(B2RS,0xFFFFFFFF)
643 Name(B2CS,0xFFFFFFFF)
679 Method(RDBT,0,Serialized){
680 If(LNot(SMWE(0x09,0x15,1,1))){
688 Name (SBUF, Buffer (128) {})
690 CreateBitField (SBUF, 3, BITY)
691 CreateByteField (SBUF, 1, BYTY)
692 CreateWordField (SBUF, 2, WRDZ)
693 CreateDwordField (SBUF, 4, DWDZ)
694 CreateQwordField (SBUF, 8, QWDZ)
695 CreateField (SBUF, 128, 12, FLDZ)
696 CreateField (SBUF, 148, 96, FLDY)
697 CreateField (SBUF, 148, 96, \_SB_.FLDW)
701 CreateField (\_SB_.SBUF, 148, 96, FLDV)
707 Name(_HID,EISAID("PNP0A03"))
710 Method(_CRS,, Serialized)
712 Name(PRT0, ResourceTemplate() {
713 WORDBusNumber( // Bus number resource(0)
714 ResourceConsumer, // bit 0 of general flags is 1
715 MinFixed, // Range is notfixed
716 MaxFixed, // Range is not fixed
717 SubDecode, // SubDecode
718 0x0000, // Granularity
721 0x0032, // Translation
722 0x0002,,, // Range Length
726 CreateWordField(PRT0, BUS0._MIN, BMIN) //Minimum bus number suported under this bridge.
740 OperationRegion(FJIO,SystemIO,0xFD60,0x6)
741 Field(FJIO,ByteAcc,NoLock,Preserve)
755 IndexField(GIDX,GDTA,ByteAcc,NoLock,Preserve)
811 Method(RDBT,3,Serialized){
820 If(LNot(SMRE(0x09,0x15,1,RefOf(Local0)))){
821 If(LNot(SMWE(0x08,0x14,1,Local1))){
822 If(LNot(SMRE(0x09,0x17,Local2,RefOf(Local3)))){
826 Or(Local0,0xFFF,Local0)
827 SMWE(0x08,0x14,1,Local0)
833 Or(0xFFFF0000,Arg0,Local0)
834 Or(Local0,ShiftLeft(Arg1,8),Local0)
835 Subtract(Zero,Local0,Local0)
838 Or(Local0,ShiftLeft(Arg1,8),Local0)
845 Name(_HID,EISAID("PNP0C0A"))
847 Alias(\_SB.PCI0.EIO.B1P,\_SB_.PCI0.XXXX)
848 Alias(\_SB.PCI0.EIO.B1P,B1P)
849 Alias(\_SB.PCI0.EIO.B1C,B1C)
850 Alias(\_SB.PCI0.EIO.B1CH,B1CH)
851 Alias(\_SB.PCI0.EIO.B1CL,B1CL)
852 Alias(\_SB.PCI0.EIO.B1VH,B1VH)
853 Alias(\_SB.PCI0.EIO.B1VL,B1VL)
854 Alias(\_SB.PCI0.EIO.B1CP,B1CP)
864 RDBT(Zero,Zero,RefOf(B1DC))
865 RDBT(Zero,One,RefOf(B1LF))
866 Store(B1DC,Index(RBIF,1))
867 Store(B1LF,Index(RBIF,2))
868 Store("CA54200-5003/5",Index(RBIF,9))
869 Store("1",Index(RBIF,10))
873 Method(_BST,, Serialized) {
879 if (LAnd(B1P,LNot(B1C))){
887 if (LLessEqual(B1CP,1)) {
891 Store(MKWD(B1CL,B1CH),Local1)
893 Store(Divide(Add(Multiply(B1CP,B1LF),99),100),Local2)
895 Store(MKWD(B1VL,B1VH),Local3)
897 Name(STAT,Package(4){})
898 Store(Local0,Index(STAT,0))
899 Store(Local1,Index(STAT,1))
900 Store(Local2,Index(STAT,2))
901 Store(Local3,Index(STAT,3))
904 // \_SB.PCI0.EIO.EC0.IECT()
905 // \_SB.PCI0.EIO.EC0.SECT()
928 Method (TZ2, 0, SERIALIZED)
946 Notify (\_PR.CPU0, 0)
952 Store ("Run-time exception:", Debug)
956 Return (0) // Map error to AE_OK
963 Divide (Local0, Local1, Local3)
965 Store ("DIV0 - noabort", Debug)
970 Local0 = ToDecimalString (Arg1)
971 if (LEqual (Arg0, 0))
973 Printf ("+*+*+*+* MTHD_ERROR at line %o: Results not equal!", Local0)
975 if (LEqual (Arg0, 1))
977 Printf ("+*+*+*+* MTHD_ERROR at line %o: Numeric result is incorrect!", Local0)
979 if (LEqual (Arg0, 2))
981 Printf ("+*+*+*+* MTHD_ERROR at line %o: Operand was clobbered!", Local0)
1009 Store (0x01010101, Local0)
1010 R222 (0xABAB, Local0)
1011 Store (Local0, Local1)
1018 Store (NUM1(), Local0)
1034 Store (\IFEL.TEST(), Local0)
1035 if (LGreater (Local0, 0))
1041 Store (\NOSV.TEST(), Local0)
1042 if (LGreater (Local0, 0))
1048 Store (\IDXF.TEST(), Local0)
1049 if (LGreater (Local0, 0))
1055 Store (\_SB_.NSTL.TEST(), Local0)
1056 if (LGreater (Local0, 0))
1062 Store (\RTBF.TEST(), Local0)
1063 if (LGreater (Local0, 0))
1069 Store (\_SB_.RTLV.TEST(), Local0)
1070 if (LGreater (Local0, 0))
1076 Store (\_SB_.RETP.TEST(), Local0)
1077 if (LGreater (Local0, 0))
1083 Store (\WHLR.TEST(), Local0)
1084 if (LGreater (Local0, 0))
1090 Store (\ANDO.TEST(), Local0)
1091 if (LGreater (Local0, 0))
1097 Store (\BRKP.TEST(), Local0)
1098 if (LGreater (Local0, 0))
1104 Store (\ADSU.TEST(), Local0)
1105 if (LGreater (Local0, 0))
1111 Store (\INDC.TEST(), Local0)
1112 if (LGreater (Local0, 0))
1118 Store (\LOPS.TEST(), Local0)
1119 if (LGreater (Local0, 0))
1125 Store (\FDSO.TEST(), Local0)
1126 if (LGreater (Local0, 0))
1132 Store (\MLDV.TEST(), Local0)
1133 if (LGreater (Local0, 0))
1139 Store (\NBIT.TEST(), Local0)
1140 if (LGreater (Local0, 0))
1146 Store (\SHFT.TEST(), Local0)
1147 if (LGreater (Local0, 0))
1153 Store (\XORD.TEST(), Local0)
1154 if (LGreater (Local0, 0))
1160 Store (\CRBF.TEST(), Local0)
1161 if (LGreater (Local0, 0))
1167 Store (\IDX4.TEST(), Local0)
1168 if (LGreater (Local0, 0))
1174 Store (\EVNT.TEST(), Local0)
1175 if (LGreater (Local0, 0))
1181 Store (\SZLV.TEST(), Local0)
1182 if (LGreater (Local0, 0))
1188 Store (\_SB_.BYTF.TEST(), Local0)
1189 if (LGreater (Local0, 0))
1195 Store (\DWDF.TEST(), Local0)
1196 if (LGreater (Local0, 0))
1202 Store (\DVAX.TEST(), Local0)
1203 if (LGreater (Local0, 0))
1209 Store (\IDX6.TEST(), Local0)
1210 if (LGreater (Local0, 0))
1216 Store (\IDX5.TEST(), Local0)
1217 if (LGreater (Local0, 0))
1223 Store (\_SB_.IDX0.TEST(), Local0)
1224 if (LGreater (Local0, 0))
1230 Store (\_SB_.IDX3.TEST(), Local0)
1231 if (LGreater (Local0, 0))
1237 Store (\IDX7.TEST(), Local0)
1238 if (LGreater (Local0, 0))
1244 Store (\MTCH.TEST(), Local0)
1245 if (LGreater (Local0, 0))
1251 Store (\WHLB.TEST(), Local0)
1252 if (LGreater (Local0, 0))
1258 Store (\_SB_.IDX2.TEST(), Local0)
1259 if (LGreater (Local0, 0))
1265 Store (\SIZO.TEST(), Local0)
1266 if (LGreater (Local0, 0))
1272 Store (\_SB_.SMIS.TEST(), Local0)
1273 if (LGreater (Local0, 0))
1279 if (LGreater (ERRS, 0))
1281 Store ("****** There were errors during the execution of the test ******", Debug)
1284 // Flush all notifies
1292 Return(0) // Success
1296 Method (OBJ1, 1, SERIALIZED)
1300 Name(BUFR, Buffer (Local0) {})
1301 Name(BUF1, Buffer (4) {1,2,3,4})
1302 Name(BUF2, Buffer (4) {})
1318 Method (FLDS,, Serialized)
1320 Store ("++++++++ Creating BufferFields", Debug)
1321 Name (BUF2, Buffer (128) {})
1323 CreateBitField (BUF2, 3, BIT2)
1324 CreateByteField (BUF2, 1, BYT2)
1325 CreateWordField (BUF2, 2, WRD2)
1326 CreateDwordField (BUF2, 4, DWD2)
1327 CreateQwordField (BUF2, 8, QWD2)
1328 CreateField (BUF2, 128, 12, FLD2)
1329 CreateField (BUF2, 148, 96, FLD3)
1332 Store (BIT2, Local0)
1333 if (LNotEqual (Local0, 0x1))
1339 Store (DerefOf (Index (BUF2, 0)), Local0)
1340 if (LNotEqual (Local0, 0x08))
1346 Store ("++++++++ Bit BufferField I/O PASS", Debug)
1351 Store (BYT2, Local0)
1352 if (LNotEqual (Local0, 0x1A))
1358 Store ("++++++++ Byte BufferField I/O PASS", Debug)
1361 Store (0x1234, WRD2)
1362 Store (WRD2, Local0)
1363 if (LNotEqual (Local0, 0x1234))
1369 Store ("++++++++ Word BufferField I/O PASS", Debug)
1373 Store (FLD2, Local0)
1374 if (LNotEqual (Local0, 0x123))
1380 Store ("++++++++ 12-bit BufferField I/O PASS", Debug)
1383 Store (0x12345678, DWD2)
1384 Store (DWD2, Local0)
1385 if (LNotEqual (Local0, 0x12345678))
1391 Store ("++++++++ Dword BufferField I/O PASS", Debug)
1394 Store (0x1234567887654321, QWD2)
1395 Store (QWD2, Local0)
1396 if (LNotEqual (Local0, 0x1234567887654321))
1402 Store ("++++++++ Qword BufferField I/O PASS", Debug)
1407 /* Field execution */
1409 Method (FLDX,, Serialized)
1411 Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
1412 { // Field: SMEM overlay using 32-bit field elements
1413 SMD0, 32, // 32-bits
1414 SMD1, 32, // 32-bits
1415 SMD2, 32, // 32-bits
1417 } // Field: SMEM overlay using 32-bit field elements
1418 Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
1419 { // Field: SMEM overlay using greater than 32-bit field elements
1420 SME0, 69, // larger than an integer (32 or 64)
1421 SME1, 97 // larger than an integer
1422 } // Field: SMEM overlay using greater than 32-bit field elements
1428 /* Test "Force release" of mutex on method exit */
1430 Acquire (MTXT, 0xFFFF)
1431 Acquire (MTXX, 0xFFFF)
1433 Store ("++++++++ Acquiring Mutex MTX2", Debug)
1434 Acquire (_GL_, 0xFFFF)
1437 Store ("++++++++ Releasing Mutex MTX2", Debug)
1442 Method (OBJ2, 1, Serialized)
1444 Store ("++++++++ Creating Buffer BUFO", Debug)
1445 Name (BUFO, Buffer (32) {})
1447 Store ("++++++++ Creating OpRegion OPR2", Debug)
1448 OperationRegion (OPR2, SystemMemory, Arg0, 256)
1450 Store ("++++++++ Creating Field(s) in OpRegion OPR2", Debug)
1451 Field (OPR2, ByteAcc, NoLock, Preserve)
1458 Store ("++++++++ Creating BankField BNK2 in OpRegion OPR2", Debug)
1460 // mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1
1462 BankField (OPR2, BNK2, 0, ByteAcc, NoLock, Preserve)
1468 Store ("++++++++ Creating IndexField", Debug)
1469 IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve)
1475 Store ("++++++++ SizeOf (BUFO)", Debug)
1478 Store ("++++++++ Store (SizeOf (BUFO), Local0)", Debug)
1479 Store (SizeOf (BUFO), Local0)
1481 Store ("++++++++ Concatenate (\"abd\", \"def\", Local0)", Debug)
1482 Concatenate ("abd", "def", Local0)
1483 Store (Local0, Debug)
1485 Store ("++++++++ Concatenate (\"abd\", 0x7B, Local0)", Debug)
1486 Concatenate ("abd", 0x7B, Local0)
1487 Store (Local0, Debug)
1489 Store ("++++++++ Creating Event EVT2", Debug)
1492 Store ("++++++++ Creating Mutex MTX2", Debug)
1495 Store ("++++++++ Creating Alias MTXA to MTX2", Debug)
1498 Store ("++++++++ Acquiring Mutex MTX2", Debug)
1499 Acquire (MTX2, 0xFFFF)
1501 Store ("++++++++ Acquiring Mutex MTX2 (2nd acquire)", Debug)
1504 Store ("++++++++ Releasing Mutex MTX2", Debug)
1509 Store ("++++++++ Signalling Event EVT2", Debug)
1512 Store ("++++++++ Resetting Event EVT2", Debug)
1515 Store ("++++++++ Signalling Event EVT2", Debug)
1518 Store ("++++++++ Waiting Event EVT2", Debug)
1521 Store ("++++++++ Sleep", Debug)
1524 Store ("++++++++ Stall", Debug)
1527 Store ("++++++++ NoOperation", Debug)
1532 Store ("++++++++ Return from Method OBJ2", Debug)
1541 Store ("++++++++ Add (0x12345678, 0x11111111, Local0)", Debug)
1542 Add (0x12345678, 0x11111111, Local0)
1544 Store ("++++++++ Store (Add (0x12345678, 0x11111111), Local1)", Debug)
1545 Store (Add (0x12345678, 0x11111111), Local1)
1547 Store ("++++++++ Checking result from ADD", Debug)
1548 if (LNotEqual (Local0, Local1))
1556 Store ("++++++++ Subtract (0x87654321, 0x11111111, Local4)", Debug)
1557 Subtract (0x87654321, 0x11111111, Local4)
1559 Store ("++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)", Debug)
1560 Store (Subtract (0x87654321, 0x11111111), Local5)
1562 Store ("++++++++ Checking result from SUBTRACT", Debug)
1563 if (LNotEqual (Local4, Local5))
1571 Store ("++++++++ Multiply (33, 10, Local6)", Debug)
1572 Multiply (33, 10, Local6)
1574 Store ("++++++++ Store (Multiply (33, 10), Local7)", Debug)
1575 Store (Multiply (33, 10), Local7)
1578 Store ("++++++++ Checking result from MULTIPLY", Debug)
1579 if (LNotEqual (Local6, Local7))
1587 Store ("++++++++ Divide (100, 9, Local1, Local2)", Debug)
1588 Divide (100, 9, Local1, Local2)
1590 Store ("++++++++ Store (Divide (100, 9), Local3)", Debug)
1591 Store (Divide (100, 9), Local3)
1593 Store ("++++++++ Checking (quotient) result from DIVIDE", Debug)
1594 if (LNotEqual (Local2, Local3))
1602 Store ("++++++++ Increment (Local0)", Debug)
1607 Store ("++++++++ Checking result from INCREMENT", Debug)
1608 if (LNotEqual (Local0, Local1))
1616 Store ("++++++++ Decrement (Local0)", Debug)
1621 Store ("++++++++ Checking result from DECREMENT", Debug)
1622 if (LNotEqual (Local0, Local1))
1631 Store ("++++++++ ToBCD (0x1234, Local5)", Debug)
1632 ToBCD (0x1234, Local5)
1634 Store ("++++++++ FromBCD (Local5, Local6)", Debug)
1635 FromBCD (Local5, Local6)
1637 Store ("++++++++ Return (Local6)", Debug)
1647 Store (Local0, Debug)
1650 Add (Local0, Local1)
1651 if (LNotEqual (Local0, 3))
1655 if (LNotEqual (Local1, 7))
1661 Add (Local0, Local1, Local2)
1662 if (LNotEqual (Local0, 3))
1666 if (LNotEqual (Local1, 7))
1692 Store ("++++++++ FindSetLeftBit (0x00100100, Local0)", Debug)
1693 FindSetLeftBit (0x00100100, Local0)
1694 if (LNotEqual (Local0, 21))
1699 Store ("++++++++ FindSetRightBit (0x00100100, Local1)", Debug)
1700 FindSetRightBit (0x00100100, Local1)
1701 if (LNotEqual (Local1, 9))
1706 Store ("++++++++ And (0xF0F0F0F0, 0x11111111, Local2)", Debug)
1707 And (0xF0F0F0F0, 0x11111111, Local2)
1708 if (LNotEqual (Local2, 0x10101010))
1713 Store ("++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)", Debug)
1714 NAnd (0xF0F0F0F0, 0x11111111, Local3)
1715 if (LNotEqual (Local3, 0xEFEFEFEF))
1720 Store ("++++++++ Or (0x11111111, 0x22222222, Local4)", Debug)
1721 Or (0x11111111, 0x22222222, Local4)
1722 if (LNotEqual (Local4, 0x33333333))
1727 Store ("++++++++ NOr (0x11111111, 0x22222222, Local5)", Debug)
1728 NOr (0x11111111, 0x22222222, Local5)
1729 if (LNotEqual (Local5, 0xCCCCCCCC))
1734 Store ("++++++++ XOr (0x11113333, 0x22222222, Local6)", Debug)
1735 XOr (0x11113333, 0x22222222, Local6)
1736 if (LNotEqual (Local6, 0x33331111))
1741 Store ("++++++++ ShiftLeft (0x11112222, 2, Local7)", Debug)
1742 ShiftLeft (0x11112222, 2, Local7)
1743 if (LNotEqual (Local7, 0x44448888))
1748 Store ("++++++++ ShiftRight (Local7, 2, Local7)", Debug)
1749 ShiftRight (Local7, 2, Local7)
1750 if (LNotEqual (Local7, 0x11112222))
1756 Store ("++++++++ Not (Local0, Local1)", Debug)
1757 Store (0x22224444, Local0)
1758 Not (Local0, Local1)
1759 if (LNotEqual (Local0, 0x22224444))
1764 if (LNotEqual (Local1, 0xDDDDBBBB))
1776 Store ("++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)", Debug)
1777 Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)
1779 Store ("++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)", Debug)
1780 Store (LEqual (0xFFFFFFFF, 0x11111111), Local1)
1782 Store ("++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)", Debug)
1783 Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)
1785 Store ("++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)", Debug)
1786 Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)
1788 Store ("++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)", Debug)
1789 Store (LLess (0xFFFFFFFF, 0x11111111), Local4)
1791 Store ("++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)", Debug)
1792 Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)
1794 Store ("++++++++ Store (LNot (0x31313131), Local6)", Debug)
1795 Store (0x00001111, Local6)
1796 Store (LNot (Local6), Local7)
1797 if (LNotEqual (Local6, 0x00001111))
1802 if (LNotEqual (Local7, 0x0))
1808 Store ("++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)", Debug)
1809 Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)
1811 Store ("++++++++ Lor (0x0, 0x1)", Debug)
1814 Store ("+_+_+_+_+ Lor (0x0, 0x1) returned TRUE", Debug)
1823 Store ("++++++++ Store (0x4, Local0)", Debug)
1826 Store ("++++++++ While (Local0)", Debug)
1829 Store ("++++++++ Decrement (Local0)", Debug)
1834 Store ("++++++++ Store (0x3, Local6)", Debug)
1837 Store ("++++++++ While (Subtract (Local6, 1))", Debug)
1838 While (Subtract (Local6, 1))
1840 Store ("++++++++ Decrement (Local6)", Debug)
1845 Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
1846 If (LGreater (0x2, 0x1))
1848 Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
1849 If (LEqual (0x11111111, 0x22222222))
1851 Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
1856 Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
1859 Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
1860 If (LAnd (0xEEEEEEEE, 0x2))
1862 Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
1863 If (LLess (0x44444444, 0x3))
1865 Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
1870 Store ("++++++++ Exiting from nested IF/ELSE statements", Debug)
1878 Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
1879 If (LGreater (0x2, 0x1))
1881 Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
1882 If (LEqual (0x11111111, 0x22222222))
1884 Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
1889 Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
1892 Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
1893 If (LAnd (0xEEEEEEEE, 0x2))
1895 Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
1896 If (LLess (0x44444444, 0x3))
1898 Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
1903 Store ("++++++++ Returning from nested IF/ELSE statements", Debug)
1914 Method (REFS,, Serialized)
1916 Name (BBUF, Buffer() {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7})
1918 Name (NEST, Package ()
1922 0x01, 0x02, 0x03, 0x04, 0x05, 0x06
1926 0x11, 0x12, 0x12, 0x14, 0x15, 0x16
1930 Store (RefOf (MAIN), Local5)
1932 // For this to work, ABCD must NOT exist.
1934 Store (CondRefOf (ABCD, Local0), Local1)
1935 if (LNotEqual (Local1, 0))
1940 Store (CondRefOf (BBUF, Local0), Local1)
1941 if (LNotEqual (Local1, Ones))
1946 Store (DeRefOf (Index (BBUF, 3)), Local6)
1947 if (LNotEqual (Local6, 0xB3))
1952 Store (DeRefOf (Index (DeRefOf (Index (NEST, 1)), 3)), Local0)
1953 if (LNotEqual (Local0, 0x14))
1959 Store (0x11223344, Local0)
1960 Store (RefOf (Local0), Local1)
1962 Store (DerefOf (Local1), Local2)
1963 If (LNotEqual (Local2, 0x11223344))
1969 /* Parser thinks this is a method invocation!! */
1977 // Store (RefOf (Local0), Local1)
1979 // CondRefOf (BBUF, Local2)
1980 // CondRefOf (R___, Local3)
1982 // Store (DerefOf (Local1), Local4)
1988 Method (INDX, 0, Serialized)
1990 Name(STAT,Package(4){})
1991 Store(0x44443333,Index(STAT,0))
1994 //=================================================================
1995 //=================================================================
1996 //===================== iPCO TESTS ================================
1997 //=================================================================
1998 //=================================================================
2001 // test IfElseOp.asl
2003 // test for IfOp and ElseOp, including validation of object stack cleanup
2010 // IFNR control method executes IfOp branch with NO nested Return
2011 // and no Else branch
2015 If (LEqual (DWRD, 1))
2021 // NINR control method does not execute If branch and has no Else branch
2025 If (LNotEqual (DWRD, 1))
2031 // IENR control method executes IfOp branch with NO nested Return
2034 If (LEqual (DWRD, 1))
2044 // ELNR control method executes ElseOp branch with NO nested Return
2047 If (LNotEqual (DWRD, 1))
2057 // IFRT control method executes IfOp branch with nested Return with
2062 If (LEqual (DWRD, 1))
2069 // IERT control method executes IfOp branch with nested Return with
2073 If (LEqual (DWRD, 1))
2083 // ELRT control method executes ElseOp branch with nested Return
2086 If (LNotEqual (DWRD, 1))
2098 Store ("++++++++ IfElseOp Test", Debug)
2100 // IfOp with NO return value
2102 If (LNotEqual (RSLT, 0))
2107 // IfOp with NO return value
2109 If (LNotEqual (RSLT, 0))
2114 // IfOp with NO return value
2116 If (LNotEqual (RSLT, 0))
2121 // ElseOp with NO return value
2123 If (LNotEqual (RSLT, 0))
2128 // IfOp with return value
2130 If (LNotEqual (RSLT, 0))
2135 // IfOp with return value
2137 If (LNotEqual (RSLT, 0))
2142 // ElseOp with return value
2144 If (LNotEqual (RSLT, 0))
2157 // Internal test cases to validate IfOp (Operator (,,)) where Operator
2158 // target is ZeroOp to throw away the results.
2159 // Includes internal test cases for logical operators with no destination
2164 Method (TEST,, Serialized)
2166 Store ("++++++++ NoSave Test", Debug)
2171 // Begin test of nested operators without saving results
2174 // Test If (And ()) with no save of And result
2177 Store (1, WRD) // pass -- just do something
2184 // Test If (And ()) with no save of And result
2191 Store (2, WRD) // pass -- just do something
2195 // Test If (NAnd ()) with no save of NAnd result
2198 Store (3, WRD) // pass -- just do something
2205 // Test If (NAnd ()) with no save of NAnd result
2206 If (NAnd (0xFFFFFFFF, 0xFFFFFFFF, ))
2212 Store (4, WRD) // pass -- just do something
2216 // Test If (NOr ()) with no save of NOr result
2219 Store (5, WRD) // pass -- just do something
2226 // Test If (NOr ()) with no save of NOr result
2227 If (NOr (0xFFFFFFFE, 1, ))
2233 Store (6, WRD) // pass -- just do something
2237 // Test If (Not ()) with no save of Not result
2240 Store (7, WRD) // pass -- just do something
2247 // Test If (Not ()) with no save of Not result
2248 If (Not (0xFFFFFFFF, ))
2254 Store (8, WRD) // pass -- just do something
2258 // Test If (Or ()) with no save of Or result
2261 Store (9, WRD) // pass -- just do something
2268 // Test If (Or ()) with no save of Or result
2275 Store (10, WRD) // pass -- just do something
2279 // Test If (XOr ()) with no save of XOr result
2282 Store (11, WRD) // pass -- just do something
2289 // Test If (XOr ()) with no save of XOr result
2296 Store (12, WRD) // pass -- just do something
2301 // Begin test of logical operators with no destination operands
2304 // Test If (LAnd ()) with no save of LAnd result
2307 Store (21, WRD) // pass -- just do something
2314 // Test If (LAnd ()) with no save of LAnd result
2321 Store (22, WRD) // pass -- just do something
2324 // Test If (LAnd ()) with no save of LAnd result
2331 Store (23, WRD) // pass -- just do something
2334 // Test If (LAnd ()) with no save of LAnd result
2341 Store (24, WRD) // pass -- just do something
2345 // Test If (LEqual ()) with no save of LEqual result
2348 Store (31, WRD) // pass -- just do something
2355 // Test If (LEqual ()) with no save of LEqual result
2362 Store (32, WRD) // pass -- just do something
2366 // Test If (LGreater ()) with no save of LGreater result
2367 If (LGreater (3, 1))
2369 Store (41, WRD) // pass -- just do something
2376 // Test If (LGreater ()) with no save of LGreater result
2377 If (LGreater (4, 4))
2383 Store (42, WRD) // pass -- just do something
2386 // Test If (LGreater ()) with no save of LGreater result
2387 If (LGreater (1, 4))
2393 Store (43, WRD) // pass -- just do something
2396 // Test If (LGreaterEqual ()) with no save of LGreaterEqual result
2397 If (LGreaterEqual (3, 1))
2399 Store (44, WRD) // pass -- just do something
2406 // Test If (LGreaterEqual ()) with no save of LGreaterEqual result
2407 If (LGreaterEqual (3, 3))
2409 Store (45, WRD) // pass -- just do something
2416 // Test If (LGreaterEqual ()) with no save of LGreaterEqual result
2417 If (LGreaterEqual (3, 4))
2423 Store (46, WRD) // pass -- just do something
2427 // Test If (LLess ()) with no save of LLess result
2430 Store (51, WRD) // pass -- just do something
2437 // Test If (LLess ()) with no save of LLess result
2444 Store (52, WRD) // pass -- just do something
2447 // Test If (LLess ()) with no save of LLess result
2454 Store (53, WRD) // pass -- just do something
2458 // Test If (LLessEqual ()) with no save of LLessEqual result
2459 If (LLessEqual (1, 3))
2461 Store (54, WRD) // pass -- just do something
2468 // Test If (LLessEqual ()) with no save of LLessEqual result
2469 If (LLessEqual (2, 2))
2471 Store (55, WRD) // pass -- just do something
2478 // Test If (LLessEqual ()) with no save of LLessEqual result
2479 If (LLessEqual (4, 2))
2485 Store (56, WRD) // pass -- just do something
2489 // Test If (LNot ()) with no save of LNot result
2492 Store (61, WRD) // pass -- just do something
2499 // Test If (LNot ()) with no save of LNot result
2506 Store (62, WRD) // pass -- just do something
2510 // Test If (LNotEqual ()) with no save of LNotEqual result
2511 If (LNotEqual (3, 3))
2517 Store (63, WRD) // pass -- just do something
2520 // Test If (LNotEqual ()) with no save of LNotEqual result
2521 If (LNotEqual (1, 3))
2523 Store (64, WRD) // pass -- just do something
2531 // Test If (LOr ()) with no save of LOr result
2534 Store (71, WRD) // pass -- just do something
2541 // Test If (LOr ()) with no save of LOr result
2544 Store (72, WRD) // pass -- just do something
2551 // Test If (LOr ()) with no save of LOr result
2554 Store (73, WRD) // pass -- just do something
2561 // Test If (LOr ()) with no save of LOr result
2568 Store (74, WRD) // pass -- just do something
2580 // This is just a subset of the many RegionOp/Index Field test cases.
2581 // Tests index field element AccessAs macro.
2584 { // Test device name
2586 OperationRegion (SIO, SystemIO, 0x100, 2)
2587 Field (SIO, ByteAcc, NoLock, Preserve)
2592 IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
2594 AccessAs (ByteAcc, 0),
2609 Store ("++++++++ IndxFld Test", Debug)
2611 Store (IFE0, Local0)
2612 Store (IFE1, Local1)
2613 Store (IFE2, Local2)
2620 // test NestdLor.asl
2622 Scope (\_SB) // System Bus
2634 Store ("++++++++ NestdLor Test", Debug)
2636 If (Lor (ZER0, Lor (ZER1, Lor (ZER2, ONE0))))
2638 Store (0x00, Local0)
2643 Store (0x01, Local0)
2647 } // End Method TEST
2654 // Test ReturnOp(Buffer)
2655 // This is required to support Control Method Batteries on
2656 // Dell Latitude Laptops (e.g., CP1-A)
2665 Method (RBUF,, Serialized)
2666 { // RBUF: Return Buffer from local variable
2667 Name (ABUF, Buffer() {"ARBITRARY_BUFFER"})
2669 // store local buffer ABUF into Local0
2670 Store (ABUF, Local0)
2672 // save Local0 object type value into Local1
2673 Store (ObjectType (Local0), Local1)
2675 // validate Local0 is a Buffer
2676 If (LNotEqual (Local1, 3)) // Buffer type is 3
2678 Return (1) // failure
2681 // store value returned by control method SUBR into Local0
2682 Store (SUBR (ABUF), Local0)
2684 // save Local0 object type value into Local1
2685 Store (ObjectType (Local0), Local1)
2687 // validate Local0 is a Buffer
2688 If (LNotEqual (Local1, 3)) // Buffer type is 3
2690 Return (2) // failure
2693 // allocate buffer using Local1 as buffer size (run-time evaluation)
2695 Name (BUFR, Buffer(Local1) {})
2697 // store value returned by control method SUBR into Local0
2698 Store (SUBR (BUFR), Local0)
2700 // save Local0 object type value into Local1
2701 Store (ObjectType (Local0), Local1)
2703 // validate Local0 is a Buffer
2704 If (LNotEqual (Local1, 3)) // Buffer type is 3
2706 Return (3) // failure
2709 // store BUFR Buffer into Local0
2710 Store (BUFR, Local0)
2712 // save Local0 object type value into Local1
2713 Store (ObjectType (Local0), Local1)
2715 // validate Local0 is a Buffer
2716 If (LNotEqual (Local1, 3)) // Buffer type is 3
2718 Return (4) // failure
2722 // return Local0 Buffer
2728 Store ("++++++++ RetBuf Test", Debug)
2730 // store RBUF Buffer return value into Local0
2731 Store (RBUF, Local0)
2733 // save Local0 object type value into Local1
2734 Store (ObjectType (Local0), Local1)
2736 // validate Local0 is a Buffer
2737 If (LNotEqual (Local1, 3)) // Buffer type is 3
2739 Return (10) // failure
2743 Return (0) // success
2751 // Test ReturnOp(Lvalue)
2752 // This is required to support _PSR on IBM ThinkPad 560D and
2753 // _DCK on Toshiba Tecra 8000.
2760 Store ("Method GPE2._L03 invoked", Debug)
2766 Store ("Method GPE2._E05 invoked", Debug)
2773 Name (_PRW, Package(2) {Package(2){\GPE2, 0x05}, 3})
2783 Store ("Method _GPE._L08 invoked", Debug)
2789 Store ("Method _GPE._E09 invoked", Debug)
2795 Store ("Method _GPE._E11 invoked", Debug)
2801 Store ("Method _GPE._L22 invoked", Debug)
2807 Store ("Method _GPE._L33 invoked", Debug)
2813 Store ("Method _GPE._E64 invoked", Debug)
2821 Name (_PRW, Package(2) {0x11, 3})
2826 Name (_HID, EISAID("PNP0C0C"))
2827 Name (_PRW, Package(2) {0x33, 3})
2831 Scope (\_SB) // System Bus
2835 { // ACAD: AC adapter device
2836 Name (_HID, "ACPI0003") // AC adapter device
2838 Name (_PCL, Package () {\_SB})
2840 OperationRegion (AREG, SystemIO, 0x0372, 2)
2841 Field (AREG, ByteAcc, NoLock, Preserve)
2846 IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve)
2859 Store (\_GPE.ACST, Local0)
2860 Store (ACIN, Local1)
2861 If (LNotEqual (\_GPE.ACST, Local1))
2863 Store (Local1, \_GPE.ACST)
2864 // This Notify is commented because it causes a
2865 // method error when running on a system without the
2867 // Notify (\_SB_.ACAD, 0)
2879 Store (ACIN, \_GPE.ACST)
2881 } // ACAD: AC adapter device
2883 // test implicit return from control method
2886 Store (Arg0, Local0)
2891 // test implicit return inside nested if with explicit return of Lvalue
2893 // Arg0: 1 == dock, 0 == undock
2897 Store (0x87, Local0)
2909 Store (Arg0, Local0)
2919 } // _DCK control method
2923 Store ("++++++++ RetLVal Test", Debug)
2925 // store _PSR return value into Local0
2926 Store (\_SB_.ACAD._PSR, Local0)
2928 // save Local0 object type value into Local1
2929 Store (ObjectType (Local0), Local1)
2931 // validate Local0 is a Number
2932 If (LNotEqual (Local1, 1)) // Number/Integer type is 1
2934 Return (1) // failure
2937 // test implicit return inside nested if with explicit return of Lvalue
2938 Store (_DCK (1), Local2)
2940 // save Local2 object type value into Local3
2941 Store (ObjectType (Local2), Local3)
2943 // validate Local2 is a Number
2944 If (LNotEqual (Local3, 1)) // Number/Integer type is 1
2946 Return (2) // failure
2949 If (LNotEqual (Local2, 1))
2951 Return (3) // failure
2954 Return (0) // success
2962 // Test ReturnOp(Package)
2963 // This is required to support _PRT on Dell Optiplex Workstations (e.g. GX1)
2966 Scope (\_SB) // System Bus
2970 Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
2975 Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
2980 Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
2985 Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link
2990 { // PCI1: Root PCI Bus
2991 Name (_HID, "PNP0A03") // Need _HID for root device (String format)
2992 Name (_ADR,0x00000000)
2995 Name (_PRT, Package ()
2997 Package () {0x0004ffff, 0, LNKA, 0}, // Slot 1, INTA
2998 Package () {0x0004ffff, 1, LNKB, 0}, // Slot 1, INTB
2999 Package () {0x0004ffff, 2, LNKC, 0}, // Slot 1, INTC
3000 Package () {0x0004ffff, 3, LNKD, 0}, // Slot 1, INTD
3001 Package () {0x0005ffff, 0, \_SB_.LNKB, 0}, // Slot 2, INTA
3002 Package () {0x0005ffff, 1, \_SB_.LNKC, 0}, // Slot 2, INTB
3003 Package () {0x0005ffff, 2, \_SB_.LNKD, 0}, // Slot 2, INTC
3004 Package () {0x0006ffff, 3, \_SB_.LNKA, 0}, // Slot 2, INTD
3005 Package () {0x0006ffff, 0, LNKC, 0}, // Slot 3, INTA
3006 Package () {0x0006ffff, 1, LNKD, 0}, // Slot 3, INTB
3007 Package () {0x0006ffff, 2, LNKA, 0}, // Slot 3, INTC
3008 Package () {0x0006ffff, 3, LNKB, 0}, // Slot 3, INTD
3012 { // Map f0 space, Start PX40
3013 Name (_ADR,0x00070000) // Address+function.
3015 } // PCI0: Root PCI Bus
3020 { // RPKG: Return Package from local variable
3022 // store _PRT package into Local0
3023 Store (\_SB_.PCI1._PRT, Local0)
3025 // return Local0 Package
3031 Store ("++++++++ RetPkg Test", Debug)
3033 // store RPKG package return value into Local0
3034 Store (RPKG, Local0)
3036 // save Local0 object type value into Local1
3037 Store (ObjectType (Local0), Local1)
3039 // validate Local0 is a Package
3040 If (LNotEqual (Local1, 4)) // Package type is 4
3041 { Return (1) } // failure
3043 { Return (0) } // success
3049 // test WhileRet.asl
3051 // WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp.
3057 { // WIR: control method that returns inside of IfOp inside of WhileOp
3058 While (LLess (LCNT, 4))
3060 If (LEqual (LCNT, 2))
3069 } // WIR: control method that returns inside of IfOp inside of WhileOp
3073 Store ("++++++++ WhileRet Test", Debug)
3084 //This code tests the bitwise AndOp and OrOp Operator terms
3086 //Syntax of Andop term
3089 // Source1, //TermArg=>Integer
3090 // Source2, //TermArg=>Integer
3091 // Result //Nothing | SuperName
3093 //Source1 and Source2 are evaluated as integer data types,
3094 // a bit-wise AND is performed, and the result is optionally
3095 //stored into Result.
3101 // Source1, //TermArg=>Integer
3102 // Source2 //TermArg=>Integer
3103 // Result //Nothing | SuperName
3105 //Source1 and Source2 are evaluated as integer data types,
3106 // a bit-wide OR is performed, and the result is optionally
3111 OperationRegion (TMEM, SystemMemory, 0xC4, 0x02)
3112 Field (TMEM, ByteAcc, NoLock, Preserve)
3118 //Create System Memory Operation Region and field overlays
3119 OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3120 Field (RAM, AnyAcc, NoLock, Preserve)
3122 SMDW, 32, // 32-bit DWORD
3123 SMWD, 16, // 16-bit WORD
3124 SMBY, 8, // 8-bit BYTE
3128 //And with Byte Data
3133 //And with Word Data
3138 //And with DWord Data
3139 Name (DWD1, 0xffffffff)
3140 Name (DWD2, 0xffffffff)
3141 Name (DRSL, 0x00000000)
3145 //Check with 1 And 1 on byte data
3146 And(BYT1, BYT2, BRSL)
3147 if(LNotEqual(BRSL,0xff))
3150 //Check with 1 And 1 on Word data
3151 And(WRD1, WRD2, WRSL)
3152 if(LNotEqual(WRSL,0xffff))
3154 Return (1) // failure
3157 //Check with 1 And 1 Dword
3158 And(DWD1, DWD2, DRSL)
3159 if(LNotEqual(DRSL,0xffffffff))
3161 Return (1) // failure
3164 //Check with 0 And 0 on byte data
3168 And(BYT1, BYT2, BRSL)
3169 if(LNotEqual(BRSL,0x00))
3171 Return (1) // failure
3174 //Check with 0 And 0 on Word data
3178 And(WRD1, WRD2, WRSL)
3179 if(LNotEqual(WRSL,0x0000))
3181 Return (1) // failure
3184 //Check with 0 And 0 Dword
3185 Store (0x00000000,DWD1)
3186 Store (0x00000000,DWD2)
3187 Store (0x00000000,DRSL)
3188 And(DWD1, DWD2, DRSL)
3189 if(LNotEqual(DRSL,0x00000000))
3191 Return (1) // failure
3195 //Check with 1 And 0 on byte data
3199 And(BYT1, BYT2, BRSL)
3200 if(LNotEqual(BRSL,0x00))
3202 Return (1) // failure
3205 //Check with 1 And 0 on Word data
3209 And(WRD1, WRD2, WRSL)
3210 if(LNotEqual(WRSL,0x0000))
3212 Return (1) // failure
3215 //Check with 1 And 0 on Dword
3216 Store (0x55555555,DWD1)
3217 Store (0xAAAAAAAA,DWD2)
3218 Store (0x00000000,DRSL)
3219 And(DWD1, DWD2, DRSL)
3220 if(LNotEqual(DRSL,0x00000000))
3222 Return (1) // failure
3225 Store (0x1FFF, TOUD)
3226 Store (TOUD, Local0)
3227 if(LNotEqual(Local0,0x1FFF))
3229 Return (1) // failure
3232 //TBD- Do We need to check for system memory data also for each test case ??
3241 //Check with 1 Ored with 1 on byte data
3245 Or(BYT1, BYT2, BRSL)
3246 if(LNotEqual(BRSL,0xff))
3248 Return (1) // failure
3252 //Check with 1 Ored with 1 on Word data
3256 Or(WRD1, WRD2, WRSL)
3257 if(LNotEqual(WRSL,0xffff))
3259 Return (1) // failure
3262 //Check with 1 Ored with 1 on Dword data
3263 Store(0xffffffff,DWD1)
3264 Store(0xffffffff,DWD2)
3265 Store(0x00000000,DRSL)
3266 Or(DWD1, DWD2, DRSL)
3267 if(LNotEqual(DRSL,0xffffffff))
3269 Return (1) // failure
3272 //Check with 0 Ored with 0 on byte data
3276 Or(BYT1, BYT2, BRSL)
3277 if(LNotEqual(BRSL,0x00))
3279 Return (1) // failure
3282 //Check with 0 Ored with 0 on Word data
3286 Or(WRD1, WRD2, WRSL)
3287 if(LNotEqual(WRSL,0x0000))
3289 Return (1) // failure
3292 //Check with 0 Ored with 0 Dword data
3293 Store (0x00000000,DWD1)
3294 Store (0x00000000,DWD2)
3295 Store (0x00000000,DRSL)
3296 Or(DWD1, DWD2, DRSL)
3297 if(LNotEqual(DRSL,0x00000000))
3299 Return (1) // failure
3303 //Check with 1 Ored with 0 on byte data
3307 Or(BYT1, BYT2, BRSL)
3308 if(LNotEqual(BRSL,0xff))
3310 Return (1) // failure
3313 //Check with 1 Ored with 0 on Word data
3317 Or(WRD1, WRD2, WRSL)
3318 if(LNotEqual(WRSL,0xffff))
3320 Return (1) // failure
3323 //Check with 1 Ored with 0 on Dword data
3324 Store (0x55555555,DWD1)
3325 Store (0xAAAAAAAA,DWD2)
3326 Store (0x00000000,DRSL)
3327 Or(DWD1, DWD2, DRSL)
3328 if(LNotEqual(DRSL,0xffffffff))
3330 Return (1) // failure
3333 //TBD - Do We need to check for system memory data also for each test case ??
3339 Method(TEST,, Serialized)
3341 Store ("++++++++ AndOrOp Test", Debug)
3359 // Return original conditions to allow iterative execution
3367 Store (0xffffffff,DWD1)
3368 Store (0xffffffff,DWD2)
3369 Store (0x00000000,DRSL)
3376 // test BreakPnt.asl
3378 // This code tests the BreakPoint opcode term. The syntax of BreakPoint Term is
3379 // BreakPointTerm := BreakPoint
3380 // Used for debugging, the Breakpoint opcode stops the execution and enters the AML debugger.
3381 // In the non-debug version of the interpreter, BreakPoint is equivalent to Noop.
3395 Store ("++++++++ BreakPnt Test", Debug)
3399 //Check BreakPoint statement
3400 While(LLess(CNT0,10))
3405 //Check the BreakPoint statement
3418 // test AddSubOp.asl
3422 // create System Memory Operation Region and field overlays
3423 OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3424 Field (RAM, AnyAcc, NoLock, Preserve)
3426 SMDW, 32, // 32-bit DWORD
3427 SMWD, 16, // 16-bit WORD
3428 SMBY, 8, // 8-bit BYTE
3431 Method (TEST,, Serialized)
3433 Store ("++++++++ AddSubOp Test", Debug)
3435 Name (DWRD, 0x12345678)
3439 // Test AddOp with DWORD data
3440 Store (0x12345678, DWRD)
3442 If (LNotEqual (DWRD, 0x1234567F))
3445 // Test AddOp with WORD data
3447 If (LNotEqual (WRD, 0x1239))
3450 // Test AddOp with BYTE data
3452 If (LNotEqual (BYT, 0x15))
3455 // Test SubtractOp with DWORD data
3456 Subtract (DWRD, 7, DWRD)
3457 If (LNotEqual (DWRD, 0x12345678))
3460 // Test SubtractOp with WORD data
3461 Subtract (WRD, 3, WRD)
3462 If (LNotEqual (WRD, 0x1236))
3465 // Test SubtractOp with BYTE data
3466 Subtract (BYT, 3, BYT)
3467 If (LNotEqual (BYT, 0x12))
3471 // test AddOp with DWORD SystemMemory OpRegion
3472 Store (0x01234567, SMDW)
3474 If (LNotEqual (SMDW, 0x0123456F))
3477 // test SubtractOp with DWORD SystemMemory OpRegion
3478 Subtract (SMDW, 7, SMDW)
3479 If (LNotEqual (SMDW, 0x01234568))
3483 // test AddOp with WORD SystemMemory OpRegion
3484 Store (0x0123, SMWD)
3486 If (LNotEqual (SMWD, 0x0129))
3489 // test SubtractOp with WORD SystemMemory OpRegion
3490 Subtract (SMWD, 5, SMWD)
3491 If (LNotEqual (SMWD, 0x0124))
3495 // test AddOp with BYTE SystemMemory OpRegion
3498 If (LNotEqual (SMBY, 0x05))
3501 // test SubtractOp with BYTE SystemMemory OpRegion
3502 Subtract (SMBY, 3, SMBY)
3503 If (LNotEqual (SMBY, 0x02))
3511 // test IncDecOp.asl
3515 // create System Memory Operation Region and field overlays
3516 OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3517 Field (RAM, AnyAcc, NoLock, Preserve)
3519 SMDW, 32, // 32-bit DWORD
3520 SMWD, 16, // 16-bit WORD
3521 SMBY, 8, // 8-bit BYTE
3524 Method (TEST,, Serialized)
3526 Store ("++++++++ IncDecOp Test", Debug)
3528 Name (DWRD, 0x12345678)
3532 // Test IncrementOp with DWORD data
3533 Store (0x12345678, DWRD)
3535 If (LNotEqual (DWRD, 0x12345679))
3538 // Test IncrementOp with WORD data
3540 If (LNotEqual (WRD, 0x1235))
3543 // Test IncrementOp with BYTE data
3545 If (LNotEqual (BYT, 0x13))
3548 // Test DecrementOp with DWORD data
3550 If (LNotEqual (DWRD, 0x12345678))
3553 // Test DecrementOp with WORD data
3555 If (LNotEqual (WRD, 0x1234))
3558 // Test DecrementOp with BYTE data
3560 If (LNotEqual (BYT, 0x12))
3564 // test IncrementOp with DWORD SystemMemory OpRegion
3565 Store (0x01234567, SMDW)
3567 If (LNotEqual (SMDW, 0x01234568))
3570 // test DecrementOp with DWORD SystemMemory OpRegion
3572 If (LNotEqual (SMDW, 0x01234567))
3576 // test IncrementOp with WORD SystemMemory OpRegion
3577 Store (0x0123, SMWD)
3579 If (LNotEqual (SMWD, 0x0124))
3582 // test DecrementOp with WORD SystemMemory OpRegion
3584 If (LNotEqual (SMWD, 0x0123))
3588 // test IncrementOp with BYTE SystemMemory OpRegion
3591 If (LNotEqual (SMBY, 0x02))
3594 // test DecrementOp with BYTE SystemMemory OpRegion
3596 If (LNotEqual (SMBY, 0x01))
3606 //This source tests all the logical operators. Logical operators in ASL are as follows.
3607 //LAnd, LEqual, LGreater, LLess, LNot, LNotEqual, LOr.
3608 // Success will return 0 and failure will return a non zero number. Check the source code for
3609 // non zero number to find where the test failed
3613 //Create System Memory Operation Region and field overlays
3614 OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3615 Field (RAM, AnyAcc, NoLock, Preserve)
3617 SMDW, 32, // 32-bit DWORD
3618 SMWD, 16, // 16-bit WORD
3619 SMBY, 8, // 8-bit BYTE
3622 //And with Byte Data
3627 //And with Word Data
3632 //And with DWord Data
3633 Name (DWD1, 0xffffffff)
3634 Name (DWD2, 0xffffffff)
3635 Name (DRSL, 0x00000000)
3639 Method (ANDL,2) // Test Logical And
3641 //test with the arguments passed
3642 if(LEqual(Arg0,Arg1))
3643 { Store(LAnd(Arg0,Arg1),RSLT)
3644 if(LNotEqual(Ones,RSLT))
3648 //test with he locals
3652 if(LEqual(Local0,Local1))
3654 Store(LAnd(Local0,Local1),RSLT)
3655 if(LNotEqual(Ones,RSLT))
3659 //test with BYTE data
3660 if(LEqual(BYT1,BYT2))
3661 { Store(LAnd(BYT1,BYT2),BRSL)
3662 if(LNotEqual(Ones,BRSL))
3666 //test with WORD data
3667 if(LEqual(WRD1,WRD2))
3668 { Store(LAnd(WRD1,WRD2),WRSL)
3669 if(LNotEqual(Ones,WRSL))
3673 //test with DWORD data
3674 if(LEqual(DWD1,DWD2))
3675 { Store(LAnd(DWD1,DWD2),DRSL)
3676 if(LNotEqual(Ones,DRSL))
3680 //Test for system memory data for each test case.
3686 //test with BYTE system memory data
3687 if(LEqual(BYT1,SMBY))
3688 { Store(LAnd(BYT1,SMBY),BRSL)
3689 if(LNotEqual(Ones,BRSL))
3696 //test with WORD system memory data
3697 if(LEqual(WRD1,SMWD))
3698 { Store(LAnd(WRD1,SMWD),WRSL)
3699 if(LNotEqual(Ones,WRSL))
3703 Store(0x000000,DRSL)
3704 Store (0xffffff,DWD1)
3705 Store(0xffffff,SMDW)
3707 //test with DWORD system memory data
3708 if(LEqual(DWD1,SMDW))
3709 { Store(LAnd(DWD1,SMDW),DRSL)
3710 if(LNotEqual(Ones,DRSL))
3718 //Test the LOr Operator
3723 //test with the arguments passed
3724 if(LEqual(Arg0,Arg1))
3726 Store(LOr(Arg0,Arg1),RSLT)
3727 if(LNotEqual(Ones,RSLT))
3733 //test with he locals
3737 if(LEqual(Local0,Local1))
3739 Store(LOr(Local0,Local1),RSLT)
3740 if(LNotEqual(Ones,RSLT))
3744 //Check with 1 LOred with 0 on byte data
3749 if(LNotEqual(BYT1, BYT2))
3751 Store(LOr(BYT1, BYT2), BRSL)
3752 if(LNotEqual(Ones,BRSL))
3756 //Check with 1 LOred with 0 on WORD data
3761 if(LNotEqual(WRD1, WRD2))
3763 Store(LOr(WRD1, WRD2), WRSL)
3764 if(LNotEqual(Ones,WRSL))
3768 //Check with 1 LOred with 0 on DWORD data
3769 Store(0xffffffff,DWD1)
3770 Store(0x00000000,DWD2)
3771 Store(0x00000000,DRSL)
3773 if(LNotEqual(DWD1, DWD2))
3775 Store(LOr(DWD1, DWD2), DRSL)
3776 if(LNotEqual(Ones,DRSL))
3784 //test with BYTE system memory data
3785 if(LEqual(BYT1,SMBY))
3786 { Store(LOr(BYT1,SMBY),BRSL)
3787 if(LNotEqual(Ones,BRSL))
3795 //test with WORD system memory data
3796 if(LEqual(WRD1,SMWD))
3797 { Store(LOr(WRD1,SMWD),WRSL)
3798 if(LNotEqual(Ones,WRSL))
3803 Store(0x00000000,DWD1)
3804 Store(0xffffffff,SMDW)
3805 Store(0x00000000,DRSL)
3807 //test with DWORD system memory data
3808 if(LEqual(DWD1,SMDW))
3809 { Store(LAnd(DWD1,SMDW),DRSL)
3810 if(LNotEqual(Ones,DRSL))
3817 //This method tests LGreater and LNot operator
3821 //Test on arguements passed
3823 //in test data, Arg1 > Arg0
3824 if(LEqual(Ones,LNot(LGreater(Arg1,Arg0))))
3828 if(LEqual(Ones,LNot(LGreaterEqual(Arg1,Arg0))))
3831 if(LEqual(Ones,LLess(Arg1,Arg0)))
3835 if(LEqual(Ones,LLessEqual(Arg1,Arg0)))
3841 //test with the locals
3842 if(LNot(LGreater(Local1,Local0)))
3849 if(LNot(LGreater(BYT2,BYT1)))
3852 if(LNot(LLess(BYT1,BYT2)))
3855 //test LGreaterEqual with byte data
3856 if(LNot(LGreaterEqual(BYT2,BYT1)))
3859 //test LLessEqual byte data
3860 if(LNot(LLessEqual(BYT1,BYT2)))
3868 if(LNot(LGreater(WRD2,WRD1)))
3871 if(LNot(LLess(WRD1,WRD2)))
3874 //Test LGreaterEqual with Word Data
3875 if(LNot(LGreaterEqual(WRD2,WRD1)))
3879 //Test LLessEqual with Word Data
3880 if(LNot(LLessEqual(WRD1,WRD2)))
3883 //test on DWord data
3884 Store(0x12121212,DWD1)
3885 Store(0x21212121,DWD2)
3887 if(LNot(LGreater(DWD2,DWD1)))
3890 if(LNot(LLess(DWD1,DWD2)))
3894 //Test LGreaterEqual with Dword
3895 if(LNot(LGreaterEqual(DWD2,DWD1)))
3898 //Test LLessEqual DWord
3899 if(LNot(LLessEqual(DWD1,DWD2)))
3908 Store ("++++++++ LOps Test", Debug)
3911 //Call LAndOp method
3912 Store(ANDL(2,2),RSLT)
3913 if(LNotEqual(RSLT,0))
3917 Store(ORL_(5,5),RSLT)
3918 if(LNotEqual(RSLT,0))
3922 Store(LSGR(5,7),RSLT)
3923 if(LNotEqual(RSLT,0))
3931 // test FdSetOps.asl
3933 // FindSetLeftBit - Find Set Left Bit
3934 // FindSetLeftBitTerm := FindSetLeftBit
3935 // ( Source, //TermArg=>Integer
3936 // Result //Nothing | SuperName
3938 // Source is evaluated as integer data type, and the one-based bit location of
3939 // the first MSb (most significant set bit) is optionally stored into Result.
3940 // The result of 0 means no bit was set, 1 means the left-most bit set is the
3941 // first bit, 2 means the left-most bit set is the second bit, and so on.
3942 // FindSetRightBit - Find Set Right Bit
3944 // FindSetRightBitTerm := FindSetRightBit
3945 // ( Source, //TermArg=>Integer
3946 // Result //Nothing | SuperName
3948 // Source is evaluated as integer data type, and the one-based bit location of
3949 // the most LSb (least significant set bit) is optionally stored in Result.
3950 // The result of 0 means no bit was set, 32 means the first bit set is the
3951 // 32nd bit, 31 means the first bit set is the 31st bit, and so on.
3953 // If the Control method is success Zero is returned. Otherwise a non-zero
3954 // number is returned.
3959 // Create System Memory Operation Region and field overlays
3960 OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3961 Field (RAM, AnyAcc, NoLock, Preserve)
3963 SMDW, 32, // 32-bit DWORD
3964 SMWD, 16, // 16-bit WORD
3965 SMBY, 8, // 8-bit BYTE
3977 Name (DWD1, 0x10000)
3978 Name (DRSL, 0x00000000)
3983 // Arg0 is the actual data and Arg1 is the bit position
3985 Store (Arg0, Local0)
3986 Store (Arg1, Local1)
3988 FindSetLeftBit (Arg0, BRSL)
3989 If (LNotEqual (BRSL, Arg1))
3991 If (LNotEqual (Arg0, Local0))
3994 FindSetLeftBit (Local0, BRSL)
3995 If (LNotEqual (BRSL, Local1))
3997 If (LNotEqual (Arg0, Local0))
4000 // test the byte value for SetLeftBit
4002 FindSetLeftBit (BYT1, BRSL)
4003 If (LNotEqual (BRSL, 3))
4005 If (LNotEqual (BYT1, 7))
4010 While (LLessEqual (CNTR, 8))
4011 { // FindSetLeftBit check loop for byte data
4012 FindSetLeftBit (BYT1, BRSL)
4013 If (LNotEqual (BRSL, CNTR))
4016 // Shift the bits to check the same
4017 ShiftLeft (BYT1, 1, BYT1)
4019 } // FindSetLeftBit check loop for byte data
4022 // Check BYTE value for SetRightBit
4024 FindSetRightBit (BYT1, BRSL)
4025 If (LNotEqual (BRSL, 1))
4027 If (LNotEqual (BYT1, 7))
4032 While (LLessEqual (CNTR, 8))
4033 { // FindSetRightBit check loop for byte data
4034 FindSetRightBit (BYT1, BRSL)
4035 If (LNotEqual (BRSL, CNTR))
4038 ShiftLeft (BYT1, 1, BYT1)
4040 } // FindSetRightBit check loop for byte data
4043 // Test Word value for SetLeftBit
4046 While (LLessEqual (CNTR, 16))
4048 // FindSetLeftBit check loop for Word data
4049 FindSetLeftBit (WRD1, WRSL)
4050 If (LNotEqual (WRSL, CNTR))
4053 // Shift the bits to check the same
4054 ShiftLeft (WRD1, 1, WRD1)
4056 } // FindSetLeftBit check loop for Word data
4058 // Check Word value for SetRightBit
4060 Store (0xFF00, WRD1)
4061 While (LLessEqual (CNTR, 16))
4063 // FindSetRightBit check loop for Word data
4064 FindSetRightBit (WRD1, WRSL)
4065 If (LNotEqual (WRSL, CNTR))
4068 ShiftLeft (WRD1, 1, WRD1)
4070 } // FindSetRightBit check loop for Word data
4072 // Test the DWord value for SetLeftBit
4074 Store (0x10000, DWD1)
4075 While (LLessEqual (CNTR, 32))
4077 // FindSetLeftBit check loop for Dword
4078 FindSetLeftBit (DWD1, DRSL)
4079 If (LNotEqual (DRSL, CNTR))
4082 // Shift the bits to check the same
4083 ShiftLeft (DWD1, 1, DWD1)
4085 } // FindSetLeftBit check loop for Dword
4087 // Check DWord value for SetRightBit
4089 Store (0xFFFF0000, DWD1)
4090 While (LLessEqual (CNTR, 32))
4091 { // FindSetRightBit Check loop for DWORD
4092 FindSetRightBit (DWD1, DRSL)
4093 If (LNotEqual (DRSL, CNTR))
4096 ShiftLeft (DWD1, 1, DWD1)
4098 } // FindSetRightBit Check loop for DWORD
4103 // Test method called from amlexec
4107 Store ("++++++++ FdSetOps Test", Debug)
4109 Store (SHFT (0x80, 8), RSLT)
4110 If (LNotEqual (RSLT, 0))
4118 // test MulDivOp.asl
4122 // create System Memory Operation Region and field overlays
4123 OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
4124 Field (RAM, AnyAcc, NoLock, Preserve)
4126 SMDW, 32, // 32-bit DWORD
4127 SMWD, 16, // 16-bit WORD
4128 SMBY, 8, // 8-bit BYTE
4131 Method (TEST,, Serialized)
4133 Store ("++++++++ MulDivOp Test", Debug)
4136 Name (DWRD, 0x12345678)
4140 // Test MultiplyOp with DWORD data
4141 Store (0x12345678, DWRD)
4142 Multiply (DWRD, 3, DWRD)
4143 If (LNotEqual (DWRD, 0x369D0368))
4146 // Test MultiplyOp with WORD data
4147 Multiply (WRD, 4, WRD)
4148 If (LNotEqual (WRD, 0x48D0))
4151 // Test MultiplyOp with BYTE data
4152 Multiply (BYT, 5, BYT)
4153 If (LNotEqual (BYT, 0x5A))
4156 // Test DivideOp with DWORD data
4157 Divide (DWRD, 3, DWRD, RMDR)
4158 If (LNotEqual (DWRD, 0x12345678))
4160 If (LNotEqual (RMDR, 0))
4163 // Test DivideOp with WORD data
4164 Divide (WRD, 4, WRD, RMDR)
4165 If (LNotEqual (WRD, 0x1234))
4167 If (LNotEqual (RMDR, 0))
4170 // Test DivideOp with BYTE data
4171 Divide (BYT, 5, BYT, RMDR)
4172 If (LNotEqual (BYT, 0x12))
4174 If (LNotEqual (RMDR, 0))
4178 // test MultiplyOp with DWORD SystemMemory OpRegion
4179 Store (0x01234567, SMDW)
4180 Multiply (SMDW, 2, SMDW)
4181 If (LNotEqual (SMDW, 0x02468ACE))
4184 // test DivideOp with DWORD SystemMemory OpRegion
4185 Divide (SMDW, 3, SMDW, RMDR)
4186 If (LNotEqual (SMDW, 0x00C22E44))
4188 If (LNotEqual (RMDR, 2))
4192 // test MultiplyOp with WORD SystemMemory OpRegion
4193 Store (0x0123, SMWD)
4194 Multiply (SMWD, 3, SMWD)
4195 If (LNotEqual (SMWD, 0x369))
4198 // test DivideOp with WORD SystemMemory OpRegion
4199 Divide (SMWD, 2, SMWD, RMDR)
4200 If (LNotEqual (SMWD, 0x01B4))
4202 If (LNotEqual (RMDR, 1))
4206 // test MultiplyOp with BYTE SystemMemory OpRegion
4208 Multiply (SMBY, 7, SMBY)
4209 If (LNotEqual (SMBY, 0x07))
4212 // test DivideOp with BYTE SystemMemory OpRegion
4213 Divide (SMBY, 4, SMBY, RMDR)
4214 If (LNotEqual (SMBY, 0x01))
4216 If (LNotEqual (RMDR, 3))
4226 //NAnd - Bit-wise NAnd
4228 // Source1, //TermArg=>Integer
4229 // Source2 //TermArg=>Integer
4230 // Result //Nothing | SuperName
4232 //Source1 and Source2 are evaluated as integer data types, a bit-wise NAND is performed, and the result is optionally
4237 // Source1, //TermArg=>Integer
4238 // Source2 //TermArg=>Integer
4239 // Result //Nothing | SuperName
4241 //Source1 and Source2 are evaluated as integer data types, a bit-wise NOR is performed, and the result is optionally
4245 // Source, //TermArg=>Integer
4246 // Result //Nothing | SuperName
4248 //Source1 is evaluated as an integer data type, a bit-wise NOT is performed, and the result is optionally stored in
4251 //If the Control method is success Zero is returned else a non-zero number is returned
4256 //Create System Memory Operation Region and field overlays
4257 OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
4258 Field (RAM, AnyAcc, NoLock, Preserve)
4260 SMDW, 32, // 32-bit DWORD
4261 SMWD, 16, // 16-bit WORD
4262 SMBY, 8, // 8-bit BYTE
4266 //And with Byte Data
4271 //And with Word Data
4276 //And with DWord Data
4277 Name (DWD1, 0xffffffff)
4278 Name (DWD2, 0xffffffff)
4279 Name (DRSL, 0x00000000)
4289 Store(0xffffffff,SMDW)
4294 NAnd(Arg0,Arg1,ARSL)
4295 if(LNotEqual(ARSL,0xfffffffd))
4301 NAnd(Local0,Local1,LRSL)
4302 if(LNotEqual(LRSL,0xfffffffd))
4307 NAnd(BYT1,BYT2,BRSL)
4308 if(LNotEqual(BRSL,0xffffff00))
4312 NAnd(WRD1,WRD2,WRSL)
4313 if(LNotEqual(WRSL,0xffff0000))
4317 NAnd(DWD1,DWD2,DRSL)
4318 if(LNotEqual(DRSL,0x00000000))
4322 NAnd(SMBY,0xff,BRSL)
4323 if(LNotEqual(BRSL,0xffffff00))
4327 NAnd(SMWD,0xffff,WRSL)
4328 if(LNotEqual(WRSL,0xffff0000))
4332 NAnd(SMDW,0xffffffff,DRSL)
4333 if(LNotEqual(DRSL,0x00000000))
4344 if(LNotEqual(ARSL,0xfffffffd))
4350 NOr(Local0,Local1,LRSL)
4351 if(LNotEqual(LRSL,0xfffffffd))
4357 if(LNotEqual(BRSL,0xffffff00))
4362 if(LNotEqual(WRSL,0xffff0000))
4367 if(LNotEqual(DRSL,0x00000000))
4370 //System Memory Byte data
4372 if(LNotEqual(BRSL,0xffffff00))
4375 //System Memory Word Data
4376 NOr(SMWD,0xffff,WRSL)
4377 if(LNotEqual(WRSL,0xffff0000))
4380 //System Memory DWord Data
4381 NOr(SMDW,0xffffffff,DRSL)
4382 if(LNotEqual(DRSL,0x00000000))
4394 if(LNotEqual(ARSL,0xfffffffd))
4400 Or(Local0,Local1,LRSL)
4402 if(LNotEqual(LRSL,0xfffffffd))
4409 if(LNotEqual(BRSL,0xffffff00))
4415 if(LNotEqual(WRSL,0xffff0000))
4421 if(LNotEqual(DRSL,0x00000000))
4424 //System Memory Byte data
4427 if(LNotEqual(BRSL,0xffffff00))
4430 //System Memory Word Data
4431 Or(SMWD,0xffff,WRSL)
4433 if(LNotEqual(WRSL,0xffff0000))
4436 //System Memory DWord Data
4437 Or(SMDW,0xffffffff,DRSL)
4439 if(LNotEqual(DRSL,0x00000000))
4449 Store ("++++++++ NBitOps Test", Debug)
4451 Store(NNDB(2,2),RSLT)
4452 if(LNotEqual(RSLT,0))
4455 Store(NNOR(2,2),RSLT)
4456 if(LNotEqual(RSLT,0))
4459 Store(NNOT(2,2),RSLT)
4460 if(LNotEqual(RSLT,0))
4472 //ShiftRightTerm := ShiftRight(
4473 // Source, //TermArg=>Integer
4474 // ShiftCount //TermArg=>Integer
4475 // Result //Nothing | SuperName
4477 //Source and ShiftCount are evaluated as integer data types. Source is shifted right with the most significant bit
4478 //zeroed ShiftCount times. The result is optionally stored into Result.
4481 // Source, //TermArg=>Integer
4482 // ShiftCount //TermArg=>Integer
4483 // Result //Nothing | SuperName
4485 //Source and ShiftCount are evaluated as integer data types. Source is shifted left with the least significant
4486 //bit zeroed ShiftCount times. The result is optionally stored into Result.
4488 //If the Control method is success Zero is returned else a non-zero number is returned
4492 //Create System Memory Operation Region and field overlays
4493 OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
4494 Field (RAM, AnyAcc, NoLock, Preserve)
4496 SMDW, 32, // 32-bit DWORD
4497 SMWD, 16, // 16-bit WORD
4498 SMBY, 8, // 8-bit BYTE
4504 //And with Byte Data
4508 //And with Word Data
4512 //And with DWord Data
4513 Name (DWD1, 0xffffffff)
4514 Name (DRSL, 0x00000000)
4524 Store(0xffffffff,SMDW)
4529 //Arg0-> 2 & Arg1->2
4530 ShiftLeft(Arg0,Arg1,ARSL)
4531 if(LNotEqual(ARSL,8))
4537 //Local0->8 and Local1->2
4538 ShiftLeft(Local0,Local1,LRSL)
4539 if(LNotEqual(LRSL,8))
4544 ShiftLeft(BYT1,SHFC,BRSL)
4545 if(LNotEqual(BRSL,0x3FC))
4550 ShiftLeft(WRD1,SHFC,WRSL)
4551 if(LNotEqual(WRSL,0xFFFF0))
4556 ShiftLeft(DWD1,SHFC,DRSL)
4557 if(LNotEqual(DRSL,0xFFFFFF00))
4561 //System Memory Byte data
4563 ShiftLeft(SMBY,SHFC,BRSL)
4564 if(LNotEqual(BRSL,0xFF0))
4569 ShiftLeft(SMWD,SHFC,WRSL)
4570 if(LNotEqual(WRSL,0xffff0))
4575 ShiftLeft(SMDW,SHFC,DRSL)
4576 if(LNotEqual(DRSL,0xFFFFFF00))
4585 //And with Byte Data
4589 //And with Word Data
4593 //And with DWord Data
4594 Store(0xffffffff,DWD1)
4595 Store (0x00000000,DRSL)
4597 //Reinitialize the result objects
4601 Store(0xffffffff,SMDW)
4605 //Arg0-> 2 & Arg1->2
4606 ShiftRight(Arg0,Arg1,ARSL)
4607 if(LNotEqual(ARSL,0))
4613 //Local0->8 and Local1->2
4614 ShiftRight(Local0,Local1,LRSL)
4615 if(LNotEqual(LRSL,0))
4620 ShiftRight(BYT1,SHFC,BRSL)
4621 if(LNotEqual(BRSL,0x3F))
4626 ShiftRight(WRD1,SHFC,WRSL)
4627 if(LNotEqual(WRSL,0xFFF))
4632 ShiftRight(DWD1,SHFC,DRSL)
4633 if(LNotEqual(DRSL,0xFFFFFF))
4636 //System Memory Byte data
4638 ShiftRight(SMBY,SHFC,BRSL)
4639 if(LNotEqual(BRSL,0xF))
4644 ShiftRight(SMWD,SHFC,WRSL)
4645 if(LNotEqual(WRSL,0xFFF))
4650 ShiftRight(SMDW,SHFC,DRSL)
4651 if(LNotEqual(DRSL,0xFFFFFF))
4657 //Test method called from amlexec
4660 Store ("++++++++ ShftOp Test", Debug)
4662 Store(SLFT(2,2),RSLT)
4663 if(LNotEqual(RSLT,0))
4665 Store(SRGT(2,2),RSLT)
4666 if(LNotEqual(RSLT,0))
4674 // test Xor.asl and slightly modified
4676 //This code tests the XOR opcode term
4677 //Syntax of XOR term
4679 // Source1 //TermArg=>BufferTerm
4680 // Source2 //TermArg=>Integer
4681 // Result //NameString
4683 //"Source1" and "Source2" are evaluated as integers, a bit-wise XOR is performed, and the result is optionally stored in
4687 //This Method tests XOr operator for all the data types i.e. BYTE, WORD and DWORD
4688 Method (TEST,, Serialized)
4690 Store ("++++++++ Xor Test", Debug)
4692 //Overlay in system memory
4693 OperationRegion (RAM, SystemMemory, 0x800000, 256)
4694 Field (RAM, ByteAcc, NoLock, Preserve)
4697 BYT1, 8, //First BYTE
4698 BYT2, 8, //Second BYTE
4699 RBYT, 8, //Result Byte
4701 WRD1, 16, //First WORD field
4702 WRD2, 16, //Second WORD field
4703 RWRD, 16, //RSLT WORD field
4705 DWD1, 32, //First Dword
4706 DWD2, 32, //Second Dword
4707 RDWD, 32, //Result Dword
4711 // Store bits in the single bit fields for checking
4718 // Check the stored single bits
4719 if(LNotEqual(RES1, 1))
4724 if(LNotEqual(RES2, 1))
4729 if(LNotEqual(RES3, 1))
4734 if(LNotEqual(RES4, 1))
4739 //************************************************
4740 // (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition
4743 XOr(BYT1,BYT2,Local0)
4744 Store (Local0, RBYT)
4745 if(LNotEqual(RBYT,0))
4748 // (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition
4751 XOr(BYT1,BYT2,Local0)
4752 Store (Local0, RBYT)
4753 if(LNotEqual(RBYT,0))
4756 // (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition
4759 XOr(BYT1,BYT2,Local0)
4760 Store (Local0, RBYT)
4761 if(LNotEqual(RBYT,0xFF))
4764 //(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition
4767 XOr(BYT1,BYT2,Local0)
4768 Store (Local0, RBYT)
4769 if(LNotEqual(RBYT,0xFF))
4775 XOr(BYT1,BYT2,Local0)
4776 Store (Local0, RBYT)
4777 if(LNotEqual(RBYT,0xFF))
4782 // Store known values for checking later
4784 if(LNotEqual(BYT1, 0x12))
4790 if(LNotEqual(BYT2, 0xFE))
4796 if(LNotEqual(RBYT, 0xAB))
4801 //***********************************************
4802 // (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition
4806 if(LNotEqual(RWRD,0))
4809 // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition
4813 if(LNotEqual(RWRD,0))
4816 // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition
4820 if(LNotEqual(RWRD,0xFFFF))
4823 //(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition
4827 if(LNotEqual(RWRD,0xFFFF))
4833 if(LNotEqual(RWRD,0xFFFF))
4836 // Store known values for checking later
4838 if(LNotEqual(WRD1, 0x1234))
4844 if(LNotEqual(WRD2, 0xFEDC))
4850 if(LNotEqual(RWRD, 0x87AB))
4856 //**************************************************
4857 // (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition
4858 Store(0x00000000,DWD1)
4859 Store(0x00000000,DWD2)
4861 if(LNotEqual(RDWD,0))
4864 // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition
4865 Store(0xffffffff,DWD1)
4866 Store(0xffffffff,DWD2)
4868 if(LNotEqual(RDWD,0))
4871 // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
4872 Store(0x55555555,DWD1)
4873 Store(0xAAAAAAAA,DWD2)
4875 if(LNotEqual(RDWD,0xFFFFFFFF))
4878 //(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition
4879 Store(0xAAAAAAAA,DWD1)
4880 Store(0x55555555,DWD2)
4882 if(LNotEqual(RDWD,0xFFFFFFFF))
4885 // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
4886 Store(0x12345678,DWD1)
4887 Store(0xEDCBA987,DWD2)
4889 if(LNotEqual(RDWD,0xFFFFFFFF))
4892 Store(0x12345678,DWD1)
4893 if(LNotEqual(DWD1,0x12345678))
4898 Store(0xFEDCBA98,DWD2)
4899 if(LNotEqual(DWD2,0xFEDCBA98))
4904 Store(0x91827364,RDWD)
4905 if(LNotEqual(RDWD,0x91827364))
4910 //****************************************************
4911 // Check the stored single bits
4912 if(LNotEqual(RES1, 1))
4917 if(LNotEqual(RES2, 1))
4922 if(LNotEqual(RES3, 1))
4927 if(LNotEqual(RES4, 1))
4932 // Change all of the single bit fields to zero
4938 // Now, check all of the fields
4941 if(LNotEqual(BYT1, 0x12))
4946 if(LNotEqual(BYT2, 0xFE))
4951 if(LNotEqual(RBYT, 0xAB))
4957 if(LNotEqual(WRD1, 0x1234))
4962 if(LNotEqual(WRD2, 0xFEDC))
4967 if(LNotEqual(RWRD, 0x87AB))
4973 if(LNotEqual(DWD1, 0x12345678))
4978 if(LNotEqual(DWD2, 0xFEDCBA98))
4983 if(LNotEqual(RDWD, 0x91827364))
4989 if(LNotEqual(RES1, 0))
4994 if(LNotEqual(RES2, 0))
4999 if(LNotEqual(RES3, 0))
5004 if(LNotEqual(RES4, 0))
5015 // test CrBytFld.asl
5018 // Test for CreateByteField.
5019 // Tests creating byte field overlay of buffer stored in Local0.
5020 // Tests need to be added for Arg0 and Name buffers.
5023 { // Test device name
5026 Store ("++++++++ CrBytFld Test", Debug)
5028 // Local0 is unitialized buffer with 4 elements
5029 Store (Buffer (4) {}, Local0)
5031 // create Byte Field named BF0 based on Local0 element 0
5032 CreateByteField (Local0, 0, BF0)
5034 // validate CreateByteField did not alter Local0
5035 Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
5036 If (LNotEqual (Local1, 3)) // Buffer object type value is 3
5039 // store something into BF0
5042 // validate Store did not alter Local0 object type
5043 Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
5044 If (LNotEqual (Local1, 3)) // Buffer object type value is 3
5047 // verify that the Store into BF0 was successful
5048 If (LNotEqual (BF0, 1))
5052 // create Byte Field named BF1 based on Local0 element 1
5053 CreateByteField (Local0, 1, BF1)
5055 // validate CreateByteField did not alter Local0
5056 Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
5057 If (LNotEqual (Local1, 3)) // Buffer object type value is 3
5060 // store something into BF1
5063 // validate Store did not alter Local0 object type
5064 Store (ObjectType (Local0), Local1) // Local1 = Local0 object type
5065 If (LNotEqual (Local1, 3)) // Buffer object type value is 3
5068 // verify that the Store into BF1 was successful
5069 If (LNotEqual (BF1, 5))
5072 // verify that the Store into BF1 did not alter BF0
5073 If (LNotEqual (BF0, 1))
5077 // store something into BF0
5080 // verify that the Store into BF0 was successful
5081 If (LNotEqual (BF0, 0xFF))
5084 // verify that the Store into BF0 did not alter BF1
5085 If (LNotEqual (BF1, 5))
5094 // test IndexOp4.asl
5097 // This is just a subset of the many RegionOp/Index Field test cases.
5098 // Tests access of index fields smaller than 8 bits.
5101 { // Test device name
5103 // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion
5104 // Tests OperationRegion memory access using misaligned BYTE,
5105 // WORD, and DWORD field element accesses. Validation is performed
5106 // using both misaligned field entries and aligned field entries.
5108 // MADM returns 0 if all test cases pass or non-zero identifying
5109 // the failing test case for debug purposes. This non-zero numbers
5110 // are not guaranteed to be in perfect sequence (i.e., test case
5111 // index), but are guaranteed to be unique so the failing test
5112 // case can be uniquely identified.
5114 Method (MADM, 1, Serialized) // Misaligned Dynamic RAM SystemMemory OperationRegion
5115 // Arg0 -- SystemMemory OperationRegion base address
5116 { // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion
5117 OperationRegion (RAM, SystemMemory, Arg0, 0x100)
5118 Field (RAM, DwordAcc, NoLock, Preserve)
5119 { // aligned field definition (for verification)
5120 DWD0, 32, // aligned DWORD field
5121 DWD1, 32 // aligned DWORD field
5123 Field (RAM, ByteAcc, NoLock, Preserve)
5124 { // bit access field definition
5125 BIT0, 1, // single bit field entry
5126 BIT1, 1, // single bit field entry
5127 BIT2, 1, // single bit field entry
5128 BIT3, 1, // single bit field entry
5129 BIT4, 1, // single bit field entry
5130 BIT5, 1, // single bit field entry
5131 BIT6, 1, // single bit field entry
5132 BIT7, 1, // single bit field entry
5133 BIT8, 1, // single bit field entry
5134 BIT9, 1, // single bit field entry
5135 BITA, 1, // single bit field entry
5136 BITB, 1, // single bit field entry
5137 BITC, 1, // single bit field entry
5138 BITD, 1, // single bit field entry
5139 BITE, 1, // single bit field entry
5140 BITF, 1, // single bit field entry
5141 BI10, 1, // single bit field entry
5142 BI11, 1, // single bit field entry
5143 BI12, 1, // single bit field entry
5144 BI13, 1, // single bit field entry
5145 BI14, 1, // single bit field entry
5146 BI15, 1, // single bit field entry
5147 BI16, 1, // single bit field entry
5148 BI17, 1, // single bit field entry
5149 BI18, 1, // single bit field entry
5150 BI19, 1, // single bit field entry
5151 BI1A, 1, // single bit field entry
5152 BI1B, 1, // single bit field entry
5153 BI1C, 1, // single bit field entry
5154 BI1D, 1, // single bit field entry
5155 BI1E, 1, // single bit field entry
5156 BI1F, 1 // single bit field entry
5157 } // bit access field definition
5159 Field (RAM, ByteAcc, NoLock, Preserve)
5160 { // two-bit access field definition
5161 B2_0, 2, // single bit field entry
5162 B2_1, 2, // single bit field entry
5163 B2_2, 2, // single bit field entry
5164 B2_3, 2, // single bit field entry
5165 B2_4, 2, // single bit field entry
5166 B2_5, 2, // single bit field entry
5167 B2_6, 2, // single bit field entry
5168 B2_7, 2, // single bit field entry
5169 B2_8, 2, // single bit field entry
5170 B2_9, 2, // single bit field entry
5171 B2_A, 2, // single bit field entry
5172 B2_B, 2, // single bit field entry
5173 B2_C, 2, // single bit field entry
5174 B2_D, 2, // single bit field entry
5175 B2_E, 2, // single bit field entry
5176 B2_F, 2 // single bit field entry
5177 } // bit access field definition
5179 // initialize memory contents using aligned field entries
5180 Store (0x5AA55AA5, DWD0)
5181 Store (0x5AA55AA5, DWD1)
5183 // set memory contents to known values using misaligned field entries
5185 // verify memory contents using misaligned field entries
5186 If (LNotEqual (BIT0, 0))
5188 // verify memory contents using aligned field entries
5189 If (LNotEqual (DWD0, 0x5AA55AA4))
5192 // set memory contents to known values using misaligned field entries
5194 // verify memory contents using misaligned field entries
5195 If (LNotEqual (BIT1, 1))
5197 // verify memory contents using aligned field entries
5198 If (LNotEqual (DWD0, 0x5AA55AA6))
5201 // set memory contents to known values using misaligned field entries
5203 // verify memory contents using misaligned field entries
5204 If (LNotEqual (BIT2, 0))
5206 // verify memory contents using aligned field entries
5207 If (LNotEqual (DWD0, 0x5AA55AA2))
5210 // set memory contents to known values using misaligned field entries
5212 // verify memory contents using misaligned field entries
5213 If (LNotEqual (BIT3, 1))
5215 // verify memory contents using aligned field entries
5216 If (LNotEqual (DWD0, 0x5AA55AAA))
5219 // set memory contents to known values using misaligned field entries
5221 // verify memory contents using misaligned field entries
5222 If (LNotEqual (BIT4, 1))
5224 // verify memory contents using aligned field entries
5225 If (LNotEqual (DWD0, 0x5AA55ABA))
5228 // set memory contents to known values using misaligned field entries
5230 // verify memory contents using misaligned field entries
5231 If (LNotEqual (BIT5, 0))
5233 // verify memory contents using aligned field entries
5234 If (LNotEqual (DWD0, 0x5AA55A9A))
5237 // set memory contents to known values using misaligned field entries
5239 // verify memory contents using misaligned field entries
5240 If (LNotEqual (BIT6, 1))
5242 // verify memory contents using aligned field entries
5243 If (LNotEqual (DWD0, 0x5AA55ADA))
5246 // set memory contents to known values using misaligned field entries
5248 // verify memory contents using misaligned field entries
5249 If (LNotEqual (BIT7, 0))
5251 // verify memory contents using aligned field entries
5252 If (LNotEqual (DWD0, 0x5AA55A5A))
5255 // set memory contents to known values using misaligned field entries
5257 // verify memory contents using misaligned field entries
5258 If (LNotEqual (BIT8, 1))
5260 // verify memory contents using aligned field entries
5261 If (LNotEqual (DWD0, 0x5AA55B5A))
5264 // set memory contents to known values using misaligned field entries
5266 // verify memory contents using misaligned field entries
5267 If (LNotEqual (BIT9, 0))
5269 // verify memory contents using aligned field entries
5270 If (LNotEqual (DWD0, 0x5AA5595A))
5273 // set memory contents to known values using misaligned field entries
5275 // verify memory contents using misaligned field entries
5276 If (LNotEqual (BITA, 1))
5278 // verify memory contents using aligned field entries
5279 If (LNotEqual (DWD0, 0x5AA55D5A))
5282 // set memory contents to known values using misaligned field entries
5284 // verify memory contents using misaligned field entries
5285 If (LNotEqual (BITB, 0))
5287 // verify memory contents using aligned field entries
5288 If (LNotEqual (DWD0, 0x5AA5555A))
5291 // set memory contents to known values using misaligned field entries
5293 // verify memory contents using misaligned field entries
5294 If (LNotEqual (BITC, 0))
5296 // verify memory contents using aligned field entries
5297 If (LNotEqual (DWD0, 0x5AA5455A))
5300 // set memory contents to known values using misaligned field entries
5302 // verify memory contents using misaligned field entries
5303 If (LNotEqual (BITD, 1))
5305 // verify memory contents using aligned field entries
5306 If (LNotEqual (DWD0, 0x5AA5655A))
5309 // set memory contents to known values using misaligned field entries
5311 // verify memory contents using misaligned field entries
5312 If (LNotEqual (BITE, 0))
5314 // verify memory contents using aligned field entries
5315 If (LNotEqual (DWD0, 0x5AA5255A))
5318 // set memory contents to known values using misaligned field entries
5320 // verify memory contents using misaligned field entries
5321 If (LNotEqual (BITF, 1))
5323 // verify memory contents using aligned field entries
5324 If (LNotEqual (DWD0, 0x5AA5A55A))
5327 // set memory contents to known values using misaligned field entries
5329 // verify memory contents using misaligned field entries
5330 If (LNotEqual (BI10, 0))
5332 // verify memory contents using aligned field entries
5333 If (LNotEqual (DWD0, 0x5AA4A55A))
5336 // set memory contents to known values using misaligned field entries
5338 // verify memory contents using misaligned field entries
5339 If (LNotEqual (BI11, 1))
5341 // verify memory contents using aligned field entries
5342 If (LNotEqual (DWD0, 0x5AA6A55A))
5345 // set memory contents to known values using misaligned field entries
5347 // verify memory contents using misaligned field entries
5348 If (LNotEqual (BI12, 0))
5350 // verify memory contents using aligned field entries
5351 If (LNotEqual (DWD0, 0x5AA2A55A))
5354 // set memory contents to known values using misaligned field entries
5356 // verify memory contents using misaligned field entries
5357 If (LNotEqual (BI13, 1))
5359 // verify memory contents using aligned field entries
5360 If (LNotEqual (DWD0, 0x5AAAA55A))
5363 // set memory contents to known values using misaligned field entries
5365 // verify memory contents using misaligned field entries
5366 If (LNotEqual (BI14, 1))
5368 // verify memory contents using aligned field entries
5369 If (LNotEqual (DWD0, 0x5ABAA55A))
5372 // set memory contents to known values using misaligned field entries
5374 // verify memory contents using misaligned field entries
5375 If (LNotEqual (BI15, 0))
5377 // verify memory contents using aligned field entries
5378 If (LNotEqual (DWD0, 0x5A9AA55A))
5381 // set memory contents to known values using misaligned field entries
5383 // verify memory contents using misaligned field entries
5384 If (LNotEqual (BI16, 1))
5386 // verify memory contents using aligned field entries
5387 If (LNotEqual (DWD0, 0x5ADAA55A))
5390 // set memory contents to known values using misaligned field entries
5392 // verify memory contents using misaligned field entries
5393 If (LNotEqual (BI17, 0))
5395 // verify memory contents using aligned field entries
5396 If (LNotEqual (DWD0, 0x5A5AA55A))
5399 // set memory contents to known values using misaligned field entries
5401 // verify memory contents using misaligned field entries
5402 If (LNotEqual (BI18, 1))
5404 // verify memory contents using aligned field entries
5405 If (LNotEqual (DWD0, 0x5B5AA55A))
5408 // set memory contents to known values using misaligned field entries
5410 // verify memory contents using misaligned field entries
5411 If (LNotEqual (BI19, 0))
5413 // verify memory contents using aligned field entries
5414 If (LNotEqual (DWD0, 0x595AA55A))
5417 // set memory contents to known values using misaligned field entries
5419 // verify memory contents using misaligned field entries
5420 If (LNotEqual (BI1A, 1))
5422 // verify memory contents using aligned field entries
5423 If (LNotEqual (DWD0, 0x5D5AA55A))
5426 // set memory contents to known values using misaligned field entries
5428 // verify memory contents using misaligned field entries
5429 If (LNotEqual (BI1B, 0))
5431 // verify memory contents using aligned field entries
5432 If (LNotEqual (DWD0, 0x555AA55A))
5435 // set memory contents to known values using misaligned field entries
5437 // verify memory contents using misaligned field entries
5438 If (LNotEqual (BI1C, 0))
5440 // verify memory contents using aligned field entries
5441 If (LNotEqual (DWD0, 0x455AA55A))
5444 // set memory contents to known values using misaligned field entries
5446 // verify memory contents using misaligned field entries
5447 If (LNotEqual (BI1D, 1))
5449 // verify memory contents using aligned field entries
5450 If (LNotEqual (DWD0, 0x655AA55A))
5453 // set memory contents to known values using misaligned field entries
5455 // verify memory contents using misaligned field entries
5456 If (LNotEqual (BI1E, 0))
5458 // verify memory contents using aligned field entries
5459 If (LNotEqual (DWD0, 0x255AA55A))
5462 // set memory contents to known values using misaligned field entries
5464 // verify memory contents using misaligned field entries
5465 If (LNotEqual (BI1F, 1))
5467 // verify memory contents using aligned field entries
5468 If (LNotEqual (DWD0, 0xA55AA55A))
5472 // set memory contents to known values using misaligned field entries
5474 // verify memory contents using misaligned field entries
5475 If (LNotEqual (B2_0, 3))
5477 // verify memory contents using aligned field entries
5478 If (LNotEqual (DWD0, 0xA55AA55B))
5481 // set memory contents to known values using misaligned field entries
5483 // verify memory contents using misaligned field entries
5484 If (LNotEqual (B2_1, 1))
5486 // verify memory contents using aligned field entries
5487 If (LNotEqual (DWD0, 0xA55AA557))
5490 // set memory contents to known values using misaligned field entries
5492 // verify memory contents using misaligned field entries
5493 If (LNotEqual (B2_2, 0))
5495 // verify memory contents using aligned field entries
5496 If (LNotEqual (DWD0, 0xA55AA547))
5499 // set memory contents to known values using misaligned field entries
5501 // verify memory contents using misaligned field entries
5502 If (LNotEqual (B2_3, 3))
5504 // verify memory contents using aligned field entries
5505 If (LNotEqual (DWD0, 0xA55AA5C7))
5508 // set memory contents to known values using misaligned field entries
5510 // verify memory contents using misaligned field entries
5511 If (LNotEqual (B2_4, 3))
5513 // verify memory contents using aligned field entries
5514 If (LNotEqual (DWD0, 0xA55AA7C7))
5517 // set memory contents to known values using misaligned field entries
5519 // verify memory contents using misaligned field entries
5520 If (LNotEqual (B2_5, 0))
5522 // verify memory contents using aligned field entries
5523 If (LNotEqual (DWD0, 0xA55AA3C7))
5526 // set memory contents to known values using misaligned field entries
5528 // verify memory contents using misaligned field entries
5529 If (LNotEqual (B2_6, 1))
5531 // verify memory contents using aligned field entries
5532 If (LNotEqual (DWD0, 0xA55A93C7))
5535 // set memory contents to known values using misaligned field entries
5537 // verify memory contents using misaligned field entries
5538 If (LNotEqual (B2_7, 1))
5540 // verify memory contents using aligned field entries
5541 If (LNotEqual (DWD0, 0xA55A53C7))
5544 // set memory contents to known values using misaligned field entries
5546 // verify memory contents using misaligned field entries
5547 If (LNotEqual (B2_8, 0))
5549 // verify memory contents using aligned field entries
5550 If (LNotEqual (DWD0, 0xA55853C7))
5553 // set memory contents to known values using misaligned field entries
5555 // verify memory contents using misaligned field entries
5556 If (LNotEqual (B2_9, 1))
5558 // verify memory contents using aligned field entries
5559 If (LNotEqual (DWD0, 0xA55453C7))
5562 // set memory contents to known values using misaligned field entries
5564 // verify memory contents using misaligned field entries
5565 If (LNotEqual (B2_A, 2))
5567 // verify memory contents using aligned field entries
5568 If (LNotEqual (DWD0, 0xA56453C7))
5571 // set memory contents to known values using misaligned field entries
5573 // verify memory contents using misaligned field entries
5574 If (LNotEqual (B2_B, 2))
5576 // verify memory contents using aligned field entries
5577 If (LNotEqual (DWD0, 0xA5A453C7))
5580 // set memory contents to known values using misaligned field entries
5582 // verify memory contents using misaligned field entries
5583 If (LNotEqual (B2_C, 3))
5585 // verify memory contents using aligned field entries
5586 If (LNotEqual (DWD0, 0xA7A453C7))
5589 // set memory contents to known values using misaligned field entries
5591 // verify memory contents using misaligned field entries
5592 If (LNotEqual (B2_D, 3))
5594 // verify memory contents using aligned field entries
5595 If (LNotEqual (DWD0, 0xAFA453C7))
5598 // set memory contents to known values using misaligned field entries
5600 // verify memory contents using misaligned field entries
5601 If (LNotEqual (B2_E, 1))
5603 // verify memory contents using aligned field entries
5604 If (LNotEqual (DWD0, 0x9FA453C7))
5607 // set memory contents to known values using misaligned field entries
5609 // verify memory contents using misaligned field entries
5610 If (LNotEqual (B2_F, 0))
5612 // verify memory contents using aligned field entries
5613 If (LNotEqual (DWD0, 0x1FA453C7))
5618 } // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion
5622 Store ("++++++++ IndexOp4 Test", Debug)
5624 // MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments:
5625 // Arg0 -- SystemMemory OperationRegion base address
5626 Store (MADM (0x800000), Local0)
5627 If (LNotEqual (Local0, 0)) // MADM returns zero if successful
5628 { Return (Local0) } // failure: return MADM error code
5637 // EventOp, ResetOp, SignalOp, and WaitOp test cases.
5641 Event (EVNT) // event synchronization object
5644 // Arg0: time to Wait for event in milliseconds
5645 { // TEVN control method to test ResetOp, SignalOp, and WaitOp
5646 // reset EVNT to initialization (zero) state
5649 // prime EVNT with two outstanding signals
5654 // acquire existing signal
5655 Store (Wait (EVNT, Arg0), Local0)
5657 // validate Local0 is a Number
5658 Store (ObjectType (Local0), Local1)
5659 If (LNotEqual (Local1, 1)) // Number is type 1
5660 { Return (0x21) } // Local1 indicates Local0 is not a Number
5662 If (LNotEqual (Local0, 0)) // Number is type 1
5663 { Return (0x22) } // timeout occurred without acquiring signal
5665 Store ("Acquire 1st existing signal PASS", Debug)
5668 // acquire existing signal
5669 Store (Wait (EVNT, Arg0), Local0)
5671 // validate Local0 is a Number
5672 Store (ObjectType (Local0), Local1)
5673 If (LNotEqual (Local1, 1)) // Number is type 1
5674 { Return (0x31) } // Local1 indicates Local0 is not a Number
5676 If (LNotEqual (Local0, 0)) // Number is type 1
5677 { Return (0x32) } // timeout occurred without acquiring signal
5679 Store ("Acquire 2nd existing signal PASS", Debug)
5682 // ensure WaitOp timeout test cases do not hang
5683 if (LEqual (Arg0, 0xFFFF))
5684 { Store (0xFFFE, Arg0) }
5686 // acquire non-existing signal
5687 Store (Wait (EVNT, Arg0), Local0)
5689 // validate Local0 is a Number
5690 Store (ObjectType (Local0), Local1)
5691 If (LNotEqual (Local1, 1)) // Number is type 1
5692 { Return (0x41) } // Local1 indicates Local0 is not a Number
5694 If (LEqual (Local0, 0)) // Number is type 1
5695 { Return (0x42) } // non-existant signal was acquired
5697 Store ("Acquire signal timeout PASS", Debug)
5700 // prime EVNT with two outstanding signals
5704 // reset EVNT to initialization (zero) state
5707 // acquire non-existing signal
5708 Store (Wait (EVNT, Arg0), Local0)
5710 // validate Local0 is a Number
5711 Store (ObjectType (Local0), Local1)
5712 If (LNotEqual (Local1, 1)) // Number is type 1
5713 { Return (0x51) } // Local1 indicates Local0 is not a Number
5715 If (LEqual (Local0, 0)) // Number is type 1
5716 { Return (0x52) } // non-existant signal was acquired
5718 Store ("Reset signal PASS", Debug)
5721 // acquire non-existing signal using Lvalue timeout
5722 Store (Wait (EVNT, Zero), Local0)
5724 // validate Local0 is a Number
5725 Store (ObjectType (Local0), Local1)
5726 If (LNotEqual (Local1, 1)) // Number is type 1
5727 { Return (0x61) } // Local1 indicates Local0 is not a Number
5729 If (LEqual (Local0, 0)) // Number is type 1
5730 { Return (0x62) } // non-existant signal was acquired
5732 Store ("Zero Lvalue PASS", Debug)
5735 // acquire non-existing signal using Lvalue timeout
5736 Store (Wait (EVNT, One), Local0)
5738 // validate Local0 is a Number
5739 Store (ObjectType (Local0), Local1)
5740 If (LNotEqual (Local1, 1)) // Number is type 1
5741 { Return (0x71) } // Local1 indicates Local0 is not a Number
5743 If (LEqual (Local0, 0)) // Number is type 1
5744 { Return (0x72) } // non-existant signal was acquired
5746 Store ("One Lvalue PASS", Debug)
5748 // Lvalue Event test cases
5749 // ILLEGAL SOURCE OPERAND Store (EVNT, Local2)
5751 // validate Local2 is an Event
5752 Store (ObjectType (EVNT), Local1)
5753 If (LNotEqual (Local1, 7)) // Event is type 7
5754 { Return (0x81) } // Local1 indicates Local0 is not a Number
5756 // reset EVNT to initialization (zero) state
5759 // prime EVNT with two outstanding signals
5762 // acquire existing signal
5763 Store (Wait (EVNT, Arg0), Local0)
5765 // validate Local0 is a Number
5766 Store (ObjectType (Local0), Local1)
5767 If (LNotEqual (Local1, 1)) // Number is type 1
5768 { Return (0x82) } // Local1 indicates Local0 is not a Number
5770 If (LNotEqual (Local0, 0)) // Number is type 1
5771 { Return (0x83) } // timeout occurred without acquiring signal
5773 Store ("Acquire Lvalue existing signal PASS", Debug)
5776 // acquire non-existing signal
5777 Store (Wait (EVNT, Arg0), Local0)
5779 // validate Local0 is a Number
5780 Store (ObjectType (Local0), Local1)
5781 If (LNotEqual (Local1, 1)) // Number is type 1
5782 { Return (0x84) } // Local1 indicates Local0 is not a Number
5784 If (LEqual (Local0, 0)) // Number is type 1
5785 { Return (0x85) } // non-existant signal was acquired
5787 Store ("Acquire Lvalue signal timeout PASS", Debug)
5790 Return (0) // success
5791 } // TEVN control method to test ResetOp, SignalOp, and WaitOp
5795 Store ("++++++++ Event Test", Debug)
5797 Store (TEVN (100), Local0)
5804 // test SizeOfLv.asl
5806 // Test for SizeOf (Lvalue)
5808 // This next section will contain the packages that the SizeOfOp will be
5809 // exercised on. The first one, PKG0, is a regular package of 3 elements.
5810 // The 2nd one, PKG1, is a nested package with 3 packages inside it, each
5811 // with 3 elements. It is expected that SizeOf operator will return the
5812 // same value for these two packages since they both have 3 elements. The
5813 // final package, PKG2, has 4 elements and the SizeOf operator is expected
5814 // to return different results for this package.
5818 {0x0123, 0x4567, 0x89AB}
5824 Package (3) {0x0123, 0x4567, 0x89AB},
5825 Package (3) {0xCDEF, 0xFEDC, 0xBA98},
5826 Package (3) {0x7654, 0x3210, 0x1234}
5832 {0x0123, 0x4567, 0x89AB, 0x8888}
5837 {0x0123, 0x4567, 0x89AB, 0x8888, 0x7777}
5840 // End Packages **********************************************************
5842 // The following section will declare the data strings that will be used to
5843 // exercise the SizeOf operator. STR0 and STR1 are expected to be equal,
5844 // STR2 is expected to have a different SizeOf value than STR0 and STR1.
5846 Name (STR0, "ACPI permits very flexible methods of expressing a system")
5848 Name (STR1, "MIKE permits very flexible methods of expressing a system")
5850 Name (STR2, "Needless to say, Mike and ACPI are frequently at odds")
5852 // This string is being made in case we want to do a SizeOf comparison
5853 // between strings and packages or buffers
5854 Name (STR3, "12345")
5856 // End Strings **********************************************************
5858 // The following section will declare the buffers that will be used to exercise
5859 // the SizeOf operator.
5861 Name (BUF0, Buffer (10) {})
5862 Name (BUF1, Buffer (10) {})
5863 Name (BUF2, Buffer (8) {})
5864 Name (BUF3, Buffer (5) {})
5866 // End Buffers **********************************************************
5872 // CMPR is passed two arguments. If unequal, return 1 to indicate
5873 // that, otherwise return 0 to indicate SizeOf each is equal.
5875 Store (0x01, Local0)
5877 if (LEqual (SizeOf(Arg0), SizeOf(Arg1)))
5879 Store (0x00, Local0)
5889 Store ("++++++++ SizeOfLv Test", Debug)
5891 // TBD: SizeOf ("string")
5895 // SizeOf (STR0) -- where Name (STR0,...) -- lot's of cases
5896 // buffer, string, package,
5897 // SizeOf (METH) -- where METH control method returns
5898 // buffer, string, package,
5900 // TBD: SLOC [SizeOf (Local0)] -- dup SARG
5902 // Compare the elements that we expect to be the same. Exit out with an error
5903 // code on the first failure.
5904 if (LNotEqual (0x00, CMPR (STR0, STR1)))
5909 if (LNotEqual (0x00, CMPR (STR3, BUF3)))
5914 if (LNotEqual (0x00, CMPR (STR3, PKG3)))
5919 // In the following section, this test will cover the SizeOf
5920 // operator for Local values.
5921 // In this case, both Local0 and Local1 should have the same Size
5922 Store (STR0, Local0)
5923 Store (STR1, Local1)
5925 if (LNotEqual (SizeOf (Local0), SizeOf (Local1)))
5930 // Now create a case where Local0 and Local1 are different
5931 Store (STR2, Local1)
5933 if (LEqual (SizeOf (Local0), SizeOf (Local1)))
5938 // Finally, check for the return of SizeOf for a known Buffer. Just
5939 // in case we magically pass above cases due to all Buffers being Zero
5940 // bytes in size, or Infinity, etc.
5941 if (LNotEqual (0x05, SizeOf (BUF3)))
5952 // test BytField.asl
5955 // This is just a subset of the many RegionOp/Index Field test cases.
5956 // Tests access of TBD.
5958 Scope (\_SB) // System Bus
5961 { // Test device name
5964 Store ("++++++++ BytField Test", Debug)
5966 Return (\_TZ.C19B.RSLT)
5978 { // C115 control method
5979 Acquire (\_GL, 0xFFFF)
5980 Store (\_SB.C005.C013.C058.C07E, Local0)
5982 And (Local0, 16, Local0)
5983 Store (ShiftRight (Local0, 4, ), Local1)
5984 If (LEqual (Local1, 0))
5988 } // C115 control method
5991 OperationRegion (C018, SystemIO, 0x5028, 4)
5992 Field (C018, AnyAcc, NoLock, Preserve)
5993 { // Field overlaying C018
5995 } // Field overlaying C018
5997 OperationRegion (C01A, SystemIO, 0x5030, 4)
5998 Field (C01A, ByteAcc, NoLock, Preserve)
5999 { // Field overlaying C01A
6004 } // Field overlaying C01A
6011 { // \C022 control method
6012 Acquire (\C01F, 0xFFFF)
6013 If (LEqual (\C021, 0))
6015 Store (C019, Local0)
6016 And (Local0, 0xFFFEFFFE, Local0)
6017 Store (Local0, C019)
6021 } // \C022 control method
6023 Scope (\_SB.C005.C013)
6024 { // Scope \_SB.C005.C013
6027 Name (_HID, "*PNP0A06")
6029 OperationRegion (C059, SystemIO, 0xE0, 2)
6030 Field (C059, ByteAcc, NoLock, Preserve)
6031 { // Field overlaying C059
6034 } // Field overlaying C059
6036 OperationRegion (C05C, SystemIO, 0xE2, 2)
6037 Field (C05C, ByteAcc, NoLock, Preserve)
6038 { // Field overlaying C05C
6041 } // Field overlaying C05C
6042 IndexField (C05D, C05E, ByteAcc, NoLock, Preserve)
6043 { // IndexField overlaying C05D/C05E
6078 } // IndexField overlaying C05D/C05E
6080 OperationRegion (C07F, SystemIO, 0xE4, 2)
6081 Field (C07F, ByteAcc, NoLock, Preserve)
6082 { // Field overlaying C07F
6085 } // Field overlaying C07F
6087 OperationRegion (C082, SystemIO, 0xE0, 1)
6088 Field (C082, ByteAcc, NoLock, Preserve)
6089 { // Field overlaying C082
6091 } // Field overlaying C082
6093 OperationRegion (C084, SystemIO, 0xFF, 1)
6094 Field (C084, ByteAcc, NoLock, Preserve)
6095 { // Field overlaying C084
6097 } // Field overlaying C084
6099 OperationRegion (C086, SystemIO, 0xFD, 1)
6100 Field (C086, ByteAcc, NoLock, Preserve)
6101 { // Field overlaying C086
6103 } // Field overlaying C086
6112 Name (C08E, 0xFFFFFFFD)
6116 { // C0AA control method
6117 Store (Buffer (4) {}, Local7)
6118 CreateByteField (Local7, 0, C0AB)
6119 CreateByteField (Local7, 1, C0AC)
6120 CreateByteField (Local7, 2, C0AD)
6121 CreateByteField (Local7, 3, C0AE)
6122 Acquire (^C08B, 0xFFFF)
6123 Acquire (\_GL, 0xFFFF)
6125 Store (1, \_SB.C005.C013.C058.C06B)
6126 While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
6128 Store (Arg3, \_SB.C005.C013.C058.C06E)
6129 Store (Arg2, \_SB.C005.C013.C058.C06D)
6130 Store (Arg1, \_SB.C005.C013.C058.C06C)
6131 Store (Arg0, \_SB.C005.C013.C058.C06B)
6132 While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
6134 Store (\_SB.C005.C013.C058.C06E, C0AB)
6135 Store (\_SB.C005.C013.C058.C06D, C0AC)
6136 Store (\_SB.C005.C013.C058.C06C, C0AD)
6137 Store (\_SB.C005.C013.C058.C06B, C0AE)
6138 If (LNot (LEqual (Arg0, 23)))
6140 Store (2, \_SB.C005.C013.C058.C06B)
6146 } // C0AA control method
6148 } // Scope \_SB.C005.C013
6151 { // \_TZ thermal zone scope
6152 Name (C18B, Package (2)
6156 Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
6157 Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
6161 Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
6162 Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
6166 Name (C18C, Package (2)
6170 Package (3) {0x64, 0x4B, 0x32},
6171 Package (3) {0x64, 0x4B, 0x32}
6187 Name (C199, 0xFFFFFFFD)
6192 Name (RSLT, 0) // default to zero
6195 { // _INI control method (Uses Global Lock -- can't run under AcpiExec)
6196 Store (\_SB.C115, C19A)
6198 Subtract (0x0EB2, 0x0AAC, Local1) // Local1 = AACh - EB2h
6199 Divide (Local1, 10, Local0, Local2) // Local0 = Local1 / 10
6200 // Local2 = Local1 % 10
6201 \_SB.C005.C013.C058.C0AA (14, Local2, 0, 0)
6203 (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 0, )), C18D)
6205 (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 1, )), C18E)
6207 (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 2, )), C18F)
6209 Store (1, RSLT) // set RSLT to 1 if _INI control method completes
6210 } // _INI control method
6212 // PowerResource (C19D) {...}
6218 { // _SCP control method
6219 Store (Arg0, Local0)
6220 If (LEqual (Local0, 0))
6222 Store (0, \_TZ.C192)
6223 Store (1, \_TZ.C193)
6224 Store (2, \_TZ.C194)
6225 Store (3, \_TZ.C191)
6229 Store (0, \_TZ.C191)
6230 Store (1, \_TZ.C192)
6231 Store (2, \_TZ.C193)
6232 Store (3, \_TZ.C194)
6234 } // _SCP control method
6235 } // ThermalZone C19C
6236 } // \_TZ thermal zone scope
6242 Name (BUFR, buffer(10) {0,0,0,0,0,0,0,0,0,0} )
6248 Store ("++++++++ DwrdFld Test", Debug)
6250 CreateByteField (BUFR, 0, BYTE)
6253 CreateWordField (BUFR, 1, WORD)
6254 Store (0xBBCC, WORD)
6256 CreateDWordField (BUFR, 3, DWRD)
6257 Store (0xDDEEFF00, DWRD)
6259 CreateByteField (BUFR, 7, BYT2)
6262 CreateWordField (BUFR, 8, WRD2)
6263 Store (0x2233, WRD2)
6267 } // End Method TEST
6277 { // This control method will take two bytes and make them into a WORD
6279 Multiply (B1HI, 256, Local0) // Make high byte.....high
6280 Or (Local0, B1LO, Local0) // OR in the low byte
6281 Return (Local0) // Return the WORD
6290 Store ("++++++++ DivAddx Test", Debug)
6295 // We'll multiply 25 * 3 to get 75, add 99 to it then divide
6296 // by 100. We expect to get 74 for the remainder and 1 for
6299 Add (Multiply (3, MKW_ (B1LO, B1HI)), 0x63),
6302 Local4, // Remainder
6305 If (LAnd (LEqual (74, Local4), LEqual (1, Local2)))
6307 Store (0x00, Local0)
6312 Store (0x01, Local0)
6316 } // End Method TEST
6320 // test IndexFld.asl (IndexOp6.asl)
6323 // This is just a subset of the many RegionOp/Index Field test cases.
6324 // Tests index field element AccessAs macro.
6325 // Also tests name resolution of index field elements with same names
6326 // but different namespace scopes.
6329 { // Test device name
6331 OperationRegion (SIO, SystemIO, 0x100, 2)
6332 Field (SIO, ByteAcc, NoLock, Preserve)
6337 IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
6339 AccessAs (ByteAcc, 0),
6353 { // TST_: provides a different namespace scope for IFE0 and IFE1
6354 OperationRegion (SIO2, SystemIO, 0x100, 2)
6355 Field (SIO2, ByteAcc, NoLock, Preserve)
6360 IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes)
6362 IFE0, 8, // duplicate IndexField name with different scope
6365 } // TST_: provides a different namespace scope for IFE0 and IFE1
6369 Store ("++++++++ IndexOp6 Test", Debug)
6371 Store (IFE0, Local0)
6372 Store (IFE1, Local1)
6373 Store (IFE2, Local2)
6375 // validate name resolution of IndexFields with different scopes
6376 Store (\IDX6.IFE0, Local3)
6377 Store (\IDX6.IFE1, Local4)
6378 // verioading of namespace can resolve following names
6379 Store (\IDX6.TST_.IFE0, Local5)
6380 Store (\IDX6.TST_.IFE1, Local6)
6387 // test IndexOp5.asl
6390 // This is just a subset of the many RegionOp/Index Field test cases.
6391 // Tests copying string into buffer then performing IndexOp on result.
6394 { // Test device name
6396 Name (OSFL, 0) // 0 == Windows 98, 1 == Windows NT
6398 // MCTH is a control method to compare two strings. It returns
6399 // zero if the strings mismatch, or 1 if the strings match.
6400 // This exercises the test case of copying a string into a buffer
6401 // and performing an IndexOp on the resulting buffer.
6402 Method (MCTH, 2, Serialized) // Control Method to compare two strings
6403 { // MCTH: Control Method to compare two strings
6404 // Arg0: first string to compare
6405 // Arg1: second string to compare
6406 // Return: zero if strings mismatch, 1 if strings match
6408 // check if first string's length is less than second string's length
6409 If (LLess (SizeOf (Arg0), SizeOf (Arg1)))
6412 // increment length to include NULL termination character
6413 Add (SizeOf (Arg0), 1, Local0) // Local0 = strlen(Arg0) + 1
6415 // create two buffers of size Local0 [strlen(Arg0)+1]
6416 Name (BUF0, Buffer (Local0) {})
6417 Name (BUF1, Buffer (Local0) {})
6419 // copy strings into buffers
6423 // validate BUF0 and BUF1 are still buffers
6424 Store (ObjectType (BUF0), Local1)
6425 If (LNotEqual (Local1, 3)) // Buffer is type 3
6427 Store (ObjectType (BUF1), Local1)
6428 If (LNotEqual (Local1, 3)) // Buffer is type 3
6431 // Decrement because the Index base below is zero based
6432 // while Local0 length is one based.
6436 { // loop through all BUF0 buffer elements
6439 // check if BUF0[n] == BUF1[n]
6440 If (LEqual (DerefOf (Index (BUF0, Local0, )),
6441 DerefOf (Index (BUF1, Local0, ))))
6442 { } // this is how the code was really implemented
6445 } // loop through all BUF0 buffer elements
6447 Return (One) // strings / buffers match
6448 } // MCTH: Control Method to compare two strings
6453 Store ("++++++++ IndexOp5 Test", Debug)
6455 If (MCTH (\_OS, "Microsoft Windows NT"))
6458 If (LNotEqual (OSFL, 1))
6468 Scope (\_SB) // System Bus
6476 Name (_HID, EISAID("PNP0A03"))
6477 Name (_ADR, 0x00000000)
6478 Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."})
6479 Method (_STA) {Return (0x0F)}
6483 Name (_ADR, 0x00030000) // ISA bus ID
6486 { // Embedded Controller
6487 Name (_GPE, 0) // EC use GPE0
6488 Name (_ADR, 0x0030000) // PCI address
6490 Method (_STA,0) // EC Status
6491 { Return(0xF) } // EC is functioning
6493 Name (_CRS, ResourceTemplate()
6495 IO (Decode16, 0x62, 0x62, 1, 1)
6496 IO (Decode16, 0x66, 0x66, 1, 1)
6500 // create EC's region and field
6501 OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
6502 Field (RAM, AnyAcc, NoLock, Preserve)
6505 ADP, 1, // AC Adapter 1:On-line, 0:Off-line
6506 AFLT, 1, // AC Adapter Fault 1:Fault 0:Normal
6507 BAT0, 1, // BAT0 1:present, 0:not present
6509 , 28, // filler to force DWORD alignment
6511 // CMBatt information
6512 BPU0, 32, // Power Unit
6513 BDC0, 32, // Designed Capacity
6514 BFC0, 32, // Last Full Charge Capacity
6515 BTC0, 32, // Battery Technology
6516 BDV0, 32, // Design Voltage
6517 BST0, 32, // Battery State
6518 BPR0, 32, // Battery Present Rate
6519 // (Designed Capacity)x(%)/{(h)x100}
6520 BRC0, 32, // Battery Remaining Capacity
6521 // (Designed Capacity)(%)^100
6522 BPV0, 32, // Battery Present Voltage
6523 BTP0, 32, // Trip Point
6524 BCW0, 32, // Design capacity of Warning
6525 BCL0, 32, // Design capacity of Low
6526 BCG0, 32, // capacity granularity 1
6527 BG20, 32, // capacity granularity 2
6528 BMO0, 32, // Battery model number field
6529 BIF0, 32, // OEM Information(00h)
6530 BSN0, 32, // Battery Serial Number
6531 BTY0, 32, // Battery Type (e.g., "Li-Ion")
6532 BTY1, 32 // Battery Type (e.g., "Li-Ion")
6534 } // EC0: Embedded Controller
6536 } // PCI2 Root PCI Bus
6539 { // Test device name
6540 Name (_HID, EISAID ("PNP0C0A")) // Control Method Battey ID
6541 Name (_PCL, Package() {\_SB})
6544 // _STA bits 0-3 indicate existence of battery slot
6545 // _STA bit 4 indicates battery (not) present
6546 If (\_SB.PCI2.ISA.EC0.BAT0)
6547 { Return (0x1F) } // Battery present
6549 { Return (0x0F) } // Battery not present
6552 Method (_BIF,, Serialized)
6554 Name (BUFR, Package(13) {})
6555 Store (\_SB.PCI2.ISA.EC0.BPU0, Index (BUFR,0)) // Power Unit
6556 Store (\_SB.PCI2.ISA.EC0.BDC0, Index (BUFR,1)) // Designed Capacity
6557 Store (\_SB.PCI2.ISA.EC0.BFC0, Index (BUFR,2)) // Last Full Charge Capa.
6558 Store (\_SB.PCI2.ISA.EC0.BTC0, Index (BUFR,3)) // Battery Technology
6559 Store (\_SB.PCI2.ISA.EC0.BDV0, Index (BUFR,4)) // Designed Voltage
6560 Store (\_SB.PCI2.ISA.EC0.BCW0, Index (BUFR,5)) // Designed warning level
6561 Store (\_SB.PCI2.ISA.EC0.BCL0, Index (BUFR,6)) // Designed Low level
6562 Store (\_SB.PCI2.ISA.EC0.BCG0, Index (BUFR,7)) // Capacity granularity 1
6563 Store (\_SB.PCI2.ISA.EC0.BG20, Index (BUFR,8)) // Capacity granularity 2
6565 Store ("", Index (BUFR,9)) // Model Number
6567 Store ("", Index (BUFR,10)) // Serial Number
6569 Store ("LiOn", Index (BUFR,11)) // Battery Type
6571 Store ("Chicony", Index (BUFR,12)) // OEM Information
6576 Method (_BST,, Serialized)
6578 Name (BUFR, Package(4) {1, 0x100, 0x76543210, 0x180})
6584 Store (arg0, \_SB.PCI2.ISA.EC0.BTP0) // Set Battery Trip point
6587 Method (TEST,, Serialized)
6590 Store ("++++++++ IndexOp Test", Debug)
6592 // test storing into uninitialized package elements
6593 Name (PBUF, Package(4) {}) // leave unitialized
6594 Store (0x01234567, Index (PBUF,0))
6595 Store (0x89ABCDEF, Index (PBUF,1))
6596 Store (0xFEDCBA98, Index (PBUF,2))
6597 Store (0x76543210, Index (PBUF,3))
6599 // verify values stored into uninitialized package elements
6600 If (LNotEqual (DerefOf (Index (PBUF,0)), 0x01234567))
6603 If (LNotEqual (DerefOf (Index (PBUF,1)), 0x89ABCDEF))
6606 If (LNotEqual (DerefOf (Index (PBUF,2)), 0xFEDCBA98))
6609 If (LNotEqual (DerefOf (Index (PBUF,3)), 0x76543210))
6613 // store _BIF package return value into Local0
6614 Store (_BIF, Local0)
6616 // save Local0 object type value into Local1
6617 Store (ObjectType (Local0), Local1)
6619 // validate Local0 is a Package
6620 If (LNotEqual (Local1, 4)) // Package type is 4
6621 { Return (0x21) } // failure
6624 // test storing into buffer field elements
6625 Name (BUFR, Buffer(16)
6627 00, 00, 00, 00, 00, 00, 00, 00,
6628 00, 00, 00, 00, 00, 00, 00, 00,
6631 // test storing into buffer field elements
6632 Store (0x01234567, Index (BUFR,0)) // should only store 0x67
6633 Store (0x89ABCDEF, Index (BUFR,4)) // should only store 0xEF
6634 Store (0xFEDCBA98, Index (BUFR,8)) // should only store 0x98
6635 Store (0x76543210, Index (BUFR,12)) // should only store 0x10
6637 // verify storing into buffer field elements
6638 If (LNotEqual (DerefOf (Index (BUFR,0)), 0x67))
6641 If (LNotEqual (DerefOf (Index (BUFR,1)), 0))
6644 If (LNotEqual (DerefOf (Index (BUFR,4)), 0xEF))
6647 If (LNotEqual (DerefOf (Index (BUFR,8)), 0x98))
6650 If (LNotEqual (DerefOf (Index (BUFR,12)), 0x10))
6660 // test BitIndex.asl
6663 // This is a test case for accessing fields defined as single bits in
6664 // memory. This is done by creating two index fields that overlay the
6665 // same DWORD in memory. One field accesses the DWORD as a DWORD, the
6666 // other accesses individual bits of the same DWORD field in memory.
6668 Scope (\_SB) // System Bus
6670 OperationRegion (RAM, SystemMemory, 0x800000, 0x100)
6671 Field (RAM, AnyAcc, NoLock, Preserve)
6679 DWRD, 32, // DWORD field
6681 Field (RAM, AnyAcc, NoLock, Preserve)
6689 BYT0, 8, // Start off with a BYTE
6690 BIT0, 1, // single-bit field
6691 BIT1, 1, // single-bit field
6692 BIT2, 1, // single-bit field
6693 BIT3, 1, // single-bit field
6694 BIT4, 1, // single-bit field
6695 BIT5, 1, // single-bit field
6696 BIT6, 1, // single-bit field
6697 BIT7, 1, // single-bit field
6698 BIT8, 1, // single-bit field
6699 BIT9, 1, // single-bit field
6700 BITA, 1, // single-bit field
6701 BITB, 1, // single-bit field
6702 BITC, 1, // single-bit field
6703 BITD, 1, // single-bit field
6704 BITE, 1, // single-bit field
6705 BITF, 1, // single-bit field
6706 BYTZ, 8, // End with a BYTE for a total of 32 bits
6710 { // Test device name
6712 Method (MBIT) // Test single bit memory accesses
6715 If (LNotEqual (DWRD, 0x00))
6717 Store (0xFF00, Local0)
6721 // Prime Local0 with 0...assume passing condition
6724 // set memory contents to known values using DWORD field
6725 Store (0x5A5A5A5A, DWRD)
6727 // Given the value programmed into DWRD, only the odd bits
6728 // of the lower nibble should be set. BIT1, BIT3 should be set.
6729 // BIT0 and BIT2 should be clear
6733 Or (Local0, 0x01, Local0)
6738 Or (Local0, 0x02, Local0)
6743 Or (Local0, 0x04, Local0)
6748 Or (Local0, 0x08, Local0)
6751 // Now check the upper nibble. Only the "even" bits should
6752 // be set. BIT4, BIT6. BIT5 and BIT7 should be clear.
6755 Or (Local0, 0x10, Local0)
6760 Or (Local0, 0x20, Local0)
6765 Or (Local0, 0x40, Local0)
6770 Or (Local0, 0x80, Local0)
6772 } // End Else DWRD zeroed out
6775 } // MBIT: Test single bit memory accesses
6780 Store ("++++++++ BitIndex Test", Debug)
6783 Store (0x00000000, DWRD)
6785 // MBIT returns zero if successful
6786 // This may be causing problems -- Return (MBIT)
6787 Store (MBIT, Local0)
6795 // test IndexOp3.asl
6797 // Additional IndexOp test cases to support ACPICMB (control method battery
6798 // test) on Compaq laptops. Test cases include storing a package into
6799 // an IndexOp target and validating that changing source and destination
6800 // package contents are independent of each other.
6802 Scope (\_SB) // System Bus
6809 { // C158: AC Adapter device
6810 Name (_HID, "ACPI0003") // AC Adapter device
6811 Name (_PCL, Package (1) {\_SB})
6815 Acquire (\_GL, 0xFFFF)
6817 And (Local0, 1, Local0) // Local0 &= 1
6820 } // C158: AC Adapter device
6822 Name (C176, Package (4) {"Primary", "MultiBay", "DockRight", "DockLeft"})
6824 Name (C177, Package (4) {0x99F5, 0x99F5, 0x995F, 0x995F})
6826 Name (C178, Package (4)
6828 Package (4) {0, 0, 0x966B, 0x4190},
6829 Package (4) {0, 0, 0x966B, 0x4190},
6830 Package (4) {0, 0, 0x966B, 0x4190},
6831 Package (4) {0, 0, 0x966B, 0x4190}
6834 Name (C179, Package (4) {0, 0, 0x966B, 0x4190})
6836 Name (C17A, Package (4)
6838 Package (3) {0, 0, 0},
6839 Package (3) {0, 0, 0},
6840 Package (3) {0, 0, 0},
6841 Package (3) {0, 0, 0}
6844 Method (C17B, 1, Serialized)
6845 { // C17B: _BIF implementation
6846 Name (C17C, Package (13)
6847 { // C17C: _BIF control method return package
6848 0, // Power Unit (0 ==> mWh and mW)
6849 0x99F5, // Design Capacity
6850 0x99F5, // Last Full Charge Capacity
6851 1, // Battery Technology (1 ==> rechargeable)
6852 0x3840, // Design Voltage
6853 0x1280, // Design Capacity of Warning
6854 0x0AC7, // Design Capacity of Low
6855 1, // Battery Capacity Granularity 1 (Low -- Warning)
6856 1, // Battery Capacity Granularity 2 (Warning -- Full)
6857 "2891", // Model Number (ASCIIZ)
6858 "(-Unknown-)", // Serial Number (ASCIIZ)
6859 "LIon", // Battery Type (ASCIIZ)
6860 0 // OEM Information (ASCIIZ)
6861 }) // C17C: _BIF control method return package
6863 And (Arg0, 7, Local0) // Local0 = Arg0 & 7
6865 ShiftRight (Local0, 1, Local4) // Local4 = Local0 >> 1
6867 Store (C179, Index (C178, Local4, )) // C178->Local4 = C179
6869 // verify source and destination packages can be altered independent
6870 // of each other (i.e., changing one's contents does NOT change other's
6872 Store (0x1234, Index (C179, 2, )) // C179[2] = 0x1234
6873 Store (DerefOf (Index (C179, 2, )), Local2) // Local2 = C179[2]
6874 if (LNotEqual (Local2, 0x1234))
6876 // Local2 = C178[0,2]
6877 Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 2, )), Local2)
6878 if (LNotEqual (Local2, 0x966B))
6881 // Restore data to allow iterative execution
6882 Store (0x966B, Index (C179, 2, )) // C179[2] = 0x966B
6884 // C178[0,3] = 0x5678
6885 Store (0x5678, Index (DerefOf (Index (C178, 0, )), 3, ))
6886 // Local2 = C178[0,3]
6887 Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 3, )), Local2)
6888 if (LNotEqual (Local2, 0x5678))
6891 Store (DerefOf (Index (C179, 3, )), Local2) // Local2 = C179[3]
6892 if (LNotEqual (Local2, 0x4190))
6895 // Restore data to allow iterative execution
6896 Store (0x4190, Index (DerefOf (Index (C178, 0, )), 3, )) // C179[2] = 0x4190
6899 } // C17B: _BIF implementation
6902 { // C154: Battery 0
6903 Name (_HID, "*PNP0C0A") // Control Method Battey ID
6904 Name (_UID, 0) // first instance
6910 } // C154: Battery 0
6914 Method (LCLB,, Serialized)
6915 { // LCLB control method: test Index(Local#) where Local# is buffer
6916 // Local0 is index counter
6918 // Local2 receives BUFR[Local0] via Deref(Index(Local1...))
6919 // Local3 is Local1 or Local2 object type
6920 // Local4 is return error code
6922 Name (BUFR, Buffer () {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
6924 // save PKG into Local1
6925 Store (BUFR, Local1)
6927 // save Local2 object type value into Local3
6928 Store (ObjectType (Local1), Local3)
6930 // validate Local1 is a Buffer
6931 If (LNotEqual (Local3, 3)) // Buffer type is 3
6936 While (LLess (Local0, 5))
6937 { // While (Local0 < 5)
6938 // Local2 = Local1[Local0]
6939 Store (DerefOf (Index (Local1, Local0, )), Local2)
6941 // save Local2 object type value into Local3
6942 Store (ObjectType (Local2), Local3)
6944 // validate Local2 is a Number
6945 If (LNotEqual (Local3, 1)) // Number type is 1
6948 // validate Local1[Local0] value == Local0
6949 If (LNotEqual (Local0, Local2))
6950 { // Local0 != Local2 == PKG[Local0]
6951 // Local4 = 0x90 + loop index (Local0)
6952 Add (0x90, Local0, Local4)
6954 // return 0x90 + loop index
6959 } // While (Local0 < 5)
6961 Store ("DerefOf(Index(LocalBuffer,,)) PASS", Debug)
6964 } // LCLB control method: test Index(Local#) where Local# is buffer
6966 Method (LCLP,, Serialized)
6967 { // LCLP control method: test Index(Local#) where Local# is package
6968 // Local0 is index counter
6969 // Local1 is package
6970 // Local2 receives PKG[Local0] via Deref(Index(Local1...))
6971 // Local3 is Local1 or Local2 object type
6972 // Local4 is return error code
6974 Name (PKG, Package () {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
6976 // save PKG into Local1
6979 // save Local2 object type value into Local3
6980 Store (ObjectType (Local1), Local3)
6982 // validate Local1 is a Package
6983 If (LNotEqual (Local3, 4)) // Package type is 4
6988 While (LLess (Local0, 5))
6989 { // While (Local0 < 5)
6990 // Local2 = Local1[Local0]
6991 Store (DerefOf (Index (Local1, Local0, )), Local2)
6993 // save Local2 object type value into Local3
6994 Store (ObjectType (Local2), Local3)
6996 // validate Local2 is a Number
6997 If (LNotEqual (Local3, 1)) // Number type is 1
7000 // validate Local1[Local0] value == Local0
7001 If (LNotEqual (Local0, Local2))
7002 { // Local0 != Local2 == PKG[Local0]
7003 // Local4 = 0x80 + loop index (Local0)
7004 Add (0x80, Local0, Local4)
7006 // return 0x80 + loop index
7011 } // While (Local0 < 5)
7013 Store ("DerefOf(Index(LocalPackage,,)) PASS", Debug)
7016 } // LCLP control method: test Index(Local#) where Local# is package
7021 Store ("++++++++ IndexOp3 Test", Debug)
7023 // store _BIF package return value into Local0
7024 Store (\_SB.C154._BIF, Local0)
7026 // save Local0 object type value into Local1
7027 Store (ObjectType (Local0), Local1)
7029 // validate Local0 is a Package
7030 If (LNotEqual (Local1, 4)) // Package type is 4
7031 { // failure: did not return a Package (type 4)
7032 // if Local0 is a Number, it contains an error code
7033 If (LEqual (Local1, 1)) // Number type is 1
7034 { Return (Local0) } // return Local0 error code
7035 Else // Local0 is not a Number
7036 { Return (1) } // return default error code
7037 } // failure: did not return a Package (type 4)
7039 // save LCLB control method return value into Local2
7040 Store (LCLB, Local2)
7041 If (LNotEqual (Local2, 0))
7042 { Return (Local2) } // return failure code
7044 // save LCLP control method return value into Local2
7045 Store (LCLP, Local2)
7046 If (LNotEqual (Local2, 0))
7047 { Return (Local2) } // return failure code
7051 } // IDX3: Test device name
7055 // MTL developed test to exercise Indexes into buffers
7060 Name (PKG4, Package() {
7063 Buffer() {0xA, 0xB, 0xC, 0xD},
7065 Package() {IDX7, 0x3}
7069 // Generic Test method
7071 // This test returns 0xE (14) - ObjectType = Buffer Field
7072 Method(TST1,, Serialized)
7074 Name (DEST, Buffer () // 62 characters plus NULL
7075 {"Destination buffer that is longer than the short source buffer"})
7077 // verify object type returned by Index(Buffer,Element,)
7078 Store (Index (DEST, 2, ), Local1)
7079 Store (ObjectType (Local1), Local2)
7080 If (LEqual(Local2, 14))
7091 Method(TST2,, Serialized)
7093 Name (BUF0, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
7094 Store(0x55, Index(BUF0, 2))
7095 Store(DerefOf(Index(BUF0, 2)), Local0)
7096 If (LEqual(Local0, 0x55))
7108 Method(TST3,, Serialized)
7110 Name (BUF1, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
7111 Store(Index(BUF1, 1), Local0)
7112 Store(DerefOf(Local0), Local1)
7113 If (LEqual(Local1, 0x2))
7126 // Index (PKG4, 0) is a Number
7127 Store (Index (PKG4, 0), Local0)
7128 Store (ObjectType(Local0), Local1)
7129 If (LEqual(Local1, 0x1))
7142 // Index (PKG4, 1) is a String
7143 Store (Index (PKG4, 1), Local0)
7144 Store (ObjectType(Local0), Local1)
7145 If (LEqual(Local1, 0x2))
7158 // Index (PKG4, 2) is a Buffer
7159 Store (Index (PKG4, 2), Local0)
7160 Store (ObjectType(Local0), Local1)
7161 If (LEqual(Local1, 0x3))
7174 // Index (PKG4, 3) is a Number
7175 Store (Index (PKG4, 3), Local0)
7176 Store (ObjectType(Local0), Local1)
7177 If (LEqual(Local1, 0x1))
7190 // Index (PKG4, 4) is a Package
7191 Store (Index (PKG4, 4), Local0)
7192 Store (ObjectType(Local0), Local1)
7193 If (LEqual(Local1, 0x4))
7206 // DerefOf (Index (PKG4, 0)) is a Number
7207 Store (DerefOf (Index (PKG4, 0)), Local0)
7208 If (LEqual(Local0, 0x2))
7221 // DerefOf (Index (PKG4, 1)) is a String
7222 Store (DerefOf (Index (PKG4, 1)), Local0)
7223 Store (SizeOf(Local0), Local1)
7224 If (LEqual(Local1, 0xE))
7237 // DerefOf (Index (PKG4, 2)) is a Buffer
7238 Store (DerefOf (Index (PKG4, 2)), Local0)
7239 Store (SizeOf(Local0), Local1)
7240 If (LEqual(Local1, 0x4))
7253 // DerefOf (Index (PKG4, 3)) is a Number
7254 Store (DerefOf (Index (PKG4, 3)), Local0)
7255 If (LEqual(Local0, 0x1234))
7268 // DerefOf (Index (PKG4, 4)) is a Package
7269 Store (DerefOf (Index (PKG4, 4)), Local0)
7270 Store (SizeOf(Local0), Local1)
7271 If (LEqual(Local1, 0x2))
7284 // DerefOf (Index (PKG4, 2)) is a Buffer
7285 Store (DerefOf (Index (PKG4, 2)), Local0)
7286 // DerefOf (Index (Local0, 1)) is a Number
7287 Store (DerefOf (Index (Local0, 1)), Local1)
7288 If (LEqual(Local1, 0xB))
7299 Method (TSTF,, Serialized)
7301 Name (SRCB, Buffer (12) {}) // 12 characters
7302 Store ("Short Buffer", SRCB)
7304 Name (DEST, Buffer () // 62 characters plus NULL
7305 {"Destination buffer that is longer than the short source buffer"})
7307 // overwrite DEST contents, starting at buffer position 2
7308 Store (SRCB, Index (DEST, 2))
7311 // The DEST buffer element should be replaced with the last element of
7312 // the SRCB element (i.e. 's'->'r')
7313 Store (DerefOf (Index (DEST, 2)), Local0)
7315 If (LNotEqual (Local0, 0x72)) // 'r'
7317 // DEST element does not match the value from SRCB
7318 Return(Or(Local0, 0x1000))
7324 Method (TSTG,, Serialized)
7327 Name (SRCB, Buffer (12) {}) // 12 characters
7328 Store ("Short Buffer", SRCB)
7330 Name (DEST, Buffer () // 62 characters plus NULL
7331 {"Destination buffer that is longer than the short source buffer"})
7333 // overwrite DEST contents, starting at buffer position 2
7334 Store (SRCB, Index (DEST, 2))
7337 // The next element of DEST should be unchanged
7339 Store (DerefOf (Index (DEST, 3)), Local0)
7341 If (LNotEqual (Local0, 0x74)) // 't'
7343 // DEST has been changed
7344 Return(Or(Local0, 0x2000))
7348 // The next element of DEST should be unchanged
7350 Store (DerefOf (Index (DEST, 4)), Local0)
7352 If (LNotEqual (Local0, 0x69)) // 'i'
7354 // DEST has been changed
7355 Return(Or(Local0, 0x2100))
7359 // The next element of DEST should be unchanged
7361 Store (DerefOf (Index (DEST, 5)), Local0)
7363 If (LNotEqual (Local0, 0x6E)) // 'n'
7365 // DEST has been changed
7366 Return(Or(Local0, 0x2200))
7370 // The next element of DEST should be unchanged
7372 Store (DerefOf (Index (DEST, 6)), Local0)
7374 If (LNotEqual (Local0, 0x61)) // 'a'
7376 // DEST has been changed
7377 Return(Or(Local0, 0x2300))
7381 // The next element of DEST should be unchanged
7383 Store (DerefOf (Index (DEST, 7)), Local0)
7385 If (LNotEqual (Local0, 0x74)) // 't'
7387 // DEST has been changed
7388 Return(Or(Local0, 0x2400))
7392 // Verify DEST elements beyond end of SRCB buffer copy
7393 // have not been changed
7394 Store (DerefOf (Index (DEST, 14)), Local0)
7396 If (LNotEqual (Local0, 0x66)) // 'f'
7398 // DEST has been changed
7399 Return(Or(Local0, 0x2400))
7406 // This test shows that MS ACPI.SYS stores only the lower 8-bits of a 32-bit
7407 // number into the index'ed buffer
7409 Method (TSTH,, Serialized)
7411 // Create a Destination Buffer
7412 Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7414 // Store a number > UINT8 into an index of the buffer
7415 Store (0x12345678, Index(DBUF, 2))
7417 // Check the results
7418 Store (DerefOf (Index (DBUF, 2)), Local0)
7419 If (LNotEqual (Local0, 0x78)) // 0x78
7421 Return(Or(Local0, 0x3000))
7424 Store (DerefOf (Index (DBUF, 3)), Local0)
7425 If (LNotEqual (Local0, 0x64)) // 'd'
7427 Return(Or(Local0, 0x3100))
7430 Store (DerefOf (Index (DBUF, 4)), Local0)
7431 If (LNotEqual (Local0, 0x65)) // 'e'
7433 Return(Or(Local0, 0x3200))
7436 Store (DerefOf (Index (DBUF, 5)), Local0)
7437 If (LNotEqual (Local0, 0x66)) // 'f'
7439 Return(Or(Local0, 0x3300))
7445 Method (TSTI,, Serialized)
7447 // Create a Destination Buffer
7448 Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7450 // Store a String into an index of the buffer
7451 Store ("ABCDEFGH", Index(DBUF, 2))
7453 // Check the results
7454 Store (DerefOf (Index (DBUF, 2)), Local0)
7455 If (LNotEqual (Local0, 0x48)) // 'H'
7457 Return(Or(Local0, 0x4000))
7460 Store (DerefOf (Index (DBUF, 3)), Local0)
7461 If (LNotEqual (Local0, 0x64)) // 'd'
7463 Return(Or(Local0, 0x4100))
7466 Store (DerefOf (Index (DBUF, 4)), Local0)
7467 If (LNotEqual (Local0, 0x65)) // 'e'
7469 Return(Or(Local0, 0x4200))
7472 Store (DerefOf (Index (DBUF, 5)), Local0)
7473 If (LNotEqual (Local0, 0x66)) // 'f'
7475 Return(Or(Local0, 0x4300))
7481 Method(TSTJ,, Serialized)
7483 // Create a Destination Buffer
7484 Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7486 // Store a number > UINT8 into an index of the buffer
7487 Store (0x1234, Index(DBUF, 2))
7489 // Check the results
7490 Store (DerefOf (Index (DBUF, 2)), Local0)
7491 If (LNotEqual (Local0, 0x34)) // 0x34
7493 Return(Or(Local0, 0x3000))
7496 Store (DerefOf (Index (DBUF, 3)), Local0)
7497 If (LNotEqual (Local0, 0x64)) // 'd'
7499 Return(Or(Local0, 0x3100))
7502 Store (DerefOf (Index (DBUF, 4)), Local0)
7503 If (LNotEqual (Local0, 0x65)) // 'e'
7505 Return(Or(Local0, 0x3200))
7508 Store (DerefOf (Index (DBUF, 5)), Local0)
7509 If (LNotEqual (Local0, 0x66)) // 'f'
7511 Return(Or(Local0, 0x3300))
7517 Method(TSTK,, Serialized)
7519 // Create a Destination Buffer
7520 Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7522 // Store a number > UINT8 into an index of the buffer
7523 Store (0x123456, Index(DBUF, 2))
7525 // Check the results
7526 Store (DerefOf (Index (DBUF, 2)), Local0)
7527 If (LNotEqual (Local0, 0x56)) // 0x56
7529 Return(Or(Local0, 0x3000))
7532 Store (DerefOf (Index (DBUF, 3)), Local0)
7533 If (LNotEqual (Local0, 0x64)) // 'd'
7535 Return(Or(Local0, 0x3100))
7538 Store (DerefOf (Index (DBUF, 4)), Local0)
7539 If (LNotEqual (Local0, 0x65)) // 'e'
7541 Return(Or(Local0, 0x3200))
7544 Store (DerefOf (Index (DBUF, 5)), Local0)
7545 If (LNotEqual (Local0, 0x66)) // 'f'
7547 Return(Or(Local0, 0x3300))
7553 Method(TSTL,, Serialized)
7555 // Create a Destination Buffer
7556 Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7558 // Store a number > UINT8 into an index of the buffer
7559 Store (0x12, Index(DBUF, 2))
7561 // Check the results
7562 Store (DerefOf (Index (DBUF, 2)), Local0)
7563 If (LNotEqual (Local0, 0x12)) // 0x12
7565 Return(Or(Local0, 0x3000))
7568 Store (DerefOf (Index (DBUF, 3)), Local0)
7569 If (LNotEqual (Local0, 0x64)) // 'd'
7571 Return(Or(Local0, 0x3100))
7574 Store (DerefOf (Index (DBUF, 4)), Local0)
7575 If (LNotEqual (Local0, 0x65)) // 'e'
7577 Return(Or(Local0, 0x3200))
7580 Store (DerefOf (Index (DBUF, 5)), Local0)
7581 If (LNotEqual (Local0, 0x66)) // 'f'
7583 Return(Or(Local0, 0x3300))
7591 Store ("++++++++ IndexOp7 Test", Debug)
7593 Store(TST1(), Local0)
7594 if (LGreater (Local0, 0))
7599 Store(TST2(), Local0)
7600 if (LGreater (Local0, 0))
7605 Store(TST3(), Local0)
7606 if (LGreater (Local0, 0))
7611 Store(TST4(), Local0)
7612 if (LGreater (Local0, 0))
7617 Store(TST5(), Local0)
7618 if (LGreater (Local0, 0))
7623 Store(TST6(), Local0)
7624 if (LGreater (Local0, 0))
7629 Store(TST7(), Local0)
7630 if (LGreater (Local0, 0))
7635 Store(TST8(), Local0)
7636 if (LGreater (Local0, 0))
7641 Store(TST9(), Local0)
7642 if (LGreater (Local0, 0))
7647 Store(TSTA(), Local0)
7648 if (LGreater (Local0, 0))
7653 Store(TSTB(), Local0)
7654 if (LGreater (Local0, 0))
7659 Store(TSTC(), Local0)
7660 if (LGreater (Local0, 0))
7665 Store(TSTD(), Local0)
7666 if (LGreater (Local0, 0))
7671 Store(TSTE(), Local0)
7672 if (LGreater (Local0, 0))
7677 /* No longer ACPI compliant */
7679 Store(TSTF(), Local0)
7680 if (LGreater (Local0, 0))
7686 Store(TSTG(), Local0)
7687 if (LGreater (Local0, 0))
7692 Store(TSTH(), Local0)
7693 if (LGreater (Local0, 0))
7698 /* No longer ACPI compliant */
7700 Store(TSTI(), Local0)
7701 if (LGreater (Local0, 0))
7706 Store(TSTJ(), Local0)
7707 if (LGreater (Local0, 0))
7712 Store(TSTK(), Local0)
7713 if (LGreater (Local0, 0))
7718 Store(TSTL(), Local0)
7719 if (LGreater (Local0, 0))
7733 // MatchOp test cases that utilize nested DerefOf(Index(...)) to validate
7734 // MatchOp, DerefOfOp, and IndexOp of nested packages.
7739 Method (TEST,, Serialized)
7741 Store ("++++++++ MatchOp Test", Debug)
7743 Name (TIM0, Package ()
7745 Package () {0x78, 0xB4, 0xF0, 0x0384},
7746 Package () {0x23, 0x21, 0x10, 0},
7747 Package () {0x0B, 9, 4, 0},
7748 Package () {0x70, 0x49, 0x36, 0x27, 0x19},
7749 Package () {0, 1, 2, 1, 2},
7750 Package () {0, 0, 0, 1, 1},
7751 Package () {4, 3, 2, 0},
7752 Package () {2, 1, 0, 0}
7755 Name (TMD0, Buffer (20) {0xFF, 0xFF, 0xFF, 0xFF })
7756 CreateDWordField (TMD0, 0, PIO0) // 0xFFFFFFFF
7757 CreateDWordField (TMD0, 4, DMA0)
7758 CreateDWordField (TMD0, 8, PIO1)
7759 CreateDWordField (TMD0, 12, DMA1)
7760 CreateDWordField (TMD0, 16, CHNF)
7763 // validate PIO0 value
7764 Store (PIO0, Local3)
7766 // save Local3 object type value into Local2
7767 Store (ObjectType (Local3), Local2)
7769 // validate Local3 is a Number
7770 If (LNotEqual (Local2, 1)) // Number type is 1
7771 { Return (2) } // failure
7773 // validate Local3 Number value
7774 If (LNotEqual (Local3, 0xFFFFFFFF)) // Number value 0xFFFFFFFF
7775 { Return (3) } // failure
7777 Store ("DWordField PASS", Debug)
7781 Store (Match (DerefOf (Index (TIM0, 1, )), MLE, Local5, MTR, 0, 0), Local6)
7783 // save Local6 object type value into Local2
7784 Store (ObjectType (Local6), Local2)
7786 // validate Local6 is a Number
7787 If (LNotEqual (Local2, 1)) // Number type is 1
7788 { Return (4) } // failure
7790 Store ("Match(DerefOf(Index(TIM0,1)),... PASS", Debug)
7793 // validate following produces a nested package to validate
7794 // that MatchOp did not corrupt SearchPackage (TIM0)
7795 Store (DerefOf (Index (TIM0, 1, )), Local4)
7797 // save Local4 object type value into Local2
7798 Store (ObjectType (Local4), Local2)
7800 // validate Local4 is a Package
7801 If (LNotEqual (Local2, 4)) // Package type is 4
7802 { Return (5) } // failure
7804 Store ("DerefOf(Index(TIM0,1)),... PASS", Debug)
7807 And (Match (DerefOf (Index (TIM0, 0, )), MGE, PIO0, MTR, 0, 0), 3, Local0)
7809 // save Local0 object type value into Local2
7810 Store (ObjectType (Local0), Local2)
7812 // validate Local0 is a Number
7813 If (LNotEqual (Local2, 1)) // Number type is 1
7814 { Return (6) } // failure
7816 // validate Local0 Number value
7817 If (LNotEqual (Local0, 3)) // Number value 3
7818 { Return (7) } // failure
7820 Store ("And(Match(DerefOf(Index(TIM0,0)),... PASS", Debug)
7823 // again, validate following produces a nested package
7824 Store (DerefOf (Index (TIM0, 1, )), Local4)
7826 // save Local4 object type value into Local2
7827 Store (ObjectType (Local4), Local2)
7829 // validate Local4 is a Package
7830 If (LNotEqual (Local2, 4)) // Package type is 4
7831 { Return (8) } // failure
7833 Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7836 // again, validate following produces a nested package
7837 Store (DerefOf (Index (TIM0, 1, )), Local4)
7839 // save Local4 object type value into Local2
7840 Store (ObjectType (Local4), Local2)
7842 // validate Local4 is a Package
7843 If (LNotEqual (Local2, 4)) // Package type is 4
7844 { Return (9) } // failure
7846 Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7849 // test nested DerefOf(Index) operators
7850 Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
7852 // save Local1 object type value into Local2
7853 Store (ObjectType (Local1), Local2)
7855 // validate Local1 is a Number
7856 If (LNotEqual (Local2, 1)) // Number type is 1
7857 { Return (10) } // failure
7859 // zero indicates pass, non-zero is an error code
7860 If (LNotEqual (Local1, 0))
7861 { Return (11) } // failure
7863 Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS", Debug)
7866 // again, validate following produces a nested package
7867 Store (DerefOf (Index (TIM0, 1, )), Local4)
7869 // save Local4 object type value into Local2
7870 Store (ObjectType (Local4), Local2)
7872 // validate Local4 is a Package
7873 If (LNotEqual (Local2, 4)) // Package type is 4
7874 { Return (12) } // failure
7876 Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7879 // retest nested DerefOf(Index) operators
7880 Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
7882 // save Local1 object type value into Local2
7883 Store (ObjectType (Local1), Local2)
7885 // validate Local1 is a Number
7886 If (LNotEqual (Local2, 1)) // Number type is 1
7887 { Return (13) } // failure
7889 // zero indicates pass, non-zero is an error code
7890 If (LNotEqual (Local1, 0))
7891 { Return (14) } // failure
7893 Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again", Debug)
7896 // again, validate following produces a nested package
7897 Store (DerefOf (Index (TIM0, 1, )), Local4)
7899 // save Local4 object type value into Local2
7900 Store (ObjectType (Local4), Local2)
7902 // validate Local4 is a Package
7903 If (LNotEqual (Local2, 4)) // Package type is 4
7904 { Return (15) } // failure
7906 Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7914 // test WhileBrk.asl
7916 // This code tests the Break term and While term
7918 // Syntax of Break term
7919 // BreakTerm := Break
7920 // The break operation causes the current package execution to complete.
7922 // Syntax of While Term
7923 // WhileTerm := While(
7924 // Predicate //TermArg=>Integer
7926 // Predicate is evaluated as an integer.
7927 // If the integer is non-zero, the list of terms in TermList is executed.
7928 // The operation repeats until the Predicate evaluates to zero.
7930 // MTL NOTE: This test has been modified to reflect ACPI 2.0 break
7931 // NOTE: This test, when run under the MS ACPI.SYS grinds the system to
7941 // Check Break statement nested in If nested in While nested in
7942 // While only exits inner-most While loop
7945 While (LLess (CNT0, 4))
7948 While (LLess (CNT1, 10))
7950 if (LEqual (CNT1, 1))
7952 Break // exit encompassing loop
7958 If (LNotEqual (CNT1, 1))
7967 // Verify Break only exited inner-most While loop
7969 If (LNotEqual (CNT0, 4))
7975 Store ("While/While/If/Break PASS", Debug)
7977 Store ("++++++++ WhileBrk Test", Debug)
7979 // Check Break statement nested in While
7982 While (LLess (CNT0, 10))
7984 Break // exit encompassing package
7988 If (LNotEqual (CNT0, 0)) // instruction after Break executed
7997 While (LLess (CNT0, 10))
8002 // Check if the while loop was executed until the condition is satisfied.
8003 If (LNotEqual (CNT0, 10))
8009 // While loop in a reverse order
8010 While (LGreater (CNT0, 0))
8015 // Check if the while loop was executed until the condition is satisfied.
8016 If (LNotEqual (CNT0, 0))
8022 Store ("While/Break PASS", Debug)
8025 // Check Break statement nested in If nested in While
8028 While (LLess (CNT0, 10))
8030 if (LEqual (CNT0, 5))
8032 Break // exit encompassing Package (If)
8034 // if we execute the next instruction,
8035 // Break did not exit the loop
8036 Store (20, CNT0) // exit While loop with value larger
8040 Increment (CNT0) // check if Break exited both If and While
8043 If (LGreater (CNT0, 19))
8044 { // instruction after Break inside IfOp executed
8049 // Break will exit out of the while loop, therefore
8050 // the CNT0 counter should still Increment until 5
8052 If (LNotEqual (CNT0, 5))
8053 { // instruction after Break inside WhileOp executed
8056 Store ("While/If/Break PASS", Debug)
8059 // All the conditions passed
8066 // test IndexOp2.asl
8068 // Additional IndexOp test cases to support ACPICMB (control method battery
8069 // test) on Toshiba Portege 7020CT. Test cases include appropriate bit
8070 // shifting of Field elements and reading Field elements greater than 64 bits.
8072 // MTL NOTE: This test has been modified slightly from the original test
8073 // to take into account ACPI specification limitations.
8075 Scope (\_SB) // System Bus
8080 Name (_HID, 0x010CD041)
8083 OperationRegion (SMEM, SystemMemory, 0x800000, 0x100)
8084 Field (SMEM, AnyAcc, NoLock, Preserve)
8085 { // Field: SMEM overlay using 32-bit field elements
8086 SMD0, 32, // 32-bits
8087 SMD1, 32, // 32-bits
8088 SMD2, 32, // 32-bits
8090 } // Field: SMEM overlay using 32-bit field elements
8091 Field (SMEM, AnyAcc, NoLock, Preserve)
8092 { // Field: SMEM overlay using greater than 32-bit field elements
8093 SME0, 69, // larger than an integer (32 or 64)
8094 SME1, 97 // larger than an integer
8095 } // Field: SMEM overlay using greater than 32-bit field elements
8097 OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000)
8098 Field (SRAM, AnyAcc, NoLock, Preserve)
8099 { // Field: SRAM overlay
8256 } // Field: SRAM overlay
8261 Name (_HID, EISAID ("PNP0C0A")) // Control Method Battey ID
8263 Name (_PCL, Package (1) {\_SB})
8268 { Return (0x1F) } // battery present
8270 { Return (0x0F) } // battery not present
8273 Method (_BIF,, Serialized)
8275 Name (BUFR, Package (13) {})
8277 Store (\_SB.MEM.BPU1, Index (BUFR, 0))
8278 Store (\_SB.MEM.BDC1, Index (BUFR, 1))
8279 Store (\_SB.MEM.BLF1, Index (BUFR, 2))
8280 Store (\_SB.MEM.BTC1, Index (BUFR, 3))
8281 Store (\_SB.MEM.BDV1, Index (BUFR, 4))
8282 Store (\_SB.MEM.BCW1, Index (BUFR, 5))
8283 Store (\_SB.MEM.BCL1, Index (BUFR, 6))
8284 Store (\_SB.MEM.BG11, Index (BUFR, 7))
8285 Store (\_SB.MEM.BG21, Index (BUFR, 8))
8286 Store (\_SB.MEM.BMN1, Index (BUFR, 9))
8287 Store (\_SB.MEM.BSN1, Index (BUFR, 10))
8288 Store (\_SB.MEM.BTP1, Index (BUFR, 11))
8289 Store (\_SB.MEM.BOI1, Index (BUFR, 12))
8297 Method (B2IB,, Serialized)
8298 { // B2IB: store from Buffer into Index'ed Buffer
8300 Name (SRCB, Buffer () {"Short Buffer"}) // 12 characters plus NULL
8302 Name (DEST, Buffer () // 62 characters plus NULL
8303 {"Destination buffer that is longer than the short source buffer"})
8306 // verify object type returned by Index(Buffer,Element,)
8308 Store (Index (DEST, 2, ), Local1)
8309 Store (ObjectType (Local1), Local2)
8311 If (LNotEqual (Local2, 14)) // Buffer Field is type 14
8313 // Local2 indicates Local1 is not a Buffer Field
8318 // verify object type and value returned by DerefOf(Index(Buffer,Element,))
8319 // should return Number containing element value
8321 Store (DerefOf (Local1), Local3)
8322 Store (ObjectType (Local3), Local4)
8324 If (LNotEqual (Local4, 1)) // Number is type 1
8326 // Local2 indicates Local1 is not a Number
8331 If (LNotEqual (Local3, 0x73)) // expect 's' element from DEST
8337 Store ("DerefOf(Index(Buffer,,)) PASS", Debug)
8341 // The following sections have been rewritten because storing into
8342 // an Indexed buffer only changes one byte - the FIRST byte of the
8343 // buffer is written to the source index. This is the ONLY byte
8344 // written -- as per ACPI 2.0
8346 // Overwrite DEST contents, at buffer position 2 [only]
8348 Store (SRCB, Index (DEST, 2, ))
8351 // Check that the next byte is not changed
8353 Store (DerefOf (Index (DEST, 3, )), Local0)
8354 If (LNotEqual (Local0, 0x74)) // 't'
8356 // DEST element is not matching original value
8357 If (LEqual (Local0, 0x68))
8359 // DEST element was altered to 'h'
8364 // DEST element is an unknown value
8370 // Check that the elements beyond the SRCB buffer copy
8371 // have not been altered.
8373 Store (DerefOf (Index (DEST, 14)), Local0)
8376 // This should be an 'f'.
8378 If (LNotEqual (Local0, 0x66))
8380 // DEST element was zero'd by buffer copy
8381 If (LEqual (Local0, 0))
8383 // DEST element is zero
8388 // DEST element is unknown value
8393 Store ("Store(SRCB,Index(Buffer,,)) PASS", Debug)
8396 // verify altering SRCB does NOT alter DEST
8398 Store (0x6A, Index (SRCB, 1)) // SRCB = "Sjort Buffer"
8400 Store (DerefOf (Index (SRCB, 1)), Local0)
8402 If (LNotEqual (Local0, 0x6A)) // 'j'
8404 // SRCB element is unaltered
8408 Store (DerefOf (Index (DEST, 3)), Local0) // DEST = "Destination buffer that...
8410 If (LNotEqual (Local0, 0x74)) // 't'
8412 // DEST element is altered
8413 If (LEqual (Local0, 0x6A)) // 'j'
8415 // SRCB change altered DEST element
8420 // DEST element is unknown value
8425 // verify altering DEST does NOT alter SRCB
8427 Store (0x6B, Index (DEST, 4, )) // DEST = "DeSkination buffer..."
8429 Store (DerefOf (Index (DEST, 4, )), Local0)
8431 If (LNotEqual (Local0, 0x6B)) // 'k'
8433 // DEST element is unaltered
8437 Store (DerefOf (Index (SRCB, 2, )), Local0)
8439 If (LNotEqual (Local0, 0x6F)) // 'o'
8440 { // SRC element is altered
8441 If (LEqual (Local0, 0x6B)) // 'k'
8443 // DEST change altered SRCB element
8448 // SRCB element is unknown value
8453 Store ("SRCB and DEST independent PASS", Debug)
8456 // verify string can be written to Index target/destination
8457 // Only FIRST byte is written
8459 Store ("New Buff", Index (DEST, 2, )) // DEST = "DeNkination buffer..."
8461 Store (DerefOf (Index (DEST, 2, )), Local0)
8463 If (LNotEqual (Local0, 0x4E)) // 'N'
8465 // DEST element is unaltered
8469 Store (DerefOf (Index (DEST, 6, )), Local0)
8471 If (LNotEqual (Local0, 0x61)) // 'a'
8473 // DEST element is unaltered
8477 Store (DerefOf (Index (DEST, 10, )), Local0)
8479 If (LNotEqual (Local0, 0x6E)) // 'n'
8481 // DEST element is unaltered
8485 Store ("Store(String,Index) PASS", Debug)
8489 } // B2IB: store from Buffer into Index'ed Buffer
8491 Method (FB2P,, Serialized)
8492 { // FB2P: store from Field Buffer into Index'ed Package
8493 Name (DEST, Package (2) {})
8495 // initialize memory using 32-bit field elements
8496 Store (0x01234567, \_SB.MEM.SMD0)
8497 Store (0x89ABCDEF, \_SB.MEM.SMD1)
8498 Store (0xFEDCBA98, \_SB.MEM.SMD2)
8499 Store (0x76543210, \_SB.MEM.SMD3)
8501 // move greater than 64-bit buffers into DEST package
8502 Store (\_SB.MEM.SME0, Index (DEST, 0))
8503 Store (\_SB.MEM.SME1, Index (DEST, 1))
8505 // validate DEST contents
8506 Store (DerefOf (Index (DEST, 0, )), Local0)
8507 Store (DerefOf (Index (DEST, 1, )), Local1)
8509 // verify Local0 and Local1 are Buffers
8510 Store (ObjectType (Local0), Local2)
8511 if (LNotEqual (Local2, 3)) // Buffer type is 3
8516 Store (ObjectType (Local1), Local3)
8517 if (LNotEqual (Local3, 3)) // Buffer type is 3
8522 // validate DEST buffer contents
8523 Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 0)), Local4)
8524 If (LNotEqual (Local4, 0x67))
8529 Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 1)), Local4)
8530 If (LNotEqual (Local4, 0x45))
8535 Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 4)), Local4)
8536 If (LNotEqual (Local4, 0xEF))
8541 Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 5, )), Local4)
8542 If (LNotEqual (Local4, 0xCD))
8547 Store ("Store(Mem,PkgElement) PASS", Debug)
8550 // validate changing source \_SB.MEM.SMD* does not impact DEST
8551 Store (0x12345678, \_SB.MEM.SMD0)
8553 Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 0, )), Local5)
8554 If (LNotEqual (Local5, 0x67))
8559 Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 1, )), Local5)
8560 If (LNotEqual (Local5, 0x45))
8565 // validate changing DEST does not impact source \_SB.MEM.SMD*
8566 Store (0x30, Index (DerefOf (Index (DEST, 0)), 0))
8568 Store (DerefOf(Index (DerefOf (Index (DEST, 0)), 0)), Local5)
8569 If (LNotEqual (Local5, 0x30))
8575 // This section was modified from the original iPCO code because
8576 // it attempted to compare two buffers. This is not allowed until
8577 // ACPI v2.0, so the test has been modified to just check the
8578 // changed \_SB.MEM.SMD0
8580 Store (\_SB.MEM.SMD0, Local5)
8582 If(LNotEqual(Local5, 0x12345678))
8587 Store ("Mem and Pkg independent PASS", Debug)
8591 } // FB2P: store from Field Buffer into Index'ed Package
8595 Store ("++++++++ IndexOp2 Test", Debug)
8597 // store _BIF package return value into Local0
8599 Store (\_SB.BAT1._BIF, Local0)
8601 // save Local0 object type value into Local1
8602 Store (ObjectType (Local0), Local1)
8604 // validate Local0 is a Package
8605 If (LNotEqual (Local1, 4)) // Package type is 4
8611 // validate source and destination buffers are independent of each
8612 // of each other (i.e., changing one's contents does not change
8613 // other's contents) using B2IB (store from Buffer into Index'ed
8614 // Buffer) and FB2P (store from Field Buffer into Index'ed Package)
8616 // call B2IB (store from Buffer into Index'ed Buffer)
8617 Store (B2IB, Local2) // Local2 is B2IB return value
8619 // save Local2 object type value into Local3
8620 Store (ObjectType (Local2), Local3)
8622 // validate Local2 is a Number
8623 If (LNotEqual (Local3, 1)) // Number type is 1
8629 // zero indicates pass, non-zero is an error code
8630 If (LNotEqual (Local2, 0))
8632 // return B2IB error code
8636 // call FB2P (store from Field Buffer into Index'ed Package)
8637 Store (FB2P, Local2) // Local2 is FB2P return value
8639 // save Local2 object type value into Local3
8640 Store (ObjectType (Local2), Local3)
8642 // validate Local2 is a Number
8643 If (LNotEqual (Local3, 1)) // Number type is 1
8649 // zero indicates pass, non-zero is an error code
8650 If (LNotEqual (Local2, 0))
8652 // return FB2P error code
8659 } // IDX2: Test device name
8666 // test cases include following SizeOf arguments:
8667 // buffer, buffer field;
8668 // control method argument, control method local variable;
8669 // control method return values;
8670 // direct string, string;
8672 // buffer, package, and string package elements
8674 // MTL NOTE: This test has been modified to remove any SizeOf(Index(Buff,...
8675 // calls because it is not legal to perform a SizeOf operation on a Buffer Field.
8676 // This test has also been extended to test additional Package element sizes.
8680 // SAR0 control method validates SizeOf(Arg)
8681 // SAR0 should only be called by SARG
8683 // Arg0 object to determine size of
8684 // Arg1 expected Arg length
8685 { // SAR0: SizeOf(Arg) test control method
8686 // Local0 Arg0 length
8687 // Local1 Local0 object type
8689 // Store first string size (Arg0) into Local7
8690 Store (SizeOf (Arg0), Local0)
8692 // save Local0 object type value into Local1
8693 Store (ObjectType (Local0), Local1)
8695 // validate Local0 is a Number
8696 If (LNotEqual (Local1, 1)) // Number type is 1
8699 // If strings are not of equal size, return error code
8700 If (LNotEqual (Local0, Arg1))
8704 } // SAR0: SizeOf(Arg) test control method
8706 Method (SARG,, Serialized)
8707 { // SARG: SizeOf(Arg) test control method
8708 Name (BUFR, Buffer (12) {}) // uninitialized Buffer
8709 Name (BUF1, Buffer() {0x01, 0x02, 0x03, 0x04, 0x05})
8710 Name (PKG0, Package (4) {}) // uninitialized Package
8711 Name (STR0, "String")
8712 Name (PKG1, Package (4)
8720 Name (PKG2, Package (4)
8727 // Namespace entry buffer reference
8728 Store (SAR0 (BUFR, 12), Local0)
8730 // save Local0 object type value into Local1
8731 Store (ObjectType (Local0), Local1)
8733 // validate Local0 is a Number
8734 If (LNotEqual (Local1, 1)) // Number type is 1
8739 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8744 Store ("SizeOf(Arg=BUFR) PASS", Debug)
8747 // Namespace entry package reference
8748 Store (SAR0 (PKG0, 4), Local0)
8750 // save Local0 object type value into Local1
8751 Store (ObjectType (Local0), Local1)
8753 // validate Local0 is a Number
8754 If (LNotEqual (Local1, 1)) // Number type is 1
8759 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8764 Store ("SizeOf(Arg=PKG0) PASS", Debug)
8767 // Namespace entry string reference
8768 Store (SAR0 (STR0, 6), Local0)
8770 // save Local0 object type value into Local1
8771 Store (ObjectType (Local0), Local1)
8773 // validate Local0 is a Number
8774 If (LNotEqual (Local1, 1)) // Number type is 1
8779 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8784 Store ("SizeOf(Arg=STR0) PASS", Debug)
8787 // direct string reference
8788 Store (SAR0 ("String", 6), Local0)
8790 // save Local0 object type value into Local1
8791 Store (ObjectType (Local0), Local1)
8793 // validate Local0 is a Number
8794 If (LNotEqual (Local1, 1)) // Number type is 1
8799 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8804 Store ("SizeOf(Arg=String) PASS", Debug)
8806 Store (0x55, Index (BUF1, 2))
8808 /****************************************************
8810 // This section is commented because it is illegal to
8811 // perform a SizeOf operation on a Buffer Field
8813 // Namespace BufferField reference
8814 Store (SAR0 (Index (BUFR, 2, ), 10), Local0)
8816 // save Local0 object type value into Local1
8817 Store (ObjectType (Local0), Local1)
8819 // validate Local0 is a Number
8820 If (LNotEqual (Local1, 1)) // Number type is 1
8823 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8826 Store ("SizeOf(Arg=BufferField) PASS", Debug)
8827 ****************************************************/
8829 // Namespace BufferPackageElement reference
8831 Store (SAR0 (Index(PKG1, 0), 12), Local0)
8833 // save Local0 object type value into Local1
8834 Store (ObjectType (Local0), Local1)
8836 // validate Local0 is a Number
8837 If (LNotEqual (Local1, 1)) // Number type is 1
8842 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8847 Store ("SizeOf(Arg=PackageBuffer NTE Reference Element) PASS", Debug)
8850 // Namespace StringPackageElement reference
8851 Store (SAR0 (Index (PKG1, 1, ), 7), Local0)
8853 // save Local0 object type value into Local1
8854 Store (ObjectType (Local0), Local1)
8856 // validate Local0 is a Number
8857 If (LNotEqual (Local1, 1)) // Number type is 1
8862 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8867 Store ("SizeOf(Arg=Package String Element) PASS", Debug)
8870 // Namespace StringPackageElement reference
8871 Store (SAR0 (Index (PKG1, 2, ), 6), Local0)
8873 // save Local0 object type value into Local1
8874 Store (ObjectType (Local0), Local1)
8876 // validate Local0 is a Number
8877 If (LNotEqual (Local1, 1)) // Number type is 1
8882 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8887 Store ("SizeOf(Arg=Package String NTE Reference Element) PASS", Debug)
8890 // Namespace PackagePackageElement reference
8891 Store (SAR0 (Index (PKG1, 3, ), 4), Local0)
8893 // save Local0 object type value into Local1
8894 Store (ObjectType (Local0), Local1)
8896 // validate Local0 is a Number
8897 If (LNotEqual (Local1, 1)) // Number type is 1
8902 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8907 Store ("SizeOf(Arg=Package Package NTE Reference Element) PASS", Debug)
8909 // Package Buffer Element
8910 Store (SAR0 (Index (PKG2, 0), 15), Local0)
8912 // save Local0 object type value into Local1
8913 Store (ObjectType (Local0), Local1)
8915 // validate Local0 is a Number
8916 If (LNotEqual (Local1, 1)) // Number type is 1
8921 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8926 Store ("SizeOf(Arg=Package Buffer Element) PASS", Debug)
8928 // Package String Element
8929 Store (SAR0 (Index (PKG2, 1), 8), Local0)
8931 // save Local0 object type value into Local1
8932 Store (ObjectType (Local0), Local1)
8934 // validate Local0 is a Number
8935 If (LNotEqual (Local1, 1)) // Number type is 1
8940 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8945 Store ("SizeOf(Arg=Package String Element) PASS", Debug)
8947 // Package Package Element
8948 Store (SAR0 (Index (PKG2, 2), 2), Local0)
8950 // save Local0 object type value into Local1
8951 Store (ObjectType (Local0), Local1)
8953 // validate Local0 is a Number
8954 If (LNotEqual (Local1, 1)) // Number type is 1
8959 If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code
8964 Store ("SizeOf(Arg=Package Package Element) PASS", Debug)
8966 Store ("SizeOf(Arg) PASS", Debug)
8969 } // SARG: SizeOf(Arg) test control method
8971 Method (SBUF,, Serialized)
8972 { // SBUF: SizeOf(Buffer) test control method
8973 Name (BUFR, Buffer (12) {})
8975 // store size of BUFR buffer into Local0
8976 Store (SizeOf (BUFR), Local0)
8978 // save Local0 object type value into Local1
8979 Store (ObjectType (Local0), Local1)
8981 // validate Local0 is a Number
8982 If (LNotEqual (Local1, 1)) // Number type is 1
8987 If (LNotEqual (Local0, 12)) // BUFR size is 12
8992 Store ("SizeOf(BUFR) PASS", Debug)
8995 } // SBUF: SizeOf(Buffer) test control method
8998 /****************************************************
9000 // This section is commented because it is illegal to
9001 // perform a SizeOf operation on a Buffer Field
9004 { // SIND: SizeOf(Index(,,)) test control method
9005 Name (BUFR, Buffer (12) {})
9007 // store size of Index(BUFR,2,) buffer into Local0
9008 Store (SizeOf (Index (BUFR, 2, )), Local0)
9010 // save Local0 object type value into Local1
9011 Store (ObjectType (Local0), Local1)
9013 // validate Local0 is a Number
9014 If (LNotEqual (Local1, 1)) // Number type is 1
9019 If (LNotEqual (Local0, 10)) // 12 - 2 = 10
9024 Store ("SizeOf(Index(BUFR,,)) PASS", Debug)
9026 // TBD: strings and packages
9029 } // SIND: SizeOf(Index(,,)) test control method
9030 ****************************************************/
9032 Method (SLOC,, Serialized)
9033 { // SLOC: SizeOf(Local) test control method
9034 Name (BUFR, Buffer (12) {}) // uninitialized Buffer
9035 Name (STR0, "String")
9036 Name (PKG0, Package (4) {}) // uninitialized Package
9039 // store BUFR Buffer into Local2
9040 Store (BUFR, Local2)
9042 // store size of BUFR buffer into Local0
9043 Store (SizeOf (Local2), Local0)
9045 // save Local0 object type value into Local1
9046 Store (ObjectType (Local0), Local1)
9048 // validate Local0 is a Number
9049 If (LNotEqual (Local1, 1)) // Number type is 1
9054 If (LNotEqual (Local0, 12)) // BUFR size is 12
9059 Store ("SizeOf(Local2=Buffer) PASS", Debug)
9062 // store STR0 string into Local2
9063 Store (STR0, Local2)
9065 // store size of STR0 buffer into Local0
9066 Store (SizeOf (Local2), Local0)
9068 // save Local0 object type value into Local1
9069 Store (ObjectType (Local0), Local1)
9071 // validate Local0 is a Number
9072 If (LNotEqual (Local1, 1)) // Number type is 1
9077 If (LNotEqual (Local0, 6)) // STR0 size is 6
9082 Store ("SizeOf(Local2=String) PASS", Debug)
9085 // store PKG0 Package into Local2
9086 Store (PKG0, Local2)
9088 // store size of PKG0 buffer into Local0
9089 Store (SizeOf (Local2), Local0)
9091 // save Local0 object type value into Local1
9092 Store (ObjectType (Local0), Local1)
9094 // validate Local0 is a Number
9095 If (LNotEqual (Local1, 1)) // Number type is 1
9100 If (LNotEqual (Local0, 4)) // PKG0 size is 4
9105 Store ("SizeOf(Local2=Package) PASS", Debug)
9109 } // SLOC: SizeOf(Local) test control method
9113 Store ("++++++++ SizeOf Test", Debug)
9115 // Store current operating system string into Local0
9118 Store (SizeOf (_OS), Local3)
9120 // save Local3 object type value into Local4
9121 Store (ObjectType (Local3), Local4)
9123 // validate Local3 is a Number
9124 If (LNotEqual (Local4, 1)) // Number type is 1
9130 // Store current operating system string into Local0
9131 // This verifies above SizeOf(_OS) did not corrupt ACPI namespace
9134 // Store SARG [Validate SizeOf(Arg)] return value into Local1
9135 Store (SARG, Local1)
9137 // save Local1 object type value into Local2
9138 Store (ObjectType (Local1), Local2)
9140 // validate Local1 is a Number
9141 If (LNotEqual (Local2, 1)) // Number type is 1
9147 // zero indicates pass, non-zero is an error code
9148 If (LNotEqual (Local1, 0))
9150 // return SARG error code
9155 // Store SBUF [Validate SizeOf(Buffer)] return value into Local1
9156 Store (SBUF, Local1)
9158 // save Local1 object type value into Local2
9159 Store (ObjectType (Local1), Local2)
9161 // validate Local1 is a Number
9162 If (LNotEqual (Local2, 1)) // Number type is 1
9168 // zero indicates pass, non-zero is an error code
9169 If (LNotEqual (Local1, 0))
9171 // return SBUF error code
9175 /****************************************************
9177 // This section is commented because it is illegal to
9178 // perform a SizeOf operation on a Buffer Field
9180 // Store SIND [verify SizeOf(Index(,,))] return value into Local1
9181 Store (SIND, Local1)
9183 // save Local1 object type value into Local2
9184 Store (ObjectType (Local1), Local2)
9186 // validate Local1 is a Number
9187 If (LNotEqual (Local2, 1)) // Number type is 1
9193 // zero indicates pass, non-zero is an error code
9194 If (LNotEqual (Local1, 0))
9196 // return SARG error code
9199 ****************************************************/
9201 // Store SLOC [verify SizeOf(Local)] return value into Local1
9202 Store (SLOC, Local1)
9204 // save Local1 object type value into Local2
9205 Store (ObjectType (Local1), Local2)
9207 // validate Local1 is a Number
9208 If (LNotEqual (Local2, 1)) // Number type is 1
9214 // zero indicates pass, non-zero is an error code
9215 If (LNotEqual (Local1, 0))
9217 // return SLOC error code
9222 // TBD: SizeOf (METH) -- where METH control method returns
9223 // buffer, BufferField, string, package, package element
9231 // test SmiShare.asl
9233 Scope (\_SB) // System Bus
9235 // Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
9236 OperationRegion(RAM1, SystemMemory, 0x400000, 0xA)
9238 Field (RAM1, AnyAcc, NoLock, Preserve)
9240 BI1T, 1, // Create some bits in memory to access
9246 Field (RAM1, WordAcc, NoLock, WriteAsZeros)
9249 } // End 2nd Field RAM1
9251 Field (RAM1, ByteAcc, NoLock, WriteAsOnes)
9254 } // End 3rd Field RAM1
9256 Field (RAM1, ByteAcc, NoLock, Preserve)
9270 } // End _INI Method
9271 } // End Device MBIT
9278 } // End _INI Method
9279 } // End Device MWRD
9288 } // End _INI Method
9289 } // End Device MBYT
9292 // Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
9293 OperationRegion(\RAM1, SystemMemory, 0x400000, 0xA)
9295 Field (\RAM1, AnyAcc, NoLock, Preserve)
9297 BI1T, 1, // Create some bits in memory to access
9303 Field (\RAM1, WordAcc, NoLock, WriteAsZeros)
9306 } // End 2nd Field RAM1
9308 Field (\RAM1, ByteAcc, NoLock, WriteAsOnes)
9311 } // End 3rd Field RAM1
9313 Field (\RAM1, ByteAcc, NoLock, Preserve)
9326 Store (SMIX, Local0)
9328 Notify (\_SB_, 0x29)
9329 If (And (Local0, 0x01))
9330 { Notify (\_SB_.SMIS, 0x21)}
9332 If (And (Local0, 0x02))
9333 { Notify (\_SB_.SMIS, 0x22)}
9335 If (And (Local0, 0x04))
9336 { Notify (\_SB_.SMIS, 0x24)}
9338 If (And (Local0, 0x08))
9339 { Notify (\_SB_.SMIS, 0x28)}
9341 } // End Method EVNT
9346 Notify (\_TZ_.TZ1, 2)
9347 Notify (\_PR_.CPU0, 3)
9349 Notify (\_SB_, 0x81)
9350 Notify (\_TZ_.TZ1, 0x82)
9351 Notify (\_PR_.CPU0, 0x83)
9358 Store (0, Local0) // Zero out Local0
9360 If (LNotEqual (SMID, 0xD))
9361 { Or (0x80, Local0, Local0)}
9363 If (LNotEqual (SMIC, 0xC))
9364 { Or (0x40, Local0, Local0)}
9366 If (LNotEqual (BYTE, 0))
9367 { Or (0x20, Local0, Local0)}
9369 If (LNotEqual (WRD, 0))
9370 { Or (0x10, Local0, Local0)}
9372 If (LNotEqual (LST2, 0))
9373 { Or (0x8, Local0, Local0)}
9375 If (LNotEqual (BI3T, 0x7))
9376 { Or (0x4, Local0, Local0)}
9378 If (LNotEqual (BI2T, 0x3))
9379 { Or (0x2, Local0, Local0)}
9381 If (LNotEqual (BI1T, 0))
9382 { Or (0x1, Local0, Local0)}
9385 } // End Method BINK
9389 Store ("++++++++ SmiShare Test", Debug)
9391 // Expect EVNT to generate Notify value we just previously
9405 } // End Method TEST
9431 /* Test a very big buffer */
9433 Name(WQAB, Buffer(6756)
9435 0x46,0x4F,0x4D,0x42,0x01,0x00,0x00,0x00,
9436 0x54,0x1A,0x00,0x00,0xBA,0xAD,0x00,0x00,
9437 0x44,0x53,0x00,0x01,0x1A,0x7D,0xDA,0x54,
9438 0x98,0xBD,0x92,0x00,0x01,0x06,0x18,0x42,
9439 0x10,0x47,0x10,0x92,0x46,0x62,0x02,0x89,
9440 0x80,0x90,0x18,0x18,0x14,0x81,0x85,0x00,
9441 0x49,0x02,0x88,0xC4,0x41,0xE1,0x20,0xD4,
9442 0x9F,0x40,0x7E,0x05,0x20,0x74,0x28,0x40,
9443 0xA6,0x00,0x83,0x02,0x9C,0x22,0x88,0xA0,
9444 0x57,0x01,0x36,0x05,0x98,0x14,0x60,0x51,
9445 0x80,0x76,0x01,0x96,0x05,0xE8,0x16,0x20,
9446 0x1D,0x96,0x88,0x04,0x47,0x89,0x01,0x47,
9447 0xE9,0xC4,0x16,0x6E,0xD8,0xE0,0x85,0xA2,
9448 0x68,0x06,0x51,0x12,0x94,0x8B,0x20,0x5D,
9449 0x10,0x52,0x2E,0xC0,0x37,0x82,0x06,0x10,
9450 0xA5,0x77,0x01,0xB6,0x05,0x98,0x86,0x27,
9451 0xD2,0x20,0xE4,0x60,0x08,0x54,0xCE,0x80,
9452 0x20,0x69,0x44,0x21,0x1E,0xA7,0x44,0x08,
9453 0x0A,0x84,0x90,0xD4,0xF1,0xA0,0xA0,0x71,
9454 0x88,0xAD,0xCE,0x46,0x93,0xA9,0x74,0x7E,
9455 0x48,0x82,0x70,0xC6,0x2A,0x7E,0x3A,0x9A,
9456 0xD0,0xD9,0x9C,0x60,0xE7,0x18,0x72,0x3C,
9457 0x48,0xF4,0x20,0xB8,0x00,0x0F,0x1C,0x2C,
9458 0x34,0x84,0x22,0x6B,0x80,0xC1,0x8C,0xDD,
9459 0x63,0xB1,0x0B,0x4E,0x0A,0xEC,0x61,0xB3,
9460 0x01,0x19,0xA2,0x24,0x38,0xD4,0x11,0xC0,
9461 0x12,0x05,0x98,0x1F,0x87,0x0C,0x0F,0x95,
9462 0x8C,0x25,0x24,0x1B,0xAB,0x87,0xC2,0xA5,
9463 0x40,0x68,0x6C,0x27,0xED,0x19,0x45,0x2C,
9464 0x79,0x4A,0x82,0x49,0xE0,0x51,0x44,0x36,
9465 0x1A,0x27,0x28,0x1B,0x1A,0x25,0x03,0x42,
9466 0x9E,0x05,0x58,0x07,0x26,0x04,0x76,0x2F,
9467 0xC0,0x9A,0x00,0x73,0xB3,0x90,0xB1,0xB9,
9468 0xE8,0xFF,0x0F,0x71,0xB0,0x31,0xDA,0x9A,
9469 0xAE,0x90,0xC2,0xC4,0x88,0x12,0x2C,0x5E,
9470 0xC5,0xC3,0x10,0xCA,0x93,0x42,0xA8,0x48,
9471 0x95,0xA1,0x68,0xB4,0x51,0x2A,0x14,0xE0,
9472 0x4C,0x80,0x30,0x5C,0x1D,0x03,0x82,0x46,
9473 0x88,0x15,0x29,0x56,0xFB,0x83,0x20,0xF1,
9474 0x2D,0x40,0x54,0x01,0xA2,0x48,0xA3,0x41,
9475 0x9D,0x03,0x3C,0x5C,0x0F,0xF5,0xF0,0x3D,
9476 0xF6,0x93,0x0C,0x72,0x90,0x67,0xF1,0xA8,
9477 0x70,0x9C,0x06,0x49,0xE0,0x0B,0x80,0x4F,
9478 0x08,0x1E,0x38,0xDE,0x35,0xA0,0x66,0x7C,
9479 0xBC,0x4C,0x10,0x1C,0x6A,0x88,0x1E,0x68,
9480 0xB8,0x13,0x38,0x44,0x06,0xE8,0x49,0x3D,
9481 0x52,0x60,0x07,0x77,0x32,0xEF,0x01,0xAF,
9482 0x0A,0xCD,0x5E,0x12,0x08,0xC1,0xF1,0xF8,
9483 0x7E,0xC0,0x26,0x9C,0xC0,0xF2,0x07,0x81,
9484 0x1A,0x99,0xA1,0x3D,0xCA,0xD3,0x8A,0x19,
9485 0xF2,0x31,0xC1,0x04,0x16,0x0B,0x21,0x05,
9486 0x10,0x1A,0x0F,0xF8,0x6F,0x00,0x8F,0x17,
9487 0xBE,0x12,0xC4,0xF6,0x80,0x12,0x0C,0x0B,
9488 0x21,0x23,0xAB,0xF0,0x78,0xE8,0x28,0x7C,
9489 0x95,0x38,0x9C,0xD3,0x8A,0x67,0x82,0xE1,
9490 0x20,0xF4,0x05,0x90,0x00,0x51,0xE7,0x0C,
9491 0xD4,0x61,0xC1,0xE7,0x04,0x76,0x33,0x38,
9492 0x83,0x47,0x00,0x8F,0xE4,0x84,0xFC,0x2B,
9493 0xF1,0xC0,0xE0,0x03,0xE2,0xEF,0x1F,0xA7,
9494 0xEC,0x11,0x9C,0xA9,0x01,0x7D,0x1C,0xF0,
9495 0xFF,0x7F,0x28,0x7C,0x88,0x1E,0xDF,0x29,
9496 0x1F,0xAF,0x4F,0x17,0x96,0x35,0x4E,0xE8,
9497 0x77,0x08,0x9F,0x38,0x7C,0x64,0x71,0x44,
9498 0x08,0x39,0x39,0x05,0xA0,0x81,0x4F,0xF7,
9499 0xEC,0x22,0x9C,0xAE,0x27,0xE5,0x40,0xC3,
9500 0xA0,0xE3,0x04,0xC7,0x79,0x00,0x1C,0xE3,
9501 0x84,0x7F,0x2E,0x80,0x3F,0x40,0x7E,0xCA,
9502 0x78,0xC5,0x48,0xE0,0x98,0x23,0x44,0x9F,
9503 0x6B,0x3C,0x42,0x2C,0xFC,0x53,0x45,0xE1,
9504 0x03,0x21,0x63,0x04,0x17,0xA0,0xC7,0x08,
9505 0x7C,0x03,0x8E,0x11,0x7D,0x94,0xE0,0xEA,
9506 0x0F,0x1A,0x74,0x80,0xB8,0xFF,0xFF,0x00,
9507 0xE1,0x83,0x7A,0x80,0xC0,0x37,0xFA,0xD1,
9508 0x03,0x3D,0x2E,0x8B,0x3E,0x0F,0xC8,0xF8,
9509 0x89,0x46,0xF3,0xE2,0xA7,0x03,0x7E,0xF8,
9510 0x00,0x0F,0xA8,0x87,0x84,0x03,0xC5,0x4C,
9511 0x9B,0x83,0x3E,0xBB,0x1C,0x3A,0x76,0xB8,
9512 0xE0,0x3F,0x81,0x80,0x4B,0xDE,0x21,0x0C,
9513 0x14,0x23,0xC6,0x9F,0x83,0x7C,0x0A,0x03,
9514 0xFF,0xFF,0xFF,0x14,0x06,0xFE,0xE1,0xF0,
9515 0x20,0x4F,0x07,0x9F,0xB6,0xA8,0x74,0x18,
9516 0xD4,0x81,0x0B,0xB0,0x32,0x89,0x08,0xCF,
9517 0x12,0xB5,0x41,0xE8,0xD4,0xF0,0x36,0xF1,
9518 0xB6,0xE5,0x5B,0x40,0x9C,0xD3,0xEC,0xED,
9519 0xC0,0x45,0x30,0x22,0xD4,0x0C,0x45,0x4E,
9520 0x5A,0x11,0x63,0x44,0x79,0xDC,0x32,0xCA,
9521 0xDB,0xD6,0x0B,0x40,0xBC,0x13,0x7B,0xDE,
9522 0x32,0x46,0xF0,0xC8,0x0F,0x5C,0x2C,0xC6,
9523 0xEA,0xF5,0x5F,0xF3,0x81,0x0B,0x70,0xF6,
9524 0xFF,0x3F,0x70,0x01,0x1C,0x0A,0x7A,0x18,
9525 0x42,0x0F,0xC3,0x53,0x39,0x97,0x87,0xC8,
9526 0x53,0x89,0x18,0x35,0x4C,0xD4,0x67,0x28,
9527 0xDF,0x2D,0x7C,0x20,0x02,0xDF,0x99,0x0B,
9528 0xF8,0xFD,0xFF,0x0F,0x44,0x70,0x8E,0x29,
9529 0xB8,0x33,0x0D,0x78,0x7C,0xCE,0x40,0x20,
9530 0xA7,0xE2,0x43,0x0D,0x60,0x41,0xF4,0x13,
9531 0xC2,0x27,0x1A,0x2A,0x13,0x06,0x75,0xA8,
9532 0x01,0xAC,0x5C,0x61,0x9E,0x46,0xCF,0xF9,
9533 0x59,0xC6,0xA7,0x1A,0x1F,0x4A,0x8D,0x63,
9534 0x88,0x97,0x99,0x87,0x1A,0x1F,0x0B,0x5E,
9535 0x49,0x7D,0xA8,0x31,0x54,0x9C,0x87,0x1A,
9536 0x0F,0x37,0x50,0xD4,0x37,0x9B,0x67,0x1B,
9537 0xA3,0xC7,0xF7,0x0D,0xD5,0x10,0x0F,0x35,
9538 0x4C,0xF2,0x4A,0x35,0x16,0x1F,0x6A,0xC0,
9539 0xF1,0xFF,0x3F,0xD4,0x00,0xFC,0xFF,0xFF,
9540 0x1F,0x6A,0x00,0x47,0x47,0x03,0x38,0x47,
9541 0x46,0xDC,0xD1,0x00,0x5C,0x87,0x52,0xE0,
9542 0x70,0x34,0x00,0x1E,0x47,0x21,0x30,0x5F,
9543 0x68,0x7C,0x14,0x02,0x16,0xFF,0xFF,0xA3,
9544 0x10,0xF8,0x65,0x9F,0x83,0x50,0x42,0x8F,
9545 0x42,0x80,0xA0,0xDB,0xCF,0x53,0xC4,0xB3,
9546 0x8F,0x2F,0x3F,0x0F,0x04,0x11,0x5E,0xF3,
9547 0x7D,0x0A,0xF2,0x21,0xDF,0x47,0x21,0x06,
9548 0x63,0x28,0x5F,0x83,0x7C,0x14,0x62,0x50,
9549 0xAF,0x41,0xBE,0xEF,0x1B,0xE4,0xF1,0x22,
9550 0x48,0xEC,0x67,0x02,0x1F,0x85,0x98,0xE8,
9551 0xA3,0x10,0xA0,0xF0,0xFF,0x7F,0x14,0x02,
9552 0xF8,0xFF,0xFF,0x3F,0x0A,0x01,0xCE,0x02,
9553 0x1C,0x0D,0x40,0x37,0xAD,0x47,0x21,0xF0,
9554 0xDE,0x59,0x4E,0xFB,0x04,0x7C,0x16,0x02,
9555 0xCC,0xFE,0xFF,0xCF,0x42,0xC0,0xEC,0x28,
9556 0x74,0x14,0x67,0xF9,0x2A,0xF4,0x04,0xF0,
9557 0x02,0x10,0x23,0xCC,0x3B,0xD0,0x4B,0x26,
9558 0xBB,0x8B,0x1B,0xE7,0xC9,0xE5,0x2C,0x9E,
9559 0xC4,0x7D,0x09,0xF2,0x81,0xE2,0x59,0xC8,
9560 0x50,0xA7,0x1B,0xF4,0x8D,0xDC,0x03,0x8B,
9561 0x19,0x3F,0xC4,0xF3,0x90,0x21,0x9E,0x85,
9562 0x00,0x76,0xFD,0xFF,0xCF,0x42,0x00,0xFF,
9563 0xFF,0xFF,0x47,0x03,0xF8,0x2F,0x00,0x9F,
9564 0x85,0x80,0xE7,0x09,0xE0,0x41,0xDB,0x67,
9565 0x21,0x80,0x33,0x87,0xCB,0xF3,0x7F,0x05,
9566 0x3A,0x96,0xF7,0x08,0xCF,0xFA,0x24,0x5F,
9567 0x2F,0x3D,0xD3,0x87,0x82,0x67,0x21,0x86,
9568 0x75,0x18,0x3E,0x0B,0x31,0x88,0x17,0x4D,
9569 0x43,0xBC,0x70,0xFA,0x30,0xE0,0xFF,0x3F,
9570 0x5E,0xE0,0x57,0x4E,0x03,0x05,0x09,0xF4,
9571 0x2C,0x04,0x30,0xFE,0xFF,0x7F,0x16,0x02,
9572 0xC8,0xB8,0x46,0x9D,0x85,0x80,0xE5,0x6D,
9573 0xE5,0x19,0xDB,0xA7,0x95,0x04,0xFF,0xFF,
9574 0x67,0x21,0xC0,0x41,0x2E,0x23,0x07,0x21,
9575 0x4C,0xC4,0x87,0x83,0x8F,0x99,0x80,0x9E,
9576 0x29,0xBE,0xB8,0x1B,0xE3,0x09,0xE0,0x45,
9577 0xE2,0x31,0x93,0x1D,0x35,0x0D,0xF3,0x2C,
9578 0x64,0xBC,0xB3,0x78,0x0D,0x78,0x82,0xF7,
9579 0xE4,0x9F,0x85,0x18,0xD8,0x61,0x05,0x7B,
9580 0x14,0x32,0xA8,0xC1,0x63,0x87,0x08,0x13,
9581 0xE8,0x59,0x88,0xC5,0x7D,0xAE,0xE8,0x3C,
9582 0xE1,0xB3,0x10,0xF0,0xFE,0xFF,0x9F,0x25,
9583 0xE0,0x5E,0x0D,0x9E,0x85,0x00,0x13,0x87,
9584 0x0D,0x9F,0x35,0xC0,0x33,0x7C,0x8F,0xEA,
9585 0x1C,0x1E,0x8F,0x81,0x7F,0x56,0x1D,0xE7,
9586 0x04,0x96,0x7B,0xD1,0xB2,0x71,0xA0,0xA1,
9587 0x23,0xB2,0x3A,0x20,0x8D,0x0D,0x73,0x29,
9588 0x89,0x7C,0x72,0x6C,0xD4,0x56,0x04,0xA7,
9589 0x33,0x93,0x4F,0x00,0xD6,0x42,0x21,0x05,
9590 0x34,0x1A,0x8B,0xE1,0x9D,0xF9,0xE8,0x44,
9591 0x41,0x0C,0xE8,0xE3,0x90,0x6D,0x1C,0x0A,
9592 0x50,0x7B,0xD1,0x14,0xC8,0x39,0x07,0xA3,
9593 0x7F,0x76,0x74,0x36,0xBE,0x13,0x70,0x0D,
9594 0x10,0x3A,0x25,0x18,0xDA,0x6A,0x04,0xFC,
9595 0xFF,0x67,0x89,0x01,0x33,0xFE,0x53,0x8C,
9596 0x09,0x7C,0x8E,0xC1,0x1F,0x0C,0xF0,0x03,
9597 0x7F,0x31,0xA8,0xFA,0x5E,0xA0,0xFB,0x82,
9598 0xD5,0xDD,0x64,0x20,0xCC,0xC8,0x04,0xF5,
9599 0x9D,0x0E,0x40,0x01,0xE4,0x0B,0x81,0xCF,
9600 0x51,0x0F,0x05,0x6C,0x22,0x21,0xC2,0x44,
9601 0x33,0x3A,0x62,0xC2,0xA8,0xE8,0x13,0xA6,
9602 0x20,0x9E,0xB0,0x63,0x4D,0x18,0x3D,0x13,
9603 0x5F,0x74,0xD8,0x88,0x31,0x21,0xAE,0x1E,
9604 0xD0,0x26,0x18,0xD4,0x97,0x22,0x58,0x43,
9605 0xE6,0x63,0xF1,0x05,0x02,0x37,0x65,0x30,
9606 0xCE,0x89,0x5D,0x13,0x7C,0xD9,0xC1,0xCD,
9607 0x19,0x8C,0xF0,0x98,0xBB,0x18,0xBF,0x3A,
9608 0x79,0x74,0xFC,0xA0,0xE0,0x1B,0x0E,0xC3,
9609 0x7E,0x32,0xF3,0x8C,0xDE,0xCB,0x7C,0x8D,
9610 0xC3,0xC0,0x7A,0xBC,0x1C,0xD6,0x68,0x61,
9611 0x0F,0xED,0x3D,0xC4,0xFF,0xFF,0x43,0x8C,
9612 0xCF,0x13,0xC6,0x08,0xEB,0xDB,0x0B,0x38,
9613 0xEE,0x59,0xF0,0xEF,0x1A,0xE0,0xB9,0x84,
9614 0xF8,0xAE,0x01,0x30,0xF0,0xFF,0x7F,0xD7,
9615 0x00,0x4E,0xD7,0x04,0xDF,0x35,0x80,0xF7,
9616 0xD0,0x7D,0xD7,0x00,0xAE,0xD9,0xEF,0x1A,
9617 0xA8,0x63,0x80,0x15,0xDE,0x35,0xA0,0x5D,
9618 0xD9,0xDE,0xD7,0x9E,0xB0,0xAC,0xE9,0xB2,
9619 0x81,0x52,0x73,0xD9,0x00,0x14,0xFC,0xFF,
9620 0x2F,0x1B,0x80,0x01,0x29,0x13,0x46,0x85,
9621 0x9F,0x30,0x05,0xF1,0x84,0x1D,0xEC,0xB2,
9622 0x01,0x8A,0x18,0x97,0x0D,0xD0,0x8F,0xED,
9623 0x65,0x03,0x18,0xDC,0x13,0xF8,0x6D,0x03,
9624 0x78,0x43,0xFA,0xB6,0x01,0xD6,0xFF,0xFF,
9625 0x6D,0x03,0xAC,0xF9,0x6F,0x1B,0x28,0x0E,
9626 0xAB,0xBC,0x6D,0x40,0x3C,0xC9,0x33,0x02,
9627 0xAB,0xBA,0x6E,0xA0,0xF4,0x5C,0x37,0x00,
9628 0x12,0x88,0x99,0x30,0x2A,0xFE,0x84,0x29,
9629 0x88,0x27,0xEC,0x68,0xD7,0x0D,0x50,0x04,
9630 0xB9,0x6E,0x80,0x7E,0x5E,0x09,0xFE,0xFF,
9631 0xAF,0x1B,0xC0,0xE0,0xA2,0x80,0xB9,0x6F,
9632 0x00,0x6F,0x58,0x7E,0xDF,0x00,0x7C,0xDC,
9633 0xC4,0x31,0xF7,0x0D,0xC0,0xCC,0xFF,0xFF,
9634 0xBE,0x01,0xB0,0xE7,0xA2,0x80,0xBB,0x6F,
9635 0x00,0xEF,0x8B,0xB4,0xEF,0x1B,0x60,0xFE,
9636 0xFF,0xDF,0x37,0xC0,0x28,0x6D,0xFD,0x1E,
9637 0x1C,0x3D,0x21,0x78,0x7C,0xB8,0xFB,0xA5,
9638 0xC7,0xE7,0xBB,0x39,0x38,0x06,0x79,0x8C,
9639 0x87,0x76,0xC0,0xAF,0xEF,0x9E,0x98,0xEF,
9640 0xE6,0xC0,0xFF,0x4C,0x70,0x3C,0x18,0x68,
9641 0x1C,0x62,0xAB,0x97,0x06,0x72,0x34,0x38,
9642 0x3F,0xDC,0x19,0x81,0x61,0x15,0x7F,0xF2,
9643 0x47,0x38,0xC7,0xD0,0xD9,0xE1,0x20,0xB1,
9644 0x83,0xE0,0xC1,0x56,0x6D,0x02,0x85,0x86,
9645 0x50,0x14,0x18,0x14,0x8B,0x0F,0x18,0xF8,
9646 0x61,0xB3,0xB3,0x00,0x93,0x04,0x87,0x3A,
9647 0x02,0xF8,0x3E,0xD1,0xFC,0x38,0x74,0x37,
9648 0x38,0x54,0x8F,0xE5,0xA1,0x80,0x9E,0x01,
9649 0x71,0xC7,0x0C,0x32,0x69,0xCF,0x28,0xE2,
9650 0x53,0xC2,0x29,0x85,0x49,0xE0,0xF3,0x03,
9651 0x43,0xE3,0x04,0xAF,0x0D,0xA1,0xF9,0xFF,
9652 0xFF,0xA4,0xC0,0x3C,0xDF,0x31,0x04,0x6C,
9653 0x02,0xBB,0xBF,0x64,0xC8,0xDA,0xC0,0x75,
9654 0x4B,0x32,0x44,0x6F,0x38,0xB2,0x85,0xA2,
9655 0xE9,0x44,0x79,0xDF,0x88,0x62,0x67,0x08,
9656 0xC2,0x88,0x12,0x2C,0xC8,0xA3,0x42,0xAC,
9657 0x28,0x2F,0x05,0x46,0x88,0x18,0xE2,0x95,
9658 0x23,0xD0,0x09,0x87,0x0F,0xF2,0xD8,0x14,
9659 0xA7,0xFD,0x41,0x90,0x58,0x4F,0x02,0x8D,
9660 0xC5,0x91,0x46,0x83,0x3A,0x07,0x78,0xB8,
9661 0x3E,0xC4,0x78,0xF8,0x0F,0x21,0x06,0x39,
9662 0xC8,0x73,0x7B,0x54,0x38,0x4E,0x5F,0x25,
9663 0x4C,0xF0,0x02,0xE0,0x83,0x0A,0x1C,0xD7,
9664 0x80,0x9A,0xF1,0x33,0x06,0x58,0x8E,0xE3,
9665 0x3E,0xA9,0xC0,0x1D,0x8F,0xEF,0x07,0x6C,
9666 0xC2,0x09,0x2C,0x7F,0x10,0xA8,0xE3,0x0C,
9667 0x9F,0xE7,0x0B,0x8B,0x21,0x1F,0x13,0x4C,
9668 0x60,0xB1,0x27,0x1B,0x3A,0x1E,0xF0,0xDF,
9669 0x63,0x1E,0x2F,0x7C,0x32,0xF1,0x7C,0x4D,
9670 0x30,0x22,0x84,0x9C,0x8C,0x07,0x7D,0x87,
9671 0xC0,0x5C,0x6F,0xD8,0xB9,0x85,0x8B,0x3A,
9672 0x68,0xA0,0x4E,0x0B,0x3E,0x28,0xB0,0x9B,
9673 0x11,0xE6,0xB8,0xCE,0xCF,0x2A,0x60,0xF8,
9674 0xFF,0x9F,0x55,0x60,0x8F,0x10,0xFE,0xED,
9675 0xC1,0xF3,0xF2,0x95,0xE1,0xD5,0x21,0x81,
9676 0x43,0x8E,0x10,0x3D,0x2E,0x8F,0x10,0x73,
9677 0x3E,0xC2,0x0C,0x11,0x5C,0x67,0x01,0x70,
9678 0x0C,0x11,0xF8,0x1C,0x70,0xC0,0x71,0x69,
9679 0xE2,0x03,0xF5,0x01,0x07,0x70,0x70,0x4D,
9680 0xC3,0x1D,0x70,0xC0,0x71,0x16,0x60,0xFF,
9681 0xFF,0xC3,0x0D,0x2C,0x49,0x26,0x0E,0x23,
9682 0x18,0x11,0x30,0x28,0x02,0x02,0xA4,0xB3,
9683 0x80,0x0F,0x29,0x00,0x1F,0xAE,0x0C,0x0F,
9684 0x29,0xD8,0x93,0x86,0x07,0x8E,0x1B,0x85,
9685 0x07,0x8D,0x0B,0x30,0x68,0x7A,0xE2,0x80,
9686 0x7F,0x4C,0xF0,0x19,0x05,0x1C,0xE3,0x06,
9687 0xDF,0x2A,0x0C,0xFC,0xFF,0x3F,0x30,0xCC,
9688 0xE1,0xC2,0x63,0x39,0x8A,0xA0,0x07,0x1E,
9689 0xD4,0xF7,0x8C,0x33,0xF7,0x24,0x8F,0xD1,
9690 0x51,0x0F,0x27,0xF4,0xE4,0x85,0x3B,0x57,
9691 0xF9,0x0A,0x71,0x14,0x18,0xB8,0x77,0x29,
9692 0x8F,0xCF,0x17,0x2B,0xC3,0x63,0x46,0xFB,
9693 0x1E,0x72,0xD6,0x11,0x02,0xE2,0x2F,0x75,
9694 0x6C,0xC0,0x60,0x39,0x18,0x00,0x87,0x01,
9695 0xE3,0x13,0x0D,0x58,0x67,0x1B,0x3C,0xF4,
9696 0x69,0x31,0xC4,0xE3,0x0B,0xFB,0x56,0x61,
9697 0x82,0xEA,0x41,0x75,0x12,0xF4,0xD0,0xC0,
9698 0x01,0xE8,0xA1,0xC1,0x3F,0xB9,0x90,0xFB,
9699 0x2B,0x1D,0x82,0xB5,0xE2,0x69,0xDE,0x47,
9700 0x1E,0xF3,0xDC,0xA2,0xBC,0x0D,0x3C,0x07,
9701 0xF0,0xD3,0x82,0x87,0xE3,0x63,0x81,0xC7,
9702 0xE9,0x4B,0x58,0x82,0xF7,0x1A,0x9F,0x6C,
9703 0x1E,0x5C,0x58,0xB2,0x21,0xA0,0x06,0xEB,
9704 0x21,0x60,0xA6,0x9A,0xC0,0x49,0x46,0x80,
9705 0xCA,0x00,0xA1,0x1B,0xCB,0xE9,0x3E,0x8B,
9706 0x84,0x38,0xCD,0x47,0x99,0xC7,0x02,0x8F,
9707 0xF5,0xC1,0xC0,0xFF,0x7F,0xCD,0x23,0xD4,
9708 0x7D,0xCD,0x33,0x7B,0x3A,0xC0,0xAC,0x22,
9709 0xDC,0x7B,0xCE,0x1B,0x86,0xD1,0x9E,0x2D,
9710 0x7C,0xCD,0x78,0xD6,0x34,0x42,0x38,0x76,
9711 0x83,0xF3,0x48,0x8C,0xF0,0x82,0xC0,0x4E,
9712 0x0C,0x0F,0x30,0xC6,0x39,0x79,0xC3,0xFA,
9713 0xC2,0xCB,0x40,0x83,0x19,0xDB,0x97,0x01,
9714 0x36,0x2A,0xDF,0x88,0xC0,0x97,0xFC,0x62,
9715 0x00,0x65,0x16,0xBE,0x9E,0xF8,0xA0,0xC4,
9716 0x2E,0x06,0x2C,0xE5,0xC5,0x00,0x54,0x37,
9717 0x0C,0x5F,0x0C,0xE0,0x5F,0x89,0x5E,0x0C,
9718 0xC0,0x70,0x71,0xF2,0x3D,0xC0,0x1E,0xEE,
9719 0xA3,0x74,0x9C,0xBE,0xFD,0xBD,0x19,0xF8,
9720 0x6C,0xC0,0x60,0x3C,0xC3,0x30,0xC6,0x08,
9721 0xE3,0x51,0x86,0x31,0xC1,0xDC,0xB7,0x03,
9722 0xE8,0x39,0x87,0x81,0x4A,0x78,0x3B,0x80,
9723 0x72,0x0E,0xE8,0xF2,0x68,0x42,0x4F,0x01,
9724 0x4F,0x07,0x3E,0x29,0x1A,0xA2,0xAF,0xB1,
9725 0x0A,0x26,0x50,0xC4,0x07,0x0D,0x3E,0xB5,
9726 0x28,0x3E,0x15,0x78,0x2D,0xCF,0x4E,0xE1,
9727 0xE2,0x9C,0x89,0xA7,0x6A,0x38,0x03,0xBD,
9728 0xE6,0x86,0x63,0xFF,0x7F,0x38,0xFC,0xA9,
9729 0xE0,0x35,0x80,0x1D,0x24,0x3D,0x2D,0x23,
9730 0xC2,0x38,0xA4,0x3C,0x32,0xF8,0xB6,0x18,
9731 0xC7,0x90,0x0F,0x91,0xBE,0x13,0x18,0xF2,
9732 0x21,0xEF,0x79,0xC7,0xC0,0xAF,0x08,0x71,
9733 0x9E,0xB2,0x7C,0x67,0xF0,0x65,0x01,0x7C,
9734 0x91,0x2E,0x0B,0x68,0x68,0x9F,0x64,0x7C,
9735 0x41,0x30,0xEC,0x89,0xB3,0x00,0x77,0x05,
9736 0x50,0x81,0xFA,0xAE,0x00,0xFF,0x42,0xF0,
9737 0xAE,0x00,0x86,0x79,0xF9,0x56,0xC0,0x35,
9738 0x1D,0x4A,0xD0,0x67,0x12,0x5F,0x17,0x70,
9739 0x53,0x64,0xA9,0x8E,0x0A,0xD0,0x53,0x4C,
9740 0x02,0x75,0x47,0xF7,0x51,0x01,0xC6,0x4D,
9741 0xD9,0x07,0x54,0x76,0x5A,0x60,0x67,0x21,
9742 0x76,0x1D,0xC1,0x5D,0x49,0x18,0xCA,0xB3,
9743 0x81,0x2F,0x59,0xFC,0x70,0x00,0x03,0xDC,
9744 0xB3,0x38,0xC4,0x08,0xB1,0xD9,0x81,0xEB,
9745 0x75,0xD2,0x70,0x2F,0x44,0xEC,0xFF,0x7F,
9746 0x32,0x00,0xE3,0x51,0x1B,0x1C,0x27,0x9D,
9747 0xF0,0x91,0x9E,0x59,0xF8,0x49,0x19,0x30,
9748 0x71,0xF2,0x03,0xE3,0xC9,0x1A,0xC6,0x00,
9749 0xB8,0xBC,0x57,0x95,0x81,0xFC,0x43,0x90,
9750 0x20,0x18,0xD4,0x29,0x19,0x38,0x1C,0xC5,
9751 0x70,0xA7,0x64,0x78,0x50,0xF8,0xC3,0x00,
9752 0xE6,0x46,0xE8,0x7B,0x82,0xA1,0xDE,0x93,
9753 0x0E,0xE3,0x91,0xD0,0x04,0x3E,0x2D,0xC3,
9754 0xFA,0xFF,0x9F,0x96,0x81,0xD5,0xB1,0xDD,
9755 0x43,0xF6,0x59,0x01,0x77,0x76,0x80,0x3B,
9756 0x3D,0x7E,0x7A,0x00,0x9C,0x00,0x3D,0x3D,
9757 0x80,0xED,0xBC,0x01,0xF7,0x40,0x80,0x38,
9758 0xFE,0xA3,0x82,0x5F,0x59,0x28,0x1C,0x3F,
9759 0xB6,0xF3,0x63,0x09,0xEE,0x70,0xE0,0x23,
9760 0x83,0x0F,0x90,0xB8,0xA1,0xF8,0x50,0x81,
9761 0x3C,0x0B,0x80,0x62,0xF4,0x6C,0x04,0xEC,
9762 0x06,0xF3,0xD2,0x12,0xE5,0xFF,0xFF,0xDE,
9763 0xC0,0x4E,0x29,0xB8,0x83,0x00,0xF8,0x8E,
9764 0x01,0xE0,0x1D,0x0C,0x97,0x35,0x66,0x94,
9765 0x10,0x18,0x8D,0x19,0x77,0x08,0xE1,0x27,
9766 0x02,0xDC,0x98,0x3D,0x6E,0x8F,0x19,0x77,
9767 0x9C,0xE5,0xA3,0x7A,0xCA,0x08,0xE5,0x03,
9768 0x07,0x3B,0x67,0xBC,0x11,0xF0,0xA1,0x03,
9769 0x8F,0x03,0x0C,0xEE,0x48,0x01,0xC6,0xCB,
9770 0x01,0x1B,0x3B,0xB8,0x83,0x90,0x53,0x20,
9771 0x4B,0x87,0xD1,0xD8,0x71,0xB2,0x81,0x74,
9772 0x8C,0xF1,0x21,0xD7,0x63,0xC7,0x0D,0xD6,
9773 0x63,0xC7,0x1D,0x5F,0xB0,0xFF,0xFF,0xE3,
9774 0x0B,0x18,0xC6,0xC0,0xC5,0x0F,0x03,0x7D,
9775 0xF3,0xF3,0xE8,0x0C,0xEE,0x61,0xFB,0x04,
9776 0x13,0xE3,0xF9,0x25,0xC4,0x23,0xCC,0x8B,
9777 0x4B,0x84,0xA3,0x08,0xF2,0xE6,0x12,0xE7,
9778 0xD5,0x20,0xCC,0x63,0x4B,0x94,0x10,0x11,
9779 0x0E,0x26,0xCE,0x13,0x8C,0x11,0x0E,0x3C,
9780 0x8A,0x21,0x22,0x9C,0x40,0x88,0x93,0x3E,
9781 0xD9,0x20,0xE1,0x63,0x84,0x8D,0xF6,0x04,
9782 0xC3,0xC7,0xC2,0xCF,0x2B,0x1E,0x3C,0x3F,
9783 0xAD,0xF9,0x2E,0xE8,0xC9,0x9C,0xE3,0x43,
9784 0x96,0xA7,0xF6,0x38,0xE9,0xC3,0x2C,0x6E,
9785 0x50,0x0F,0x8E,0xEC,0xAE,0xE3,0xE3,0x35,
9786 0xF6,0x14,0xE4,0x21,0xF0,0x13,0x81,0x2F,
9787 0x88,0x9E,0xAC,0xEF,0x7A,0xEC,0x5E,0x66,
9788 0x8C,0xEA,0xA7,0x80,0x3A,0xA6,0x9C,0xC1,
9789 0x2B,0x04,0xBB,0xE7,0xF9,0x90,0xED,0xBB,
9790 0x24,0x1B,0x05,0xEE,0x90,0xE0,0x33,0x12,
9791 0x3F,0x55,0x78,0x18,0x1E,0x05,0x8C,0x19,
9792 0xBC,0x23,0x1C,0x5A,0x88,0x03,0x7E,0xDF,
9793 0x65,0x43,0x8D,0x71,0x7A,0x3E,0x7F,0xB0,
9794 0x41,0xC0,0x87,0x3A,0x54,0x0F,0xF3,0xA8,
9795 0x5E,0x0A,0x19,0xCE,0xD9,0xC1,0x1D,0x04,
9796 0xF6,0xF8,0xE1,0x41,0xF0,0x9B,0x25,0x1F,
9797 0x04,0x3B,0xDF,0xBC,0xC1,0x19,0xE4,0xFF,
9798 0x7F,0x0C,0xB0,0xCF,0x54,0x3E,0x9A,0x20,
9799 0x8E,0x80,0xE8,0xF3,0x87,0xC7,0xF0,0x26,
9800 0xC7,0x87,0x83,0x3D,0x7A,0xE0,0x4E,0x22,
9801 0x70,0x8F,0x5D,0x07,0xED,0x6B,0x9C,0x2F,
9802 0x5A,0x30,0xEE,0x7B,0xCF,0x22,0xE0,0xC7,
9803 0x78,0x6C,0x01,0xC7,0xA1,0x04,0xDC,0xC1,
9804 0x8E,0x6B,0x1C,0x42,0x51,0x60,0x74,0x28,
9805 0xC1,0xC5,0x00,0x12,0x8C,0x63,0x9C,0xD1,
9806 0xD0,0x97,0x48,0x1F,0xD2,0xE0,0x0C,0x1A,
9807 0xF6,0x3C,0x9F,0x50,0xB8,0x3D,0x01,0x8A,
9808 0x4E,0x28,0x20,0xC3,0x7D,0x06,0xC1,0x9E,
9809 0x10,0xF8,0x19,0x84,0xFD,0xFF,0x0F,0x8E,
9810 0x1E,0xF7,0x7B,0xA3,0x4F,0x8D,0x6C,0xEE,
9811 0x0F,0x01,0x27,0x70,0xEE,0xEC,0xD4,0x8C,
9812 0x3B,0x33,0x60,0xCF,0x1F,0x1E,0x02,0x3F,
9813 0x17,0x78,0xF8,0x1E,0x02,0x7E,0xF0,0x0F,
9814 0xCC,0x06,0x07,0xE3,0x29,0xC2,0xD7,0x0E,
9815 0x0E,0xCE,0x4F,0x03,0x06,0xE7,0xAF,0x50,
9816 0x9F,0xE7,0x19,0x38,0xF6,0xD4,0xEB,0x7B,
9817 0x87,0xE7,0xEB,0x43,0x05,0xFE,0xA6,0xE7,
9818 0x43,0x05,0x38,0x0E,0x0F,0xFC,0xB0,0xC2,
9819 0x86,0xF0,0x28,0x80,0x3F,0xB5,0xF8,0xF8,
9820 0x17,0xE7,0x29,0x82,0xDD,0x46,0xB0,0x87,
9821 0x0B,0xC0,0x51,0xB4,0xB3,0x18,0x2A,0xCC,
9822 0x59,0x8C,0xFC,0xFF,0xCF,0x51,0xA8,0xB3,
9823 0x18,0x3D,0x5C,0x00,0x2E,0x04,0x1F,0x0F,
9824 0x40,0x73,0x10,0x78,0x5C,0xF0,0x85,0xE0,
9825 0x48,0x0E,0xE4,0xE9,0x00,0xF0,0x19,0x4A,
9826 0xC3,0xA1,0x09,0x13,0x03,0x06,0x75,0x3E,
9827 0xF0,0x09,0xC5,0xC7,0x0E,0x7E,0x36,0xF0,
9828 0x8D,0xDC,0x43,0xE5,0xA7,0x66,0x5F,0xF2,
9829 0x11,0xE0,0x02,0x75,0xA0,0x61,0xA0,0x46,
9830 0xE4,0x23,0xD2,0xFF,0xFF,0xB9,0x0D,0x1B,
9831 0x60,0x68,0xF4,0x1C,0x0E,0xE3,0x80,0xEB,
9832 0x73,0x38,0x76,0x40,0x3E,0x87,0xC3,0x3F,
9833 0x47,0xC3,0x1F,0x1B,0x3B,0xDD,0xF3,0x81,
9834 0xC1,0xBA,0x7E,0x63,0x06,0x06,0xB6,0x6F,
9835 0x91,0x07,0x06,0x1C,0x51,0xCF,0xC6,0x57,
9836 0x08,0x0F,0x0C,0x6C,0x80,0x1E,0x18,0xF0,
9837 0x89,0x05,0x21,0x27,0x03,0x43,0x9D,0x32,
9838 0x8C,0x1C,0xF3,0x89,0xC3,0xC3,0xF0,0xA1,
9839 0x22,0xEA,0x33,0xC0,0x23,0x1E,0x1B,0x1B,
9840 0xFB,0xFF,0x8F,0x0D,0x2C,0xC7,0x16,0x8F,
9841 0x0D,0xFC,0x47,0x78,0xFC,0xD8,0xE0,0x8C,
9842 0xE5,0xD1,0xC4,0x97,0x99,0x23,0x3B,0x8D,
9843 0x33,0x7B,0x0D,0xF1,0xD1,0xEE,0xF1,0xDB,
9844 0x63,0x03,0x97,0x85,0xB1,0x01,0xA5,0x90,
9845 0x63,0x43,0x1F,0x52,0x7C,0x0A,0xB0,0x71,
9846 0x54,0x32,0x0F,0x1F,0xAF,0x7C,0x62,0x38,
9847 0xBA,0x20,0x6F,0xE8,0xBE,0x5C,0xF8,0x48,
9848 0x63,0x30,0x5F,0x5A,0x7C,0x06,0xE5,0x43,
9849 0x04,0xD7,0x57,0xC5,0x43,0x04,0x3E,0xA1,
9850 0x86,0x88,0x1E,0xCF,0xFF,0xFF,0x11,0xCC,
9851 0x43,0x64,0x43,0x03,0xAF,0x87,0xA1,0x01,
9852 0xA5,0x98,0xC0,0x5E,0x85,0x87,0x46,0x4F,
9853 0x3F,0x3E,0x04,0x30,0x08,0xDF,0x06,0xD8,
9854 0x55,0xC0,0x57,0x21,0x83,0x24,0x18,0xE7,
9855 0x64,0x41,0x07,0x07,0x8E,0x21,0x79,0x70,
9856 0xF0,0x07,0xE3,0x21,0x70,0x60,0xCF,0xE0,
9857 0xB9,0xE8,0x31,0xD8,0xA7,0x1D,0x9F,0x4A,
9858 0xC0,0x77,0xE6,0x04,0xC7,0xE9,0x1D,0x7B,
9859 0x29,0xF0,0x08,0x1E,0xAD,0x3C,0x02,0x7E,
9860 0xB4,0x02,0x66,0xFF,0xFF,0xA3,0x15,0x30,
9861 0x09,0x7A,0xE6,0xA4,0x03,0x77,0x34,0x18,
9862 0xD4,0xD1,0x0A,0x5C,0x11,0xC0,0x75,0xDC,
9863 0xF0,0xD1,0x02,0xCE,0x50,0x0F,0xDA,0x07,
9864 0x65,0xCF,0xDA,0x97,0x21,0x76,0xB4,0x00,
9865 0x97,0x89,0x43,0x08,0xD0,0x04,0x3E,0x89,
9866 0x67,0xEF,0x43,0x03,0xB3,0x8A,0xA1,0x01,
9867 0xA5,0xA3,0x01,0xEE,0x44,0x81,0xFD,0xFF,
9868 0x9F,0x28,0x60,0xDE,0x30,0x70,0x07,0x0A,
9869 0xC0,0xCD,0xE9,0xDB,0xE3,0xE2,0xD0,0x38,
9870 0xC4,0xE7,0xA7,0x73,0xF6,0xD1,0xE8,0x4C,
9871 0x71,0x67,0x11,0x30,0x9C,0x7D,0x11,0x8F,
9872 0x18,0x03,0xF9,0x81,0x21,0x59,0x30,0x28,
9873 0x16,0x0F,0xC5,0x07,0x03,0x0E,0xEC,0x23,
9874 0x02,0x3B,0x17,0xB0,0x73,0xAD,0xE1,0xF8,
9875 0x59,0xC0,0xA7,0x84,0xB7,0xA6,0x17,0x7B,
9876 0x9F,0xD7,0x7D,0xD6,0x08,0xC9,0xCE,0xF4,
9877 0x3E,0x89,0xE2,0x0E,0xA2,0x70,0x4E,0x9F,
9878 0xE0,0x22,0xF0,0x65,0xDF,0xA3,0xE0,0xA7,
9879 0x07,0xCF,0xF1,0x8D,0xC1,0xA7,0x07,0xE6,
9880 0x7E,0xF8,0x9A,0xF1,0x33,0xC3,0xE3,0x43,
9881 0x88,0x27,0xE2,0xDA,0xA6,0x20,0x5B,0x18,
9882 0x42,0x09,0xF4,0xFF,0x8F,0x10,0xE5,0x6D,
9883 0x20,0xCA,0x29,0x44,0x88,0x12,0xA4,0xB1,
9884 0xC9,0x0B,0x35,0xCA,0xD9,0x45,0x6E,0x6D,
9885 0xF6,0x82,0x0B,0x14,0x2A,0x66,0x9C,0x28,
9886 0xEF,0x10,0xB1,0xDA,0x1F,0x04,0x91,0xF4,
9887 0x32,0xD0,0x71,0xC9,0x91,0x0E,0x7D,0xE8,
9888 0x61,0xFB,0x04,0x8C,0x3F,0x48,0xE2,0xAE,
9889 0x2A,0x3E,0x28,0xF8,0x00,0x80,0x77,0x09,
9890 0xA8,0x5B,0x9D,0xC7,0xED,0xF3,0x06,0xF8,
9891 0xAF,0x17,0x58,0x82,0xF2,0x07,0x81,0x1A,
9892 0x99,0xA1,0x3D,0xCC,0xB7,0x19,0x43,0xBE,
9893 0x07,0x1C,0x16,0x3B,0x27,0xF9,0xF0,0x08,
9894 0x1C,0x8E,0x01,0x4F,0x1B,0xBE,0x51,0x7B,
9895 0xBE,0x3E,0x62,0x01,0x8E,0xFE,0xFF,0x47,
9896 0x2C,0x30,0x9D,0xDF,0x7D,0x82,0x01,0xC7,
9897 0xCD,0x82,0x9F,0x61,0x00,0x67,0x40,0xCF,
9898 0x30,0x60,0x1F,0x2A,0x6E,0x08,0x5C,0xEE,
9899 0x8A,0x28,0x90,0x05,0xC2,0xA0,0x0E,0xFD,
9900 0xE4,0x08,0x42,0xCF,0x9C,0x70,0x86,0x72,
9901 0xB2,0xBD,0x5F,0x1D,0xC8,0x2D,0xC2,0x43,
9902 0x3D,0x8B,0xC7,0x04,0x76,0xDA,0x02,0x36,
9903 0xFF,0xFF,0xE3,0x29,0xB0,0x98,0xF7,0xD3,
9904 0x69,0x84,0x63,0x03,0xFB,0x71,0x0B,0x38,
9905 0x1D,0xCC,0xE0,0xDC,0x7F,0xD8,0x2D,0x1A,
9906 0x37,0x34,0xB0,0x0D,0xCC,0x43,0x03,0x3E,
9907 0x27,0x47,0x30,0x9E,0x98,0xF8,0x55,0xE2,
9908 0xE1,0x89,0x1F,0x43,0xC0,0xFA,0xFF,0x3F,
9909 0x99,0x01,0xF6,0x84,0x1E,0xCB,0x50,0xD2,
9910 0x4E,0x66,0x80,0xC0,0xFB,0xD8,0x3B,0xC3,
9911 0x4B,0x83,0xE7,0x74,0xD2,0xCF,0x62,0x3E,
9912 0x99,0x19,0x21,0x0A,0xBB,0x8F,0x19,0xAD,
9913 0x37,0x14,0xCD,0x3C,0xE8,0x3B,0x99,0x51,
9914 0x62,0x46,0x6A,0x0E,0x4C,0x48,0x11,0x0F,
9915 0x27,0x4A,0x88,0x60,0xAF,0x13,0x6F,0x67,
9916 0x4F,0x66,0x4C,0xD6,0xC9,0x0C,0x24,0xFF,
9917 0xFF,0x93,0x19,0x98,0x5C,0x9F,0xCC,0x80,
9918 0xCA,0x39,0x0A,0x7F,0x32,0x03,0x78,0x74,
9919 0xC0,0xC2,0x9D,0xCC,0xC0,0xF2,0xFF,0x3F,
9920 0xC4,0x00,0xCE,0xC7,0x0A,0x63,0x0C,0x3C,
9921 0xDA,0xC1,0x0C,0x15,0xE6,0x6C,0x86,0x0E,
9922 0x72,0x08,0xA1,0xC1,0x0E,0x21,0x50,0xE6,
9923 0x72,0xA0,0xA7,0xF0,0x9A,0xE0,0x73,0x14,
9924 0xD8,0x0F,0x67,0xC0,0xE1,0xD4,0x80,0x0F,
9925 0x74,0xE2,0x42,0x8F,0xC2,0x23,0x0E,0x58,
9926 0xFD,0xC0,0xC8,0xFF,0xFF,0x64,0x06,0x18,
9927 0x78,0x6A,0xF8,0x40,0x82,0x63,0x31,0xEA,
9928 0x1B,0xC4,0x21,0xBE,0x8D,0xF8,0xE8,0xFE,
9929 0x6A,0xE2,0x4B,0x00,0xE6,0x42,0xE2,0xD3,
9930 0x09,0xB3,0x70,0x38,0x03,0x5A,0x43,0x60,
9931 0x57,0x26,0xCF,0x9C,0x0F,0xE1,0x6C,0x3C,
9932 0x7A,0xDC,0xE9,0x04,0xDE,0x38,0x7C,0x3A,
9933 0x01,0x5E,0x07,0x0C,0xCC,0x0C,0xC2,0x3F,
9934 0x84,0xB0,0x21,0x9C,0xAA,0xC7,0x70,0xEE,
9935 0xAF,0x38,0x3E,0x9D,0x80,0xF3,0xFF,0x7F,
9936 0x62,0x03,0x0C,0x0A,0x7E,0x32,0xF8,0xB8,
9937 0x46,0x25,0xC2,0xA0,0x8E,0xE6,0x80,0x7B,
9938 0x98,0x27,0x36,0x26,0x6F,0xC5,0x1A,0x8B,
9939 0x4F,0x6C,0x30,0xFF,0xFF,0x27,0x36,0x80,
9940 0xD1,0x87,0x20,0xB0,0xFD,0xFF,0x0F,0x41,
9941 0x60,0x1C,0xA0,0x0F,0x41,0x80,0x9B,0xD3,
9942 0x09,0xEE,0xC4,0x07,0xB6,0x63,0x10,0x60,
9943 0x6D,0xE8,0x3E,0x06,0x81,0xF9,0xFF,0x3F,
9944 0x5A,0x98,0xA3,0xE0,0xC2,0x8E,0x7C,0x28,
9945 0x29,0xA7,0x3E,0xB4,0x0C,0x20,0x69,0x38,
9946 0xC9,0x01,0x9D,0xD3,0x3D,0x70,0x92,0x75,
9947 0xEA,0x40,0x8F,0xC7,0xA0,0xAF,0x1C,0xBE,
9948 0x12,0xF0,0x23,0x07,0x93,0x00,0xAA,0x41,
9949 0xFA,0xCC,0x07,0x9C,0x8E,0x1C,0xE0,0x38,
9950 0x26,0x05,0xC6,0xDE,0x0E,0xDE,0x22,0x3D,
9951 0x89,0xA7,0xA1,0xE3,0x0C,0x51,0x38,0x26,
9952 0x39,0x18,0x44,0x7A,0x95,0x62,0x03,0x7C,
9953 0xAB,0xF1,0xD9,0xC8,0x07,0x10,0x78,0xE3,
9954 0xF6,0xD8,0x61,0xFF,0xFF,0x0F,0x75,0xC0,
9955 0x01,0xE2,0xA4,0xF8,0x21,0xC3,0x98,0x67,
9956 0xC5,0x0F,0x75,0x80,0xF5,0x18,0x27,0x3A,
9957 0x94,0xF0,0x43,0x1D,0x20,0xE8,0xFF,0x7F,
9958 0xA8,0x03,0x86,0x38,0x6F,0x24,0xD1,0x1E,
9959 0xEA,0x98,0xE8,0x43,0x1D,0x40,0xC8,0xFF,
9960 0xFF,0xA1,0x0E,0x18,0x9E,0x87,0x00,0xAE,
9961 0x9C,0xEF,0xC0,0x7C,0x22,0x02,0xEF,0xFF,
9962 0xFF,0x7C,0x07,0xB8,0x1B,0x2D,0xCC,0x51,
9963 0x70,0x41,0xAF,0x0E,0x03,0x51,0x09,0x30,
9964 0x28,0x02,0xC7,0x5F,0x9B,0x60,0x1C,0xEA,
9965 0x7C,0x87,0x3E,0x2F,0x78,0xD8,0x4F,0x05,
9966 0x9E,0xC4,0xA9,0xFA,0x5A,0x70,0x14,0x4F,
9967 0x00,0x3E,0xE1,0x01,0xFF,0xA1,0xC1,0x9A,
9968 0x44,0xF1,0x43,0x03,0xF5,0x11,0xE4,0xFF,
9969 0x7F,0x68,0xC0,0x28,0xEA,0xF9,0x06,0x7D,
9970 0xCC,0xF2,0xD9,0x20,0xE6,0x0B,0x48,0x84,
9971 0x07,0x10,0x5F,0x1F,0xD8,0x71,0xD2,0x67,
9972 0xA0,0x40,0x51,0xDE,0x37,0xF8,0x09,0x07,
9973 0x5C,0x83,0xF3,0x09,0x07,0xBC,0x87,0x23,
9974 0x1F,0x4B,0xC0,0x77,0xD0,0x84,0x73,0x81,
9975 0xF1,0x8D,0x8D,0x9D,0x06,0xC0,0x76,0x00,
9976 0x06,0xDF,0x69,0x00,0x1C,0xC7,0x24,0x7E,
9977 0x3A,0x04,0x13,0xCC,0xC1,0xBC,0x34,0xFB,
9978 0xFF,0xEF,0xFD,0x94,0x43,0xCF,0x86,0x80,
9979 0x75,0x49,0x07,0x43,0x94,0x88,0xB3,0x21,
9980 0x20,0xFD,0xFF,0x7F,0x36,0xC4,0x20,0xC4,
9981 0x09,0xFC,0x12,0xD1,0xDC,0xD9,0x90,0xAE,
9982 0xD8,0x67,0x43,0x80,0xE1,0xFF,0xFF,0x23,
9983 0x00,0xF6,0x7C,0x04,0x38,0x3D,0x64,0x83,
9984 0xE7,0x14,0x08,0xE3,0xE4,0x03,0x38,0xFE,
9985 0xFF,0x8F,0x15,0xE6,0x18,0x78,0xEA,0x97,
9986 0x9B,0x8F,0x03,0x54,0xD4,0x2B,0xC2,0x30,
9987 0x94,0xC5,0x87,0x05,0x1F,0x11,0xF8,0x61,
9988 0xC1,0x23,0xA8,0x78,0x9C,0xF4,0x74,0xE3,
9989 0x33,0x21,0x3B,0x24,0x38,0xFC,0x20,0xE9,
9990 0x41,0x13,0x3C,0xE7,0x23,0x78,0xB7,0x1E,
9991 0x38,0xA7,0x02,0xC0,0x4D,0xAE,0x27,0xA3,
9992 0x4E,0x17,0x0E,0x70,0x8E,0x92,0x8D,0x63,
9993 0x08,0xE5,0x70,0xCC,0xB7,0x87,0xA6,0xC9,
9994 0x4E,0x56,0x30,0x63,0x41,0xEA,0x24,0xE0,
9995 0x01,0x38,0x10,0x8C,0xB4,0x93,0x68,0x34,
9996 0x86,0xB3,0x5A,0x18,0xC1,0x19,0xC4,0xC7,
9997 0x11,0xE7,0x3A,0x19,0xA1,0x3F,0x07,0x3E,
9998 0x15,0x61,0x82,0xDC,0x4B,0xE8,0xBC,0x7D,
9999 0x37,0xE0,0x57,0x61,0x8F,0xC5,0xFF,0x7F,
10000 0x60,0xDF,0x4E,0xC0,0x31,0x17,0xAB,0x01,
10001 0x45,0x0D,0xC0,0x68,0x98,0x53,0xC0,0x53,
10002 0x09,0xB8,0x82,0xCD,0x0D,0x7D,0x61,0xB1,
10003 0xD6,0xA9,0xE8,0x14,0xF4,0x3E,0x70,0x70,
10004 0xC0,0x63,0xF6,0x1E,0x1C,0x2C,0x34,0x0F,
10005 0x0E,0x6C,0xD9,0x06,0x87,0x56,0x72,0x17,
10006 0x21,0x87,0x0F,0xFC,0xEC,0x80,0x03,0xA0,
10007 0x67,0x07,0x0B,0xC9,0xB3,0x03,0x9B,0xBE,
10008 0xB3,0x08,0x28,0x70,0xFE,0xFF,0x11,0xDE,
10009 0x3B,0x7C,0x6E,0x79,0xF6,0x60,0x63,0x78,
10010 0x74,0x31,0x9A,0xD1,0xB9,0xA6,0xDB,0x04,
10011 0x4A,0xC5,0x6D,0x82,0x82,0xF8,0x06,0xE0,
10012 0x84,0x34,0xBA,0x75,0xE2,0x66,0x62,0xFC,
10013 0x47,0x0C,0x1F,0x11,0x0E,0xE9,0x6C,0x4D,
10014 0x30,0x0F,0xA4,0x9E,0x81,0xBE,0xB3,0xE1,
10015 0x67,0x1F,0xF2,0xC1,0xC5,0xD3,0xF0,0xF5,
10016 0x86,0xDC,0x3B,0xE8,0xB4,0x7D,0x66,0xC0,
10017 0x1C,0x74,0x7D,0x9D,0x7A,0x83,0x27,0x57,
10018 0x09,0xEA,0xE1,0x02,0x42,0x2F,0x34,0xBE,
10019 0xDC,0x25,0x78,0xE0,0xF4,0xE9,0xEE,0xBD,
10020 0x84,0x9D,0xF1,0x12,0xBC,0xE0,0x25,0x98,
10021 0x77,0x10,0xA8,0x51,0x79,0x10,0x98,0xAB,
10022 0x3C,0xCB,0x37,0x06,0x54,0xB2,0x8B,0x16,
10023 0x3D,0xC3,0xBC,0xC3,0xF8,0x92,0xE0,0xEB,
10024 0x87,0xCF,0x2D,0x5E,0xC0,0xEB,0x16,0x0C,
10025 0x82,0x67,0xA0,0x57,0x17,0xDF,0xD9,0x0D,
10026 0xFC,0x2A,0xF0,0x46,0x13,0x22,0x98,0x61,
10027 0x0F,0xFF,0xDD,0xDD,0xA8,0xBE,0xE9,0x18,
10028 0xEB,0x75,0xC4,0x23,0xE5,0xC7,0x96,0x03,
10029 0x8A,0xF4,0xF2,0xE6,0x09,0xF8,0x2C,0xE3,
10030 0x53,0xDD,0x49,0xF9,0x7A,0x68,0xF4,0x57,
10031 0x08,0x1F,0x7E,0x8C,0xEC,0x73,0x0E,0x3B,
10032 0xDF,0xB1,0x41,0x71,0xC4,0x07,0x86,0x97,
10033 0x1A,0x4F,0x85,0x9D,0xBB,0x60,0x1C,0x1C,
10034 0xD8,0xB1,0x08,0x73,0x7C,0x05,0xD7,0xC9,
10035 0xE6,0xFF,0xFF,0xE4,0x00,0x6E,0x78,0xCC,
10036 0xC1,0xD7,0xE7,0x0D,0xDF,0x0C,0x3C,0x2E,
10037 0x7E,0xE4,0xF0,0x49,0xE3,0xA5,0xD3,0xD8,
10038 0xA7,0xE9,0xA3,0xD1,0xCB,0x9B,0x4F,0x2F,
10039 0x18,0x58,0x5F,0x1A,0x38,0xAC,0xD1,0xC2,
10040 0x3E,0x06,0x9C,0xB9,0x2F,0x44,0xB8,0xC3,
10041 0x23,0x58,0x00,0xF1,0xB7,0x92,0x47,0x0E,
10042 0x4F,0xC0,0x80,0x4C,0xD3,0xBA,0x74,0x20,
10043 0xE2,0xA7,0x3C,0x2B,0x5F,0x99,0x2E,0x43,
10044 0x0C,0xE3,0xA9,0xF2,0xF1,0xC3,0xB3,0xF1,
10045 0x51,0xC0,0xC7,0x28,0xCF,0xFC,0x8C,0x22,
10046 0xBD,0x32,0x10,0x50,0x9D,0x88,0xB8,0x42,
10047 0x18,0x89,0xA1,0xD1,0x9D,0x83,0xC7,0x1F,
10048 0x22,0x05,0x31,0xA0,0x6F,0x2E,0xC0,0xF4,
10049 0x4C,0x04,0x5C,0xFE,0xFF,0x37,0x17,0x80,
10050 0xFF,0xFF,0xFF,0x9B,0x0B,0xE0,0xE6,0xFE,
10051 0xE0,0x9B,0x0B,0x70,0x8D,0xB4,0x2A,0x7A,
10052 0x61,0x77,0x08,0x18,0xD4,0x9D,0x1D,0x70,
10053 0x78,0x2B,0x78,0x67,0x87,0xF5,0xFF,0xBF,
10054 0xB3,0xC3,0xC3,0x8C,0x13,0xE5,0x85,0x21,
10055 0xC6,0x3B,0x3B,0x0B,0xF0,0x26,0xD0,0x51,
10056 0xC6,0x77,0x76,0x80,0x1F,0x67,0xD8,0x77,
10057 0x69,0xF0,0x5E,0x75,0x81,0xF5,0xFF,0xFF,
10058 0xAA,0x0B,0x3C,0x04,0xDF,0xA7,0x41,0x3E,
10059 0x5E,0x30,0x8C,0x83,0x2B,0x27,0xA1,0xC7,
10060 0x02,0x6B,0x85,0x41,0xDD,0xA9,0xC1,0xA5,
10061 0x09,0x5C,0x17,0x5F,0x1F,0x6A,0x7C,0xA4,
10062 0xC5,0x9F,0x2F,0x70,0x01,0x86,0x4C,0x4F,
10063 0x65,0x30,0xAE,0x29,0x3E,0x95,0x61,0xEE,
10064 0x0E,0x1E,0x90,0x8F,0x18,0xC0,0x67,0x15,
10065 0x1E,0x18,0xEE,0xB4,0xE0,0x9B,0x92,0x41,
10066 0xCF,0x31,0xA8,0x8F,0x3C,0x27,0xEF,0x7B,
10067 0xC2,0xE3,0x84,0xA3,0x9E,0x83,0xE8,0xD8,
10068 0xC0,0x71,0xDC,0xC0,0xFD,0xFF,0xC7,0x06,
10069 0xEF,0x70,0x83,0x3B,0xE8,0xF8,0x62,0x70,
10070 0x5C,0x18,0xB8,0xE7,0x02,0x0F,0xC3,0x37,
10071 0x1D,0x8F,0x08,0x33,0xFE,0xD7,0x3F,0x23,
10072 0x04,0xC4,0x5F,0x8C,0xD8,0x80,0xC1,0x78,
10073 0x6B,0xF3,0xF5,0x0D,0x37,0x60,0x5F,0x1D,
10074 0x7C,0xC1,0xF0,0x09,0xCC,0xE8,0x2F,0x30,
10075 0x4F,0x62,0x3E,0x36,0x90,0x0B,0x1C,0x1D,
10076 0x30,0x38,0x00,0x3D,0x60,0xF8,0x87,0x8B,
10077 0x77,0x39,0x30,0x5C,0x05,0x7D,0x5C,0xF0,
10078 0xB1,0xC7,0x8A,0xEE,0x72,0xE8,0x9B,0x9C,
10079 0x61,0xE2,0x18,0xE2,0x0D,0x8C,0xDD,0x25,
10080 0xC8,0x61,0x0E,0xEA,0x5D,0xC2,0x73,0xE0,
10081 0x67,0x0B,0x9F,0xE0,0x7C,0xF3,0x09,0x71,
10082 0xAA,0x8F,0x56,0xEF,0x01,0x3E,0x7A,0xBC,
10083 0x77,0xF9,0xEC,0xC4,0x2E,0x02,0x3E,0x72,
10084 0x19,0xC7,0xD3,0xF4,0x15,0xD0,0x43,0x36,
10085 0xD8,0xAB,0x86,0x4F,0x60,0x3E,0xBA,0xE1,
10086 0x8E,0x51,0x9E,0x89,0xA7,0xEF,0x3B,0x08,
10087 0x3B,0x92,0x1C,0x75,0xA8,0x6B,0x7A,0x44,
10088 0xF9,0xFF,0x9F,0xD0,0x81,0xF8,0xD6,0x06,
10089 0xCE,0x68,0xF7,0x0F,0xF4,0x36,0x3D,0x32,
10090 0xCC,0xD1,0x00,0xD6,0x25,0x04,0x5C,0x77,
10091 0x0C,0x5F,0x42,0x80,0x4F,0xD0,0x4B,0x04,
10092 0xFA,0x9A,0xE1,0xD1,0x3D,0x02,0x60,0xAE,
10093 0x18,0xEC,0x58,0xE0,0xC3,0x86,0xAF,0x01,
10094 0xEC,0x5E,0xE0,0x30,0xF7,0x08,0x50,0x81,
10095 0x7A,0x78,0xF0,0xD5,0xDE,0x23,0x40,0x71,
10096 0xB2,0xF4,0xA1,0xC1,0x03,0xB5,0xAA,0x33,
10097 0x26,0x94,0x23,0x26,0x3F,0x9B,0xF9,0x26,
10098 0x81,0xB9,0x5D,0xFA,0x26,0x01,0x37,0xCF,
10099 0x2C,0x50,0x49,0x20,0xF4,0xFF,0xBF,0x49,
10100 0xC0,0x85,0xE9,0xF2,0x32,0x43,0xE7,0x7F,
10101 0xE0,0xBE,0xD5,0x79,0x84,0x3E,0x44,0x30,
10102 0x94,0xF7,0x3C,0x9F,0xC2,0xF8,0x19,0xC2,
10103 0x07,0x4C,0x76,0xA6,0xE0,0x67,0x4D,0xDC,
10104 0x1D,0xC0,0x28,0x6F,0x9E,0x9E,0x00,0x3B,
10105 0x7F,0x1A,0xF9,0xDD,0xE0,0x5D,0xC0,0xD3,
10106 0xF7,0xBD,0x88,0x9F,0x28,0xC0,0x17,0xEC,
10107 0x4E,0x07,0x05,0xFA,0x84,0x3C,0x22,0xA3,
10108 0xFA,0x88,0xC0,0x2F,0x49,0x60,0x3C,0x92,
10109 0xF8,0x40,0x01,0x84,0xEE,0x05,0xA8,0xD3,
10110 0x07,0x47,0x3D,0xE3,0x17,0x54,0x63,0xBE,
10111 0x5B,0x3D,0xC2,0x79,0x72,0x98,0xCB,0x01,
10112 0x8B,0x73,0x4D,0x02,0xD5,0x71,0x97,0x8F,
10113 0x0E,0xEE,0xB5,0x15,0xFB,0xFF,0x27,0x38,
10114 0xB8,0x77,0x96,0x77,0x3E,0x43,0x79,0x90,
10115 0xE0,0xBB,0xB6,0x82,0xE3,0xAA,0x06,0xE3,
10116 0xD8,0xC2,0x2F,0x79,0x80,0x9D,0x61,0x71,
10117 0xC1,0x7F,0x0F,0x03,0x51,0x89,0x30,0x28,
10118 0x02,0xCB,0xBB,0xB7,0x52,0xF8,0x43,0x06,
10119 0xE3,0x4D,0x81,0x4F,0x1A,0x3B,0x6A,0xE0,
10120 0xFB,0xFF,0x1F,0x35,0xD8,0x86,0x8A,0xBB,
10121 0x29,0x82,0x75,0xAA,0x98,0x21,0xF0,0x60,
10122 0x0F,0x00,0x9F,0xAF,0x7C,0x06,0x50,0x14,
10123 0x18,0xD4,0xA1,0x1D,0xCE,0x6D,0x18,0x70,
10124 0x30,0x62,0xDC,0xA5,0x10,0xEE,0x94,0xDF,
10125 0x51,0x62,0x3F,0x97,0xB3,0xE9,0xE2,0xAE,
10126 0xE6,0x3E,0x9D,0xB0,0x0B,0x32,0x8C,0xB3,
10127 0xC0,0x23,0xC0,0xAB,0x39,0xBF,0x20,0x3F,
10128 0x17,0xBF,0x10,0x3C,0x26,0x85,0x78,0x53,
10129 0x7A,0x25,0x36,0xC6,0x93,0x71,0x73,0xB7,
10130 0x62,0x72,0xDE,0x79,0x41,0x36,0xC6,0xD1,
10131 0x44,0x8C,0x72,0x6E,0x0F,0x03,0x91,0x5F,
10132 0x90,0x7D,0x3F,0x79,0x21,0x88,0x18,0xCD,
10133 0x10,0x41,0x9F,0x97,0x8D,0x15,0x28,0xDE,
10134 0x0B,0x32,0x13,0xF8,0x56,0xD0,0xC1,0xC5,
10135 0x17,0x64,0xEC,0xFF,0xFF,0x82,0x0C,0x30,
10136 0xE2,0x64,0x04,0xF8,0x3C,0x71,0xE0,0xCE,
10137 0x35,0x30,0xFE,0xFF,0x97,0x6A,0xD8,0x27,
10138 0x1B,0xC0,0xD9,0xD0,0x7D,0xB2,0x01,0xF7,
10139 0x68,0xE1,0x1D,0x4D,0x10,0x27,0x1B,0x0A,
10140 0xE4,0xE0,0xEB,0xA2,0x70,0x3C,0xF4,0x49,
10141 0x84,0x1E,0x9D,0x7C,0x94,0xC4,0x9D,0x19,
10142 0x3C,0x91,0x77,0x16,0x8F,0xE2,0x65,0xD0,
10143 0xF7,0x82,0x13,0x79,0x7D,0xB0,0x9C,0x63,
10144 0x24,0xA8,0x46,0xE2,0xE3,0x03,0xFC,0xEB,
10145 0x8B,0x8F,0x91,0xF0,0xF9,0xFC,0xC3,0xF2,
10146 0x60,0x0C,0xF9,0xFF,0x7F,0x8A,0xC4,0x80,
10147 0x3C,0xBB,0x3C,0x86,0xF0,0x0B,0x24,0xDC,
10148 0xD3,0xCC,0x01,0x60,0x64,0x5D,0x1E,0xD1,
10149 0x67,0x47,0x8E,0x11,0xD7,0x17,0x45,0x5F,
10150 0x81,0x7D,0x10,0x38,0x9F,0xE7,0x44,0xB0,
10151 0x8E,0x9A,0x1F,0x6D,0xF8,0xF8,0x39,0xF8,
10152 0x5B,0xC1,0x03,0xA5,0x8F,0x45,0x21,0x1E,
10153 0x91,0xF8,0x39,0x11,0x5C,0x26,0xCE,0x89,
10154 0x40,0xE2,0xD0,0x0B,0xE3,0xB4,0x80,0x1B,
10155 0x88,0xCF,0x94,0xD8,0x29,0x9F,0x08,0x3B,
10156 0x97,0x60,0x46,0x07,0xAE,0xCB,0xBD,0x47,
10157 0x07,0xFE,0x93,0x00,0x1E,0xEB,0xFF,0xFF,
10158 0x78,0x07,0xBE,0x93,0xBA,0xEF,0x26,0xBE,
10159 0xC8,0xF8,0x50,0xF4,0x7C,0x07,0xF8,0x0F,
10160 0x77,0xB8,0x43,0xC5,0x39,0xDF,0x01,0xD2,
10161 0xFE,0xFF,0xE7,0x3B,0x60,0x79,0xB6,0x7E,
10162 0xBE,0x03,0xBB,0xC8,0xF3,0x1D,0x40,0xAC,
10163 0xFF,0xFF,0xF9,0x0E,0xB0,0x73,0x46,0xC3,
10164 0x9D,0xEF,0xC0,0x76,0xB4,0x01,0xCC,0x4D,
10165 0xE3,0xD1,0x06,0xDC,0xC3,0x85,0x3D,0x0C,
10166 0xAE,0xD0,0xA6,0x4F,0x8D,0x46,0xAD,0x1A,
10167 0x94,0xA9,0x51,0xE6,0xFF,0xDF,0xA0,0x56,
10168 0x9F,0x4A,0x8D,0x19,0xCB,0x0E,0xA5,0x80,
10169 0x8F,0x0A,0x8D,0xCD,0xF2,0x28,0x04,0x62,
10170 0x31,0xAF,0x06,0x81,0x38,0x2C,0x08,0x8D,
10171 0xF4,0xCA,0x11,0x88,0x25,0x3F,0xFB,0x05,
10172 0x62,0xB9,0x6F,0x06,0x81,0x38,0xE0,0x1B,
10173 0x4C,0xE0,0xE4,0x61,0x25,0x70,0xF2,0x6E,
10174 0x10,0x88,0x23,0x83,0x50,0xA1,0x3A,0x40,
10175 0x58,0x4C,0x10,0x1A,0xCA,0x07,0x08,0x93,
10176 0xFE,0x48,0x10,0x20,0x31,0x02,0xC2,0xC2,
10177 0xBD,0xBF,0x04,0x62,0x69,0xEF,0x09,0x81,
10178 0x58,0x88,0x15,0x10,0x16,0x17,0x84,0x86,
10179 0xD3,0x02,0xC2,0x24,0x99,0x01,0x61,0x81,
10180 0x40,0xA8,0x7C,0x35,0x20,0x4C,0xA4,0x1B,
10181 0x40,0xBA,0x7A,0x81,0x38,0x88,0x1E,0x10,
10182 0x26,0xC3,0x0F,0x08,0x0B,0x0D,0x42,0xA3,
10183 0x3D,0x30,0x04,0x48,0x0C,0x81,0xB0,0xF8,
10184 0x8E,0x40,0x98,0xF8,0x57,0x91,0x40,0x9C,
10185 0xDF,0x12,0xC4,0x4D,0x69,0x88,0x35,0x01,
10186 0x31,0x0D,0x9E,0x80,0x98,0x22,0x10,0x01,
10187 0x39,0xF6,0xD3,0x43,0x40,0xD6,0x60,0x0A,
10188 0x88,0x45,0x07,0x11,0x90,0x85,0xA8,0x02,
10189 0x62,0x79,0x5D,0x01,0xB1,0xF0,0x20,0x02,
10190 0x72,0xE6,0x97,0x9F,0x80,0xAC,0xE0,0xA5,
10191 0xF3,0x10,0xC0,0xDE,0x10,0x81,0x48,0x72,
10192 0x10,0x01,0x39,0xB0,0x2F,0x20,0x16,0x1F,
10193 0x44,0x40,0xCE,0xFA,0x28,0x14,0x90,0x83,
10194 0x83,0x68,0x10,0xE4,0x6B,0x26,0x20,0xA7,
10195 0x07,0x11,0x10,0xF9,0x04,0x05,0x21,0x6A,
10196 0xBD,0x81,0x30,0x3D,0x8F,0x42,0x0D,0x85,
10197 0x80,0x50,0xE5,0xEA,0xCE,0x31,0x2C,0x07,
10198 0x08,0xCD,0x05,0x22,0x30,0xAB,0x70,0x07,
10199 0xC4,0x54,0x81,0x08,0xC8,0x09,0x80,0xC8,
10200 0xFF,0x9F,0x60,0x2A,0x10,0x9A,0x12,0x8C,
10201 0xEA,0x92,0x07,0xC4,0x12,0x80,0xD0,0x54,
10202 0x20,0x34,0x25,0x88,0x00,0xAD,0xCA,0x1E,
10203 0x10,0x53,0x0A,0x42,0x95,0x83,0xD0,0x74,
10204 0x20,0x54,0xB6,0xBE,0xC3,0x02,0x05,0x11,
10205 0x90,0xA3,0x83,0x50,0xE1,0xFE,0x40,0x98,
10206 0xDE,0x97,0x86,0x00,0x9D,0x0E,0x44,0x40,
10207 0x4E,0x0C,0x42,0x15,0x7C,0x32,0x82,0x10,
10208 0xB1,0x20,0x54,0xC1,0x27,0x23,0x28,0xD1,
10209 0xF2,0xB2,0x13,0x90,0xF5,0x81,0x50,0xBD,
10210 0x20,0x02,0x73,0x36,0x20,0x9A,0x17,0x84,
10211 0xE6,0x07,0xA3,0x5A,0x8D,0x02,0x31,0xFD,
10212 0x20,0x34,0x0F,0x88,0xC0,0xAC,0xE0,0xF9,
10213 0x71,0xC0,0x0C,0x84,0xAA,0x04,0x11,0x98,
10214 0x73,0x01,0xD1,0xAC,0x20,0x34,0x3B,0x18,
10215 0xD5,0xFE,0x0F,0xD1,0x00,0x08,0x08,0xCD,
10216 0x07,0xA2,0xC3,0x00,0x79,0x96,0x09,0xC8,
10217 0x1A,0x41,0xA8,0x66,0x10,0x81,0x39,0x27,
10218 0x10,0xCD,0x0E,0x42,0x95,0xFD,0x4D,0x82,
10219 0x91,0x8C,0x0F,0xD0,0x40,0x24,0x37,0x08,
10220 0xD5,0xF1,0x0C,0x0A,0x46,0x74,0x83,0x08,
10221 0xC8,0x59,0x40,0x68,0x36,0x30,0x9A,0x4C,
10222 0xED,0x91,0x80,0xBA,0x05,0x61,0xE9,0x41,
10223 0x68,0x3A,0xBB,0x83,0xA7,0x20,0x54,0x81,
10224 0x5E,0x30,0xA6,0x19,0x44,0x87,0x05,0x02,
10225 0x42,0x73,0x81,0x51,0x1D,0xAF,0x96,0x40,
10226 0x44,0x1B,0x08,0xD5,0x0A,0xA2,0x81,0x93,
10227 0x1F,0x53,0x10,0x92,0x14,0x84,0xFC,0xFF,
10228 0x07,0xAA,0xC7,0x9C,0x40,0xAC,0xFA,0x5B,
10229 0x25,0x50,0x27,0x01,0xA1,0xC9,0x40,0x74,
10230 0x7C,0x20,0x0F,0xB8,0x83,0x64,0x20,0x54,
10231 0x29,0x88,0xC0,0xAC,0xF4,0x63,0xA4,0x23,
10232 0x05,0x51,0x7D,0xBC,0xA0,0x20,0x34,0xD1,
10233 0x3B,0x2C,0x08,0x7B,0xB8,0x69,0xA8,0xE4,
10234 0x59,0xA5,0xA1,0x12,0x10,0x9A,0x0D,0x44,
10235 0xC7,0x04,0xF2,0xAA,0x79,0x4C,0x60,0x20,
10236 0x54,0x2F,0x08,0xCD,0x01,0x42,0x13,0x83,
10237 0x08,0xD4,0xA9,0xBF,0x37,0x1A,0x2A,0xF9,
10238 0x5B,0x09,0xC4,0xCA,0x5E,0x69,0x02,0xB1,
10239 0xDE,0xA7,0x4E,0x20,0xE6,0x1D,0x98,0xA9,
10240 0x05,0xA1,0xEA,0x41,0x04,0xE6,0xB4,0x40,
10241 0x54,0x81,0x78,0x10,0xA6,0x08,0x44,0x60,
10242 0x4E,0x02,0x44,0xD3,0x81,0xD0,0xEC,0x60,
10243 0x54,0xE7,0xA3,0x4D,0x40,0xD6,0x0E,0x42,
10244 0xB3,0x80,0x08,0xCC,0x59,0x1E,0x69,0x02,
10245 0xB1,0x92,0x2F,0x9D,0x0E,0x24,0x04,0x84,
10246 0x26,0xD3,0x7F,0x68,0xA1,0x05,0x80,0x99,
10247 0x84,0x04,0x20,0x4C,0x16,0x88,0x0E,0x27,
10248 0xD6,0x08,0x22,0x40,0xC7,0x01,0xA3,0xD1,
10249 0x40,0x68,0x5C,0x40,0x9A,0x1D,0x90,0x2A,
10250 0x6D,0x00,0xC6,0x54,0x83,0xD0,0x24,0x20,
10251 0x02,0x74,0x2C,0x10,0x01,0x5A,0x74,0x04,
10252 0x30,0x16,0x01,0x84,0x46,0x05,0xA1,0xC9,
10253 0x2A,0x80,0xB2,0x9C,0x20,0x1A,0x20,0xC9,
10254 0x30,0x60,0x0A,0x42,0x33,0x81,0xD0,0x8C,
10255 0x20,0x54,0x7C,0x07,0x10,0x16,0x04,0x84,
10256 0x86,0x03,0xD1,0x00,0xFE,0xFF,0x8F,0x0C,
10257 0x02,0xD1,0x00,0x9C,0x23,0xC4,0x61,0x85,
10258 0x82,0xD0,0xF4,0x20,0x34,0x6C,0x09,0x50,
10259 0x16,0x1D,0x44,0xC7,0x23,0x92,0x02,0x8C,
10260 0x05,0x02,0xA1,0x31,0x41,0x68,0x6C,0x10,
10261 0x1A,0x29,0x06,0x28,0x13,0x54,0xE3,0x50,
10262 0x44,0x7B,0x80,0x31,0x99,0x20,0x54,0x36,
10263 0x88,0xC0,0x1C,0x14,0x88,0x86,0x07,0xA1,
10264 0x62,0x82,0x00,0x52,0x10,0x01,0x12,0x20,
10265 0x1A,0x1E,0x84,0x8A,0x29,0x32,0x74,0x0A,
10266 0x42,0x55,0x24,0x39,0x9A,0x50,0x10,0x1D,
10267 0x4D,0x08,0x08,0xCD,0x07,0x46,0x75,0x35,
10268 0x39,0x6E,0x50,0x10,0xAA,0x1D,0x84,0x06,
10269 0x05,0xA1,0x39,0xA2,0x80,0xB2,0xEC,0x20,
10270 0x02,0xB2,0x9E,0x2A,0x87,0x0A,0x0A,0x22,
10271 0x30,0xA7,0x02,0xA2,0x49,0x41,0xA8,0x8E,
10272 0x2C,0x47,0x0A,0x9A,0x06,0x84,0x25,0x06,
10273 0xA1,0xC9,0xDA,0x80,0xB0,0x0C,0x75,0x0E,
10274 0x24,0x14,0x84,0xE6,0x04,0xA1,0x4A,0xF2,
10275 0x0C,0x8F,0x82,0xE8,0x38,0x42,0x80,0x68,
10276 0x7A,0x10,0xAA,0xA6,0xCF,0x00,0x28,0x88,
10277 0x06,0x40,0x40,0x68,0x4E,0x30,0xAA,0xA8,
10278 0xD1,0xD1,0x84,0x82,0x50,0xDD,0x2F,0x4E,
10279 0x81,0xF8,0xFF,0x0F,
10282 } //end DefinitionBlock