1/*
2 * Some or all of this work - Copyright (c) 2006 - 2020, Intel Corp.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
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.
16 *
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.
27 */
28
29//
30//
31// Grammar.asl - Minimally exercises most ASL constructs
32//
33// NOTE -- use: iasl -f -of grammar.asl to compile
34//
35//         This 1) Ignores errors (checks compiler error handling)
36//              2) Disables constant folding
37//
38//
39
40/*******************************************************************************
41Compilation should look like this:
42
43C:\acpica\tests\misc>iasl -f -of grammar.asl
44
45Intel ACPI Component Architecture
46ASL Optimizing Compiler version 20090422 [Apr 22 2009]
47Copyright (C) 2000 - 2009 Intel Corporation
48Supports ACPI Specification Revision 3.0a
49
50grammar.asl   187:     Name (_NPK, Package (8)
51Warning  1098 -                 ^ Unknown reserved name (_NPK)
52
53grammar.asl   510:     NAME (ESC1, "abcdefg\x00hijklmn")
54Warning  1042 -                                ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
55
56grammar.asl   511:     NAME (ESC2, "abcdefg\000hijklmn")
57Warning  1042 -                                ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
58
59grammar.asl   601:     Method (RCIV, 1)
60Warning  1087 -                   ^ Not all control paths return a value (RCIV)
61
62grammar.asl   608:         RCIV (Subtract (Arg0, 1))
63Remark   5073 -               ^ Recursive method call (RCIV)
64
65grammar.asl   937:     Method (_ERR, 2)
66Warning  1077 -                   ^ Reserved method has too few arguments (_ERR requires 3)
67
68grammar.asl  1377:         Store (0x1234567887654321, QWD2)
69Warning  1032 -                                    ^ 64-bit integer in 32-bit table, truncating
70
71grammar.asl  1379:         if (LNotEqual (Local0, 0x1234567887654321))
72Warning  1032 -         64-bit integer in 32-bit table, truncating ^
73
74grammar.asl  1459:         SizeOf (BUFO)
75Warning  1105 -                       ^ Result is not used, operator has no effect
76
77grammar.asl  1485:         Acquire (MTX2, 1)
78Warning  1104 -                           ^ Possible operator timeout is ignored
79
80grammar.asl  1633:         Add (Local0, Local1)
81Warning  1105 -                      ^ Result is not used, operator has no effect
82
83grammar.asl  1804:     Method (COND)
84Warning  1087 -                   ^ Not all control paths return a value (COND)
85
86grammar.asl  6010:             Name (_HID, "*PNP0A06")
87Error    4001 -                                     ^ String must be entirely alphanumeric (*PNP0A06)
88
89grammar.asl  6461:             Name (_CRS, Buffer(26)  {"\_SB_.PCI2._CRS..........."})
90Warning  1038 -        Invalid or unknown escape sequence ^
91
92grammar.asl  6800:                 And (Local0, 1, Local0) //  Local0 &= 1
93Error    4050 -                              ^ Method local variable is not initialized (Local0)
94
95grammar.asl  6886:             Name (_HID, "*PNP0C0A")     //  Control Method Battey ID
96Error    4001 -                                     ^ String must be entirely alphanumeric (*PNP0C0A)
97
98ASL Input:  grammar.asl - 10254 lines, 322162 bytes, 4810 keywords
99AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes
100
101Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations
102
103***************************************************************************************************/
104
105DefinitionBlock (
106    "grammar.aml",      //Output filename
107    "DSDT",             //Signature
108    0x01,               //DSDT Revision ---> 32-bit table
109    "Intel",            //OEMID
110    "GRMTEST",          //TABLE ID
111    0x20090511          //OEM Revision
112    )
113{
114
115    External (\ABCD, UnknownObj)
116
117
118    /* Device with _STA and _INI */
119
120    Device (A1)
121    {
122        Method (_STA)
123        {
124            Return (0x0F)
125        }
126
127        Method (_INI)
128        {
129            Return
130        }
131    }
132
133    /* Device with no _STA, has _INI */
134
135    Device (A2)
136    {
137        Method (_INI)
138        {
139            Return
140        }
141    }
142
143    /* Device with _STA, no _INI */
144
145    Device (A3)
146    {
147        Method (_STA)
148        {
149            Return (0x0F)
150        }
151    }
152
153    /* Device with _STA and _INI, but not present */
154
155    Device (A4)
156    {
157        Method (_STA)
158        {
159            Return (Zero)
160        }
161
162        Method (_INI)
163        {
164            Return
165        }
166    }
167
168
169    /* Resource descriptors */
170
171    Device (IRES)
172    {
173        Name (PRT0, ResourceTemplate ()
174        {
175            IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15}
176
177            StartDependentFn (1,1)
178            {
179                IRQNoFlags () {0,1,2}
180            }
181            EndDependentFn ()
182        })
183
184        Method (_CRS, 0, NotSerialized)
185        {
186            Store ("_CRS:", Debug)
187            Store (PRT0, Debug)
188            Return (PRT0)
189        }
190
191        Method (_SRS, 1, Serialized)
192        {
193            Store ("_SRS:", Debug)
194            Store (Arg0, Debug)
195            Return (Zero)
196        }
197    }
198
199    Name (_NPK, Package ()
200    {
201        0x1111,
202        0x2222,
203        0x3333,
204        0x4444
205    })
206
207
208    Device (RES)
209    {
210        Name (_PRT, Package (0x04)
211        {
212            Package (0x04)
213            {
214                0x0002FFFF,
215                Zero,
216                Zero,
217                Zero
218            },
219
220            Package (0x04)
221            {
222                0x0002FFFF,
223                One,
224                Zero,
225                Zero
226            },
227
228            Package (0x04)
229            {
230                0x000AFFFF,
231                Zero,
232                Zero,
233                Zero
234            },
235
236            Package (0x04)
237            {
238                0x000BFFFF,
239                Zero,
240                Zero,
241                Zero
242            }
243        })
244
245        Method (_CRS, 0, Serialized)
246        {
247            Name (PRT0, ResourceTemplate ()
248            {
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
254                    0x0002,,,)
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
260                    0x0100,,,)
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
266                    0x2000,,,)
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
273                    0x0CF8,,,
274                    , TypeStatic)
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
280                    0xF300,,,
281                    , TypeStatic)
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
287                    0x00000CF8,,,
288                    , TypeStatic)
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
294                    0x00028000,,,
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
301                    0x00028000,,,)
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",
308                    , TypeStatic)
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,,,
315                    , TypeStatic)
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
336                    , TypeStatic)
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)
355                IRQNoFlags () {2}
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")
363                {
364                    0x00000E01,
365                }
366                Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx")
367                {
368                    0x00000601,
369                    0x00000003,
370                    0x00000002,
371                    0x00000001,
372                }
373                Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive)
374                {
375                    0xFFFF0000,
376                    0x00000003,
377                    0x00000002,
378                    0x00000001,
379                    0x00000005,
380                    0x00000007,
381                    0x00000009,
382                }
383                VendorShort () {0x01, 0x02, 0x03}
384                VendorLong ()
385                {
386                    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
387                    0x09
388                }
389                Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000)
390                Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2)
391                StartDependentFnNoPri ()
392                {
393                    IRQNoFlags () {0,1,2}
394                    IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15}
395                }
396                EndDependentFn ()
397            })
398            CreateWordField (PRT0, 0x08, BMIN)
399            CreateByteField (PRT0, R000._ASZ, RSIZ)
400            Store (0x03, BMIN)
401            Return (PRT0)
402        }
403
404        Method (_PRS, 0, Serialized)
405        {
406            Name (BUF0, ResourceTemplate ()
407            {
408                StartDependentFn (0x01, 0x02)
409                {
410                    IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08)
411                    IRQNoFlags () {4}
412                }
413                StartDependentFn (0x02, 0x01)
414                {
415                    IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08)
416                    IRQNoFlags () {4}
417                }
418                StartDependentFn (0x00, 0x02)
419                {
420                    IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08)
421                    IRQNoFlags () {3}
422                }
423                StartDependentFn (0x00, 0x02)
424                {
425                    IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08)
426                    IRQNoFlags () {3}
427                }
428                StartDependentFn (0x02, 0x00)
429                {
430                    IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08)
431                    IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15}
432                }
433                EndDependentFn ()
434            })
435            Return (BUF0)
436        }
437
438        Method (_SRS, 1, Serialized)
439        {
440            Return (Zero)
441        }
442    }
443
444
445    Name(\_S0,Package(0x04){
446        0x00,
447        0x00,
448        0x00,
449        0x00
450    })
451    Name(\_S3,Package(0x04){
452        0x05,
453        0x05,
454        0x00,
455        0x00
456    })
457    Name(\_S4,Package(0x04){
458        0x06,
459        0x06,
460        0x00,
461        0x00
462    })
463    Name(\_S5,Package(0x04){
464        0x07,
465        0x07,
466        0x00,
467        0x00
468    })
469
470/* Examine this table header (DSDT) */
471
472/*
473    DataTableRegion (HDR, "DSDT", "", "")
474    Field (HDR, AnyAcc, NoLock, Preserve)
475    {
476        SIG,  32,
477        LENG, 32,
478        REV,  8,
479        SUM,  8,
480        OID,  48,
481        OTID, 64,
482        OREV, 32,
483        CID,  32,
484        CREV, 32
485    }
486
487    Method (SIZE)
488    {
489        If (LLess (REV, 2))
490        {
491            Store ("32-bit table", Debug)
492        }
493        else
494        {
495            Store ("64-bit table", Debug)
496        }
497        Return (0)
498    }
499
500*/
501    Name (SIZE, 0)
502
503    /* Custom operation region */
504
505    OperationRegion(MYOP,0x80,0xFD60,0x6)
506    Field(MYOP,ByteAcc,NoLock,Preserve)
507    {
508        MFLD,8
509    }
510
511    Method (TCOP,, Serialized)
512    {
513        Name (_STR, Unicode ("test"))
514        Store (4, MFLD)
515        Store (MFLD, Local0)
516    }
517
518    Name (ERRS, 0x0)
519
520    /* Warning should be issued for premature string termination */
521
522    NAME (ESC1, "abcdefg\x00hijklmn")
523    NAME (ESC2, "abcdefg\000hijklmn")
524    Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\432")
525
526
527    Name(CRSA,ResourceTemplate()
528    {
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)
532
533    })
534    Name(CRSB,ResourceTemplate()
535    {
536        DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
537
538    })
539
540    Name(CRSC,ResourceTemplate()
541    {
542        VendorShort () {0x1, 0x2, 0x3}
543    })
544    Name(CRSD,ResourceTemplate()
545    {
546        VendorLong (VNDL) {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}
547    })
548
549    Name(CRSE,ResourceTemplate()
550    {
551        IRQNoFlags(){3,4,10,11}
552        IRQNoFlags(xxxt){3,4,10,11}
553    })
554    Name(CRSR, Buffer (Add (SizeOf(CRSA),SizeOf(CRSB))){})
555    Method(_CRS,0,NotSerialized)
556    {
557        Return(CRSR)
558    }
559
560
561    //
562    // Unnamed scope
563    //
564    Scope (\)
565    {
566        Name(Bxxx,0xFFFFFFFF)
567    }
568
569    Name (LANS, 0x0)
570
571    PowerResource(LANP,1,0)
572    {
573        Method(_STA){
574            If(LEqual(And(LANS,0x30),0x30)){
575                Return(One)
576            } Else {
577                Return(Zero)
578            }
579        }
580        Method(_ON){
581            If(LNot(_STA())){
582                Store (0x30, LANS)
583            }
584        }
585        Method(_OFF){
586            If(_STA()){
587                Store (0, LANS)
588            }
589        }
590    }
591
592
593    /* Can a method define another method? */
594
595    /**********************************
596    Method (TASK, 2, SERIALIZED)
597    {
598        Sleep (100)
599
600        Method (TAS2)
601        {
602            Sleep (100)
603        }
604
605        TAS2()
606        Return
607
608    }
609    ************************************/
610
611    /* A recursive method */
612
613    Method (RCIV, 1)
614    {
615        Store (Arg0, Debug)
616        If (Lequal (Arg0, 0))
617        {
618            Return ()
619        }
620        RCIV (Subtract (Arg0, 1))
621    }
622
623    Method (RTOP)
624    {
625        RCIV (100)
626    }
627
628
629    Scope(\_PR)
630    {
631        Processor(CPU0,0x0,0xFFFFFFFF,0x0) {}
632    }
633
634    Name(B1TP,0xFFFFFFFF)
635
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)
644    Name(B1DC,3000)
645    Name(B2DC,2600)
646    Name(B1LF,3000)
647    Name(B2LF,2600)
648    Name(BPIF,0)
649    Name(PBLL,0)
650
651    Name(RBIF,Package()
652    {
653        0x1,
654        2200,
655        2200,
656        0x1,
657        10800,
658        0,
659        0,
660        1,
661        1,
662        "CA54200-5003/5",
663        "1",
664        "LION",
665        "Fujitsu"
666    })
667
668    Method(SMWE, 4)
669    {
670       return(ONES)
671    }
672
673    Method(SMRE, 4)
674    {
675       return(ONES)
676    }
677
678/*
679    Method(RDBT,0,Serialized){
680        If(LNot(SMWE(0x09,0x15,1,1))){
681                    Store(0x18,Local2)
682            }
683    }
684*/
685    Scope(_SB)
686    {
687
688        Name (SBUF, Buffer (128) {})
689
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)
698
699        Method (_INI)
700        {
701            CreateField (\_SB_.SBUF, 148, 96, FLDV)
702        }
703
704
705        Device(PCI0)
706        {
707            Name(_HID,EISAID("PNP0A03"))
708            Name(_ADR,0x0)
709
710            Method(_CRS,, Serialized)
711            {
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
719                            0xfff1,                           // Min
720                            0xfff2,                           // Max
721                            0x0032,                           // Translation
722                            0x0002,,,                         // Range Length
723                            BUS0
724                    ) } )// PRT0
725
726                CreateWordField(PRT0, BUS0._MIN, BMIN)          //Minimum bus number supported under this bridge.
727
728                Store(3, BMIN)
729                Return(PRT0)
730
731            } // _CRS
732
733            Method(_SRS)
734            {
735                Return ()
736            }
737
738            Device(EIO)
739            {
740                OperationRegion(FJIO,SystemIO,0xFD60,0x6)
741                    Field(FJIO,ByteAcc,NoLock,Preserve)
742                    {
743                        GIDX,8,
744
745                        GDTA,8,
746
747                        PIDX,8,
748
749                        PDTA,8,
750
751                        SIDX,8,
752
753                        SDTA,8
754                    }
755                    IndexField(GIDX,GDTA,ByteAcc,NoLock,Preserve)
756                    {
757                        Offset(0x2),
758                         ,5,
759                        VGAS,2,
760                        Offset(0x4),
761                         ,4,
762                        DCKE,1,
763                        Offset(0x5),
764                         ,6,
765                        ACPW,1,
766
767                        Offset(0xA),
768                        B1P,1,
769
770                        B2P,1,
771
772                        B1C,1,
773
774                        B2C,1,
775
776                        B1ER,1,
777
778                        B2ER,1,
779
780                        Offset(0xB),
781                        B1CP,8,
782
783                        B2CP,8,
784
785                        BCP,8,
786
787                        B1VH,8,
788
789                        B1VL,8,
790
791                        B2VH,8,
792
793                        B2VL,8,
794
795                        B1TM,8,
796
797                        B2TM,8,
798
799                        B1CH,8,
800
801                        B1CL,8,
802
803                        B2CH,8,
804
805                        B2CL,8
806                    }
807                }
808            }
809        }
810
811        Method(RDBT,3,Serialized){
812            Store(0x1FFF,Local1)
813            If( Arg0 ){
814                Store(0x2FFF,Local1)
815            }
816            Store(0x18,Local2)
817            If( Arg1 ){
818                Store(0x10,Local2)
819            }
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)))){
823                        Store(Local1,Arg2)
824                    }
825                }
826                Or(Local0,0xFFF,Local0)
827                SMWE(0x08,0x14,1,Local0)
828            }
829        }
830        Method(MKWD,2)
831        {
832            If(And(Arg1,0x80)) {
833                Or(0xFFFF0000,Arg0,Local0)
834                Or(Local0,ShiftLeft(Arg1,8),Local0)
835                Subtract(Zero,Local0,Local0)
836            } else {
837                Store(Arg0,Local0)
838                Or(Local0,ShiftLeft(Arg1,8),Local0)
839            }
840            Return(Local0)
841        }
842
843        Device(CMB1)
844        {
845            Name(_HID,EISAID("PNP0C0A"))
846            Name(_UID,0x1)
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)
855
856            Method(_INI)
857                        {
858                Store(B1P, B1PS)
859                Store(B1CP,B1RS)
860                Store(B1C, B1CS)
861            }
862
863            Method(_BIF){
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))
870                Return(RBIF)
871            }
872
873            Method(_BST,, Serialized) {
874
875                _INI()
876
877                Store(Zero,Local0)
878
879                if (LAnd(B1P,LNot(B1C))){
880                    Or(Local0,1,Local0)
881                }
882
883                if (LAnd(B1P,B1C)) {
884                    Or(Local0,2,Local0)
885                }
886
887                if (LLessEqual(B1CP,1)) {
888                    Or(Local0,4,Local0)
889                }
890
891                Store(MKWD(B1CL,B1CH),Local1)
892
893                Store(Divide(Add(Multiply(B1CP,B1LF),99),100),Local2)
894
895                Store(MKWD(B1VL,B1VH),Local3)
896
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))
902
903                If(LNot(BPIF)){
904//                    \_SB.PCI0.EIO.EC0.IECT()
905//                    \_SB.PCI0.EIO.EC0.SECT()
906                    Store(One,BPIF)
907                }
908                return(STAT)
909            }
910
911        }
912
913    Device (DEV1)
914    {
915    }
916
917    Scope(\_TZ)
918    {
919        ThermalZone(TZ1)
920        {
921            Name(_PSL,Package()
922            {
923                \_PR.CPU0
924            })
925        }
926    }
927
928    Method (TZ2, 0, SERIALIZED)
929    {
930        Name(_PSL,Package()
931        {
932            \_PR.CPU0
933        })
934
935        Return (_PSL)
936    }
937
938    ThermalZone (THM1)
939    {
940    }
941
942    Method (NOTI)
943    {
944        Notify (\DEV1, 0)
945        Notify (\THM1, 0)
946        Notify (\_PR.CPU0, 0)
947    }
948
949    Method (_ERR, 3)
950    {
951        Increment (ERRS)
952        Store ("Run-time exception:", Debug)
953        Store (Arg0, Debug)
954        Store (Arg1, Debug)
955
956        Return (0)          // Map error to AE_OK
957    }
958
959    Method (DIV0)
960    {
961        Store (1, Local0)
962        Store (0, Local1)
963        Divide (Local0, Local1, Local3)
964
965        Store ("DIV0 - noabort", Debug)
966    }
967
968    Method (ERR_, 2)
969    {
970        Local0 = ToDecimalString (Arg1)
971        if (LEqual (Arg0, 0))
972        {
973            Printf ("+*+*+*+* MTHD_ERROR at line %o: Results not equal!", Local0)
974        }
975        if (LEqual (Arg0, 1))
976        {
977            Printf ("+*+*+*+* MTHD_ERROR at line %o: Numeric result is incorrect!", Local0)
978        }
979        if (LEqual (Arg0, 2))
980        {
981            Printf ("+*+*+*+* MTHD_ERROR at line %o: Operand was clobbered!", Local0)
982        }
983
984        Notify (DEV1, Arg0)
985        Increment (ERRS)
986    }
987
988    Method (R226, 2)
989    {
990    }
991    Method (R225, 2)
992    {
993        R226 (Arg0, Arg1)
994    }
995    Method (R224, 2)
996    {
997        R225 (Arg1, Arg0)
998    }
999    Method (R223, 2)
1000    {
1001        R224 (Arg0, Arg1)
1002    }
1003    Method (R222, 2)
1004    {
1005        R223 (Arg1, Arg0)
1006    }
1007    Method (R111)
1008    {
1009        Store (0x01010101, Local0)
1010        R222 (0xABAB, Local0)
1011        Store (Local0, Local1)
1012    }
1013
1014    Method (MAIN)
1015    {
1016
1017//      SIZE()
1018        Store (NUM1(), Local0)
1019        \CMB1._BST()
1020        RDBT(1,2,3)
1021        OBJ1(1)
1022        OBJ2(2)
1023        CHEK()
1024        RETZ()
1025        BITZ()
1026        LOGS()
1027        REFS()
1028        COND()
1029        TZ2()
1030
1031        //
1032        // iPCO tests added
1033        //
1034        Store (\IFEL.TEST(), Local0)
1035        if (LGreater (Local0, 0))
1036        {
1037            ERR_ (1, __LINE__)
1038            Return(Local0)
1039        }
1040
1041        Store (\NOSV.TEST(), Local0)
1042        if (LGreater (Local0, 0))
1043        {
1044            ERR_ (1, __LINE__)
1045            Return(Local0)
1046        }
1047
1048        Store (\IDXF.TEST(), Local0)
1049        if (LGreater (Local0, 0))
1050        {
1051            ERR_ (1, __LINE__)
1052            Return(Local0)
1053        }
1054
1055        Store (\_SB_.NSTL.TEST(), Local0)
1056        if (LGreater (Local0, 0))
1057        {
1058            ERR_ (1, __LINE__)
1059            Return(Local0)
1060        }
1061
1062        Store (\RTBF.TEST(), Local0)
1063        if (LGreater (Local0, 0))
1064        {
1065            ERR_ (1, __LINE__)
1066            Return(Local0)
1067        }
1068
1069        Store (\_SB_.RTLV.TEST(), Local0)
1070        if (LGreater (Local0, 0))
1071        {
1072            ERR_ (1, __LINE__)
1073            Return(Local0)
1074        }
1075
1076        Store (\_SB_.RETP.TEST(), Local0)
1077        if (LGreater (Local0, 0))
1078        {
1079            ERR_ (1, __LINE__)
1080            Return(Local0)
1081        }
1082
1083        Store (\WHLR.TEST(), Local0)
1084        if (LGreater (Local0, 0))
1085        {
1086            ERR_ (1, __LINE__)
1087            Return(Local0)
1088        }
1089
1090        Store (\ANDO.TEST(), Local0)
1091        if (LGreater (Local0, 0))
1092        {
1093            ERR_ (1, __LINE__)
1094            Return(Local0)
1095        }
1096
1097        Store (\BRKP.TEST(), Local0)
1098        if (LGreater (Local0, 0))
1099        {
1100            ERR_ (1, __LINE__)
1101            Return(Local0)
1102        }
1103
1104        Store (\ADSU.TEST(), Local0)
1105        if (LGreater (Local0, 0))
1106        {
1107            ERR_ (1, __LINE__)
1108            Return(Local0)
1109        }
1110
1111        Store (\INDC.TEST(), Local0)
1112        if (LGreater (Local0, 0))
1113        {
1114            ERR_ (1, __LINE__)
1115            Return(Local0)
1116        }
1117
1118        Store (\LOPS.TEST(), Local0)
1119        if (LGreater (Local0, 0))
1120        {
1121            ERR_ (1, __LINE__)
1122            Return(Local0)
1123        }
1124
1125        Store (\FDSO.TEST(), Local0)
1126        if (LGreater (Local0, 0))
1127        {
1128            ERR_ (1, __LINE__)
1129            Return(Local0)
1130        }
1131
1132        Store (\MLDV.TEST(), Local0)
1133        if (LGreater (Local0, 0))
1134        {
1135            ERR_ (1, __LINE__)
1136            Return(Local0)
1137        }
1138
1139        Store (\NBIT.TEST(), Local0)
1140        if (LGreater (Local0, 0))
1141        {
1142            ERR_ (1, __LINE__)
1143            Return(Local0)
1144        }
1145
1146        Store (\SHFT.TEST(), Local0)
1147        if (LGreater (Local0, 0))
1148        {
1149            ERR_ (1, __LINE__)
1150            Return(Local0)
1151        }
1152
1153        Store (\XORD.TEST(), Local0)
1154        if (LGreater (Local0, 0))
1155        {
1156            ERR_ (1, __LINE__)
1157            Return(Local0)
1158        }
1159
1160        Store (\CRBF.TEST(), Local0)
1161        if (LGreater (Local0, 0))
1162        {
1163            ERR_ (1, __LINE__)
1164            Return(Local0)
1165        }
1166
1167        Store (\IDX4.TEST(), Local0)
1168        if (LGreater (Local0, 0))
1169        {
1170            ERR_ (1, __LINE__)
1171            Return(Local0)
1172        }
1173
1174        Store (\EVNT.TEST(), Local0)
1175        if (LGreater (Local0, 0))
1176        {
1177            ERR_ (1, __LINE__)
1178            Return(Local0)
1179        }
1180
1181        Store (\SZLV.TEST(), Local0)
1182        if (LGreater (Local0, 0))
1183        {
1184            ERR_ (1, __LINE__)
1185            Return(Local0)
1186        }
1187
1188        Store (\_SB_.BYTF.TEST(), Local0)
1189        if (LGreater (Local0, 0))
1190        {
1191            ERR_ (1, __LINE__)
1192            Return(Local0)
1193        }
1194
1195        Store (\DWDF.TEST(), Local0)
1196        if (LGreater (Local0, 0))
1197        {
1198            ERR_ (1, __LINE__)
1199            Return(Local0)
1200        }
1201
1202        Store (\DVAX.TEST(), Local0)
1203        if (LGreater (Local0, 0))
1204        {
1205            ERR_ (1, __LINE__)
1206            Return(Local0)
1207        }
1208
1209        Store (\IDX6.TEST(), Local0)
1210        if (LGreater (Local0, 0))
1211        {
1212            ERR_ (1, __LINE__)
1213            Return(Local0)
1214        }
1215
1216        Store (\IDX5.TEST(), Local0)
1217        if (LGreater (Local0, 0))
1218        {
1219            ERR_ (1, __LINE__)
1220            Return(Local0)
1221        }
1222
1223        Store (\_SB_.IDX0.TEST(), Local0)
1224        if (LGreater (Local0, 0))
1225        {
1226            ERR_ (1, __LINE__)
1227            Return(Local0)
1228        }
1229
1230        Store (\_SB_.IDX3.TEST(), Local0)
1231        if (LGreater (Local0, 0))
1232        {
1233            ERR_ (1, __LINE__)
1234            Return(Local0)
1235        }
1236
1237        Store (\IDX7.TEST(), Local0)
1238        if (LGreater (Local0, 0))
1239        {
1240            ERR_ (1, __LINE__)
1241            Return(Local0)
1242        }
1243
1244        Store (\MTCH.TEST(), Local0)
1245        if (LGreater (Local0, 0))
1246        {
1247            ERR_ (1, __LINE__)
1248            Return(Local0)
1249        }
1250
1251        Store (\WHLB.TEST(), Local0)
1252        if (LGreater (Local0, 0))
1253        {
1254            ERR_ (1, __LINE__)
1255            Return(Local0)
1256        }
1257
1258        Store (\_SB_.IDX2.TEST(), Local0)
1259        if (LGreater (Local0, 0))
1260        {
1261            ERR_ (1, __LINE__)
1262            Return(Local0)
1263        }
1264
1265        Store (\SIZO.TEST(), Local0)
1266        if (LGreater (Local0, 0))
1267        {
1268            ERR_ (1, __LINE__)
1269            Return(Local0)
1270        }
1271
1272        Store (\_SB_.SMIS.TEST(), Local0)
1273        if (LGreater (Local0, 0))
1274        {
1275            ERR_ (1, __LINE__)
1276            Return(Local0)
1277        }
1278
1279        if (LGreater (ERRS, 0))
1280        {
1281            Store ("****** There were errors during the execution of the test ******", Debug)
1282        }
1283
1284        // Flush all notifies
1285
1286        Sleep (250)
1287
1288        //
1289        // Last Test
1290        //
1291
1292        Return(0) // Success
1293    }
1294
1295
1296    Method (OBJ1, 1, SERIALIZED)
1297    {
1298
1299        Store (3, Local0)
1300        Name(BUFR, Buffer (Local0) {})
1301        Name(BUF1, Buffer (4) {1,2,3,4})
1302        Name(BUF2, Buffer (4) {})
1303
1304        Store (BUF1, BUF2)
1305        Mutex (MTX1, 4)
1306
1307        Alias (MTX1, MTX2)
1308    }
1309
1310
1311    Mutex (MTXT, 0)
1312    Mutex (MTXX, 0)
1313
1314    /*
1315     * Field Creation
1316     */
1317
1318    Method (FLDS,, Serialized)
1319    {
1320        Store ("++++++++ Creating BufferFields", Debug)
1321        Name (BUF2, Buffer (128) {})
1322
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)
1330
1331        Store (0x1, BIT2)
1332        Store (BIT2, Local0)
1333        if (LNotEqual (Local0, 0x1))
1334        {
1335            ERR_ (1, __LINE__)
1336        }
1337        else
1338        {
1339            Store (DerefOf (Index (BUF2, 0)), Local0)
1340            if (LNotEqual (Local0, 0x08))
1341            {
1342                ERR_ (1, __LINE__)
1343            }
1344            else
1345            {
1346                Store ("++++++++ Bit BufferField I/O PASS", Debug)
1347            }
1348        }
1349
1350        Store (0x1A, BYT2)
1351        Store (BYT2, Local0)
1352        if (LNotEqual (Local0, 0x1A))
1353        {
1354            ERR_ (1, __LINE__)
1355        }
1356        else
1357        {
1358            Store ("++++++++ Byte BufferField I/O PASS", Debug)
1359        }
1360
1361        Store (0x1234, WRD2)
1362        Store (WRD2, Local0)
1363        if (LNotEqual (Local0, 0x1234))
1364        {
1365            ERR_ (1, __LINE__)
1366        }
1367        else
1368        {
1369            Store ("++++++++ Word BufferField I/O PASS", Debug)
1370        }
1371
1372        Store (0x123, FLD2)
1373        Store (FLD2, Local0)
1374        if (LNotEqual (Local0, 0x123))
1375        {
1376            ERR_ (1, __LINE__)
1377        }
1378        else
1379        {
1380            Store ("++++++++ 12-bit BufferField I/O PASS", Debug)
1381        }
1382
1383        Store (0x12345678, DWD2)
1384        Store (DWD2, Local0)
1385        if (LNotEqual (Local0, 0x12345678))
1386        {
1387            ERR_ (1, __LINE__)
1388        }
1389        else
1390        {
1391            Store ("++++++++ Dword BufferField I/O PASS", Debug)
1392        }
1393
1394        Store (0x1234567887654321, QWD2)
1395        Store (QWD2, Local0)
1396        if (LNotEqual (Local0, 0x1234567887654321))
1397        {
1398            ERR_ (1, __LINE__)
1399        }
1400        else
1401        {
1402            Store ("++++++++ Qword BufferField I/O PASS", Debug)
1403        }
1404    }
1405
1406
1407    /* Field execution */
1408
1409    Method (FLDX,, Serialized)
1410    {
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
1416            SMD3,   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
1423    }
1424
1425
1426    Method (MTX_, )
1427    {
1428        /* Test "Force release" of mutex on method exit */
1429
1430        Acquire (MTXT, 0xFFFF)
1431        Acquire (MTXX, 0xFFFF)
1432
1433        Store ("++++++++ Acquiring Mutex MTX2", Debug)
1434        Acquire (_GL_, 0xFFFF)
1435
1436
1437        Store ("++++++++ Releasing Mutex MTX2", Debug)
1438        Release (_GL_)
1439    }
1440
1441
1442    Method (OBJ2, 1, Serialized)
1443    {
1444        Store ("++++++++ Creating Buffer BUFO", Debug)
1445        Name (BUFO, Buffer (32) {})
1446
1447        Store ("++++++++ Creating OpRegion OPR2", Debug)
1448        OperationRegion (OPR2, SystemMemory, Arg0, 256)
1449
1450        Store ("++++++++ Creating Field(s) in OpRegion OPR2", Debug)
1451        Field (OPR2, ByteAcc, NoLock, Preserve)
1452        {
1453            IDX2, 8,
1454            DAT2, 8,
1455            BNK2, 4
1456        }
1457
1458        Store ("++++++++ Creating BankField BNK2 in OpRegion OPR2", Debug)
1459        //
1460        // mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1
1461        //
1462        BankField (OPR2, BNK2, 0, ByteAcc, NoLock, Preserve)
1463        {
1464            FET0, 4,
1465            FET1, 3
1466        }
1467
1468        Store ("++++++++ Creating IndexField", Debug)
1469        IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve)
1470        {
1471            FET2, 4,
1472            FET3, 3
1473        }
1474
1475        Store ("++++++++ SizeOf (BUFO)", Debug)
1476        SizeOf (BUFO)
1477
1478        Store ("++++++++ Store (SizeOf (BUFO), Local0)", Debug)
1479        Store (SizeOf (BUFO), Local0)
1480
1481        Store ("++++++++ Concatenate (\"abd\", \"def\", Local0)", Debug)
1482        Concatenate ("abd", "def", Local0)
1483        Store (Local0, Debug)
1484
1485        Store ("++++++++ Concatenate (\"abd\", 0x7B, Local0)", Debug)
1486        Concatenate ("abd", 0x7B, Local0)
1487        Store (Local0, Debug)
1488
1489        Store ("++++++++ Creating Event EVT2", Debug)
1490        Event (EVT2)
1491
1492        Store ("++++++++ Creating Mutex MTX2", Debug)
1493        Mutex (MTX2, 0)
1494
1495        Store ("++++++++ Creating Alias MTXA to MTX2", Debug)
1496        Alias (MTX2, MTXA)
1497
1498        Store ("++++++++ Acquiring Mutex MTX2", Debug)
1499        Acquire (MTX2, 0xFFFF)
1500
1501        Store ("++++++++ Acquiring Mutex MTX2 (2nd acquire)", Debug)
1502        Acquire (MTX2, 1)
1503
1504        Store ("++++++++ Releasing Mutex MTX2", Debug)
1505        Release (MTX2)
1506
1507        // Type 1 opcodes
1508
1509        Store ("++++++++ Signalling Event EVT2", Debug)
1510        Signal (EVT2)
1511
1512        Store ("++++++++ Resetting Event EVT2", Debug)
1513        Reset (EVT2)
1514
1515        Store ("++++++++ Signalling Event EVT2", Debug)
1516        Signal (EVT2)
1517
1518        Store ("++++++++ Waiting Event EVT2", Debug)
1519        Wait (EVT2, 0xFFFF)
1520
1521        Store ("++++++++ Sleep", Debug)
1522        Sleep (100)
1523
1524        Store ("++++++++ Stall", Debug)
1525        Stall (254)
1526
1527        Store ("++++++++ NoOperation", Debug)
1528        Noop
1529
1530        // Type 2 Opcodes
1531
1532        Store ("++++++++ Return from Method OBJ2", Debug)
1533        return (4)
1534    }
1535
1536
1537    Method (NUM1, 0)
1538    {
1539        /* ADD */
1540
1541        Store ("++++++++ Add (0x12345678, 0x11111111, Local0)", Debug)
1542        Add (0x12345678, 0x11111111, Local0)
1543
1544        Store ("++++++++ Store (Add (0x12345678, 0x11111111), Local1)", Debug)
1545        Store (Add (0x12345678, 0x11111111), Local1)
1546
1547        Store ("++++++++ Checking result from ADD", Debug)
1548        if (LNotEqual (Local0, Local1))
1549        {
1550            ERR_ (0, __LINE__)
1551        }
1552
1553
1554        /* SUBTRACT */
1555
1556        Store ("++++++++ Subtract (0x87654321, 0x11111111, Local4)", Debug)
1557        Subtract (0x87654321, 0x11111111, Local4)
1558
1559        Store ("++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)", Debug)
1560        Store (Subtract (0x87654321, 0x11111111), Local5)
1561
1562        Store ("++++++++ Checking result from SUBTRACT", Debug)
1563        if (LNotEqual (Local4, Local5))
1564        {
1565            ERR_ (0, __LINE__)
1566        }
1567
1568
1569        /* MULTIPLY */
1570
1571        Store ("++++++++ Multiply (33, 10, Local6)", Debug)
1572        Multiply (33, 10, Local6)
1573
1574        Store ("++++++++ Store (Multiply (33, 10), Local7)", Debug)
1575        Store (Multiply (33, 10), Local7)
1576
1577
1578        Store ("++++++++ Checking result from MULTIPLY", Debug)
1579        if (LNotEqual (Local6, Local7))
1580        {
1581            ERR_ (0, __LINE__)
1582        }
1583
1584
1585        /* DIVIDE */
1586
1587        Store ("++++++++ Divide (100, 9, Local1, Local2)", Debug)
1588        Divide (100, 9, Local1, Local2)
1589
1590        Store ("++++++++ Store (Divide (100, 9), Local3)", Debug)
1591        Store (Divide (100, 9), Local3)
1592
1593        Store ("++++++++ Checking (quotient) result from DIVIDE", Debug)
1594        if (LNotEqual (Local2, Local3))
1595        {
1596            ERR_ (0, __LINE__)
1597        }
1598
1599
1600        /* INCREMENT */
1601
1602        Store ("++++++++ Increment (Local0)", Debug)
1603        Store (1, Local0)
1604        Store (2, Local1)
1605        Increment (Local0)
1606
1607        Store ("++++++++ Checking result from INCREMENT", Debug)
1608        if (LNotEqual (Local0, Local1))
1609        {
1610            ERR_ (0, __LINE__)
1611        }
1612
1613
1614        /* DECREMENT */
1615
1616        Store ("++++++++ Decrement (Local0)", Debug)
1617        Store (2, Local0)
1618        Store (1, Local1)
1619        Decrement (Local0)
1620
1621        Store ("++++++++ Checking result from DECREMENT", Debug)
1622        if (LNotEqual (Local0, Local1))
1623        {
1624            ERR_ (0, __LINE__)
1625        }
1626
1627
1628        /* TOBCD */
1629        /* FROMBCD */
1630
1631        Store ("++++++++ ToBCD (0x1234, Local5)", Debug)
1632        ToBCD (0x1234, Local5)
1633
1634        Store ("++++++++ FromBCD (Local5, Local6)", Debug)
1635        FromBCD (Local5, Local6)
1636
1637        Store ("++++++++ Return (Local6)", Debug)
1638        Return (Local6)
1639    }
1640
1641
1642    Method (CHEK)
1643    {
1644
1645        Store (3, Local0)
1646        Store (3, Debug)
1647        Store (Local0, Debug)
1648        Store (7, Local1)
1649
1650        Add (Local0, Local1)
1651        if (LNotEqual (Local0, 3))
1652        {
1653            ERR_ (2, __LINE__)
1654        }
1655        if (LNotEqual (Local1, 7))
1656        {
1657            ERR_ (2, __LINE__)
1658        }
1659
1660
1661        Add (Local0, Local1, Local2)
1662        if (LNotEqual (Local0, 3))
1663        {
1664            ERR_ (2, __LINE__)
1665        }
1666        if (LNotEqual (Local1, 7))
1667        {
1668            ERR_ (2, __LINE__)
1669        }
1670    }
1671
1672
1673    Method (RET1)
1674    {
1675        Store (3, Local0)
1676        Return (Local0)
1677    }
1678
1679    Method (RET2)
1680    {
1681        Return (RET1())
1682    }
1683
1684    Method (RETZ)
1685    {
1686        RET2 ()
1687    }
1688
1689
1690    Method (BITZ)
1691    {
1692        Store ("++++++++ FindSetLeftBit (0x00100100, Local0)", Debug)
1693        FindSetLeftBit (0x00100100, Local0)
1694        if (LNotEqual (Local0, 21))
1695        {
1696            ERR_ (1, __LINE__)
1697        }
1698
1699        Store ("++++++++ FindSetRightBit (0x00100100, Local1)", Debug)
1700        FindSetRightBit (0x00100100, Local1)
1701        if (LNotEqual (Local1, 9))
1702        {
1703            ERR_ (1, __LINE__)
1704        }
1705
1706        Store ("++++++++ And (0xF0F0F0F0, 0x11111111, Local2)", Debug)
1707        And (0xF0F0F0F0, 0x11111111, Local2)
1708        if (LNotEqual (Local2, 0x10101010))
1709        {
1710            ERR_ (1, __LINE__)
1711        }
1712
1713        Store ("++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)", Debug)
1714        NAnd (0xF0F0F0F0, 0x11111111, Local3)
1715        if (LNotEqual (Local3, 0xEFEFEFEF))
1716        {
1717            ERR_ (1, __LINE__)
1718        }
1719
1720        Store ("++++++++ Or (0x11111111, 0x22222222, Local4)", Debug)
1721        Or (0x11111111, 0x22222222, Local4)
1722        if (LNotEqual (Local4, 0x33333333))
1723        {
1724            ERR_ (1, __LINE__)
1725        }
1726
1727        Store ("++++++++ NOr (0x11111111, 0x22222222, Local5)", Debug)
1728        NOr (0x11111111, 0x22222222, Local5)
1729        if (LNotEqual (Local5, 0xCCCCCCCC))
1730        {
1731            ERR_ (1, __LINE__)
1732        }
1733
1734        Store ("++++++++ XOr (0x11113333, 0x22222222, Local6)", Debug)
1735        XOr (0x11113333, 0x22222222, Local6)
1736        if (LNotEqual (Local6, 0x33331111))
1737        {
1738            ERR_ (1, __LINE__)
1739        }
1740
1741        Store ("++++++++ ShiftLeft (0x11112222, 2, Local7)", Debug)
1742        ShiftLeft (0x11112222, 2, Local7)
1743        if (LNotEqual (Local7, 0x44448888))
1744        {
1745            ERR_ (1, __LINE__)
1746        }
1747
1748        Store ("++++++++ ShiftRight (Local7, 2, Local7)", Debug)
1749        ShiftRight (Local7, 2, Local7)
1750        if (LNotEqual (Local7, 0x11112222))
1751        {
1752            ERR_ (1, __LINE__)
1753        }
1754
1755
1756        Store ("++++++++ Not (Local0, Local1)", Debug)
1757        Store (0x22224444, Local0)
1758        Not (Local0, Local1)
1759        if (LNotEqual (Local0, 0x22224444))
1760        {
1761            ERR_ (2, __LINE__)
1762        }
1763
1764        if (LNotEqual (Local1, 0xDDDDBBBB))
1765        {
1766            ERR_ (1, __LINE__)
1767        }
1768
1769        Return (Local7)
1770    }
1771
1772
1773    Method (LOGS)
1774    {
1775
1776        Store ("++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)", Debug)
1777        Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)
1778
1779        Store ("++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)", Debug)
1780        Store (LEqual (0xFFFFFFFF, 0x11111111), Local1)
1781
1782        Store ("++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)", Debug)
1783        Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)
1784
1785        Store ("++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)", Debug)
1786        Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)
1787
1788        Store ("++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)", Debug)
1789        Store (LLess (0xFFFFFFFF, 0x11111111), Local4)
1790
1791        Store ("++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)", Debug)
1792        Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)
1793
1794        Store ("++++++++ Store (LNot (0x31313131), Local6)", Debug)
1795        Store (0x00001111, Local6)
1796        Store (LNot (Local6), Local7)
1797        if (LNotEqual (Local6, 0x00001111))
1798        {
1799            ERR_ (2, __LINE__)
1800        }
1801
1802        if (LNotEqual (Local7, 0x0))
1803        {
1804            ERR_ (1, __LINE__)
1805        }
1806
1807
1808        Store ("++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)", Debug)
1809        Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)
1810
1811        Store ("++++++++ Lor (0x0, 0x1)", Debug)
1812        if (Lor (0x0, 0x1))
1813        {
1814            Store ("+_+_+_+_+ Lor (0x0, 0x1) returned TRUE", Debug)
1815        }
1816
1817        return (Local7)
1818    }
1819
1820
1821    Method (COND)
1822    {
1823        Store ("++++++++ Store (0x4, Local0)", Debug)
1824        Store (0x4, Local0)
1825
1826        Store ("++++++++ While (Local0)", Debug)
1827        While (Local0)
1828        {
1829            Store ("++++++++ Decrement (Local0)", Debug)
1830            Decrement (Local0)
1831        }
1832
1833
1834        Store ("++++++++ Store (0x3, Local6)", Debug)
1835        Store (0x3, Local6)
1836
1837        Store ("++++++++ While (Subtract (Local6, 1))", Debug)
1838        While (Subtract (Local6, 1))
1839        {
1840            Store ("++++++++ Decrement (Local6)", Debug)
1841            Decrement (Local6)
1842        }
1843
1844
1845        Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
1846        If (LGreater (0x2, 0x1))
1847        {
1848            Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
1849            If (LEqual (0x11111111, 0x22222222))
1850            {
1851                Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
1852            }
1853
1854            else
1855            {
1856                Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
1857                If (LNot (0x0))
1858                {
1859                    Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
1860                    If (LAnd (0xEEEEEEEE, 0x2))
1861                    {
1862                        Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
1863                        If (LLess (0x44444444, 0x3))
1864                        {
1865                            Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
1866                        }
1867
1868                        else
1869                        {
1870                            Store ("++++++++ Exiting from nested IF/ELSE statements", Debug)
1871                        }
1872                    }
1873                }
1874            }
1875        }
1876
1877
1878        Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
1879        If (LGreater (0x2, 0x1))
1880        {
1881            Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
1882            If (LEqual (0x11111111, 0x22222222))
1883            {
1884                Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
1885            }
1886
1887            else
1888            {
1889                Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
1890                If (LNot (0x0))
1891                {
1892                    Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
1893                    If (LAnd (0xEEEEEEEE, 0x2))
1894                    {
1895                        Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
1896                        If (LLess (0x44444444, 0x3))
1897                        {
1898                            Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
1899                        }
1900
1901                        else
1902                        {
1903                            Store ("++++++++ Returning from nested IF/ELSE statements", Debug)
1904                            Return (Local6)
1905                        }
1906                    }
1907                }
1908            }
1909        }
1910
1911    }
1912
1913
1914    Method (REFS,, Serialized)
1915    {
1916        Name (BBUF, Buffer() {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7})
1917
1918        Name (NEST, Package ()
1919        {
1920            Package ()
1921            {
1922                0x01, 0x02, 0x03, 0x04, 0x05, 0x06
1923            },
1924            Package ()
1925            {
1926                0x11, 0x12, 0x12, 0x14, 0x15, 0x16
1927            }
1928        })
1929
1930        Store (RefOf (MAIN), Local5)
1931
1932        // For this to work, ABCD must NOT exist.
1933
1934        Store (CondRefOf (ABCD, Local0), Local1)
1935        if (LNotEqual (Local1, 0))
1936        {
1937            ERR_ (2, __LINE__)
1938        }
1939
1940        Store (CondRefOf (BBUF, Local0), Local1)
1941        if (LNotEqual (Local1, Ones))
1942        {
1943            ERR_ (2, __LINE__)
1944        }
1945
1946        Store (DeRefOf (Index (BBUF, 3)), Local6)
1947        if (LNotEqual (Local6, 0xB3))
1948        {
1949            ERR_ (2, __LINE__)
1950        }
1951
1952        Store (DeRefOf (Index (DeRefOf (Index (NEST, 1)), 3)), Local0)
1953        if (LNotEqual (Local0, 0x14))
1954        {
1955            ERR_ (2, __LINE__)
1956        }
1957
1958
1959        Store (0x11223344, Local0)
1960        Store (RefOf (Local0), Local1)
1961
1962        Store (DerefOf (Local1), Local2)
1963        If (LNotEqual (Local2, 0x11223344))
1964        {
1965            ERR_ (2, __LINE__)
1966        }
1967
1968
1969    /* Parser thinks this is a method invocation!! */
1970
1971    //  RefOf (MAIN)
1972
1973
1974    //  RefOf (R___)
1975    //  RefOf (BBUF)
1976
1977    //  Store (RefOf (Local0), Local1)
1978
1979    //  CondRefOf (BBUF, Local2)
1980    //  CondRefOf (R___, Local3)
1981
1982    //  Store (DerefOf (Local1), Local4)
1983
1984    //  Return (Local4)
1985    }
1986
1987
1988    Method (INDX, 0, Serialized)
1989    {
1990        Name(STAT,Package(4){})
1991        Store(0x44443333,Index(STAT,0))
1992    }
1993
1994//=================================================================
1995//=================================================================
1996//===================== iPCO TESTS ================================
1997//=================================================================
1998//=================================================================
1999//
2000//
2001// test IfElseOp.asl
2002//
2003//  test for IfOp and ElseOp, including validation of object stack cleanup
2004//
2005    Device (IFEL)
2006    {
2007        Name (DWRD, 1)
2008        Name (RSLT, 0)
2009
2010        //  IFNR control method executes IfOp branch with NO nested Return
2011        //  and no Else branch
2012        Method (IFNR)
2013        {
2014            Store (DWRD, RSLT)
2015            If (LEqual (DWRD, 1))
2016            {
2017                Store (0, RSLT)
2018            }
2019        }   //  IFNR
2020
2021        //  NINR control method does not execute If branch and has no Else branch
2022        Method (NINR)
2023        {
2024            Store (0, RSLT)
2025            If (LNotEqual (DWRD, 1))
2026            {
2027                Store (DWRD, RSLT)
2028            }
2029        }   //  NINR
2030
2031        //  IENR control method executes IfOp branch with NO nested Return
2032        Method (IENR)
2033        {
2034            If (LEqual (DWRD, 1))
2035            {
2036                Store (0, RSLT)
2037            }
2038            Else
2039            {
2040                Store (DWRD, RSLT)
2041            }
2042        }   //  IENR
2043
2044        //  ELNR control method executes ElseOp branch with NO nested Return
2045        Method (ELNR)
2046        {
2047            If (LNotEqual (DWRD, 1))
2048            {
2049                Store (DWRD, RSLT)
2050            }
2051            Else
2052            {
2053                Store (0, RSLT)
2054            }
2055        }   //  ELNR
2056
2057        //  IFRT control method executes IfOp branch with nested Return with
2058        //  no Else branch
2059        Method (IFRT)
2060
2061        {
2062            If (LEqual (DWRD, 1))
2063            {
2064                Return (0)
2065            }
2066            Return (DWRD)
2067        }   //  IFRT
2068
2069        //  IERT control method executes IfOp branch with nested Return with
2070        //  Else branch
2071        Method (IERT)
2072        {
2073            If (LEqual (DWRD, 1))
2074            {
2075                Return (0)
2076            }
2077            Else
2078            {
2079                Return (DWRD)
2080            }
2081        }   //  IERT
2082
2083        //  ELRT control method executes ElseOp branch with nested Return
2084        Method (ELRT)
2085        {
2086            If (LNotEqual (DWRD, 1))
2087            {
2088                Return (DWRD)
2089            }
2090            Else
2091            {
2092                Return (0)
2093            }
2094        }   //  ELRT
2095
2096        Method (TEST)
2097        {
2098            Store ("++++++++ IfElseOp Test", Debug)
2099
2100            //  IfOp with NO return value
2101            IFNR()
2102            If (LNotEqual (RSLT, 0))
2103            {
2104                Return (RSLT)
2105            }
2106
2107            //  IfOp with NO return value
2108            NINR()
2109            If (LNotEqual (RSLT, 0))
2110            {
2111                Return (RSLT)
2112            }
2113
2114            //  IfOp with NO return value
2115            IENR()
2116            If (LNotEqual (RSLT, 0))
2117            {
2118                Return (RSLT)
2119            }
2120
2121            //  ElseOp with NO return value
2122            ELNR()
2123            If (LNotEqual (RSLT, 0))
2124            {
2125                Return (RSLT)
2126            }
2127
2128            //  IfOp with return value
2129            Store (IFRT, RSLT)
2130            If (LNotEqual (RSLT, 0))
2131            {
2132                Return (RSLT)
2133            }
2134
2135            //  IfOp with return value
2136            Store (IERT, RSLT)
2137            If (LNotEqual (RSLT, 0))
2138            {
2139                Return (RSLT)
2140            }
2141
2142            //  ElseOp with return value
2143            Store (ELRT, RSLT)
2144            If (LNotEqual (RSLT, 0))
2145            {
2146                Return (RSLT)
2147            }
2148
2149            Return (0)
2150        }   //  TEST
2151    }   //  IFEL
2152
2153//
2154// test NoSave.asl
2155//
2156//
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
2160//  operands.
2161//
2162    Device (NOSV)
2163    {
2164        Method (TEST,, Serialized)
2165        {
2166            Store ("++++++++ NoSave Test", Debug)
2167
2168            Name (WRD, 0x1234)
2169
2170            //
2171            //  Begin test of nested operators without saving results
2172            //
2173
2174            //  Test If (And ()) with no save of And result
2175            If (And (3, 1, ))
2176            {
2177                Store (1, WRD)  //  pass -- just do something
2178            }
2179            else
2180            {
2181                Return (1)      //  fail
2182            }
2183
2184            //  Test If (And ()) with no save of And result
2185            If (And (4, 1, ))
2186            {
2187                Return (2)      //  fail
2188            }
2189            else
2190            {
2191                Store (2, WRD)  //  pass -- just do something
2192            }
2193
2194
2195            //  Test If (NAnd ()) with no save of NAnd result
2196            If (NAnd (3, 1, ))
2197            {
2198                Store (3, WRD)  //  pass -- just do something
2199            }
2200            else
2201            {
2202                Return (3)      //  fail
2203            }
2204
2205            //  Test If (NAnd ()) with no save of NAnd result
2206            If (NAnd (0xFFFFFFFF, 0xFFFFFFFF, ))
2207            {
2208                Return (4)      // fail
2209            }
2210            else
2211            {
2212                Store (4, WRD)  //  pass -- just do something
2213            }
2214
2215
2216            //  Test If (NOr ()) with no save of NOr result
2217            If (NOr (0, 1, ))
2218            {
2219                Store (5, WRD)  //  pass -- just do something
2220            }
2221            else
2222            {
2223                Return (5)      //  fail
2224            }
2225
2226            //  Test If (NOr ()) with no save of NOr result
2227            If (NOr (0xFFFFFFFE, 1, ))
2228            {
2229                Return (6)      // fail
2230            }
2231            else
2232            {
2233                Store (6, WRD)  //  pass -- just do something
2234            }
2235
2236
2237            //  Test If (Not ()) with no save of Not result
2238            If (Not (1, ))
2239            {
2240                Store (7, WRD)  //  pass -- just do something
2241            }
2242            else
2243            {
2244                Return (7)      //  fail
2245            }
2246
2247            //  Test If (Not ()) with no save of Not result
2248            If (Not (0xFFFFFFFF, ))
2249            {
2250                Return (8)      // fail
2251            }
2252            else
2253            {
2254                Store (8, WRD)  //  pass -- just do something
2255            }
2256
2257
2258            //  Test If (Or ()) with no save of Or result
2259            If (Or (3, 1, ))
2260            {
2261                Store (9, WRD)  //  pass -- just do something
2262            }
2263            else
2264            {
2265                Return (9)      //  fail
2266            }
2267
2268            //  Test If (Or ()) with no save of Or result
2269            If (Or (0, 0, ))
2270            {
2271                Return (10)     //  fail
2272            }
2273            else
2274            {
2275                Store (10, WRD) //  pass -- just do something
2276            }
2277
2278
2279            //  Test If (XOr ()) with no save of XOr result
2280            If (XOr (3, 1, ))
2281            {
2282                Store (11, WRD) //  pass -- just do something
2283            }
2284            else
2285            {
2286                Return (11)     // fail
2287            }
2288
2289            //  Test If (XOr ()) with no save of XOr result
2290            If (XOr (3, 3, ))
2291            {
2292                Return (12)     // fail
2293            }
2294            else
2295            {
2296                Store (12, WRD) //  pass -- just do something
2297            }
2298
2299
2300            //
2301            //  Begin test of logical operators with no destination operands
2302            //
2303
2304            //  Test If (LAnd ()) with no save of LAnd result
2305            If (LAnd (3, 3))
2306            {
2307                Store (21, WRD) //  pass -- just do something
2308            }
2309            else
2310            {
2311                Return (21)     // fail
2312            }
2313
2314            //  Test If (LAnd ()) with no save of LAnd result
2315            If (LAnd (3, 0))
2316            {
2317                Return (22)     // fail
2318            }
2319            else
2320            {
2321                Store (22, WRD) //  pass -- just do something
2322            }
2323
2324            //  Test If (LAnd ()) with no save of LAnd result
2325            If (LAnd (0, 3))
2326            {
2327                Return (23)     //  fail
2328            }
2329            else
2330            {
2331                Store (23, WRD) //  pass -- just do something
2332            }
2333
2334            //  Test If (LAnd ()) with no save of LAnd result
2335            If (LAnd (0, 0))
2336            {
2337                Return (24)     //  fail
2338            }
2339            else
2340            {
2341                Store (24, WRD) //  pass -- just do something
2342            }
2343
2344
2345            //  Test If (LEqual ()) with no save of LEqual result
2346            If (LEqual (3, 3))
2347            {
2348                Store (31, WRD) //  pass -- just do something
2349            }
2350            else
2351            {
2352                Return (31)     //  fail
2353            }
2354
2355            //  Test If (LEqual ()) with no save of LEqual result
2356            If (LEqual (1, 3))
2357            {
2358                Return (32)     //  fail
2359            }
2360            else
2361            {
2362                Store (32, WRD) //  pass -- just do something
2363            }
2364
2365
2366            //  Test If (LGreater ()) with no save of LGreater result
2367            If (LGreater (3, 1))
2368            {
2369                Store (41, WRD) //  pass -- just do something
2370            }
2371            else
2372            {
2373                Return (41)     //  fail
2374            }
2375
2376            //  Test If (LGreater ()) with no save of LGreater result
2377            If (LGreater (4, 4))
2378            {
2379                Return (42)     //  fail
2380            }
2381            else
2382            {
2383                Store (42, WRD) //  pass -- just do something
2384            }
2385
2386            //  Test If (LGreater ()) with no save of LGreater result
2387            If (LGreater (1, 4))
2388            {
2389                Return (43)     //  fail
2390            }
2391            else
2392            {
2393                Store (43, WRD) //  pass -- just do something
2394            }
2395
2396            //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
2397            If (LGreaterEqual (3, 1))
2398            {
2399                Store (44, WRD) //  pass -- just do something
2400            }
2401            else
2402            {
2403                Return (44)     //  fail
2404            }
2405
2406            //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
2407            If (LGreaterEqual (3, 3))
2408            {
2409                Store (45, WRD) //  pass -- just do something
2410            }
2411            else
2412            {
2413                Return (45)     //  fail
2414            }
2415
2416            //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
2417            If (LGreaterEqual (3, 4))
2418            {
2419                Return (46)     //  fail
2420            }
2421            else
2422            {
2423                Store (46, WRD) //  pass -- just do something
2424            }
2425
2426
2427            //  Test If (LLess ()) with no save of LLess result
2428            If (LLess (1, 3))
2429            {
2430                Store (51, WRD) //  pass -- just do something
2431            }
2432            else
2433            {
2434                Return (51)     //  fail
2435            }
2436
2437            //  Test If (LLess ()) with no save of LLess result
2438            If (LLess (2, 2))
2439            {
2440                Return (52)     //  fail
2441            }
2442            else
2443            {
2444                Store (52, WRD) //  pass -- just do something
2445            }
2446
2447            //  Test If (LLess ()) with no save of LLess result
2448            If (LLess (4, 2))
2449            {
2450                Return (53)     //  fail
2451            }
2452            else
2453            {
2454                Store (53, WRD) //  pass -- just do something
2455            }
2456
2457
2458            //  Test If (LLessEqual ()) with no save of LLessEqual result
2459            If (LLessEqual (1, 3))
2460            {
2461                Store (54, WRD) //  pass -- just do something
2462            }
2463            else
2464            {
2465                Return (54)     //  fail
2466            }
2467
2468            //  Test If (LLessEqual ()) with no save of LLessEqual result
2469            If (LLessEqual (2, 2))
2470            {
2471                Store (55, WRD) //  pass -- just do something
2472            }
2473            else
2474            {
2475                Return (55)     //  fail
2476            }
2477
2478            //  Test If (LLessEqual ()) with no save of LLessEqual result
2479            If (LLessEqual (4, 2))
2480            {
2481                Return (56)     //  fail
2482            }
2483            else
2484            {
2485                Store (56, WRD) //  pass -- just do something
2486            }
2487
2488
2489            //  Test If (LNot ()) with no save of LNot result
2490            If (LNot (0))
2491            {
2492                Store (61, WRD) //  pass -- just do something
2493            }
2494            else
2495            {
2496                Return (61)     //  fail
2497            }
2498
2499            //  Test If (LNot ()) with no save of LNot result
2500            If (LNot (1))
2501            {
2502                Return (62)     //  fail
2503            }
2504            else
2505            {
2506                Store (62, WRD) //  pass -- just do something
2507            }
2508
2509
2510            //  Test If (LNotEqual ()) with no save of LNotEqual result
2511            If (LNotEqual (3, 3))
2512            {
2513                Return (63)     //  fail
2514            }
2515            else
2516            {
2517                Store (63, WRD) //  pass -- just do something
2518            }
2519
2520            //  Test If (LNotEqual ()) with no save of LNotEqual result
2521            If (LNotEqual (1, 3))
2522            {
2523                Store (64, WRD) //  pass -- just do something
2524            }
2525            else
2526            {
2527                Return (64)     //  fail
2528            }
2529
2530
2531            //  Test If (LOr ()) with no save of LOr result
2532            If (LOr (3, 1))
2533            {
2534                Store (71, WRD) //  pass -- just do something
2535            }
2536            else
2537            {
2538                Return (71)     //  fail
2539            }
2540
2541            //  Test If (LOr ()) with no save of LOr result
2542            If (LOr (0, 1))
2543            {
2544                Store (72, WRD) //  pass -- just do something
2545            }
2546            else
2547            {
2548                Return (72)     //  fail
2549            }
2550
2551            //  Test If (LOr ()) with no save of LOr result
2552            If (LOr (3, 0))
2553            {
2554                Store (73, WRD) //  pass -- just do something
2555            }
2556            else
2557            {
2558                Return (73)     //  fail
2559            }
2560
2561            //  Test If (LOr ()) with no save of LOr result
2562            If (LOr (0, 0))
2563            {
2564                Return (74)     //  fail
2565            }
2566            else
2567            {
2568                Store (74, WRD) //  pass -- just do something
2569            }
2570
2571            Return (0)
2572        }   //  TEST
2573    }   //  NOSV
2574
2575
2576//
2577// test IndxFld.asl
2578//
2579//  IndexFld test
2580//      This is just a subset of the many RegionOp/Index Field test cases.
2581//      Tests index field element AccessAs macro.
2582//
2583    Device (IDXF)
2584    {   //  Test device name
2585
2586        OperationRegion (SIO, SystemIO, 0x100, 2)
2587        Field (SIO, ByteAcc, NoLock, Preserve)
2588        {
2589            INDX,   8,
2590            DATA,   8
2591        }
2592        IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
2593        {
2594            AccessAs (ByteAcc, 0),
2595            IFE0,   8,
2596            IFE1,   8,
2597            IFE2,   8,
2598            IFE3,   8,
2599            IFE4,   8,
2600            IFE5,   8,
2601            IFE6,   8,
2602            IFE7,   8,
2603            IFE8,   8,
2604            IFE9,   8,
2605        }
2606
2607        Method (TEST)
2608        {
2609            Store ("++++++++ IndxFld Test", Debug)
2610
2611            Store (IFE0, Local0)
2612            Store (IFE1, Local1)
2613            Store (IFE2, Local2)
2614
2615            Return (0)
2616        }   //  TEST
2617    }   //  IDXF
2618
2619//
2620// test NestdLor.asl
2621//
2622    Scope (\_SB)    //  System Bus
2623    {   //  _SB system bus
2624
2625        Name (ZER0, 0)
2626        Name (ZER1, 0)
2627        Name (ZER2, 0)
2628        Name (ONE0, 1)
2629
2630        Device (NSTL)
2631        {
2632            Method (TEST)
2633            {
2634                Store ("++++++++ NestdLor Test", Debug)
2635
2636                If (Lor (ZER0, Lor (ZER1, Lor (ZER2, ONE0))))
2637                {   //  Indicate Pass
2638                    Store (0x00, Local0)
2639                }
2640
2641                Else
2642                {   //  Indicate Fail
2643                    Store (0x01, Local0)
2644                }
2645
2646                Return (Local0)
2647            }   //  End Method TEST
2648        }   //  Device NSTL
2649    }   //  _SB system bus
2650
2651//
2652// test RetBuf.asl
2653//
2654//  Test ReturnOp(Buffer)
2655//      This is required to support Control Method Batteries on
2656//          Dell Latitude Laptops (e.g., CP1-A)
2657//
2658    Device (RTBF)
2659    {
2660        Method (SUBR, 1)
2661        {
2662            Return (Arg0)
2663        }
2664
2665        Method (RBUF,, Serialized)
2666        {   //  RBUF: Return Buffer from local variable
2667            Name (ABUF, Buffer() {"ARBITRARY_BUFFER"})
2668
2669            //  store local buffer ABUF into Local0
2670            Store (ABUF, Local0)
2671
2672            //  save Local0 object type value into Local1
2673            Store (ObjectType (Local0), Local1)
2674
2675            //  validate Local0 is a Buffer
2676            If (LNotEqual (Local1, 3))  //  Buffer type is 3
2677            {
2678                Return (1)      //  failure
2679            }
2680
2681            //  store value returned by control method SUBR into Local0
2682            Store (SUBR (ABUF), Local0)
2683
2684            //  save Local0 object type value into Local1
2685            Store (ObjectType (Local0), Local1)
2686
2687            //  validate Local0 is a Buffer
2688            If (LNotEqual (Local1, 3))  //  Buffer type is 3
2689            {
2690                Return (2)      //  failure
2691            }
2692
2693            //  allocate buffer using Local1 as buffer size (run-time evaluation)
2694            Store (5, Local1)
2695            Name (BUFR, Buffer(Local1) {})
2696
2697            //  store value returned by control method SUBR into Local0
2698            Store (SUBR (BUFR), Local0)
2699
2700            //  save Local0 object type value into Local1
2701            Store (ObjectType (Local0), Local1)
2702
2703            //  validate Local0 is a Buffer
2704            If (LNotEqual (Local1, 3))  //  Buffer type is 3
2705            {
2706                Return (3)      //  failure
2707            }
2708
2709            //  store BUFR Buffer into Local0
2710            Store (BUFR, Local0)
2711
2712            //  save Local0 object type value into Local1
2713            Store (ObjectType (Local0), Local1)
2714
2715            //  validate Local0 is a Buffer
2716            If (LNotEqual (Local1, 3))  //  Buffer type is 3
2717            {
2718                Return (4)      //  failure
2719            }
2720
2721
2722            //  return Local0 Buffer
2723            Return (Local0)
2724        }   //  RBUF
2725
2726        Method (TEST)
2727        {
2728            Store ("++++++++ RetBuf Test", Debug)
2729
2730            //  store RBUF Buffer return value into Local0
2731            Store (RBUF, Local0)
2732
2733            //  save Local0 object type value into Local1
2734            Store (ObjectType (Local0), Local1)
2735
2736            //  validate Local0 is a Buffer
2737            If (LNotEqual (Local1, 3))  //  Buffer type is 3
2738            {
2739                Return (10)     //  failure
2740            }
2741            Else
2742            {
2743                Return (0)      //  success
2744            }
2745        }   //  TEST
2746    }   //  RTBF
2747
2748//
2749// test RetLVal.asl
2750//
2751//  Test ReturnOp(Lvalue)
2752//      This is required to support _PSR on IBM ThinkPad 560D and
2753//      _DCK on Toshiba Tecra 8000.
2754//
2755
2756    Device (GPE2)
2757    {
2758        Method (_L03)
2759        {
2760            Store ("Method GPE2._L03 invoked", Debug)
2761            Return ()
2762        }
2763
2764        Method (_E05)
2765        {
2766            Store ("Method GPE2._E05 invoked", Debug)
2767            Return ()
2768        }
2769    }
2770
2771    Device (PRW2)
2772    {
2773        Name (_PRW, Package(2) {Package(2){\GPE2, 0x05}, 3})
2774    }
2775
2776
2777    Scope (\_GPE)
2778    {
2779        Name (ACST, 0xFF)
2780
2781        Method (_L08)
2782        {
2783            Store ("Method _GPE._L08 invoked", Debug)
2784            Return ()
2785        }
2786
2787        Method (_E09)
2788        {
2789            Store ("Method _GPE._E09 invoked", Debug)
2790            Return ()
2791        }
2792
2793        Method (_E11)
2794        {
2795            Store ("Method _GPE._E11 invoked", Debug)
2796            Notify (\PRW1, 2)
2797        }
2798
2799        Method (_L22)
2800        {
2801            Store ("Method _GPE._L22 invoked", Debug)
2802            Return ()
2803        }
2804
2805        Method (_L33)
2806        {
2807            Store ("Method _GPE._L33 invoked", Debug)
2808            Return ()
2809        }
2810
2811        Method (_E64)
2812        {
2813            Store ("Method _GPE._E64 invoked", Debug)
2814            Return ()
2815        }
2816
2817    }   //  _GPE
2818
2819    Device (PRW1)
2820    {
2821        Name (_PRW, Package(2) {0x11, 3})
2822    }
2823
2824    Device (PWRB)
2825    {
2826        Name (_HID, EISAID("PNP0C0C"))
2827        Name (_PRW, Package(2) {0x33, 3})
2828    }
2829
2830
2831    Scope (\_SB)    //  System Bus
2832    {   //  _SB system bus
2833
2834        Device (ACAD)
2835        {   //  ACAD:   AC adapter device
2836            Name (_HID, "ACPI0003") //  AC adapter device
2837
2838            Name (_PCL, Package () {\_SB})
2839
2840            OperationRegion (AREG, SystemIO, 0x0372, 2)
2841            Field (AREG, ByteAcc, NoLock, Preserve)
2842            {
2843                AIDX,   8,
2844                ADAT,   8
2845            }
2846            IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve)
2847            {
2848                     ,  1,  //  skips
2849                ACIN,   1,
2850                     ,  2,  //  skips
2851                CHAG,   1,
2852                     ,  3,  //  skips
2853                     ,  7,  //  skips
2854                ABAT,   1,
2855            }   //  IndexField
2856
2857            Method (_PSR)
2858            {
2859                Store (\_GPE.ACST, Local0)
2860                Store (ACIN, Local1)
2861                If (LNotEqual (\_GPE.ACST, Local1))
2862                {
2863                    Store (Local1, \_GPE.ACST)
2864                    // This Notify is commented because it causes a
2865                    //  method error when running on a system without the
2866                    //  specific device.
2867                    // Notify (\_SB_.ACAD, 0)
2868                }
2869                Return (Local0)
2870            }   //  _PSR
2871
2872            Method (_STA)
2873            {
2874                Return (0x0F)
2875            }
2876
2877            Method (_INI)
2878            {
2879                Store (ACIN, \_GPE.ACST)
2880            }
2881        }   //  ACAD:   AC adapter device
2882
2883        //  test implicit return from control method
2884        Method (DIS_, 1)
2885        {
2886            Store (Arg0, Local0)
2887        }
2888
2889        Device (RTLV)
2890        {
2891            //  test implicit return inside nested if with explicit return of Lvalue
2892            Method (_DCK, 1)
2893            //  Arg0:   1 == dock, 0 == undock
2894            {
2895                If (Arg0)
2896                {   //  dock
2897                    Store (0x87, Local0)
2898
2899                    If (Local0)
2900                    {
2901                        DIS_ (0x23)
2902                        Return (1)
2903                    }
2904
2905                    Return (0)
2906                }   //  dock
2907                Else
2908                {   //  undock
2909                    Store (Arg0, Local0)
2910
2911                    If (Local0)
2912                    {
2913                        DIS_ (0x23)
2914                        Return (1)
2915                    }
2916
2917                    Return (0)
2918                }   //  undock
2919            }   //  _DCK control method
2920
2921            Method (TEST)
2922            {
2923                Store ("++++++++ RetLVal Test", Debug)
2924
2925                //  store _PSR return value into Local0
2926                Store (\_SB_.ACAD._PSR, Local0)
2927
2928                //  save Local0 object type value into Local1
2929                Store (ObjectType (Local0), Local1)
2930
2931                //  validate Local0 is a Number
2932                If (LNotEqual (Local1, 1))  //  Number/Integer type is 1
2933                {
2934                    Return (1)      //  failure
2935                }
2936
2937                //  test implicit return inside nested if with explicit return of Lvalue
2938                Store (_DCK (1), Local2)
2939
2940                //  save Local2 object type value into Local3
2941                Store (ObjectType (Local2), Local3)
2942
2943                //  validate Local2 is a Number
2944                If (LNotEqual (Local3, 1))  //  Number/Integer type is 1
2945                {
2946                    Return (2)      //  failure
2947                }
2948
2949                If (LNotEqual (Local2, 1))
2950                {
2951                    Return (3)      //  failure
2952                }
2953
2954                Return (0)  //  success
2955            }   //  TEST
2956        }   //  RTLV
2957    }   //  _SB system bus
2958
2959//
2960// test RetPkg.asl
2961//
2962//  Test ReturnOp(Package)
2963//      This is required to support _PRT on Dell Optiplex Workstations (e.g. GX1)
2964//
2965
2966    Scope (\_SB)    //  System Bus
2967    {   //  _SB system bus
2968        Device(LNKA)
2969        {
2970            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
2971            Name (_UID, 1)
2972        }
2973        Device(LNKB)
2974        {
2975            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
2976            Name (_UID, 2)
2977        }
2978        Device(LNKC)
2979        {
2980            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
2981            Name (_UID, 3)
2982        }
2983        Device(LNKD)
2984        {
2985            Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
2986            Name (_UID, 4)
2987        }
2988
2989        Device (PCI1)
2990        {   //  PCI1:   Root PCI Bus
2991            Name (_HID, "PNP0A03")  //  Need _HID for root device (String format)
2992            Name (_ADR,0x00000000)
2993            Name (_CRS,0)
2994
2995            Name (_PRT, Package ()
2996            {
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
3009            })
3010
3011            Device (PX40)
3012            {   // Map f0 space, Start PX40
3013                Name (_ADR,0x00070000)  //  Address+function.
3014            }
3015        }   //  PCI0:   Root PCI Bus
3016
3017        Device (RETP)
3018        {
3019            Method (RPKG)
3020            {   //  RPKG: Return Package from local variable
3021
3022                //  store _PRT package into Local0
3023                Store (\_SB_.PCI1._PRT, Local0)
3024
3025                //  return Local0 Package
3026                Return (Local0)
3027            }   //  RPKG
3028
3029            Method (TEST)
3030            {
3031                Store ("++++++++ RetPkg Test", Debug)
3032
3033                //  store RPKG package return value into Local0
3034                Store (RPKG, Local0)
3035
3036                //  save Local0 object type value into Local1
3037                Store (ObjectType (Local0), Local1)
3038
3039                //  validate Local0 is a Package
3040                If (LNotEqual (Local1, 4))  //  Package type is 4
3041                    {   Return (1)  }   //  failure
3042                Else
3043                    {   Return (0)  }   //  success
3044            }   //  TEST
3045        }   //  RETP
3046    } // _SB_
3047
3048//
3049// test WhileRet.asl
3050//
3051//  WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp.
3052//
3053    Device (WHLR)
3054    {
3055        Name (LCNT, 0)
3056        Method (WIR)
3057        {   //  WIR:    control method that returns inside of IfOp inside of WhileOp
3058            While (LLess (LCNT, 4))
3059            {
3060                    If (LEqual (LCNT, 2))
3061                    {
3062                        Return (0)
3063                    }
3064
3065                Increment (LCNT)
3066            }
3067
3068            Return (LCNT)
3069        }   //  WIR:    control method that returns inside of IfOp inside of WhileOp
3070
3071        Method (TEST)
3072        {
3073            Store ("++++++++ WhileRet Test", Debug)
3074
3075            Store (WIR, Local0)
3076
3077            Return (Local0)
3078        }   //  TEST
3079    }   //  WHLR
3080
3081//
3082// test AndOrOp.asl
3083//
3084//This code tests the bitwise AndOp and OrOp Operator terms
3085//
3086//Syntax of Andop term
3087//And - Bitwise And
3088//AndTerm   := And(
3089//  Source1,    //TermArg=>Integer
3090//  Source2,    //TermArg=>Integer
3091//  Result  //Nothing | SuperName
3092//) => Integer
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.
3096//
3097//
3098//Syntax of OrOp
3099//Or - Bit-wise Or
3100//OrTerm    := Or(
3101//  Source1,    //TermArg=>Integer
3102//  Source2 //TermArg=>Integer
3103//  Result  //Nothing | SuperName
3104//) => Integer
3105//Source1 and Source2 are evaluated as integer data types,
3106// a bit-wide OR is performed, and the result is optionally
3107//stored in Result
3108//
3109    Device (ANDO)
3110    {
3111        OperationRegion (TMEM, SystemMemory, 0xC4, 0x02)
3112        Field (TMEM, ByteAcc, NoLock, Preserve)
3113        {
3114                ,   3,
3115            TOUD,   13
3116        }
3117
3118        //Create System Memory Operation Region and field overlays
3119        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3120        Field (RAM, AnyAcc, NoLock, Preserve)
3121        {
3122            SMDW,   32, //  32-bit DWORD
3123            SMWD,   16, //  16-bit WORD
3124            SMBY,   8,  //  8-bit BYTE
3125        }// Field(RAM)
3126
3127
3128        //And with Byte Data
3129        Name (BYT1, 0xff)
3130        Name (BYT2, 0xff)
3131        Name (BRSL, 0x00)
3132
3133        //And with Word Data
3134        Name (WRD1, 0xffff)
3135        Name (WRD2, 0xffff)
3136        Name (WRSL, 0x0000)
3137
3138        //And with DWord Data
3139        Name (DWD1, 0xffffffff)
3140        Name (DWD2, 0xffffffff)
3141        Name (DRSL, 0x00000000)
3142
3143        Method (ANDP)
3144        {
3145            //Check with 1 And 1 on byte data
3146            And(BYT1, BYT2, BRSL)
3147            if(LNotEqual(BRSL,0xff))
3148            {Return(1)}
3149
3150            //Check with 1 And 1 on Word data
3151            And(WRD1, WRD2, WRSL)
3152            if(LNotEqual(WRSL,0xffff))
3153            {
3154                Return (1)      //  failure
3155            }
3156
3157            //Check with 1 And 1 Dword
3158            And(DWD1, DWD2, DRSL)
3159            if(LNotEqual(DRSL,0xffffffff))
3160            {
3161                Return (1)      //  failure
3162            }
3163
3164            //Check with 0 And 0 on byte data
3165            Store(0x00,BYT1)
3166            Store(0x00,BYT2)
3167            Store(0x00,BRSL)
3168            And(BYT1, BYT2, BRSL)
3169            if(LNotEqual(BRSL,0x00))
3170            {
3171                Return (1)      //  failure
3172            }
3173
3174            //Check with 0 And 0 on Word data
3175            Store (0x0000,WRD1)
3176            Store (0x0000,WRD2)
3177            Store (0x0000,WRSL)
3178            And(WRD1, WRD2, WRSL)
3179            if(LNotEqual(WRSL,0x0000))
3180            {
3181                Return (1)      //  failure
3182            }
3183
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))
3190            {
3191                Return (1)      //  failure
3192            }
3193
3194
3195            //Check with 1 And 0 on byte data
3196            Store(0x55,BYT1)
3197            Store(0xAA,BYT2)
3198            Store(0x00,BRSL)
3199            And(BYT1, BYT2, BRSL)
3200            if(LNotEqual(BRSL,0x00))
3201            {
3202                Return (1)      //  failure
3203            }
3204
3205            //Check with 1 And 0 on Word data
3206            Store (0x5555,WRD1)
3207            Store (0xAAAA,WRD2)
3208            Store (0x0000,WRSL)
3209            And(WRD1, WRD2, WRSL)
3210            if(LNotEqual(WRSL,0x0000))
3211            {
3212                Return (1)      //  failure
3213            }
3214
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))
3221            {
3222                Return (1)      //  failure
3223            }
3224
3225            Store (0x1FFF, TOUD)
3226            Store (TOUD, Local0)
3227            if(LNotEqual(Local0,0x1FFF))
3228            {
3229                Return (1)      //  failure
3230            }
3231
3232            //TBD- Do We need to check for system memory data also for each test case ??
3233
3234            Return(0)
3235
3236        }//ANDP
3237
3238        Method (OROP)
3239        {
3240
3241            //Check with 1 Ored with 1 on byte data
3242            Store(0xff,BYT1)
3243            Store(0xff,BYT2)
3244            Store(0x00,BRSL)
3245            Or(BYT1, BYT2, BRSL)
3246            if(LNotEqual(BRSL,0xff))
3247            {
3248                Return (1)      //  failure
3249            }
3250
3251
3252            //Check with 1 Ored with 1 on Word data
3253            Store(0xffff,WRD1)
3254            Store(0xffff,WRD2)
3255            Store(0x0000,WRSL)
3256            Or(WRD1, WRD2, WRSL)
3257            if(LNotEqual(WRSL,0xffff))
3258            {
3259                Return (1)      //  failure
3260            }
3261
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))
3268            {
3269                Return (1)      //  failure
3270            }
3271
3272            //Check with 0 Ored with 0 on byte data
3273            Store(0x00,BYT1)
3274            Store(0x00,BYT2)
3275            Store(0x00,BRSL)
3276            Or(BYT1, BYT2, BRSL)
3277            if(LNotEqual(BRSL,0x00))
3278            {
3279                Return (1)      //  failure
3280            }
3281
3282            //Check with 0 Ored with 0 on Word data
3283            Store (0x0000,WRD1)
3284            Store (0x0000,WRD2)
3285            Store (0x0000,WRSL)
3286            Or(WRD1, WRD2, WRSL)
3287            if(LNotEqual(WRSL,0x0000))
3288            {
3289                Return (1)      //  failure
3290            }
3291
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))
3298            {
3299                Return (1)      //  failure
3300            }
3301
3302
3303            //Check with 1 Ored with 0 on byte data
3304            Store(0x55,BYT1)
3305            Store(0xAA,BYT2)
3306            Store(0x00,BRSL)
3307            Or(BYT1, BYT2, BRSL)
3308            if(LNotEqual(BRSL,0xff))
3309            {
3310                Return (1)      //  failure
3311            }
3312
3313            //Check with 1 Ored with 0 on Word data
3314            Store (0x5555,WRD1)
3315            Store (0xAAAA,WRD2)
3316            Store (0x0000,WRSL)
3317            Or(WRD1, WRD2, WRSL)
3318            if(LNotEqual(WRSL,0xffff))
3319            {
3320                Return (1)      //  failure
3321            }
3322
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))
3329            {
3330                Return (1)      //  failure
3331            }
3332
3333            //TBD - Do We need to check for system memory data also for each test case ??
3334
3335            Return(0)
3336
3337        }//OROP
3338
3339        Method(TEST,, Serialized)
3340        {
3341            Store ("++++++++ AndOrOp Test", Debug)
3342
3343            Name(RSLT,1)
3344            //Call Andop method
3345            Store(ANDP,RSLT)
3346            if(LEqual(RSLT,1))
3347            {
3348                Return (RSLT)
3349            }
3350
3351            //Call OrOp Method
3352            Store(OROP,RSLT)
3353            if(LEqual(RSLT,1))
3354            {
3355                Return(RSLT)
3356            }
3357
3358            //
3359            // Return original conditions to allow iterative execution
3360            //
3361            Store(0xff,BYT1)
3362            Store(0xff,BYT2)
3363            Store(0x00,BRSL)
3364            Store (0xffff,WRD1)
3365            Store (0xffff,WRD2)
3366            Store (0x0000,WRSL)
3367            Store (0xffffffff,DWD1)
3368            Store (0xffffffff,DWD2)
3369            Store (0x00000000,DRSL)
3370
3371            Return(0)
3372        }   //TEST
3373    }   //ANDO
3374
3375//
3376// test BreakPnt.asl
3377//
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.
3382//
3383    Device (BRKP)
3384    {
3385        Name(CNT0,0)
3386
3387        Method (BK1)
3388        {
3389            BreakPoint
3390            Return(0)
3391        }
3392
3393        Method (TEST)
3394        {
3395            Store ("++++++++ BreakPnt Test", Debug)
3396
3397            Store(0,CNT0)
3398
3399            //Check BreakPoint statement
3400            While(LLess(CNT0,10))
3401            {
3402                Increment(CNT0)
3403            }
3404
3405            //Check the BreakPoint statement
3406            If(LEqual(CNT0,10))
3407            {
3408    //            BreakPoint
3409                Return(0)
3410            }
3411
3412            //failed
3413            Return(1)
3414        }
3415    }
3416
3417//
3418// test AddSubOp.asl
3419//
3420    Device (ADSU)
3421    {
3422        //  create System Memory Operation Region and field overlays
3423        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3424        Field (RAM, AnyAcc, NoLock, Preserve)
3425        {
3426            SMDW,   32, //  32-bit DWORD
3427            SMWD,   16, //  16-bit WORD
3428            SMBY,   8,  //  8-bit BYTE
3429        }   //  Field(RAM)
3430
3431        Method (TEST,, Serialized)
3432        {
3433            Store ("++++++++ AddSubOp Test", Debug)
3434
3435            Name (DWRD, 0x12345678)
3436            Name (WRD, 0x1234)
3437            Name (BYT, 0x12)
3438
3439            //  Test AddOp with DWORD data
3440            Store (0x12345678, DWRD)
3441            Add (DWRD, 7, DWRD)
3442            If (LNotEqual (DWRD, 0x1234567F))
3443                {   Return (DWRD)   }
3444
3445            //  Test AddOp with WORD data
3446            Add (WRD, 5, WRD)
3447            If (LNotEqual (WRD, 0x1239))
3448                {   Return (WRD)    }
3449
3450            //  Test AddOp with BYTE data
3451            Add (BYT, 3, BYT)
3452            If (LNotEqual (BYT, 0x15))
3453                {   Return (BYT)    }
3454
3455            //  Test SubtractOp with DWORD data
3456            Subtract (DWRD, 7, DWRD)
3457            If (LNotEqual (DWRD, 0x12345678))
3458                {   Return (DWRD)   }
3459
3460            //  Test SubtractOp with WORD data
3461            Subtract (WRD, 3, WRD)
3462            If (LNotEqual (WRD, 0x1236))
3463                {   Return (WRD)    }
3464
3465            //  Test SubtractOp with BYTE data
3466            Subtract (BYT, 3, BYT)
3467            If (LNotEqual (BYT, 0x12))
3468                {   Return (BYT)    }
3469
3470
3471            //  test AddOp with DWORD SystemMemory OpRegion
3472            Store (0x01234567, SMDW)
3473            Add (SMDW, 8, SMDW)
3474            If (LNotEqual (SMDW, 0x0123456F))
3475                {   Return (SMDW)   }
3476
3477            //  test SubtractOp with DWORD SystemMemory OpRegion
3478            Subtract (SMDW, 7, SMDW)
3479            If (LNotEqual (SMDW, 0x01234568))
3480                {   Return (SMDW)   }
3481
3482
3483            //  test AddOp with WORD SystemMemory OpRegion
3484            Store (0x0123, SMWD)
3485            Add (SMWD, 6, SMWD)
3486            If (LNotEqual (SMWD, 0x0129))
3487                {   Return (SMWD)   }
3488
3489            //  test SubtractOp with WORD SystemMemory OpRegion
3490            Subtract (SMWD, 5, SMWD)
3491            If (LNotEqual (SMWD, 0x0124))
3492                {   Return (SMWD)   }
3493
3494
3495            //  test AddOp with BYTE SystemMemory OpRegion
3496            Store (0x01, SMBY)
3497            Add (SMBY, 4, SMBY)
3498            If (LNotEqual (SMBY, 0x05))
3499                {   Return (SMBY)   }
3500
3501            //  test SubtractOp with BYTE SystemMemory OpRegion
3502            Subtract (SMBY, 3, SMBY)
3503            If (LNotEqual (SMBY, 0x02))
3504                {   Return (SMBY)   }
3505
3506            Return (0)
3507        }   //  TEST
3508    }   //  ADSU
3509
3510//
3511// test IncDecOp.asl
3512//
3513    Device (INDC)
3514    {
3515        //  create System Memory Operation Region and field overlays
3516        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3517        Field (RAM, AnyAcc, NoLock, Preserve)
3518        {
3519            SMDW,   32, //  32-bit DWORD
3520            SMWD,   16, //  16-bit WORD
3521            SMBY,   8,  //  8-bit BYTE
3522        }   //  Field(RAM)
3523
3524        Method (TEST,, Serialized)
3525        {
3526            Store ("++++++++ IncDecOp Test", Debug)
3527
3528            Name (DWRD, 0x12345678)
3529            Name (WRD, 0x1234)
3530            Name (BYT, 0x12)
3531
3532            //  Test IncrementOp with DWORD data
3533            Store (0x12345678, DWRD)
3534            Increment (DWRD)
3535            If (LNotEqual (DWRD, 0x12345679))
3536                {   Return (DWRD)   }
3537
3538            //  Test IncrementOp with WORD data
3539            Increment (WRD)
3540            If (LNotEqual (WRD, 0x1235))
3541                {   Return (WRD)    }
3542
3543            //  Test IncrementOp with BYTE data
3544            Increment (BYT)
3545            If (LNotEqual (BYT, 0x13))
3546                {   Return (BYT)    }
3547
3548            //  Test DecrementOp with DWORD data
3549            Decrement (DWRD)
3550            If (LNotEqual (DWRD, 0x12345678))
3551                {   Return (DWRD)   }
3552
3553            //  Test DecrementOp with WORD data
3554            Decrement (WRD)
3555            If (LNotEqual (WRD, 0x1234))
3556                {   Return (WRD)    }
3557
3558            //  Test DecrementOp with BYTE data
3559            Decrement (BYT)
3560            If (LNotEqual (BYT, 0x12))
3561                {   Return (BYT)    }
3562
3563
3564            //  test IncrementOp with DWORD SystemMemory OpRegion
3565            Store (0x01234567, SMDW)
3566            Increment (SMDW)
3567            If (LNotEqual (SMDW, 0x01234568))
3568                {   Return (SMDW)   }
3569
3570            //  test DecrementOp with DWORD SystemMemory OpRegion
3571            Decrement (SMDW)
3572            If (LNotEqual (SMDW, 0x01234567))
3573                {   Return (SMDW)   }
3574
3575
3576            //  test IncrementOp with WORD SystemMemory OpRegion
3577            Store (0x0123, SMWD)
3578            Increment (SMWD)
3579            If (LNotEqual (SMWD, 0x0124))
3580                {   Return (SMWD)   }
3581
3582            //  test DecrementOp with WORD SystemMemory OpRegion
3583            Decrement (SMWD)
3584            If (LNotEqual (SMWD, 0x0123))
3585                {   Return (SMWD)   }
3586
3587
3588            //  test IncrementOp with BYTE SystemMemory OpRegion
3589            Store (0x01, SMBY)
3590            Increment (SMBY)
3591            If (LNotEqual (SMBY, 0x02))
3592                {   Return (SMBY)   }
3593
3594            //  test DecrementOp with BYTE SystemMemory OpRegion
3595            Decrement (SMBY)
3596            If (LNotEqual (SMBY, 0x01))
3597                {   Return (SMBY)   }
3598
3599            Return (0)
3600        }   //  TEST
3601    }   //  INDC
3602
3603//
3604// test LOps.asl
3605//
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
3610
3611    Device (LOPS)
3612    {
3613        //Create System Memory Operation Region and field overlays
3614        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3615        Field (RAM, AnyAcc, NoLock, Preserve)
3616        {
3617            SMDW,   32, //  32-bit DWORD
3618            SMWD,   16, //  16-bit WORD
3619            SMBY,   8,  //  8-bit BYTE
3620        }// Field(RAM)
3621
3622        //And with Byte Data
3623        Name (BYT1, 0xff)
3624        Name (BYT2, 0xff)
3625        Name (BRSL, 0x00)
3626
3627        //And with Word Data
3628        Name (WRD1, 0xffff)
3629        Name (WRD2, 0xffff)
3630        Name (WRSL, 0x0000)
3631
3632        //And with DWord Data
3633        Name (DWD1, 0xffffffff)
3634        Name (DWD2, 0xffffffff)
3635        Name (DRSL, 0x00000000)
3636
3637        Name(RSLT,1)
3638
3639        Method (ANDL,2) // Test Logical And
3640        {
3641            //test with the arguments passed
3642            if(LEqual(Arg0,Arg1))
3643            { Store(LAnd(Arg0,Arg1),RSLT)
3644                if(LNotEqual(Ones,RSLT))
3645                {Return(11)}
3646            }
3647
3648            //test with he locals
3649            Store(Arg0,Local0)
3650            Store(Arg1,Local1)
3651
3652            if(LEqual(Local0,Local1))
3653            {
3654                Store(LAnd(Local0,Local1),RSLT)
3655                if(LNotEqual(Ones,RSLT))
3656                    {Return(12)}
3657            }
3658
3659            //test with BYTE data
3660            if(LEqual(BYT1,BYT2))
3661            { Store(LAnd(BYT1,BYT2),BRSL)
3662                if(LNotEqual(Ones,BRSL))
3663                {Return(13)}
3664            }
3665
3666            //test with WORD data
3667            if(LEqual(WRD1,WRD2))
3668            { Store(LAnd(WRD1,WRD2),WRSL)
3669                if(LNotEqual(Ones,WRSL))
3670                {Return(14)}
3671            }
3672
3673            //test with DWORD data
3674            if(LEqual(DWD1,DWD2))
3675            { Store(LAnd(DWD1,DWD2),DRSL)
3676                if(LNotEqual(Ones,DRSL))
3677                {Return(15)}
3678            }
3679
3680            //Test for system memory data for each test case.
3681
3682                Store(0xff,BYT1)
3683                Store(0xff,SMBY)
3684                Store(0x00,BRSL)
3685
3686            //test with BYTE system memory data
3687            if(LEqual(BYT1,SMBY))
3688            { Store(LAnd(BYT1,SMBY),BRSL)
3689                if(LNotEqual(Ones,BRSL))
3690                {Return(16)}
3691            }
3692
3693            Store (0xffff,WRD1)
3694            Store(0xffff,SMWD)
3695            Store(0x0000,WRSL)
3696            //test with WORD system memory data
3697            if(LEqual(WRD1,SMWD))
3698            { Store(LAnd(WRD1,SMWD),WRSL)
3699                if(LNotEqual(Ones,WRSL))
3700                {Return(17)}
3701            }
3702
3703            Store(0x000000,DRSL)
3704            Store (0xffffff,DWD1)
3705            Store(0xffffff,SMDW)
3706
3707            //test with DWORD system memory data
3708            if(LEqual(DWD1,SMDW))
3709            { Store(LAnd(DWD1,SMDW),DRSL)
3710                if(LNotEqual(Ones,DRSL))
3711                {Return(18)}
3712            }
3713
3714            Return(0)
3715
3716        }//ANDL
3717
3718        //Test the LOr Operator
3719
3720        Method (ORL_,2)
3721        {//ORL_
3722
3723            //test with the arguments passed
3724            if(LEqual(Arg0,Arg1))
3725            {
3726                Store(LOr(Arg0,Arg1),RSLT)
3727                if(LNotEqual(Ones,RSLT))
3728                {
3729                    Return(21)
3730                }
3731            }
3732
3733            //test with he locals
3734            Store(Arg0,Local0)
3735            Store(Arg1,Local1)
3736
3737            if(LEqual(Local0,Local1))
3738            {
3739                Store(LOr(Local0,Local1),RSLT)
3740                if(LNotEqual(Ones,RSLT))
3741                    {Return(22)}
3742            }
3743
3744            //Check with 1 LOred with 0 on byte data
3745            Store(0xff,BYT1)
3746            Store(0x00,BYT2)
3747            Store(0x00,BRSL)
3748
3749            if(LNotEqual(BYT1, BYT2))
3750            {
3751                Store(LOr(BYT1, BYT2), BRSL)
3752                if(LNotEqual(Ones,BRSL))
3753                {Return(23)}
3754            }
3755
3756            //Check with 1 LOred with 0 on WORD data
3757            Store(0xffff,WRD1)
3758            Store(0x0000,WRD2)
3759            Store(0x0000,WRSL)
3760
3761            if(LNotEqual(WRD1, WRD2))
3762            {
3763                Store(LOr(WRD1, WRD2), WRSL)
3764                if(LNotEqual(Ones,WRSL))
3765                {Return(24)}
3766            }
3767
3768            //Check with 1 LOred with 0 on DWORD data
3769            Store(0xffffffff,DWD1)
3770            Store(0x00000000,DWD2)
3771            Store(0x00000000,DRSL)
3772
3773            if(LNotEqual(DWD1, DWD2))
3774            {
3775                Store(LOr(DWD1, DWD2), DRSL)
3776                if(LNotEqual(Ones,DRSL))
3777                {Return(25)}
3778            }
3779
3780            Store(0x00,BYT1)
3781            Store(0xff,SMBY)
3782            Store(0x00,BRSL)
3783
3784            //test with BYTE system memory data
3785            if(LEqual(BYT1,SMBY))
3786            { Store(LOr(BYT1,SMBY),BRSL)
3787                if(LNotEqual(Ones,BRSL))
3788                {Return(26)}
3789            }
3790
3791            Store (0x0000,WRD1)
3792            Store(0xffff,SMWD)
3793            Store(0x0000,WRSL)
3794
3795            //test with WORD system memory data
3796            if(LEqual(WRD1,SMWD))
3797            { Store(LOr(WRD1,SMWD),WRSL)
3798                if(LNotEqual(Ones,WRSL))
3799                {Return(27)}
3800            }
3801
3802
3803            Store(0x00000000,DWD1)
3804            Store(0xffffffff,SMDW)
3805            Store(0x00000000,DRSL)
3806
3807            //test with DWORD system memory data
3808            if(LEqual(DWD1,SMDW))
3809            { Store(LAnd(DWD1,SMDW),DRSL)
3810                if(LNotEqual(Ones,DRSL))
3811                {Return(28)}
3812            }
3813            Return(0)
3814
3815        }//ORL_
3816
3817        //This method tests LGreater and LNot operator
3818        Method(LSGR,2)
3819        {//LSGR
3820
3821            //Test on arguments passed
3822
3823            //in test data, Arg1 > Arg0
3824            if(LEqual(Ones,LNot(LGreater(Arg1,Arg0))))
3825            {Return(31)}
3826
3827            //test LLessEqual
3828            if(LEqual(Ones,LNot(LGreaterEqual(Arg1,Arg0))))
3829            {Return(32)}
3830
3831            if(LEqual(Ones,LLess(Arg1,Arg0)))
3832            {Return(33)}
3833
3834            //test LLessEqual
3835            if(LEqual(Ones,LLessEqual(Arg1,Arg0)))
3836            {Return(34)}
3837
3838            Store(Arg0,Local0)
3839            Store(Arg1,Local1)
3840
3841            //test with the locals
3842            if(LNot(LGreater(Local1,Local0)))
3843                {Return(35)}
3844
3845            //test on Byte data
3846            Store(0x12,BYT1)
3847            Store(0x21,BYT2)
3848
3849            if(LNot(LGreater(BYT2,BYT1)))
3850                {Return(36)}
3851
3852            if(LNot(LLess(BYT1,BYT2)))
3853                {Return(37)}
3854
3855            //test LGreaterEqual with byte data
3856            if(LNot(LGreaterEqual(BYT2,BYT1)))
3857                {Return(38)}
3858
3859            //test LLessEqual byte data
3860            if(LNot(LLessEqual(BYT1,BYT2)))
3861                {Return(39)}
3862
3863
3864            //test on Word data
3865            Store(0x1212,WRD1)
3866            Store(0x2121,WRD2)
3867
3868            if(LNot(LGreater(WRD2,WRD1)))
3869                {Return(310)}
3870
3871            if(LNot(LLess(WRD1,WRD2)))
3872                {Return(311)}
3873
3874            //Test LGreaterEqual with Word Data
3875            if(LNot(LGreaterEqual(WRD2,WRD1)))
3876                {Return(312)}
3877
3878
3879            //Test LLessEqual with Word Data
3880            if(LNot(LLessEqual(WRD1,WRD2)))
3881                {Return(313)}
3882
3883            //test on DWord data
3884            Store(0x12121212,DWD1)
3885            Store(0x21212121,DWD2)
3886
3887            if(LNot(LGreater(DWD2,DWD1)))
3888                {Return(314)}
3889
3890            if(LNot(LLess(DWD1,DWD2)))
3891                {Return(315)}
3892
3893
3894            //Test LGreaterEqual with Dword
3895            if(LNot(LGreaterEqual(DWD2,DWD1)))
3896                {Return(316)}
3897
3898            //Test LLessEqual DWord
3899            if(LNot(LLessEqual(DWD1,DWD2)))
3900                {Return(317)}
3901
3902            Return(0)
3903        }//LSGR
3904
3905        //The test method
3906        Method(TEST)
3907        {
3908            Store ("++++++++ LOps Test", Debug)
3909
3910            Store(0,RSLT)
3911            //Call LAndOp method
3912            Store(ANDL(2,2),RSLT)
3913            if(LNotEqual(RSLT,0))
3914             {Return(RSLT)}
3915
3916            //Call LOrOp Method
3917            Store(ORL_(5,5),RSLT)
3918            if(LNotEqual(RSLT,0))
3919            {Return(RSLT)}
3920
3921            //Call LSGR Method
3922            Store(LSGR(5,7),RSLT)
3923            if(LNotEqual(RSLT,0))
3924            {Return(RSLT)}
3925
3926            Return(0)
3927        }//TEST
3928    }//LOPS
3929
3930//
3931// test FdSetOps.asl
3932//
3933//  FindSetLeftBit - Find Set Left Bit
3934//  FindSetLeftBitTerm  := FindSetLeftBit
3935//  (   Source, //TermArg=>Integer
3936//      Result  //Nothing | SuperName
3937//  ) => Integer
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
3943
3944//  FindSetRightBitTerm := FindSetRightBit
3945//  (   Source, //TermArg=>Integer
3946//      Result  //Nothing | SuperName
3947//  ) => Integer
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.
3952
3953//  If the Control method is success Zero is returned. Otherwise a non-zero
3954//  number is returned.
3955//
3956    Device (FDSO)
3957    {   //  FDSO
3958
3959        //  Create System Memory Operation Region and field overlays
3960        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3961        Field (RAM, AnyAcc, NoLock, Preserve)
3962        {
3963            SMDW,   32, //  32-bit DWORD
3964            SMWD,   16, //  16-bit WORD
3965            SMBY,   8,      //  8-bit BYTE
3966        }   //  Field(RAM)
3967
3968        //  Byte Data
3969        Name (BYT1, 1)
3970        Name (BRSL, 0x00)
3971
3972        //  Word Data
3973        Name (WRD1, 0x100)
3974        Name (WRSL, 0x0000)
3975
3976        //  DWord Data
3977        Name (DWD1, 0x10000)
3978        Name (DRSL, 0x00000000)
3979        Name (RSLT, 1)
3980        Name (CNTR, 1)
3981
3982        Method (SHFT,2)
3983        //  Arg0 is the actual data and Arg1 is the bit position
3984        {   //  SHFT
3985            Store (Arg0, Local0)
3986            Store (Arg1, Local1)
3987
3988            FindSetLeftBit (Arg0, BRSL)
3989            If (LNotEqual (BRSL, Arg1))
3990                {   Return (0x11)   }
3991            If (LNotEqual (Arg0, Local0))
3992                {   Return (0x12)   }
3993
3994            FindSetLeftBit (Local0, BRSL)
3995            If (LNotEqual (BRSL, Local1))
3996                {   Return (0x13)   }
3997            If (LNotEqual (Arg0, Local0))
3998                {   Return (0x14)   }
3999
4000            //  test the byte value for SetLeftBit
4001            Store (7, BYT1)
4002            FindSetLeftBit (BYT1, BRSL)
4003            If (LNotEqual (BRSL, 3))
4004                {   Return (0x15)   }
4005            If (LNotEqual (BYT1, 7))
4006                {   Return (0x16)   }
4007
4008            Store (1, BYT1)
4009            Store (1, CNTR)
4010            While (LLessEqual (CNTR, 8))
4011            {   //  FindSetLeftBit check loop for byte data
4012                FindSetLeftBit (BYT1, BRSL)
4013                If (LNotEqual (BRSL, CNTR))
4014                    {   Return (0x17)   }
4015
4016                //  Shift the bits to check the same
4017                ShiftLeft (BYT1, 1, BYT1)
4018                Increment (CNTR)
4019            }   //  FindSetLeftBit check loop for byte data
4020
4021
4022            //  Check BYTE value for SetRightBit
4023            Store (7, BYT1)
4024            FindSetRightBit (BYT1, BRSL)
4025            If (LNotEqual (BRSL, 1))
4026                {   Return (0x21)   }
4027            If (LNotEqual (BYT1, 7))
4028                {   Return (0x22)   }
4029
4030            Store (1, CNTR)
4031            Store (0xFF, BYT1)
4032            While (LLessEqual (CNTR, 8))
4033            {   //  FindSetRightBit check loop for byte data
4034                FindSetRightBit (BYT1, BRSL)
4035                If (LNotEqual (BRSL, CNTR))
4036                    {   Return (0x23)   }
4037
4038                ShiftLeft (BYT1, 1, BYT1)
4039                Increment (CNTR)
4040            }   //  FindSetRightBit check loop for byte data
4041
4042
4043            //  Test Word value for SetLeftBit
4044            Store (9, CNTR)
4045            Store (0x100, WRD1)
4046            While (LLessEqual (CNTR, 16))
4047            {
4048                //  FindSetLeftBit check loop for Word data
4049                FindSetLeftBit (WRD1, WRSL)
4050                If (LNotEqual (WRSL, CNTR))
4051                    {   Return (0x31)   }
4052
4053                //  Shift the bits to check the same
4054                ShiftLeft (WRD1, 1, WRD1)
4055                Increment (CNTR)
4056            }   //  FindSetLeftBit check loop for Word data
4057
4058            //  Check Word value for SetRightBit
4059            Store (9, CNTR)
4060            Store (0xFF00, WRD1)
4061            While (LLessEqual (CNTR, 16))
4062            {
4063                //  FindSetRightBit check loop for Word data
4064                FindSetRightBit (WRD1, WRSL)
4065                If (LNotEqual (WRSL, CNTR))
4066                    {   Return (0x32)   }
4067
4068                ShiftLeft (WRD1, 1, WRD1)
4069                Increment (CNTR)
4070            }   //  FindSetRightBit check loop for Word data
4071
4072            //  Test the DWord value for SetLeftBit
4073            Store (17, CNTR)
4074            Store (0x10000, DWD1)
4075            While (LLessEqual (CNTR, 32))
4076            {
4077                //  FindSetLeftBit check loop for Dword
4078                FindSetLeftBit (DWD1, DRSL)
4079                If (LNotEqual (DRSL, CNTR))
4080                    {   Return (0x41)   }
4081
4082                //  Shift the bits to check the same
4083                ShiftLeft (DWD1, 1, DWD1)
4084                Increment (CNTR)
4085            }   //  FindSetLeftBit check loop for Dword
4086
4087            //  Check DWord value for SetRightBit
4088            Store (17, CNTR)
4089            Store (0xFFFF0000, DWD1)
4090            While (LLessEqual (CNTR, 32))
4091            {   //  FindSetRightBit Check loop for DWORD
4092                FindSetRightBit (DWD1, DRSL)
4093                If (LNotEqual (DRSL, CNTR))
4094                    {   Return (0x42)   }
4095
4096                ShiftLeft (DWD1, 1, DWD1)
4097                Increment (CNTR)
4098            }   //  FindSetRightBit Check loop for DWORD
4099
4100            Return (0)
4101        }   //  SHFT
4102
4103        //  Test method called from amlexec
4104        Method (TEST)
4105        {   //  TEST
4106
4107            Store ("++++++++ FdSetOps Test", Debug)
4108
4109            Store (SHFT (0x80, 8), RSLT)
4110            If (LNotEqual (RSLT, 0))
4111                {   Return (RSLT)   }
4112
4113            Return (0)  //  pass
4114        }   //  TEST
4115    }   //  Device FDSO
4116
4117//
4118// test MulDivOp.asl
4119//
4120    Device (MLDV)
4121    {
4122        //  create System Memory Operation Region and field overlays
4123        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
4124        Field (RAM, AnyAcc, NoLock, Preserve)
4125        {
4126            SMDW,   32, //  32-bit DWORD
4127            SMWD,   16, //  16-bit WORD
4128            SMBY,   8,  //  8-bit BYTE
4129        }   //  Field(RAM)
4130
4131        Method (TEST,, Serialized)
4132        {
4133            Store ("++++++++ MulDivOp Test", Debug)
4134
4135            Name (RMDR, 0)
4136            Name (DWRD, 0x12345678)
4137            Name (WRD, 0x1234)
4138            Name (BYT, 0x12)
4139
4140            //  Test MultiplyOp with DWORD data
4141            Store (0x12345678, DWRD)
4142            Multiply (DWRD, 3, DWRD)
4143            If (LNotEqual (DWRD, 0x369D0368))
4144                {   Return (DWRD)   }
4145
4146            //  Test MultiplyOp with WORD data
4147            Multiply (WRD, 4, WRD)
4148            If (LNotEqual (WRD, 0x48D0))
4149                {   Return (WRD)    }
4150
4151            //  Test MultiplyOp with BYTE data
4152            Multiply (BYT, 5, BYT)
4153            If (LNotEqual (BYT, 0x5A))
4154                {   Return (BYT)    }
4155
4156            //  Test DivideOp with DWORD data
4157            Divide (DWRD, 3, DWRD, RMDR)
4158            If (LNotEqual (DWRD, 0x12345678))
4159                {   Return (DWRD)   }
4160            If (LNotEqual (RMDR, 0))
4161                {   Return (RMDR)   }
4162
4163            //  Test DivideOp with WORD data
4164            Divide (WRD, 4, WRD, RMDR)
4165            If (LNotEqual (WRD, 0x1234))
4166                {   Return (WRD)    }
4167            If (LNotEqual (RMDR, 0))
4168                {   Return (RMDR)   }
4169
4170            //  Test DivideOp with BYTE data
4171            Divide (BYT, 5, BYT, RMDR)
4172            If (LNotEqual (BYT, 0x12))
4173                {   Return (BYT)    }
4174            If (LNotEqual (RMDR, 0))
4175                {   Return (RMDR)   }
4176
4177
4178            //  test MultiplyOp with DWORD SystemMemory OpRegion
4179            Store (0x01234567, SMDW)
4180            Multiply (SMDW, 2, SMDW)
4181            If (LNotEqual (SMDW, 0x02468ACE))
4182                {   Return (SMDW)   }
4183
4184            //  test DivideOp with DWORD SystemMemory OpRegion
4185            Divide (SMDW, 3, SMDW, RMDR)
4186            If (LNotEqual (SMDW, 0x00C22E44))
4187                {   Return (SMDW)   }
4188            If (LNotEqual (RMDR, 2))
4189                {   Return (RMDR)   }
4190
4191
4192            //  test MultiplyOp with WORD SystemMemory OpRegion
4193            Store (0x0123, SMWD)
4194            Multiply (SMWD, 3, SMWD)
4195            If (LNotEqual (SMWD, 0x369))
4196                {   Return (SMWD)   }
4197
4198            //  test DivideOp with WORD SystemMemory OpRegion
4199            Divide (SMWD, 2, SMWD, RMDR)
4200            If (LNotEqual (SMWD, 0x01B4))
4201                {   Return (SMWD)   }
4202            If (LNotEqual (RMDR, 1))
4203                {   Return (RMDR)   }
4204
4205
4206            //  test MultiplyOp with BYTE SystemMemory OpRegion
4207            Store (0x01, SMBY)
4208            Multiply (SMBY, 7, SMBY)
4209            If (LNotEqual (SMBY, 0x07))
4210                {   Return (SMBY)   }
4211
4212            //  test DivideOp with BYTE SystemMemory OpRegion
4213            Divide (SMBY, 4, SMBY, RMDR)
4214            If (LNotEqual (SMBY, 0x01))
4215                {   Return (SMBY)   }
4216            If (LNotEqual (RMDR, 3))
4217                {   Return (RMDR)   }
4218
4219            Return (0)
4220        }   //  TEST
4221    }   //  MLDV
4222
4223//
4224// test NBitOps.asl
4225//
4226//NAnd - Bit-wise NAnd
4227//NAndTerm  := NAnd(
4228//  Source1,    //TermArg=>Integer
4229//  Source2 //TermArg=>Integer
4230//  Result  //Nothing | SuperName
4231//) => Integer
4232//Source1 and Source2 are evaluated as integer data types, a bit-wise NAND is performed, and the result is optionally
4233//stored in Result.
4234
4235//NOr - Bitwise NOr
4236//NOrTerm   := NOr(
4237//  Source1,    //TermArg=>Integer
4238//  Source2 //TermArg=>Integer
4239//  Result  //Nothing | SuperName
4240//) => Integer
4241//Source1 and Source2 are evaluated as integer data types, a bit-wise NOR is performed, and the result is optionally
4242//stored in Result.
4243// Not - Not
4244//NotTerm   := Not(
4245//  Source, //TermArg=>Integer
4246//  Result  //Nothing | SuperName
4247//) => Integer
4248//Source1 is evaluated as an integer data type, a bit-wise NOT is performed, and the result is optionally stored in
4249//Result.
4250
4251//If the Control method is success Zero is returned else a non-zero number is returned
4252
4253    Device (NBIT)
4254    {//NBIT
4255
4256        //Create System Memory Operation Region and field overlays
4257        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
4258        Field (RAM, AnyAcc, NoLock, Preserve)
4259        {
4260            SMDW,   32, //  32-bit DWORD
4261            SMWD,   16, //  16-bit WORD
4262            SMBY,   8,  //  8-bit BYTE
4263        }// Field(RAM)
4264
4265
4266        //And with Byte Data
4267        Name (BYT1, 0xff)
4268        Name (BYT2, 0xff)
4269        Name (BRSL, 0x00)
4270
4271        //And with Word Data
4272        Name (WRD1, 0xffff)
4273        Name (WRD2, 0xffff)
4274        Name (WRSL, 0x0000)
4275
4276        //And with DWord Data
4277        Name (DWD1, 0xffffffff)
4278        Name (DWD2, 0xffffffff)
4279        Name (DRSL, 0x00000000)
4280        Name(RSLT,1)
4281
4282
4283        Name(ARSL,0x00)
4284        Name(LRSL,0x00)
4285
4286        Method(NNDB,2)
4287        {//NNDB
4288
4289            Store(0xffffffff,SMDW)
4290            Store(0xffff,SMWD)
4291            Store(0xff,SMBY)
4292
4293
4294            NAnd(Arg0,Arg1,ARSL)
4295            if(LNotEqual(ARSL,0xfffffffd))
4296             {Return(11)}
4297
4298             Store(Arg0,local0)
4299             Store(Arg1,Local1)
4300
4301             NAnd(Local0,Local1,LRSL)
4302                if(LNotEqual(LRSL,0xfffffffd))
4303             {Return(12)}
4304
4305
4306            //Byte data
4307            NAnd(BYT1,BYT2,BRSL)
4308            if(LNotEqual(BRSL,0xffffff00))
4309             {Return(13)}
4310
4311            //Word Data
4312             NAnd(WRD1,WRD2,WRSL)
4313            if(LNotEqual(WRSL,0xffff0000))
4314             {Return(14)}
4315
4316             //DWord Data
4317             NAnd(DWD1,DWD2,DRSL)
4318            if(LNotEqual(DRSL,0x00000000))
4319             {Return(15)}
4320
4321             //Byte data
4322            NAnd(SMBY,0xff,BRSL)
4323            if(LNotEqual(BRSL,0xffffff00))
4324             {Return(16)}
4325
4326            //Word Data
4327             NAnd(SMWD,0xffff,WRSL)
4328            if(LNotEqual(WRSL,0xffff0000))
4329             {Return(17)}
4330
4331             //DWord Data
4332             NAnd(SMDW,0xffffffff,DRSL)
4333            if(LNotEqual(DRSL,0x00000000))
4334             {Return(18)}
4335
4336            Return(0)
4337
4338        }//NNDB
4339
4340        Method(NNOR,2)
4341        {//NNOR
4342
4343            NOr(Arg0,Arg1,ARSL)
4344            if(LNotEqual(ARSL,0xfffffffd))
4345             {Return(21)}
4346
4347            Store(Arg0,local0)
4348            Store(Arg1,Local1)
4349
4350            NOr(Local0,Local1,LRSL)
4351            if(LNotEqual(LRSL,0xfffffffd))
4352             {Return(22)}
4353
4354
4355            //Byte data
4356            NOr(BYT1,BYT2,BRSL)
4357            if(LNotEqual(BRSL,0xffffff00))
4358             {Return(23)}
4359
4360            //Word Data
4361            NOr(WRD1,WRD2,WRSL)
4362            if(LNotEqual(WRSL,0xffff0000))
4363             {Return(24)}
4364
4365            //DWord Data
4366            NOr(DWD1,DWD2,DRSL)
4367            if(LNotEqual(DRSL,0x00000000))
4368             {Return(25)}
4369
4370             //System Memory Byte data
4371            NOr(SMBY,0xff,BRSL)
4372            if(LNotEqual(BRSL,0xffffff00))
4373             {Return(26)}
4374
4375            //System Memory Word Data
4376            NOr(SMWD,0xffff,WRSL)
4377            if(LNotEqual(WRSL,0xffff0000))
4378             {Return(27)}
4379
4380            //System Memory DWord Data
4381            NOr(SMDW,0xffffffff,DRSL)
4382            if(LNotEqual(DRSL,0x00000000))
4383             {Return(28)}
4384
4385            Return(0)
4386
4387        }//NNOR
4388
4389        Method(NNOT,2)
4390        {//NNOT
4391
4392            Or(Arg0,Arg1,ARSL)
4393            Not(ARSL,ARSL)
4394            if(LNotEqual(ARSL,0xfffffffd))
4395             {Return(31)}
4396
4397            Store(Arg0,local0)
4398            Store(Arg1,Local1)
4399
4400            Or(Local0,Local1,LRSL)
4401            Not(LRSL,LRSL)
4402            if(LNotEqual(LRSL,0xfffffffd))
4403             {Return(32)}
4404
4405
4406            //Byte data
4407            Or(BYT1,BYT2,BRSL)
4408            Not(BRSL,BRSL)
4409            if(LNotEqual(BRSL,0xffffff00))
4410             {Return(33)}
4411
4412            //Word Data
4413            Or(WRD1,WRD2,WRSL)
4414            Not(WRSL,WRSL)
4415            if(LNotEqual(WRSL,0xffff0000))
4416             {Return(34)}
4417
4418            //DWord Data
4419            Or(DWD1,DWD2,DRSL)
4420            Not(DRSL,DRSL)
4421            if(LNotEqual(DRSL,0x00000000))
4422             {Return(35)}
4423
4424             //System Memory Byte data
4425            Or(SMBY,0xff,BRSL)
4426            Not(BRSL,BRSL)
4427            if(LNotEqual(BRSL,0xffffff00))
4428             {Return(36)}
4429
4430            //System Memory Word Data
4431            Or(SMWD,0xffff,WRSL)
4432            Not(WRSL,WRSL)
4433            if(LNotEqual(WRSL,0xffff0000))
4434             {Return(37)}
4435
4436            //System Memory DWord Data
4437            Or(SMDW,0xffffffff,DRSL)
4438            Not(DRSL,DRSL)
4439            if(LNotEqual(DRSL,0x00000000))
4440             {Return(38)}
4441
4442            Return(0)
4443        }//NNOT
4444
4445
4446        Method(TEST)
4447        {
4448
4449            Store ("++++++++ NBitOps Test", Debug)
4450
4451            Store(NNDB(2,2),RSLT)
4452            if(LNotEqual(RSLT,0))
4453                {Return(RSLT)}
4454
4455            Store(NNOR(2,2),RSLT)
4456            if(LNotEqual(RSLT,0))
4457                {Return(RSLT)}
4458
4459            Store(NNOT(2,2),RSLT)
4460            if(LNotEqual(RSLT,0))
4461                {Return(RSLT)}
4462
4463
4464           Return(0)
4465        }
4466
4467    }//Device NBIT
4468
4469//
4470// test ShftOp.asl
4471//
4472//ShiftRightTerm    := ShiftRight(
4473//  Source, //TermArg=>Integer
4474//  ShiftCount  //TermArg=>Integer
4475//  Result  //Nothing | SuperName
4476//) => Integer
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.
4479
4480//ShiftLeft(
4481//  Source, //TermArg=>Integer
4482//  ShiftCount  //TermArg=>Integer
4483//  Result  //Nothing | SuperName
4484//) => Integer
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.
4487
4488//If the Control method is success Zero is returned else a non-zero number is returned
4489    Device (SHFT)
4490    {//SHFT
4491
4492        //Create System Memory Operation Region and field overlays
4493        OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
4494        Field (RAM, AnyAcc, NoLock, Preserve)
4495        {
4496            SMDW,   32, //  32-bit DWORD
4497            SMWD,   16, //  16-bit WORD
4498            SMBY,   8,  //  8-bit BYTE
4499        }// Field(RAM)
4500
4501
4502        Name(SHFC,0x00)
4503
4504        //And with Byte Data
4505        Name (BYT1, 0xff)
4506        Name (BRSL, 0x00)
4507
4508        //And with Word Data
4509        Name (WRD1, 0xffff)
4510        Name (WRSL, 0x0000)
4511
4512        //And with DWord Data
4513        Name (DWD1, 0xffffffff)
4514        Name (DRSL, 0x00000000)
4515
4516        Name(RSLT,1)
4517
4518        Name(ARSL,0x00)
4519        Name(LRSL,0x00)
4520
4521        Method(SLFT,2)
4522        {//SLFT
4523
4524            Store(0xffffffff,SMDW)
4525            Store(0xffff,SMWD)
4526            Store(0xff,SMBY)
4527
4528
4529            //Arg0-> 2 & Arg1->2
4530            ShiftLeft(Arg0,Arg1,ARSL)
4531            if(LNotEqual(ARSL,8))
4532            {Return(11)}
4533
4534             Store(Arg0,local0)
4535             Store(Arg1,Local1)
4536
4537             //Local0->8 and Local1->2
4538             ShiftLeft(Local0,Local1,LRSL)
4539                if(LNotEqual(LRSL,8))
4540             {Return(12)}
4541
4542            Store(2,SHFC)
4543            //Byte data
4544            ShiftLeft(BYT1,SHFC,BRSL)
4545            if(LNotEqual(BRSL,0x3FC))
4546             {Return(13)}
4547
4548            Store(4,SHFC)
4549            //Word Data
4550             ShiftLeft(WRD1,SHFC,WRSL)
4551            if(LNotEqual(WRSL,0xFFFF0))
4552             {Return(14)}
4553
4554            Store(8,SHFC)
4555            //DWord Data
4556            ShiftLeft(DWD1,SHFC,DRSL)
4557            if(LNotEqual(DRSL,0xFFFFFF00))
4558             {Return(15)}
4559
4560
4561             //System Memory Byte data
4562            Store(4,SHFC)
4563            ShiftLeft(SMBY,SHFC,BRSL)
4564            if(LNotEqual(BRSL,0xFF0))
4565            {Return(16)}
4566
4567            //Word Data
4568            Store(4,SHFC)
4569            ShiftLeft(SMWD,SHFC,WRSL)
4570            if(LNotEqual(WRSL,0xffff0))
4571             {Return(17)}
4572
4573            //DWord Data
4574            Store(8,SHFC)
4575            ShiftLeft(SMDW,SHFC,DRSL)
4576            if(LNotEqual(DRSL,0xFFFFFF00))
4577                {Return(18)}
4578
4579            Return(0)
4580
4581        }//SLFT
4582
4583        Method(SRGT,2)
4584        {//SRGT
4585            //And with Byte Data
4586            Store (0xff,BYT1)
4587            Store (0x00,BRSL)
4588
4589            //And with Word Data
4590            Store (0xffff,WRD1)
4591            Store (0x0000,WRSL)
4592
4593            //And with DWord Data
4594            Store(0xffffffff,DWD1)
4595            Store (0x00000000,DRSL)
4596
4597            //Reinitialize the result objects
4598            Store(0x00,ARSL)
4599            Store(0x00,LRSL)
4600
4601            Store(0xffffffff,SMDW)
4602            Store(0xffff,SMWD)
4603            Store(0xff,SMBY)
4604
4605            //Arg0-> 2 & Arg1->2
4606            ShiftRight(Arg0,Arg1,ARSL)
4607            if(LNotEqual(ARSL,0))
4608            {Return(21)}
4609
4610             Store(Arg0,local0)
4611             Store(Arg1,Local1)
4612
4613             //Local0->8 and Local1->2
4614             ShiftRight(Local0,Local1,LRSL)
4615                if(LNotEqual(LRSL,0))
4616             {Return(22)}
4617
4618            Store(2,SHFC)
4619            //Byte data
4620            ShiftRight(BYT1,SHFC,BRSL)
4621            if(LNotEqual(BRSL,0x3F))
4622             {Return(23)}
4623
4624            Store(4,SHFC)
4625            //Word Data
4626             ShiftRight(WRD1,SHFC,WRSL)
4627            if(LNotEqual(WRSL,0xFFF))
4628             {Return(24)}
4629
4630            Store(8,SHFC)
4631            //DWord Data
4632            ShiftRight(DWD1,SHFC,DRSL)
4633            if(LNotEqual(DRSL,0xFFFFFF))
4634             {Return(25)}
4635
4636            //System Memory Byte data
4637            Store(4,SHFC)
4638            ShiftRight(SMBY,SHFC,BRSL)
4639            if(LNotEqual(BRSL,0xF))
4640            {Return(26)}
4641
4642            //Word Data
4643            Store(4,SHFC)
4644            ShiftRight(SMWD,SHFC,WRSL)
4645            if(LNotEqual(WRSL,0xFFF))
4646             {Return(27)}
4647
4648            //DWord Data
4649            Store(8,SHFC)
4650            ShiftRight(SMDW,SHFC,DRSL)
4651            if(LNotEqual(DRSL,0xFFFFFF))
4652                {Return(28)}
4653
4654            Return(0)
4655        }//SRGT
4656
4657        //Test method called from amlexec
4658        Method(TEST)
4659        {
4660            Store ("++++++++ ShftOp Test", Debug)
4661
4662            Store(SLFT(2,2),RSLT)
4663            if(LNotEqual(RSLT,0))
4664                {Return(RSLT)}
4665            Store(SRGT(2,2),RSLT)
4666            if(LNotEqual(RSLT,0))
4667                {Return(RSLT)}
4668           Return(0)
4669        }
4670
4671    }//Device SHFT
4672
4673//
4674// test Xor.asl and slightly modified
4675//
4676//This code tests the XOR opcode term
4677//Syntax of XOR term
4678//          XOr(
4679//                  Source1  //TermArg=>BufferTerm
4680//                  Source2  //TermArg=>Integer
4681//                  Result //NameString
4682//              )
4683//"Source1" and "Source2" are evaluated as integers, a bit-wise XOR is performed, and the result is optionally stored in
4684// Result
4685    Device (XORD)
4686    {
4687        //This Method tests XOr operator for all the data types i.e. BYTE, WORD and DWORD
4688        Method (TEST,, Serialized)
4689        {
4690            Store ("++++++++ Xor Test", Debug)
4691
4692            //Overlay in system memory
4693            OperationRegion (RAM, SystemMemory, 0x800000, 256)
4694            Field (RAM, ByteAcc, NoLock, Preserve)
4695            {
4696                RES1,   1,  //Offset
4697                BYT1,   8,  //First BYTE
4698                BYT2,   8,  //Second BYTE
4699                RBYT,   8,  //Result Byte
4700                RES2,   1,  //Offset
4701                WRD1,   16, //First WORD field
4702                WRD2,   16, //Second WORD field
4703                RWRD,   16, //RSLT WORD field
4704                RES3,   1,  //Offset
4705                DWD1,   32, //First Dword
4706                DWD2,   32, //Second Dword
4707                RDWD,   32, //Result Dword
4708                RES4,   1,  //Offset
4709            }
4710
4711            // Store bits in the single bit fields for checking
4712            //  at the end
4713            Store(1, RES1)
4714            Store(1, RES2)
4715            Store(1, RES3)
4716            Store(1, RES4)
4717
4718            // Check the stored single bits
4719            if(LNotEqual(RES1, 1))
4720            {
4721                Return(1)
4722            }
4723
4724            if(LNotEqual(RES2, 1))
4725            {
4726                Return(1)
4727            }
4728
4729            if(LNotEqual(RES3, 1))
4730            {
4731                Return(1)
4732            }
4733
4734            if(LNotEqual(RES4, 1))
4735            {
4736                Return(1)
4737            }
4738
4739            //************************************************
4740            // (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition
4741            Store(0x00,BYT1)
4742            Store(0x00,BYT2)
4743            XOr(BYT1,BYT2,Local0)
4744            Store (Local0, RBYT)
4745            if(LNotEqual(RBYT,0))
4746            {   Return(1)}
4747
4748            // (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition
4749            Store(0xff,BYT1)
4750            Store(0xff,BYT2)
4751            XOr(BYT1,BYT2,Local0)
4752            Store (Local0, RBYT)
4753            if(LNotEqual(RBYT,0))
4754            {   Return(1)}
4755
4756            // (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition
4757            Store(0x55,BYT1)
4758            Store(0xAA,BYT2)
4759            XOr(BYT1,BYT2,Local0)
4760            Store (Local0, RBYT)
4761            if(LNotEqual(RBYT,0xFF))
4762            {   Return(1)}
4763
4764            //(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition
4765            Store(0xAA,BYT1)
4766            Store(0x55,BYT2)
4767            XOr(BYT1,BYT2,Local0)
4768            Store (Local0, RBYT)
4769            if(LNotEqual(RBYT,0xFF))
4770            {   Return(1)}
4771
4772            Store(0x12,BYT1)
4773            Store(0xED,BYT2)
4774
4775            XOr(BYT1,BYT2,Local0)
4776            Store (Local0, RBYT)
4777            if(LNotEqual(RBYT,0xFF))
4778            {
4779                Return(1)
4780            }
4781
4782            // Store known values for checking later
4783            Store(0x12, BYT1)
4784            if(LNotEqual(BYT1, 0x12))
4785            {
4786                Return(1)
4787            }
4788
4789            Store(0xFE, BYT2)
4790            if(LNotEqual(BYT2, 0xFE))
4791            {
4792                Return(1)
4793            }
4794
4795            Store(0xAB, RBYT)
4796            if(LNotEqual(RBYT, 0xAB))
4797            {
4798                Return(1)
4799            }
4800
4801            //***********************************************
4802            // (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition
4803            Store(0x0000,WRD1)
4804            Store(0x0000,WRD2)
4805            XOr(WRD1,WRD2,RWRD)
4806            if(LNotEqual(RWRD,0))
4807            {   Return(1)}
4808
4809            // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition
4810            Store(0xffff,WRD1)
4811            Store(0xffff,WRD2)
4812            XOr(WRD1,WRD2,RWRD)
4813            if(LNotEqual(RWRD,0))
4814            {   Return(1)}
4815
4816            // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition
4817            Store(0x5555,WRD1)
4818            Store(0xAAAA,WRD2)
4819            XOr(WRD1,WRD2,RWRD)
4820            if(LNotEqual(RWRD,0xFFFF))
4821            {   Return(1)}
4822
4823            //(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition
4824            Store(0xAAAA,WRD1)
4825            Store(0x5555,WRD2)
4826            XOr(WRD1,WRD2,RWRD)
4827            if(LNotEqual(RWRD,0xFFFF))
4828            {   Return(1)}
4829
4830            Store(0x1234,WRD1)
4831            Store(0xEDCB,WRD2)
4832            XOr(WRD1,WRD2,RWRD)
4833            if(LNotEqual(RWRD,0xFFFF))
4834            {   Return(1)}
4835
4836            // Store known values for checking later
4837            Store(0x1234, WRD1)
4838            if(LNotEqual(WRD1, 0x1234))
4839            {
4840                Return(1)
4841            }
4842
4843            Store(0xFEDC, WRD2)
4844            if(LNotEqual(WRD2, 0xFEDC))
4845            {
4846                Return(1)
4847            }
4848
4849            Store(0x87AB, RWRD)
4850            if(LNotEqual(RWRD, 0x87AB))
4851            {
4852                Return(1)
4853            }
4854
4855
4856            //**************************************************
4857            // (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition
4858            Store(0x00000000,DWD1)
4859            Store(0x00000000,DWD2)
4860            XOr(DWD1,DWD2,RDWD)
4861            if(LNotEqual(RDWD,0))
4862            {   Return(1)}
4863
4864            // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition
4865            Store(0xffffffff,DWD1)
4866            Store(0xffffffff,DWD2)
4867            XOr(DWD1,DWD2,RDWD)
4868            if(LNotEqual(RDWD,0))
4869            {   Return(1)}
4870
4871            // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
4872            Store(0x55555555,DWD1)
4873            Store(0xAAAAAAAA,DWD2)
4874            XOr(DWD1,DWD2,RDWD)
4875            if(LNotEqual(RDWD,0xFFFFFFFF))
4876            {   Return(1)}
4877
4878            //(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition
4879            Store(0xAAAAAAAA,DWD1)
4880            Store(0x55555555,DWD2)
4881            XOr(DWD1,DWD2,RDWD)
4882            if(LNotEqual(RDWD,0xFFFFFFFF))
4883            {   Return(1)}
4884
4885            // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
4886            Store(0x12345678,DWD1)
4887            Store(0xEDCBA987,DWD2)
4888            XOr(DWD1,DWD2,RDWD)
4889            if(LNotEqual(RDWD,0xFFFFFFFF))
4890            {   Return(1)}
4891
4892            Store(0x12345678,DWD1)
4893            if(LNotEqual(DWD1,0x12345678))
4894            {
4895                Return(1)
4896            }
4897
4898            Store(0xFEDCBA98,DWD2)
4899            if(LNotEqual(DWD2,0xFEDCBA98))
4900            {
4901                Return(1)
4902            }
4903
4904            Store(0x91827364,RDWD)
4905            if(LNotEqual(RDWD,0x91827364))
4906            {
4907                Return(1)
4908            }
4909
4910            //****************************************************
4911            // Check the stored single bits
4912            if(LNotEqual(RES1, 1))
4913            {
4914                Return(1)
4915            }
4916
4917            if(LNotEqual(RES2, 1))
4918            {
4919                Return(1)
4920            }
4921
4922            if(LNotEqual(RES3, 1))
4923            {
4924                Return(1)
4925            }
4926
4927            if(LNotEqual(RES4, 1))
4928            {
4929                Return(1)
4930            }
4931
4932            // Change all of the single bit fields to zero
4933            Store(0, RES1)
4934            Store(0, RES2)
4935            Store(0, RES3)
4936            Store(0, RES4)
4937
4938            // Now, check all of the fields
4939
4940            // Byte
4941            if(LNotEqual(BYT1, 0x12))
4942            {
4943                Return(1)
4944            }
4945
4946            if(LNotEqual(BYT2, 0xFE))
4947            {
4948                Return(1)
4949            }
4950
4951            if(LNotEqual(RBYT, 0xAB))
4952            {
4953                Return(1)
4954            }
4955
4956            // Word
4957            if(LNotEqual(WRD1, 0x1234))
4958            {
4959                Return(1)
4960            }
4961
4962            if(LNotEqual(WRD2, 0xFEDC))
4963            {
4964                Return(1)
4965            }
4966
4967            if(LNotEqual(RWRD, 0x87AB))
4968            {
4969                Return(1)
4970            }
4971
4972            // Dword
4973            if(LNotEqual(DWD1, 0x12345678))
4974            {
4975                Return(1)
4976            }
4977
4978            if(LNotEqual(DWD2, 0xFEDCBA98))
4979            {
4980                Return(1)
4981            }
4982
4983            if(LNotEqual(RDWD, 0x91827364))
4984            {
4985                Return(1)
4986            }
4987
4988            // Bits
4989            if(LNotEqual(RES1, 0))
4990            {
4991                Return(1)
4992            }
4993
4994            if(LNotEqual(RES2, 0))
4995            {
4996                Return(1)
4997            }
4998
4999            if(LNotEqual(RES3, 0))
5000            {
5001                Return(1)
5002            }
5003
5004            if(LNotEqual(RES4, 0))
5005            {
5006                Return(1)
5007            }
5008
5009
5010            Return(0)
5011        }   //  TEST
5012    }   //  XORD
5013
5014//
5015// test CrBytFld.asl
5016//
5017//  CrBytFld test
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.
5021//
5022    Device (CRBF)
5023    {   //  Test device name
5024        Method (TEST)
5025        {
5026            Store ("++++++++ CrBytFld Test", Debug)
5027
5028            //  Local0 is uninitialized buffer with 4 elements
5029            Store (Buffer (4) {}, Local0)
5030
5031            //  create Byte Field named BF0 based on Local0 element 0
5032            CreateByteField (Local0, 0, BF0)
5033
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
5037                {   Return (2)  }
5038
5039            //  store something into BF0
5040            Store (1, BF0)
5041
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
5045                {   Return (3)  }
5046
5047            //  verify that the Store into BF0 was successful
5048            If (LNotEqual (BF0, 1))
5049                {   Return (4)  }
5050
5051
5052            //  create Byte Field named BF1 based on Local0 element 1
5053            CreateByteField (Local0, 1, BF1)
5054
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
5058                {   Return (10) }
5059
5060            //  store something into BF1
5061            Store (5, BF1)
5062
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
5066                {   Return (11) }
5067
5068            //  verify that the Store into BF1 was successful
5069            If (LNotEqual (BF1, 5))
5070                {   Return (12) }
5071
5072            //  verify that the Store into BF1 did not alter BF0
5073            If (LNotEqual (BF0, 1))
5074                {   Return (13) }
5075
5076
5077            //  store something into BF0
5078            Store (0xFFFF, BF0)
5079
5080            //  verify that the Store into BF0 was successful
5081            If (LNotEqual (BF0, 0xFF))
5082                {   Return (20) }
5083
5084            //  verify that the Store into BF0 did not alter BF1
5085            If (LNotEqual (BF1, 5))
5086                {   Return (21) }
5087
5088
5089            Return (0)
5090        }   //  TEST
5091    }   //  CRBF
5092
5093//
5094// test IndexOp4.asl
5095//
5096//  IndexOp4 test
5097//      This is just a subset of the many RegionOp/Index Field test cases.
5098//      Tests access of index fields smaller than 8 bits.
5099//
5100    Device (IDX4)
5101    {   //  Test device name
5102
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.
5107        //
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.
5113        //
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
5122            }
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
5158
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
5178
5179            //  initialize memory contents using aligned field entries
5180            Store (0x5AA55AA5, DWD0)
5181            Store (0x5AA55AA5, DWD1)
5182
5183            //  set memory contents to known values using misaligned field entries
5184            Store (0, BIT0)
5185                //  verify memory contents using misaligned field entries
5186                If (LNotEqual (BIT0, 0))
5187                    {   Return (1)  }
5188                //  verify memory contents using aligned field entries
5189                If (LNotEqual (DWD0, 0x5AA55AA4))
5190                    {   Return (2)  }
5191
5192            //  set memory contents to known values using misaligned field entries
5193            Store (1, BIT1)
5194                //  verify memory contents using misaligned field entries
5195                If (LNotEqual (BIT1, 1))
5196                    {   Return (3)  }
5197                //  verify memory contents using aligned field entries
5198                If (LNotEqual (DWD0, 0x5AA55AA6))
5199                    {   Return (4)  }
5200
5201            //  set memory contents to known values using misaligned field entries
5202            Store (0, BIT2)
5203                //  verify memory contents using misaligned field entries
5204                If (LNotEqual (BIT2, 0))
5205                    {   Return (5)  }
5206                //  verify memory contents using aligned field entries
5207                If (LNotEqual (DWD0, 0x5AA55AA2))
5208                    {   Return (6)  }
5209
5210            //  set memory contents to known values using misaligned field entries
5211            Store (1, BIT3)
5212                //  verify memory contents using misaligned field entries
5213                If (LNotEqual (BIT3, 1))
5214                    {   Return (7)  }
5215                //  verify memory contents using aligned field entries
5216                If (LNotEqual (DWD0, 0x5AA55AAA))
5217                    {   Return (8)  }
5218
5219            //  set memory contents to known values using misaligned field entries
5220            Store (1, BIT4)
5221                //  verify memory contents using misaligned field entries
5222                If (LNotEqual (BIT4, 1))
5223                    {   Return (9)  }
5224                //  verify memory contents using aligned field entries
5225                If (LNotEqual (DWD0, 0x5AA55ABA))
5226                    {   Return (10) }
5227
5228            //  set memory contents to known values using misaligned field entries
5229            Store (0, BIT5)
5230                //  verify memory contents using misaligned field entries
5231                If (LNotEqual (BIT5, 0))
5232                    {   Return (11) }
5233                //  verify memory contents using aligned field entries
5234                If (LNotEqual (DWD0, 0x5AA55A9A))
5235                    {   Return (12) }
5236
5237            //  set memory contents to known values using misaligned field entries
5238            Store (1, BIT6)
5239                //  verify memory contents using misaligned field entries
5240                If (LNotEqual (BIT6, 1))
5241                    {   Return (13) }
5242                //  verify memory contents using aligned field entries
5243                If (LNotEqual (DWD0, 0x5AA55ADA))
5244                    {   Return (14) }
5245
5246            //  set memory contents to known values using misaligned field entries
5247            Store (0, BIT7)
5248                //  verify memory contents using misaligned field entries
5249                If (LNotEqual (BIT7, 0))
5250                    {   Return (15) }
5251                //  verify memory contents using aligned field entries
5252                If (LNotEqual (DWD0, 0x5AA55A5A))
5253                    {   Return (16) }
5254
5255            //  set memory contents to known values using misaligned field entries
5256            Store (1, BIT8)
5257                //  verify memory contents using misaligned field entries
5258                If (LNotEqual (BIT8, 1))
5259                    {   Return (17) }
5260                //  verify memory contents using aligned field entries
5261                If (LNotEqual (DWD0, 0x5AA55B5A))
5262                    {   Return (18) }
5263
5264            //  set memory contents to known values using misaligned field entries
5265            Store (0, BIT9)
5266                //  verify memory contents using misaligned field entries
5267                If (LNotEqual (BIT9, 0))
5268                    {   Return (19) }
5269                //  verify memory contents using aligned field entries
5270                If (LNotEqual (DWD0, 0x5AA5595A))
5271                    {   Return (20) }
5272
5273            //  set memory contents to known values using misaligned field entries
5274            Store (1, BITA)
5275                //  verify memory contents using misaligned field entries
5276                If (LNotEqual (BITA, 1))
5277                    {   Return (21) }
5278                //  verify memory contents using aligned field entries
5279                If (LNotEqual (DWD0, 0x5AA55D5A))
5280                    {   Return (22) }
5281
5282            //  set memory contents to known values using misaligned field entries
5283            Store (0, BITB)
5284                //  verify memory contents using misaligned field entries
5285                If (LNotEqual (BITB, 0))
5286                    {   Return (23) }
5287                //  verify memory contents using aligned field entries
5288                If (LNotEqual (DWD0, 0x5AA5555A))
5289                    {   Return (24) }
5290
5291            //  set memory contents to known values using misaligned field entries
5292            Store (0, BITC)
5293                //  verify memory contents using misaligned field entries
5294                If (LNotEqual (BITC, 0))
5295                    {   Return (25) }
5296                //  verify memory contents using aligned field entries
5297                If (LNotEqual (DWD0, 0x5AA5455A))
5298                    {   Return (26) }
5299
5300            //  set memory contents to known values using misaligned field entries
5301            Store (1, BITD)
5302                //  verify memory contents using misaligned field entries
5303                If (LNotEqual (BITD, 1))
5304                    {   Return (27) }
5305                //  verify memory contents using aligned field entries
5306                If (LNotEqual (DWD0, 0x5AA5655A))
5307                    {   Return (28) }
5308
5309            //  set memory contents to known values using misaligned field entries
5310            Store (0, BITE)
5311                //  verify memory contents using misaligned field entries
5312                If (LNotEqual (BITE, 0))
5313                    {   Return (29) }
5314                //  verify memory contents using aligned field entries
5315                If (LNotEqual (DWD0, 0x5AA5255A))
5316                    {   Return (30) }
5317
5318            //  set memory contents to known values using misaligned field entries
5319            Store (1, BITF)
5320                //  verify memory contents using misaligned field entries
5321                If (LNotEqual (BITF, 1))
5322                    {   Return (31) }
5323                //  verify memory contents using aligned field entries
5324                If (LNotEqual (DWD0, 0x5AA5A55A))
5325                    {   Return (32) }
5326
5327            //  set memory contents to known values using misaligned field entries
5328            Store (0, BI10)
5329                //  verify memory contents using misaligned field entries
5330                If (LNotEqual (BI10, 0))
5331                    {   Return (33) }
5332                //  verify memory contents using aligned field entries
5333                If (LNotEqual (DWD0, 0x5AA4A55A))
5334                    {   Return (34) }
5335
5336            //  set memory contents to known values using misaligned field entries
5337            Store (1, BI11)
5338                //  verify memory contents using misaligned field entries
5339                If (LNotEqual (BI11, 1))
5340                    {   Return (35) }
5341                //  verify memory contents using aligned field entries
5342                If (LNotEqual (DWD0, 0x5AA6A55A))
5343                    {   Return (36) }
5344
5345            //  set memory contents to known values using misaligned field entries
5346            Store (0, BI12)
5347                //  verify memory contents using misaligned field entries
5348                If (LNotEqual (BI12, 0))
5349                    {   Return (37) }
5350                //  verify memory contents using aligned field entries
5351                If (LNotEqual (DWD0, 0x5AA2A55A))
5352                    {   Return (38) }
5353
5354            //  set memory contents to known values using misaligned field entries
5355            Store (1, BI13)
5356                //  verify memory contents using misaligned field entries
5357                If (LNotEqual (BI13, 1))
5358                    {   Return (39) }
5359                //  verify memory contents using aligned field entries
5360                If (LNotEqual (DWD0, 0x5AAAA55A))
5361                    {   Return (40) }
5362
5363            //  set memory contents to known values using misaligned field entries
5364            Store (1, BI14)
5365                //  verify memory contents using misaligned field entries
5366                If (LNotEqual (BI14, 1))
5367                    {   Return (41) }
5368                //  verify memory contents using aligned field entries
5369                If (LNotEqual (DWD0, 0x5ABAA55A))
5370                    {   Return (42) }
5371
5372            //  set memory contents to known values using misaligned field entries
5373            Store (0, BI15)
5374                //  verify memory contents using misaligned field entries
5375                If (LNotEqual (BI15, 0))
5376                    {   Return (43) }
5377                //  verify memory contents using aligned field entries
5378                If (LNotEqual (DWD0, 0x5A9AA55A))
5379                    {   Return (44) }
5380
5381            //  set memory contents to known values using misaligned field entries
5382            Store (1, BI16)
5383                //  verify memory contents using misaligned field entries
5384                If (LNotEqual (BI16, 1))
5385                    {   Return (45) }
5386                //  verify memory contents using aligned field entries
5387                If (LNotEqual (DWD0, 0x5ADAA55A))
5388                    {   Return (46) }
5389
5390            //  set memory contents to known values using misaligned field entries
5391            Store (0, BI17)
5392                //  verify memory contents using misaligned field entries
5393                If (LNotEqual (BI17, 0))
5394                    {   Return (47) }
5395                //  verify memory contents using aligned field entries
5396                If (LNotEqual (DWD0, 0x5A5AA55A))
5397                    {   Return (48) }
5398
5399            //  set memory contents to known values using misaligned field entries
5400            Store (1, BI18)
5401                //  verify memory contents using misaligned field entries
5402                If (LNotEqual (BI18, 1))
5403                    {   Return (49) }
5404                //  verify memory contents using aligned field entries
5405                If (LNotEqual (DWD0, 0x5B5AA55A))
5406                    {   Return (50) }
5407
5408            //  set memory contents to known values using misaligned field entries
5409            Store (0, BI19)
5410                //  verify memory contents using misaligned field entries
5411                If (LNotEqual (BI19, 0))
5412                    {   Return (51) }
5413                //  verify memory contents using aligned field entries
5414                If (LNotEqual (DWD0, 0x595AA55A))
5415                    {   Return (52) }
5416
5417            //  set memory contents to known values using misaligned field entries
5418            Store (1, BI1A)
5419                //  verify memory contents using misaligned field entries
5420                If (LNotEqual (BI1A, 1))
5421                    {   Return (53) }
5422                //  verify memory contents using aligned field entries
5423                If (LNotEqual (DWD0, 0x5D5AA55A))
5424                    {   Return (54) }
5425
5426            //  set memory contents to known values using misaligned field entries
5427            Store (0, BI1B)
5428                //  verify memory contents using misaligned field entries
5429                If (LNotEqual (BI1B, 0))
5430                    {   Return (55) }
5431                //  verify memory contents using aligned field entries
5432                If (LNotEqual (DWD0, 0x555AA55A))
5433                    {   Return (56) }
5434
5435            //  set memory contents to known values using misaligned field entries
5436            Store (0, BI1C)
5437                //  verify memory contents using misaligned field entries
5438                If (LNotEqual (BI1C, 0))
5439                    {   Return (57) }
5440                //  verify memory contents using aligned field entries
5441                If (LNotEqual (DWD0, 0x455AA55A))
5442                    {   Return (58) }
5443
5444            //  set memory contents to known values using misaligned field entries
5445            Store (1, BI1D)
5446                //  verify memory contents using misaligned field entries
5447                If (LNotEqual (BI1D, 1))
5448                    {   Return (59) }
5449                //  verify memory contents using aligned field entries
5450                If (LNotEqual (DWD0, 0x655AA55A))
5451                    {   Return (60) }
5452
5453            //  set memory contents to known values using misaligned field entries
5454            Store (0, BI1E)
5455                //  verify memory contents using misaligned field entries
5456                If (LNotEqual (BI1E, 0))
5457                    {   Return (61) }
5458                //  verify memory contents using aligned field entries
5459                If (LNotEqual (DWD0, 0x255AA55A))
5460                    {   Return (62) }
5461
5462            //  set memory contents to known values using misaligned field entries
5463            Store (1, BI1F)
5464                //  verify memory contents using misaligned field entries
5465                If (LNotEqual (BI1F, 1))
5466                    {   Return (63) }
5467                //  verify memory contents using aligned field entries
5468                If (LNotEqual (DWD0, 0xA55AA55A))
5469                    {   Return (64) }
5470
5471
5472            //  set memory contents to known values using misaligned field entries
5473            Store (3, B2_0)
5474                //  verify memory contents using misaligned field entries
5475                If (LNotEqual (B2_0, 3))
5476                    {   Return (65) }
5477                //  verify memory contents using aligned field entries
5478                If (LNotEqual (DWD0, 0xA55AA55B))
5479                    {   Return (66) }
5480
5481            //  set memory contents to known values using misaligned field entries
5482            Store (1, B2_1)
5483                //  verify memory contents using misaligned field entries
5484                If (LNotEqual (B2_1, 1))
5485                    {   Return (67) }
5486                //  verify memory contents using aligned field entries
5487                If (LNotEqual (DWD0, 0xA55AA557))
5488                    {   Return (68) }
5489
5490            //  set memory contents to known values using misaligned field entries
5491            Store (0, B2_2)
5492                //  verify memory contents using misaligned field entries
5493                If (LNotEqual (B2_2, 0))
5494                    {   Return (69) }
5495                //  verify memory contents using aligned field entries
5496                If (LNotEqual (DWD0, 0xA55AA547))
5497                    {   Return (70) }
5498
5499            //  set memory contents to known values using misaligned field entries
5500            Store (3, B2_3)
5501                //  verify memory contents using misaligned field entries
5502                If (LNotEqual (B2_3, 3))
5503                    {   Return (71) }
5504                //  verify memory contents using aligned field entries
5505                If (LNotEqual (DWD0, 0xA55AA5C7))
5506                    {   Return (72) }
5507
5508            //  set memory contents to known values using misaligned field entries
5509            Store (3, B2_4)
5510                //  verify memory contents using misaligned field entries
5511                If (LNotEqual (B2_4, 3))
5512                    {   Return (73) }
5513                //  verify memory contents using aligned field entries
5514                If (LNotEqual (DWD0, 0xA55AA7C7))
5515                    {   Return (74) }
5516
5517            //  set memory contents to known values using misaligned field entries
5518            Store (0, B2_5)
5519                //  verify memory contents using misaligned field entries
5520                If (LNotEqual (B2_5, 0))
5521                    {   Return (75) }
5522                //  verify memory contents using aligned field entries
5523                If (LNotEqual (DWD0, 0xA55AA3C7))
5524                    {   Return (76) }
5525
5526            //  set memory contents to known values using misaligned field entries
5527            Store (1, B2_6)
5528                //  verify memory contents using misaligned field entries
5529                If (LNotEqual (B2_6, 1))
5530                    {   Return (77) }
5531                //  verify memory contents using aligned field entries
5532                If (LNotEqual (DWD0, 0xA55A93C7))
5533                    {   Return (78) }
5534
5535            //  set memory contents to known values using misaligned field entries
5536            Store (1, B2_7)
5537                //  verify memory contents using misaligned field entries
5538                If (LNotEqual (B2_7, 1))
5539                    {   Return (79) }
5540                //  verify memory contents using aligned field entries
5541                If (LNotEqual (DWD0, 0xA55A53C7))
5542                    {   Return (80) }
5543
5544            //  set memory contents to known values using misaligned field entries
5545            Store (0, B2_8)
5546                //  verify memory contents using misaligned field entries
5547                If (LNotEqual (B2_8, 0))
5548                    {   Return (81) }
5549                //  verify memory contents using aligned field entries
5550                If (LNotEqual (DWD0, 0xA55853C7))
5551                    {   Return (82) }
5552
5553            //  set memory contents to known values using misaligned field entries
5554            Store (1, B2_9)
5555                //  verify memory contents using misaligned field entries
5556                If (LNotEqual (B2_9, 1))
5557                    {   Return (83) }
5558                //  verify memory contents using aligned field entries
5559                If (LNotEqual (DWD0, 0xA55453C7))
5560                    {   Return (84) }
5561
5562            //  set memory contents to known values using misaligned field entries
5563            Store (2, B2_A)
5564                //  verify memory contents using misaligned field entries
5565                If (LNotEqual (B2_A, 2))
5566                    {   Return (85) }
5567                //  verify memory contents using aligned field entries
5568                If (LNotEqual (DWD0, 0xA56453C7))
5569                    {   Return (86) }
5570
5571            //  set memory contents to known values using misaligned field entries
5572            Store (2, B2_B)
5573                //  verify memory contents using misaligned field entries
5574                If (LNotEqual (B2_B, 2))
5575                    {   Return (87) }
5576                //  verify memory contents using aligned field entries
5577                If (LNotEqual (DWD0, 0xA5A453C7))
5578                    {   Return (88) }
5579
5580            //  set memory contents to known values using misaligned field entries
5581            Store (3, B2_C)
5582                //  verify memory contents using misaligned field entries
5583                If (LNotEqual (B2_C, 3))
5584                    {   Return (89) }
5585                //  verify memory contents using aligned field entries
5586                If (LNotEqual (DWD0, 0xA7A453C7))
5587                    {   Return (90) }
5588
5589            //  set memory contents to known values using misaligned field entries
5590            Store (3, B2_D)
5591                //  verify memory contents using misaligned field entries
5592                If (LNotEqual (B2_D, 3))
5593                    {   Return (91) }
5594                //  verify memory contents using aligned field entries
5595                If (LNotEqual (DWD0, 0xAFA453C7))
5596                    {   Return (92) }
5597
5598            //  set memory contents to known values using misaligned field entries
5599            Store (1, B2_E)
5600                //  verify memory contents using misaligned field entries
5601                If (LNotEqual (B2_E, 1))
5602                    {   Return (93) }
5603                //  verify memory contents using aligned field entries
5604                If (LNotEqual (DWD0, 0x9FA453C7))
5605                    {   Return (94) }
5606
5607            //  set memory contents to known values using misaligned field entries
5608            Store (0, B2_F)
5609                //  verify memory contents using misaligned field entries
5610                If (LNotEqual (B2_F, 0))
5611                    {   Return (95) }
5612                //  verify memory contents using aligned field entries
5613                If (LNotEqual (DWD0, 0x1FA453C7))
5614                    {   Return (96) }
5615
5616
5617            Return (0)  //  pass
5618        }   //  MADM:   Misaligned Dynamic RAM SystemMemory OperationRegion
5619
5620        Method (TEST)
5621        {
5622            Store ("++++++++ IndexOp4 Test", Debug)
5623
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
5629
5630            Return (Local0)
5631        }   //  TEST
5632    }   //  IDX4
5633
5634//
5635// test Event.asl
5636//
5637//  EventOp, ResetOp, SignalOp, and WaitOp test cases.
5638//
5639    Device (EVNT)
5640    {
5641        Event (EVNT)    //  event synchronization object
5642
5643        Method (TEVN, 1)
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
5647            Reset (EVNT)
5648
5649            //  prime EVNT with two outstanding signals
5650            Signal (EVNT)
5651            Signal (EVNT)
5652
5653
5654            //  acquire existing signal
5655            Store (Wait (EVNT, Arg0), Local0)
5656
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
5661
5662            If (LNotEqual (Local0, 0))  //  Number is type 1
5663                {   Return (0x22)   }       //  timeout occurred without acquiring signal
5664
5665            Store ("Acquire 1st existing signal PASS", Debug)
5666
5667
5668            //  acquire existing signal
5669            Store (Wait (EVNT, Arg0), Local0)
5670
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
5675
5676            If (LNotEqual (Local0, 0))  //  Number is type 1
5677                {   Return (0x32)   }       //  timeout occurred without acquiring signal
5678
5679            Store ("Acquire 2nd existing signal PASS", Debug)
5680
5681
5682            //  ensure WaitOp timeout test cases do not hang
5683            if (LEqual (Arg0, 0xFFFF))
5684                {   Store (0xFFFE, Arg0)    }
5685
5686            //  acquire non-existing signal
5687            Store (Wait (EVNT, Arg0), Local0)
5688
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
5693
5694            If (LEqual (Local0, 0))     //  Number is type 1
5695                {   Return (0x42)   }       //  non-existent signal was acquired
5696
5697            Store ("Acquire signal timeout PASS", Debug)
5698
5699
5700            //  prime EVNT with two outstanding signals
5701            Signal (EVNT)
5702            Signal (EVNT)
5703
5704            //  reset EVNT to initialization (zero) state
5705            Reset (EVNT)
5706
5707            //  acquire non-existing signal
5708            Store (Wait (EVNT, Arg0), Local0)
5709
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
5714
5715            If (LEqual (Local0, 0))     //  Number is type 1
5716                {   Return (0x52)   }       //  non-existent signal was acquired
5717
5718            Store ("Reset signal PASS", Debug)
5719
5720
5721            //  acquire non-existing signal using Lvalue timeout
5722            Store (Wait (EVNT, Zero), Local0)
5723
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
5728
5729            If (LEqual (Local0, 0))     //  Number is type 1
5730                {   Return (0x62)   }       //  non-existent signal was acquired
5731
5732            Store ("Zero Lvalue PASS", Debug)
5733
5734
5735            //  acquire non-existing signal using Lvalue timeout
5736            Store (Wait (EVNT, One), Local0)
5737
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
5742
5743            If (LEqual (Local0, 0))     //  Number is type 1
5744                {   Return (0x72)   }       //  non-existent signal was acquired
5745
5746            Store ("One Lvalue PASS", Debug)
5747
5748            //  Lvalue Event test cases
5749    // ILLEGAL SOURCE OPERAND        Store (EVNT, Local2)
5750
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
5755
5756            //  reset EVNT to initialization (zero) state
5757            Reset (EVNT)
5758
5759            //  prime EVNT with two outstanding signals
5760            Signal (EVNT)
5761
5762            //  acquire existing signal
5763            Store (Wait (EVNT, Arg0), Local0)
5764
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
5769
5770            If (LNotEqual (Local0, 0))  //  Number is type 1
5771                {   Return (0x83)   }       //  timeout occurred without acquiring signal
5772
5773            Store ("Acquire Lvalue existing signal PASS", Debug)
5774
5775
5776            //  acquire non-existing signal
5777            Store (Wait (EVNT, Arg0), Local0)
5778
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
5783
5784            If (LEqual (Local0, 0))     //  Number is type 1
5785                {   Return (0x85)   }       //  non-existent signal was acquired
5786
5787            Store ("Acquire Lvalue signal timeout PASS", Debug)
5788
5789
5790            Return (0)  //  success
5791        }   //  TEVN control method to test ResetOp, SignalOp, and WaitOp
5792
5793        Method (TEST)
5794        {
5795            Store ("++++++++ Event Test", Debug)
5796
5797            Store (TEVN (100), Local0)
5798
5799            Return (Local0)
5800        }   //  TEST
5801    }   //  EVNT
5802
5803//
5804// test SizeOfLv.asl
5805//
5806//  Test for SizeOf (Lvalue)
5807//
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.
5815
5816    Name (PKG0,
5817        Package (3)
5818        {0x0123, 0x4567, 0x89AB}
5819    )   //  PKG0
5820
5821    Name (PKG1,
5822        Package (3)
5823        {
5824            Package (3) {0x0123, 0x4567, 0x89AB},
5825            Package (3) {0xCDEF, 0xFEDC, 0xBA98},
5826            Package (3) {0x7654, 0x3210, 0x1234}
5827        }
5828    )   //  PKG1
5829
5830    Name (PKG2,
5831        Package (4)
5832        {0x0123, 0x4567, 0x89AB, 0x8888}
5833    )   //  PKG2
5834
5835    Name (PKG3,
5836        Package (5)
5837        {0x0123, 0x4567, 0x89AB, 0x8888, 0x7777}
5838    )   //  PKG3
5839
5840//  End Packages    **********************************************************
5841
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.
5845
5846    Name (STR0, "ACPI permits very flexible methods of expressing a system")
5847
5848    Name (STR1, "MIKE permits very flexible methods of expressing a system")
5849
5850    Name (STR2, "Needless to say, Mike and ACPI are frequently at odds")
5851
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")
5855
5856//  End Strings     **********************************************************
5857
5858//  The following section will declare the buffers that will be used to exercise
5859//  the SizeOf operator.
5860
5861    Name (BUF0, Buffer (10) {})
5862    Name (BUF1, Buffer (10) {})
5863    Name (BUF2, Buffer (8)  {})
5864    Name (BUF3, Buffer (5)  {})
5865
5866//  End Buffers     **********************************************************
5867    Device (SZLV)
5868    {
5869
5870        Method (CMPR, 2)
5871        {
5872            //  CMPR is passed two arguments. If unequal, return 1 to indicate
5873            //  that, otherwise return 0 to indicate SizeOf each is equal.
5874
5875            Store (0x01, Local0)
5876
5877            if (LEqual (SizeOf(Arg0), SizeOf(Arg1)))
5878            {
5879                Store (0x00, Local0)
5880            }
5881
5882            return (Local0)
5883        }   //  CMPR
5884
5885
5886        Method (TEST)
5887        {
5888
5889            Store ("++++++++ SizeOfLv Test", Debug)
5890
5891            //  TBD:    SizeOf ("string")
5892            //          SizeOf (Buffer)
5893            //          SizeOf (Package)
5894            //          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,
5899
5900            //  TBD:    SLOC [SizeOf (Local0)] -- dup SARG
5901
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)))
5905            {
5906                Return (0x01)
5907            }
5908
5909            if (LNotEqual (0x00, CMPR (STR3, BUF3)))
5910            {
5911                Return (0x02)
5912            }
5913
5914            if (LNotEqual (0x00, CMPR (STR3, PKG3)))
5915            {
5916                Return (0x03)
5917            }
5918
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)
5924
5925            if (LNotEqual (SizeOf (Local0), SizeOf (Local1)))
5926            {
5927                Return (0x04)
5928            }
5929
5930            //  Now create a case where Local0 and Local1 are different
5931            Store (STR2, Local1)
5932
5933            if (LEqual (SizeOf (Local0), SizeOf (Local1)))
5934            {
5935                Return (0x05)
5936            }
5937
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)))
5942            {
5943                Return (0x06)
5944            }
5945
5946            Return (0)
5947        }   //  TEST
5948    }   //  SZLV
5949
5950
5951//
5952// test BytField.asl
5953//
5954//  BytField test
5955//      This is just a subset of the many RegionOp/Index Field test cases.
5956//      Tests access of TBD.
5957//
5958    Scope (\_SB)    //  System Bus
5959    {   //  _SB system bus
5960        Device (BYTF)
5961        {   //  Test device name
5962            Method (TEST)
5963            {
5964                Store ("++++++++ BytField Test", Debug)
5965
5966                Return (\_TZ.C19B.RSLT)
5967            }   //  TEST
5968        }   //  BYTF
5969
5970        Device (C005)
5971        {   //  Device C005
5972            Device (C013)
5973            {   //  Device C013
5974            }   //  Device C013
5975        }   //  Device C005
5976
5977        Method (C115)
5978        {   //  C115 control method
5979            Acquire (\_GL, 0xFFFF)
5980            Store (\_SB.C005.C013.C058.C07E, Local0)
5981            Release (\_GL)
5982            And (Local0, 16, Local0)
5983            Store (ShiftRight (Local0, 4, ), Local1)
5984            If (LEqual (Local1, 0))
5985                {   Return (1)  }
5986            Else
5987                {   Return (0)  }
5988        }   //  C115 control method
5989    }   //  _SB system bus
5990
5991    OperationRegion (C018, SystemIO, 0x5028, 4)
5992    Field (C018, AnyAcc, NoLock, Preserve)
5993    {   //  Field overlaying C018
5994        C019,   32
5995    }   //  Field overlaying C018
5996
5997    OperationRegion (C01A, SystemIO, 0x5030, 4)
5998    Field (C01A, ByteAcc, NoLock, Preserve)
5999    {   //  Field overlaying C01A
6000        C01B,   8,
6001        C01C,   8,
6002        C01D,   8,
6003        C01E,   8
6004    }   //  Field overlaying C01A
6005
6006    Mutex (\C01F, 0)
6007    Name (\C020, 0)
6008    Name (\C021, 0)
6009
6010    Method (\C022, 0)
6011    {   //  \C022 control method
6012        Acquire (\C01F, 0xFFFF)
6013        If (LEqual (\C021, 0))
6014        {
6015            Store (C019, Local0)
6016            And (Local0, 0xFFFEFFFE, Local0)
6017            Store (Local0, C019)
6018            Increment (\C021)
6019        }
6020        Release (\C01F)
6021    }   //  \C022 control method
6022
6023    Scope (\_SB.C005.C013)
6024    {   //  Scope \_SB.C005.C013
6025        Device (C058)
6026        {   //  Device C058
6027            Name (_HID, "*PNP0A06")
6028
6029            OperationRegion (C059, SystemIO, 0xE0, 2)
6030            Field (C059, ByteAcc, NoLock, Preserve)
6031            {   //  Field overlaying C059
6032                C05A,   8,
6033                C05B,   8
6034            }   //  Field overlaying C059
6035
6036            OperationRegion (C05C, SystemIO, 0xE2, 2)
6037            Field (C05C, ByteAcc, NoLock, Preserve)
6038            {   //  Field overlaying C05C
6039                C05D,   8,
6040                C05E,   8
6041            }   //  Field overlaying C05C
6042            IndexField (C05D, C05E, ByteAcc, NoLock, Preserve)
6043            {   //  IndexField overlaying C05D/C05E
6044                ,       0x410,  //  skip
6045                C05F,   8,
6046                C060,   8,
6047                C061,   8,
6048                C062,   8,
6049                C063,   8,
6050                C064,   8,
6051                C065,   8,
6052                C066,   8,
6053                C067,   8,
6054                C068,   8,
6055                C069,   8,
6056                C06A,   8,
6057                C06B,   8,
6058                C06C,   8,
6059                C06D,   8,
6060                C06E,   8,
6061                ,       0x70,       //  skip
6062                C06F,   8,
6063                C070,   8,
6064                C071,   8,
6065                C072,   8,
6066                C073,   8,
6067                C074,   8,
6068                C075,   8,
6069                C076,   8,
6070                C077,   8,
6071                C078,   8,
6072                C079,   8,
6073                C07A,   8,
6074                C07B,   8,
6075                C07C,   8,
6076                C07D,   8,
6077                C07E,   8
6078            }   //  IndexField overlaying C05D/C05E
6079
6080            OperationRegion (C07F, SystemIO, 0xE4, 2)
6081            Field (C07F, ByteAcc, NoLock, Preserve)
6082            {   //  Field overlaying C07F
6083                C080,   8,
6084                C081,   8
6085            }   //  Field overlaying C07F
6086
6087            OperationRegion (C082, SystemIO, 0xE0, 1)
6088            Field (C082, ByteAcc, NoLock, Preserve)
6089            {   //  Field overlaying C082
6090                C083,   8
6091            }   //  Field overlaying C082
6092
6093            OperationRegion (C084, SystemIO, 0xFF, 1)
6094            Field (C084, ByteAcc, NoLock, Preserve)
6095            {   //  Field overlaying C084
6096                C085,   8
6097            }   //  Field overlaying C084
6098
6099            OperationRegion (C086, SystemIO, 0xFD, 1)
6100            Field (C086, ByteAcc, NoLock, Preserve)
6101            {   //  Field overlaying C086
6102                C087,   8
6103            }   //  Field overlaying C086
6104
6105            Mutex (C088, 0)
6106            Mutex (C089, 0)
6107            Mutex (C08A, 0)
6108            Mutex (C08B, 0)
6109            Mutex (C08C, 0)
6110            Mutex (C08D, 0)
6111
6112            Name (C08E, 0xFFFFFFFD)
6113            Name (C08F, 0)
6114
6115            Method (C0AA, 4)
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)
6124                \C022 ()
6125                Store (1, \_SB.C005.C013.C058.C06B)
6126                While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
6127                    {   Stall (100) }
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)))
6133                    {   Stall (100) }
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)))
6139                {
6140                    Store (2, \_SB.C005.C013.C058.C06B)
6141                    Stall (100)
6142                }
6143                Release (\_GL)
6144                Release (^C08B)
6145                Return (Local7)
6146            }   //  C0AA control method
6147        }   //  Device C058
6148    }   //  Scope \_SB.C005.C013
6149
6150    Scope (\_TZ)
6151    {   //  \_TZ thermal zone scope
6152        Name (C18B, Package (2)
6153        {
6154            Package (2)
6155            {
6156                Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
6157                Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
6158            },
6159            Package (2)
6160            {
6161                Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
6162                Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
6163            }
6164        })  //  C18B
6165
6166        Name (C18C, Package (2)
6167        {
6168            Package (2)
6169            {
6170                Package (3) {0x64, 0x4B, 0x32},
6171                Package (3) {0x64, 0x4B, 0x32}
6172            }
6173        })  //  C81C
6174
6175        Name (C18D, 0)
6176        Name (C18E, 0)
6177        Name (C18F, 0)
6178        Name (C190, 0)
6179        Name (C191, 3)
6180        Name (C192, 0)
6181        Name (C193, 1)
6182        Name (C194, 2)
6183        Mutex (C195, 0)
6184        Name (C196, 1)
6185        Name (C197, 0x0B9C)
6186        Name (C198, 0x0B9C)
6187        Name (C199, 0xFFFFFFFD)
6188        Name (C19A, 0)
6189
6190        Device (C19B)
6191        {   //  Device C19B
6192            Name (RSLT, 0)  //  default to zero
6193
6194            Method (XINI)
6195            {   //  _INI control method (Uses Global Lock -- can't run under AcpiExec)
6196                Store (\_SB.C115, C19A)
6197                \_TZ.C19C._SCP (0)
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)
6202                Store
6203                    (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 0, )), C18D)
6204                Store
6205                    (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 1, )), C18E)
6206                Store
6207                    (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 2, )), C18F)
6208
6209                Store (1, RSLT) //  set RSLT to 1 if _INI control method completes
6210            }   //  _INI control method
6211
6212            //  PowerResource (C19D) {...}
6213        }   //  Device C19B
6214
6215        ThermalZone (C19C)
6216        {
6217            Method (_SCP, 1)
6218            {   //  _SCP control method
6219                Store (Arg0, Local0)
6220                If (LEqual (Local0, 0))
6221                {
6222                    Store (0, \_TZ.C192)
6223                    Store (1, \_TZ.C193)
6224                    Store (2, \_TZ.C194)
6225                    Store (3, \_TZ.C191)
6226                }
6227                Else
6228                {
6229                    Store (0, \_TZ.C191)
6230                    Store (1, \_TZ.C192)
6231                    Store (2, \_TZ.C193)
6232                    Store (3, \_TZ.C194)
6233                }
6234            }   //  _SCP control method
6235        }   //  ThermalZone C19C
6236    }   //  \_TZ thermal zone scope
6237
6238
6239//
6240// test DwrdFld.asl
6241//
6242    Name (BUFR, buffer(10) {0,0,0,0,0,0,0,0,0,0} )
6243
6244    Device (DWDF)
6245    {
6246        Method (TEST)
6247        {
6248            Store ("++++++++ DwrdFld Test", Debug)
6249
6250            CreateByteField (BUFR, 0, BYTE)
6251            Store (0xAA, BYTE)
6252
6253            CreateWordField (BUFR, 1, WORD)
6254            Store (0xBBCC, WORD)
6255
6256            CreateDWordField (BUFR, 3, DWRD)
6257            Store (0xDDEEFF00, DWRD)
6258
6259            CreateByteField (BUFR, 7, BYT2)
6260            Store (0x11, BYT2)
6261
6262            CreateWordField (BUFR, 8, WRD2)
6263            Store (0x2233, WRD2)
6264
6265            Return (0)
6266
6267        }   //  End Method TEST
6268    }   //  Device DWDF
6269
6270    //
6271    // test DivAddx.asl
6272    //
6273    Name (B1LO, 0xAA)
6274    Name (B1HI, 0xBB)
6275
6276    Method (MKW_, 2)
6277    {   //  This control method will take two bytes and make them into a WORD
6278
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
6282
6283    }   //  MKW_
6284
6285    Device (DVAX)
6286    {
6287        Method (TEST)
6288        {
6289
6290            Store ("++++++++ DivAddx Test", Debug)
6291
6292            Store (25, B1LO)
6293            Store (0, B1HI)
6294
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
6297            //  the quotient.
6298            Divide(
6299                Add (Multiply (3, MKW_ (B1LO, B1HI)), 0x63),
6300                            //  Dividend,
6301                100,        //  Divisor
6302                Local4,     //  Remainder
6303                Local2)     //  Quotient
6304
6305            If (LAnd (LEqual (74, Local4), LEqual (1, Local2)))
6306            {   //  Indicate Pass
6307                Store (0x00, Local0)
6308            }
6309
6310            Else
6311            {   //  Indicate Fail
6312                Store (0x01, Local0)
6313            }
6314
6315            Return (Local0)
6316        }   //  End Method TEST
6317    }   //  Device DVAX
6318
6319//
6320// test IndexFld.asl (IndexOp6.asl)
6321//
6322//  IndexFld test
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.
6327//
6328    Device (IDX6)
6329    {   //  Test device name
6330
6331        OperationRegion (SIO, SystemIO, 0x100, 2)
6332        Field (SIO, ByteAcc, NoLock, Preserve)
6333        {
6334            INDX,   8,
6335            DATA,   8
6336        }
6337        IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
6338        {
6339            AccessAs (ByteAcc, 0),
6340            IFE0,   8,
6341            IFE1,   8,
6342            IFE2,   8,
6343            IFE3,   8,
6344            IFE4,   8,
6345            IFE5,   8,
6346            IFE6,   8,
6347            IFE7,   8,
6348            IFE8,   8,
6349            IFE9,   8,
6350        }
6351
6352        Device (TST_)
6353        {   //  TST_:   provides a different namespace scope for IFE0 and IFE1
6354            OperationRegion (SIO2, SystemIO, 0x100, 2)
6355            Field (SIO2, ByteAcc, NoLock, Preserve)
6356            {
6357                IND2,   8,
6358                DAT2,   8
6359            }
6360            IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes)
6361            {
6362                IFE0,   8,  //  duplicate IndexField name with different scope
6363                IFE1,   8
6364            }
6365        }   //  TST_:   provides a different namespace scope for IFE0 and IFE1
6366
6367        Method (TEST)
6368        {
6369            Store ("++++++++ IndexOp6 Test", Debug)
6370
6371            Store (IFE0, Local0)
6372            Store (IFE1, Local1)
6373            Store (IFE2, Local2)
6374
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)
6381
6382            Return (0)
6383        }   //  TEST
6384    }   //  IDX6
6385
6386//
6387// test IndexOp5.asl
6388//
6389//  IndexOp5 test
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.
6392//
6393    Device (IDX5)
6394    {   //  Test device name
6395
6396        Name (OSFL, 0)  //  0 == Windows 98, 1 == Windows NT
6397
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
6407
6408            //  check if first string's length is less than second string's length
6409            If (LLess (SizeOf (Arg0), SizeOf (Arg1)))
6410                {   Return (0)  }
6411
6412            //  increment length to include NULL termination character
6413            Add (SizeOf (Arg0), 1, Local0)  //  Local0 = strlen(Arg0) + 1
6414
6415            //  create two buffers of size Local0 [strlen(Arg0)+1]
6416            Name (BUF0, Buffer (Local0) {})
6417            Name (BUF1, Buffer (Local0) {})
6418
6419            //  copy strings into buffers
6420            Store (Arg0, BUF0)
6421            Store (Arg1, BUF1)
6422
6423            //  validate BUF0 and BUF1 are still buffers
6424            Store (ObjectType (BUF0), Local1)
6425            If (LNotEqual (Local1, 3))  //  Buffer is type 3
6426                {   Return (20) }
6427            Store (ObjectType (BUF1), Local1)
6428            If (LNotEqual (Local1, 3))  //  Buffer is type 3
6429                {   Return (21) }
6430
6431            // Decrement because the Index base below is zero based
6432            //  while Local0 length is one based.
6433            Decrement (Local0)
6434
6435            While (Local0)
6436            {   //  loop through all BUF0 buffer elements
6437                Decrement (Local0)
6438
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
6443                Else
6444                    {   Return (Zero)   }
6445            }   //  loop through all BUF0 buffer elements
6446
6447            Return (One)    //  strings / buffers match
6448        }   //  MCTH:   Control Method to compare two strings
6449
6450
6451        Method (TEST)
6452        {
6453            Store ("++++++++ IndexOp5 Test", Debug)
6454
6455            If (MCTH (\_OS, "Microsoft Windows NT"))
6456                {   Store (1, OSFL) }
6457
6458            If (LNotEqual (OSFL, 1))
6459                {   Return (11) }
6460
6461            Return (0)
6462        }   //  TEST
6463    }   //  IDX5
6464
6465//
6466// test IndexOp.asl
6467//
6468    Scope (\_SB)    //  System Bus
6469    {   //  _SB system bus
6470
6471        Method (C097)
6472            {   Return (1)  }
6473
6474        Device (PCI2)
6475        {   //  Root PCI Bus
6476            Name (_HID, EISAID("PNP0A03"))
6477            Name (_ADR, 0x00000000)
6478            Name (_CRS, Buffer(26)  {"\_SB_.PCI2._CRS..........."})
6479            Method (_STA)   {Return (0x0F)}
6480
6481            Device (ISA)
6482            {   //  ISA bridge
6483                Name (_ADR, 0x00030000)     //  ISA bus ID
6484
6485                Device (EC0)
6486                {   //  Embedded Controller
6487                    Name (_GPE, 0)              //  EC use GPE0
6488                    Name (_ADR, 0x0030000)  //  PCI address
6489
6490                    Method (_STA,0)         //  EC Status
6491                        {   Return(0xF) }       //  EC is functioning
6492
6493                    Name (_CRS, ResourceTemplate()
6494                        {
6495                            IO (Decode16, 0x62, 0x62, 1, 1)
6496                            IO (Decode16, 0x66, 0x66, 1, 1)
6497                        }
6498                    )
6499
6500                //  create EC's region and field
6501                    OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
6502                    Field (RAM, AnyAcc, NoLock, Preserve)
6503                    {
6504                        //  AC information
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
6508                        ,       1,      //  reserved
6509                        ,       28, //  filler to force DWORD alignment
6510
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")
6533                    }   //  Field
6534                }   //  EC0: Embedded Controller
6535            }   //  ISA bridge
6536        }   //  PCI2 Root PCI Bus
6537
6538        Device (IDX0)
6539        {   //  Test device name
6540            Name (_HID, EISAID ("PNP0C0A"))     //  Control Method Battey ID
6541            Name (_PCL, Package() {\_SB})
6542            Method (_STA)
6543            {
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
6548                else
6549                    {   Return (0x0F)   }   //  Battery not present
6550            }   //  _STA
6551
6552            Method (_BIF,, Serialized)
6553            {
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
6564
6565                Store ("", Index (BUFR,9))                              //  Model Number
6566
6567                Store ("", Index (BUFR,10))                         //  Serial Number
6568
6569                Store ("LiOn", Index (BUFR,11))                     //  Battery Type
6570
6571                Store ("Chicony", Index (BUFR,12))                  //  OEM Information
6572
6573                Return (BUFR)
6574            }   //  _BIF
6575
6576            Method (_BST,, Serialized)
6577            {
6578                Name (BUFR, Package(4) {1, 0x100, 0x76543210, 0x180})
6579                Return (BUFR)
6580            }   //  _BST
6581
6582            Method (_BTP,1)
6583            {
6584                Store (arg0, \_SB.PCI2.ISA.EC0.BTP0)    //  Set Battery Trip point
6585            }
6586
6587            Method (TEST,, Serialized)
6588            {
6589
6590                Store ("++++++++ IndexOp Test", Debug)
6591
6592                //  test storing into uninitialized package elements
6593                Name (PBUF, Package(4) {})  //  leave uninitialized
6594                Store (0x01234567, Index (PBUF,0))
6595                Store (0x89ABCDEF, Index (PBUF,1))
6596                Store (0xFEDCBA98, Index (PBUF,2))
6597                Store (0x76543210, Index (PBUF,3))
6598
6599                //  verify values stored into uninitialized package elements
6600                If (LNotEqual (DerefOf (Index (PBUF,0)), 0x01234567))
6601                    {   Return (0x10)   }
6602
6603                If (LNotEqual (DerefOf (Index (PBUF,1)), 0x89ABCDEF))
6604                    {   Return (0x11)   }
6605
6606                If (LNotEqual (DerefOf (Index (PBUF,2)), 0xFEDCBA98))
6607                    {   Return (0x12)   }
6608
6609                If (LNotEqual (DerefOf (Index (PBUF,3)), 0x76543210))
6610                    {   Return (0x13)   }
6611
6612
6613                //  store _BIF package return value into Local0
6614                Store (_BIF, Local0)
6615
6616                //  save Local0 object type value into Local1
6617                Store (ObjectType (Local0), Local1)
6618
6619                //  validate Local0 is a Package
6620                If (LNotEqual (Local1, 4))  //  Package type is 4
6621                    {   Return (0x21)   }   //  failure
6622
6623
6624                //  test storing into buffer field elements
6625                Name (BUFR, Buffer(16)
6626                    {   //  initial values
6627                        00, 00, 00, 00, 00, 00, 00, 00,
6628                        00, 00, 00, 00, 00, 00, 00, 00,
6629                    }
6630                )   //  BUFR
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
6636
6637                //  verify storing into buffer field elements
6638                If (LNotEqual (DerefOf (Index (BUFR,0)), 0x67))
6639                    {   Return (0x30)   }
6640
6641                If (LNotEqual (DerefOf (Index (BUFR,1)), 0))
6642                    {   Return (0x31)   }
6643
6644                If (LNotEqual (DerefOf (Index (BUFR,4)), 0xEF))
6645                    {   Return (0x34)   }
6646
6647                If (LNotEqual (DerefOf (Index (BUFR,8)), 0x98))
6648                    {   Return (0x38)   }
6649
6650                If (LNotEqual (DerefOf (Index (BUFR,12)), 0x10))
6651                    {   Return (0x3C)   }
6652
6653
6654                Return (0)  //  pass
6655            }   //  TEST
6656        }   //  IDX0
6657    }   //  _SB system bus
6658
6659//
6660// test BitIndex.asl
6661//
6662//  BitIndex test
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.
6667//
6668    Scope (\_SB)    //  System Bus
6669    {   //  _SB system bus
6670        OperationRegion (RAM, SystemMemory, 0x800000, 0x100)
6671        Field (RAM, AnyAcc, NoLock, Preserve)
6672        {   //  Any access
6673            TREE,   3,
6674            WRD0,   16,
6675            WRD1,   16,
6676            WRD2,   16,
6677            WRD3,   16,
6678            WRD4,   16,
6679            DWRD,   32, //  DWORD field
6680        }
6681        Field (RAM, AnyAcc, NoLock, Preserve)
6682        {   //  Any access
6683            THRE,   3,
6684            WD00,   16,
6685            WD01,   16,
6686            WD02,   16,
6687            WD03,   16,
6688            WD04,   16,
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
6707        }
6708
6709        Device (BITI)
6710        {   //  Test device name
6711
6712            Method (MBIT)   //  Test single bit memory accesses
6713            {
6714
6715                If (LNotEqual (DWRD, 0x00))
6716                {
6717                    Store (0xFF00, Local0)
6718                }
6719                Else
6720                {
6721                    //  Prime Local0 with 0...assume passing condition
6722                    Store (0, Local0)
6723
6724                    //  set memory contents to known values using DWORD field
6725                    Store (0x5A5A5A5A, DWRD)
6726
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
6730
6731                    If (BIT0)
6732                    {
6733                        Or (Local0, 0x01, Local0)
6734                    }
6735
6736                    If (LNot (BIT1))
6737                    {
6738                        Or (Local0, 0x02, Local0)
6739                    }
6740
6741                    If (BIT2)
6742                    {
6743                        Or (Local0, 0x04, Local0)
6744                    }
6745
6746                    If (LNot (BIT3))
6747                    {
6748                        Or (Local0, 0x08, Local0)
6749                    }
6750
6751                    //  Now check the upper nibble. Only the "even" bits should
6752                    //  be set. BIT4, BIT6. BIT5 and BIT7 should be clear.
6753                    If (LNot (BIT4))
6754                    {
6755                        Or (Local0, 0x10, Local0)
6756                    }
6757
6758                    If (BIT5)
6759                    {
6760                        Or (Local0, 0x20, Local0)
6761                    }
6762
6763                    If (LNot (BIT6))
6764                    {
6765                        Or (Local0, 0x40, Local0)
6766                    }
6767
6768                    If (BIT7)
6769                    {
6770                        Or (Local0, 0x80, Local0)
6771                    }
6772                }   //  End Else DWRD zeroed out
6773
6774                Return (Local0)
6775            }   //  MBIT:   Test single bit memory accesses
6776
6777            Method (TEST)
6778            {
6779
6780                Store ("++++++++ BitIndex Test", Debug)
6781
6782                //  Zero out DWRD
6783                Store (0x00000000, DWRD)
6784
6785                //  MBIT returns zero if successful
6786                //  This may be causing problems -- Return (MBIT)
6787                Store (MBIT, Local0)
6788
6789                Return (Local0)
6790            }   //  TEST
6791        }   //  BITI
6792    }   //  _SB system bus
6793
6794//
6795// test IndexOp3.asl
6796//
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.
6801//
6802    Scope (\_SB)    //  System Bus
6803    {   //  _SB system bus
6804
6805        Name (C174, 13)
6806        Name (C175, 8)
6807
6808        Device (C158)
6809        {   //  C158:   AC Adapter device
6810            Name (_HID, "ACPI0003") //  AC Adapter device
6811            Name (_PCL, Package (1) {\_SB})
6812
6813            Method (_PSR)
6814            {
6815                Acquire (\_GL, 0xFFFF)
6816                Release (\_GL)
6817                And (Local0, 1, Local0) //  Local0 &= 1
6818                Return (Local0)
6819            }   //  _PSR
6820        }   //  C158:   AC Adapter device
6821
6822        Name (C176, Package (4) {"Primary", "MultiBay", "DockRight", "DockLeft"})
6823
6824        Name (C177, Package (4) {0x99F5, 0x99F5, 0x995F, 0x995F})
6825
6826        Name (C178, Package (4)
6827        {
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}
6832        })  //  C178
6833
6834        Name (C179, Package (4) {0, 0, 0x966B, 0x4190})
6835
6836        Name (C17A, Package (4)
6837        {
6838            Package (3) {0, 0, 0},
6839            Package (3) {0, 0, 0},
6840            Package (3) {0, 0, 0},
6841            Package (3) {0, 0, 0}
6842        })  //  C17A
6843
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
6862
6863            And (Arg0, 7, Local0)                       //  Local0 = Arg0 & 7
6864
6865            ShiftRight (Local0, 1, Local4)          //  Local4 = Local0 >> 1
6866
6867            Store (C179, Index (C178, Local4, ))    //  C178->Local4 = C179
6868
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
6871            //  contents)
6872            Store (0x1234, Index (C179, 2, ))               //  C179[2] = 0x1234
6873            Store (DerefOf (Index (C179, 2, )), Local2) //  Local2 = C179[2]
6874            if (LNotEqual (Local2, 0x1234))
6875                {   Return (0x1234) }
6876                                                                        //  Local2 = C178[0,2]
6877            Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 2, )), Local2)
6878            if (LNotEqual (Local2, 0x966B))
6879                {   Return (0x1234) }
6880
6881            // Restore data to allow iterative execution
6882            Store (0x966B, Index (C179, 2, ))               //  C179[2] = 0x966B
6883
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))
6889                {   Return (0x5678) }
6890
6891            Store (DerefOf (Index (C179, 3, )), Local2) //  Local2 = C179[3]
6892            if (LNotEqual (Local2, 0x4190))
6893                {   Return (0x5678) }
6894
6895            // Restore data to allow iterative execution
6896            Store (0x4190, Index (DerefOf (Index (C178, 0, )), 3, ))    //  C179[2] = 0x4190
6897
6898            Return (C17C)
6899        }   //  C17B:   _BIF implementation
6900
6901        Device (C154)
6902        {   //  C154:   Battery 0
6903            Name (_HID, "*PNP0C0A")     //  Control Method Battey ID
6904            Name (_UID, 0)                  //  first instance
6905
6906            Method (_BIF)
6907            {   //  _BIF
6908                Return (C17B (48))
6909            }   //  _BIF
6910        }   //  C154:   Battery 0
6911
6912        Device (IDX3)
6913        {
6914            Method (LCLB,, Serialized)
6915            {   //  LCLB control method: test Index(Local#) where Local# is buffer
6916                //  Local0 is index counter
6917                //  Local1 is buffer
6918                //  Local2 receives BUFR[Local0] via Deref(Index(Local1...))
6919                //  Local3 is Local1 or Local2 object type
6920                //  Local4 is return error code
6921
6922                Name (BUFR, Buffer ()   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
6923
6924                //  save PKG into Local1
6925                Store (BUFR, Local1)
6926
6927                //  save Local2 object type value into Local3
6928                Store (ObjectType (Local1), Local3)
6929
6930                //  validate Local1 is a Buffer
6931                If (LNotEqual (Local3, 3))      //  Buffer type is 3
6932                    {   Return (0x9F)   }
6933
6934
6935                Store (0, Local0)
6936                While (LLess (Local0, 5))
6937                {   //  While (Local0 < 5)
6938                    //  Local2 = Local1[Local0]
6939                    Store (DerefOf (Index (Local1, Local0, )), Local2)
6940
6941                    //  save Local2 object type value into Local3
6942                    Store (ObjectType (Local2), Local3)
6943
6944                    //  validate Local2 is a Number
6945                    If (LNotEqual (Local3, 1))      //  Number type is 1
6946                        {   Return (0x9E)   }
6947
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)
6953
6954                        //  return 0x90 + loop index
6955                        Return (Local4)
6956                    }
6957
6958                    Increment (Local0)
6959                }   //  While (Local0 < 5)
6960
6961                Store ("DerefOf(Index(LocalBuffer,,)) PASS", Debug)
6962
6963                Return (0)  //  Pass
6964            }   //  LCLB control method: test Index(Local#) where Local# is buffer
6965
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
6973
6974                Name (PKG, Package ()   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
6975
6976                //  save PKG into Local1
6977                Store (PKG, Local1)
6978
6979                //  save Local2 object type value into Local3
6980                Store (ObjectType (Local1), Local3)
6981
6982                //  validate Local1 is a Package
6983                If (LNotEqual (Local3, 4))      //  Package type is 4
6984                    {   Return (0x8F)   }
6985
6986
6987                Store (0, Local0)
6988                While (LLess (Local0, 5))
6989                {   //  While (Local0 < 5)
6990                    //  Local2 = Local1[Local0]
6991                    Store (DerefOf (Index (Local1, Local0, )), Local2)
6992
6993                    //  save Local2 object type value into Local3
6994                    Store (ObjectType (Local2), Local3)
6995
6996                    //  validate Local2 is a Number
6997                    If (LNotEqual (Local3, 1))      //  Number type is 1
6998                        {   Return (0x8E)   }
6999
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)
7005
7006                        //  return 0x80 + loop index
7007                        Return (Local4)
7008                    }
7009
7010                    Increment (Local0)
7011                }   //  While (Local0 < 5)
7012
7013                Store ("DerefOf(Index(LocalPackage,,)) PASS", Debug)
7014
7015                Return (0)  //  Pass
7016            }   //  LCLP control method: test Index(Local#) where Local# is package
7017
7018            Method (TEST)
7019            {
7020
7021                Store ("++++++++ IndexOp3 Test", Debug)
7022
7023                //  store _BIF package return value into Local0
7024                Store (\_SB.C154._BIF, Local0)
7025
7026                //  save Local0 object type value into Local1
7027                Store (ObjectType (Local0), Local1)
7028
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)
7038
7039                //  save LCLB control method return value into Local2
7040                Store (LCLB, Local2)
7041                If (LNotEqual (Local2, 0))
7042                    {   Return (Local2) }   //  return failure code
7043
7044                //  save LCLP control method return value into Local2
7045                Store (LCLP, Local2)
7046                If (LNotEqual (Local2, 0))
7047                    {   Return (Local2) }   //  return failure code
7048
7049                Return (0)  //  Pass
7050            }   //  TEST
7051        }   //  IDX3:   Test device name
7052    }   //  _SB system bus
7053
7054//
7055// MTL developed test to exercise Indexes into buffers
7056//
7057    Device(IDX7)
7058    {
7059
7060        Name (PKG4, Package() {
7061                0x2,
7062                "A short string",
7063                Buffer() {0xA, 0xB, 0xC, 0xD},
7064                0x1234,
7065                Package() {IDX7, 0x3}
7066                })
7067
7068        //
7069        // Generic Test method
7070        //
7071        // This test returns 0xE (14) - ObjectType = Buffer Field
7072        Method(TST1,, Serialized)
7073        {
7074            Name (DEST, Buffer ()                           //  62 characters plus NULL
7075                {"Destination buffer that is longer than the short source buffer"})
7076
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))
7081            {
7082                Return(0)
7083            }
7084            Else
7085            {
7086                Return(0x1)
7087            }
7088
7089        }
7090
7091        Method(TST2,, Serialized)
7092        {
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))
7097            {
7098                Return(0)
7099            }
7100            Else
7101            {
7102                Return(0x2)
7103            }
7104
7105
7106        }
7107
7108        Method(TST3,, Serialized)
7109        {
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))
7114            {
7115                Return(0)
7116            }
7117            Else
7118            {
7119                Return(0x3)
7120            }
7121
7122        }
7123
7124        Method(TST4)
7125        {
7126            // Index (PKG4, 0) is a Number
7127            Store (Index (PKG4, 0), Local0)
7128            Store (ObjectType(Local0), Local1)
7129            If (LEqual(Local1, 0x1))
7130            {
7131                Return(0)
7132            }
7133            Else
7134            {
7135                Return(0x4)
7136            }
7137
7138        }
7139
7140        Method(TST5)
7141        {
7142            // Index (PKG4, 1) is a String
7143            Store (Index (PKG4, 1), Local0)
7144            Store (ObjectType(Local0), Local1)
7145            If (LEqual(Local1, 0x2))
7146            {
7147                Return(0)
7148            }
7149            Else
7150            {
7151                Return(0x5)
7152            }
7153
7154        }
7155
7156        Method(TST6)
7157        {
7158            // Index (PKG4, 2) is a Buffer
7159            Store (Index (PKG4, 2), Local0)
7160            Store (ObjectType(Local0), Local1)
7161            If (LEqual(Local1, 0x3))
7162            {
7163                Return(0)
7164            }
7165            Else
7166            {
7167                Return(0x6)
7168            }
7169
7170        }
7171
7172        Method(TST7)
7173        {
7174            // Index (PKG4, 3) is a Number
7175            Store (Index (PKG4, 3), Local0)
7176            Store (ObjectType(Local0), Local1)
7177            If (LEqual(Local1, 0x1))
7178            {
7179                Return(0)
7180            }
7181            Else
7182            {
7183                Return(0x7)
7184            }
7185
7186        }
7187
7188        Method(TST8)
7189        {
7190            // Index (PKG4, 4) is a Package
7191            Store (Index (PKG4, 4), Local0)
7192            Store (ObjectType(Local0), Local1)
7193            If (LEqual(Local1, 0x4))
7194            {
7195                Return(0)
7196            }
7197            Else
7198            {
7199                Return(0x8)
7200            }
7201
7202        }
7203
7204        Method(TST9)
7205        {
7206            // DerefOf (Index (PKG4, 0)) is a Number
7207            Store (DerefOf (Index (PKG4, 0)), Local0)
7208            If (LEqual(Local0, 0x2))
7209            {
7210                Return(0)
7211            }
7212            Else
7213            {
7214                Return(0x9)
7215            }
7216
7217        }
7218
7219        Method(TSTA)
7220        {
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))
7225            {
7226                Return(0)
7227            }
7228            Else
7229            {
7230                Return(0xA)
7231            }
7232
7233        }
7234
7235        Method(TSTB)
7236        {
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))
7241            {
7242                Return(0)
7243            }
7244            Else
7245            {
7246                Return(0xB)
7247            }
7248
7249        }
7250
7251        Method(TSTC)
7252        {
7253            // DerefOf (Index (PKG4, 3)) is a Number
7254            Store (DerefOf (Index (PKG4, 3)), Local0)
7255            If (LEqual(Local0, 0x1234))
7256            {
7257                Return(0)
7258            }
7259            Else
7260            {
7261                Return(0xC)
7262            }
7263
7264        }
7265
7266        Method(TSTD)
7267        {
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))
7272            {
7273                Return(0)
7274            }
7275            Else
7276            {
7277                Return(0xD)
7278            }
7279
7280        }
7281
7282        Method(TSTE)
7283        {
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))
7289            {
7290                Return(0)
7291            }
7292            Else
7293            {
7294                Return(0xE)
7295            }
7296
7297        }
7298
7299        Method (TSTF,, Serialized)
7300        {
7301            Name (SRCB, Buffer (12) {}) //  12 characters
7302            Store ("Short Buffer", SRCB)
7303
7304            Name (DEST, Buffer ()                       //  62 characters plus NULL
7305                {"Destination buffer that is longer than the short source buffer"})
7306
7307            //  overwrite DEST contents, starting at buffer position 2
7308            Store (SRCB, Index (DEST, 2))
7309
7310            //
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)
7314
7315            If (LNotEqual (Local0, 0x72))       //  'r'
7316            {
7317                //  DEST element does not match the value from SRCB
7318                Return(Or(Local0, 0x1000))
7319            }
7320
7321            Return(0)
7322        }
7323
7324        Method (TSTG,, Serialized)
7325        {
7326
7327            Name (SRCB, Buffer (12) {}) //  12 characters
7328            Store ("Short Buffer", SRCB)
7329
7330            Name (DEST, Buffer ()                       //  62 characters plus NULL
7331                {"Destination buffer that is longer than the short source buffer"})
7332
7333            //  overwrite DEST contents, starting at buffer position 2
7334            Store (SRCB, Index (DEST, 2))
7335
7336            //
7337            // The next element of DEST should be unchanged
7338            //
7339            Store (DerefOf (Index (DEST, 3)), Local0)
7340
7341            If (LNotEqual (Local0, 0x74))       //  't'
7342            {
7343                //  DEST has been changed
7344                Return(Or(Local0, 0x2000))
7345            }
7346
7347            //
7348            // The next element of DEST should be unchanged
7349            //
7350            Store (DerefOf (Index (DEST, 4)), Local0)
7351
7352            If (LNotEqual (Local0, 0x69))       //  'i'
7353            {
7354                //  DEST has been changed
7355                Return(Or(Local0, 0x2100))
7356            }
7357
7358            //
7359            // The next element of DEST should be unchanged
7360            //
7361            Store (DerefOf (Index (DEST, 5)), Local0)
7362
7363            If (LNotEqual (Local0, 0x6E))       //  'n'
7364            {
7365                //  DEST has been changed
7366                Return(Or(Local0, 0x2200))
7367            }
7368
7369            //
7370            // The next element of DEST should be unchanged
7371            //
7372            Store (DerefOf (Index (DEST, 6)), Local0)
7373
7374            If (LNotEqual (Local0, 0x61))       //  'a'
7375            {
7376                //  DEST has been changed
7377                Return(Or(Local0, 0x2300))
7378            }
7379
7380            //
7381            // The next element of DEST should be unchanged
7382            //
7383            Store (DerefOf (Index (DEST, 7)), Local0)
7384
7385            If (LNotEqual (Local0, 0x74))       //  't'
7386            {
7387                //  DEST has been changed
7388                Return(Or(Local0, 0x2400))
7389            }
7390
7391            //
7392            //  Verify DEST elements beyond end of SRCB buffer copy
7393            //  have not been changed
7394            Store (DerefOf (Index (DEST, 14)), Local0)
7395
7396            If (LNotEqual (Local0, 0x66))       // 'f'
7397            {
7398                //  DEST has been changed
7399                Return(Or(Local0, 0x2400))
7400            }
7401
7402            Return(0)
7403        }
7404
7405        //
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
7408        //
7409        Method (TSTH,, Serialized)
7410        {
7411            // Create a Destination Buffer
7412            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7413
7414            // Store a number > UINT8 into an index of the buffer
7415            Store (0x12345678, Index(DBUF, 2))
7416
7417            // Check the results
7418            Store (DerefOf (Index (DBUF, 2)), Local0)
7419            If (LNotEqual (Local0, 0x78))   // 0x78
7420            {
7421                Return(Or(Local0, 0x3000))
7422            }
7423
7424            Store (DerefOf (Index (DBUF, 3)), Local0)
7425            If (LNotEqual (Local0, 0x64))   // 'd'
7426            {
7427                Return(Or(Local0, 0x3100))
7428            }
7429
7430            Store (DerefOf (Index (DBUF, 4)), Local0)
7431            If (LNotEqual (Local0, 0x65))   // 'e'
7432            {
7433                Return(Or(Local0, 0x3200))
7434            }
7435
7436            Store (DerefOf (Index (DBUF, 5)), Local0)
7437            If (LNotEqual (Local0, 0x66))   // 'f'
7438            {
7439                Return(Or(Local0, 0x3300))
7440            }
7441
7442            Return(0)
7443        }
7444
7445        Method (TSTI,, Serialized)
7446        {
7447            // Create a Destination Buffer
7448            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7449
7450            // Store a String into an index of the buffer
7451            Store ("ABCDEFGH", Index(DBUF, 2))
7452
7453            // Check the results
7454            Store (DerefOf (Index (DBUF, 2)), Local0)
7455            If (LNotEqual (Local0, 0x48))   // 'H'
7456            {
7457                Return(Or(Local0, 0x4000))
7458            }
7459
7460            Store (DerefOf (Index (DBUF, 3)), Local0)
7461            If (LNotEqual (Local0, 0x64))   // 'd'
7462            {
7463                Return(Or(Local0, 0x4100))
7464            }
7465
7466            Store (DerefOf (Index (DBUF, 4)), Local0)
7467            If (LNotEqual (Local0, 0x65))   // 'e'
7468            {
7469                Return(Or(Local0, 0x4200))
7470            }
7471
7472            Store (DerefOf (Index (DBUF, 5)), Local0)
7473            If (LNotEqual (Local0, 0x66))   // 'f'
7474            {
7475                Return(Or(Local0, 0x4300))
7476            }
7477
7478            Return(0)
7479        }
7480
7481        Method(TSTJ,, Serialized)
7482        {
7483            // Create a Destination Buffer
7484            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7485
7486            // Store a number > UINT8 into an index of the buffer
7487            Store (0x1234, Index(DBUF, 2))
7488
7489            // Check the results
7490            Store (DerefOf (Index (DBUF, 2)), Local0)
7491            If (LNotEqual (Local0, 0x34))   // 0x34
7492            {
7493                Return(Or(Local0, 0x3000))
7494            }
7495
7496            Store (DerefOf (Index (DBUF, 3)), Local0)
7497            If (LNotEqual (Local0, 0x64))   // 'd'
7498            {
7499                Return(Or(Local0, 0x3100))
7500            }
7501
7502            Store (DerefOf (Index (DBUF, 4)), Local0)
7503            If (LNotEqual (Local0, 0x65))   // 'e'
7504            {
7505                Return(Or(Local0, 0x3200))
7506            }
7507
7508            Store (DerefOf (Index (DBUF, 5)), Local0)
7509            If (LNotEqual (Local0, 0x66))   // 'f'
7510            {
7511                Return(Or(Local0, 0x3300))
7512            }
7513
7514            Return(0)
7515        }
7516
7517        Method(TSTK,, Serialized)
7518        {
7519            // Create a Destination Buffer
7520            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7521
7522            // Store a number > UINT8 into an index of the buffer
7523            Store (0x123456, Index(DBUF, 2))
7524
7525            // Check the results
7526            Store (DerefOf (Index (DBUF, 2)), Local0)
7527            If (LNotEqual (Local0, 0x56))   // 0x56
7528            {
7529                Return(Or(Local0, 0x3000))
7530            }
7531
7532            Store (DerefOf (Index (DBUF, 3)), Local0)
7533            If (LNotEqual (Local0, 0x64))   // 'd'
7534            {
7535                Return(Or(Local0, 0x3100))
7536            }
7537
7538            Store (DerefOf (Index (DBUF, 4)), Local0)
7539            If (LNotEqual (Local0, 0x65))   // 'e'
7540            {
7541                Return(Or(Local0, 0x3200))
7542            }
7543
7544            Store (DerefOf (Index (DBUF, 5)), Local0)
7545            If (LNotEqual (Local0, 0x66))   // 'f'
7546            {
7547                Return(Or(Local0, 0x3300))
7548            }
7549
7550            Return(0)
7551        }
7552
7553        Method(TSTL,, Serialized)
7554        {
7555            // Create a Destination Buffer
7556            Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7557
7558            // Store a number > UINT8 into an index of the buffer
7559            Store (0x12, Index(DBUF, 2))
7560
7561            // Check the results
7562            Store (DerefOf (Index (DBUF, 2)), Local0)
7563            If (LNotEqual (Local0, 0x12))   // 0x12
7564            {
7565                Return(Or(Local0, 0x3000))
7566            }
7567
7568            Store (DerefOf (Index (DBUF, 3)), Local0)
7569            If (LNotEqual (Local0, 0x64))   // 'd'
7570            {
7571                Return(Or(Local0, 0x3100))
7572            }
7573
7574            Store (DerefOf (Index (DBUF, 4)), Local0)
7575            If (LNotEqual (Local0, 0x65))   // 'e'
7576            {
7577                Return(Or(Local0, 0x3200))
7578            }
7579
7580            Store (DerefOf (Index (DBUF, 5)), Local0)
7581            If (LNotEqual (Local0, 0x66))   // 'f'
7582            {
7583                Return(Or(Local0, 0x3300))
7584            }
7585
7586            Return(0)
7587        }
7588
7589        Method(TEST)
7590        {
7591            Store ("++++++++ IndexOp7 Test", Debug)
7592
7593            Store(TST1(), Local0)
7594            if (LGreater (Local0, 0))
7595            {
7596                Return(Local0)
7597            }
7598
7599            Store(TST2(), Local0)
7600            if (LGreater (Local0, 0))
7601            {
7602                Return(Local0)
7603            }
7604
7605            Store(TST3(), Local0)
7606            if (LGreater (Local0, 0))
7607            {
7608                Return(Local0)
7609            }
7610
7611            Store(TST4(), Local0)
7612            if (LGreater (Local0, 0))
7613            {
7614                Return(Local0)
7615            }
7616
7617            Store(TST5(), Local0)
7618            if (LGreater (Local0, 0))
7619            {
7620                Return(Local0)
7621            }
7622
7623            Store(TST6(), Local0)
7624            if (LGreater (Local0, 0))
7625            {
7626                Return(Local0)
7627            }
7628
7629            Store(TST7(), Local0)
7630            if (LGreater (Local0, 0))
7631            {
7632                Return(Local0)
7633            }
7634
7635            Store(TST8(), Local0)
7636            if (LGreater (Local0, 0))
7637            {
7638                Return(Local0)
7639            }
7640
7641            Store(TST9(), Local0)
7642            if (LGreater (Local0, 0))
7643            {
7644                Return(Local0)
7645            }
7646
7647            Store(TSTA(), Local0)
7648            if (LGreater (Local0, 0))
7649            {
7650                Return(Local0)
7651            }
7652
7653            Store(TSTB(), Local0)
7654            if (LGreater (Local0, 0))
7655            {
7656                Return(Local0)
7657            }
7658
7659            Store(TSTC(), Local0)
7660            if (LGreater (Local0, 0))
7661            {
7662                Return(Local0)
7663            }
7664
7665            Store(TSTD(), Local0)
7666            if (LGreater (Local0, 0))
7667            {
7668                Return(Local0)
7669            }
7670
7671            Store(TSTE(), Local0)
7672            if (LGreater (Local0, 0))
7673            {
7674                Return(Local0)
7675            }
7676
7677    /* No longer ACPI compliant */
7678    /*
7679            Store(TSTF(), Local0)
7680            if (LGreater (Local0, 0))
7681            {
7682                Return(Local0)
7683            }
7684    */
7685
7686            Store(TSTG(), Local0)
7687            if (LGreater (Local0, 0))
7688            {
7689                Return(Local0)
7690            }
7691
7692            Store(TSTH(), Local0)
7693            if (LGreater (Local0, 0))
7694            {
7695                Return(Local0)
7696            }
7697
7698    /* No longer ACPI compliant */
7699    /*
7700            Store(TSTI(), Local0)
7701            if (LGreater (Local0, 0))
7702            {
7703                Return(Local0)
7704            }
7705    */
7706            Store(TSTJ(), Local0)
7707            if (LGreater (Local0, 0))
7708            {
7709                Return(Local0)
7710            }
7711
7712            Store(TSTK(), Local0)
7713            if (LGreater (Local0, 0))
7714            {
7715                Return(Local0)
7716            }
7717
7718            Store(TSTL(), Local0)
7719            if (LGreater (Local0, 0))
7720            {
7721                Return(Local0)
7722            }
7723
7724            Return(Local0)
7725
7726        }
7727
7728    } // Device(IDX7)
7729
7730//
7731// test MatchOp.asl
7732//
7733//  MatchOp test cases that utilize nested DerefOf(Index(...)) to validate
7734//  MatchOp, DerefOfOp, and IndexOp of nested packages.
7735//
7736    Device (MTCH)
7737    {
7738
7739        Method (TEST,, Serialized)
7740        {
7741            Store ("++++++++ MatchOp Test", Debug)
7742
7743            Name (TIM0, Package ()
7744                {
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}
7753                })  //  TIM0
7754
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)
7761
7762
7763            //  validate PIO0 value
7764            Store (PIO0, Local3)
7765
7766            //  save Local3 object type value into Local2
7767            Store (ObjectType (Local3), Local2)
7768
7769            //  validate Local3 is a Number
7770            If (LNotEqual (Local2, 1))  //  Number type is 1
7771                {   Return (2)  }   //  failure
7772
7773            //  validate Local3 Number value
7774            If (LNotEqual (Local3, 0xFFFFFFFF)) //  Number value 0xFFFFFFFF
7775                {   Return (3)  }   //  failure
7776
7777            Store ("DWordField PASS", Debug)
7778
7779
7780            Store (0, Local5)
7781            Store (Match (DerefOf (Index (TIM0, 1, )), MLE, Local5, MTR, 0, 0), Local6)
7782
7783            //  save Local6 object type value into Local2
7784            Store (ObjectType (Local6), Local2)
7785
7786            //  validate Local6 is a Number
7787            If (LNotEqual (Local2, 1))  //  Number type is 1
7788                {   Return (4)  }   //  failure
7789
7790            Store ("Match(DerefOf(Index(TIM0,1)),... PASS", Debug)
7791
7792
7793            //  validate following produces a nested package to validate
7794            //  that MatchOp did not corrupt SearchPackage (TIM0)
7795            Store (DerefOf (Index (TIM0, 1, )), Local4)
7796
7797            //  save Local4 object type value into Local2
7798            Store (ObjectType (Local4), Local2)
7799
7800            //  validate Local4 is a Package
7801            If (LNotEqual (Local2, 4))  //  Package type is 4
7802                {   Return (5)  }   //  failure
7803
7804            Store ("DerefOf(Index(TIM0,1)),... PASS", Debug)
7805
7806
7807            And (Match (DerefOf (Index (TIM0, 0, )), MGE, PIO0, MTR, 0, 0), 3, Local0)
7808
7809            //  save Local0 object type value into Local2
7810            Store (ObjectType (Local0), Local2)
7811
7812            //  validate Local0 is a Number
7813            If (LNotEqual (Local2, 1))  //  Number type is 1
7814                {   Return (6)  }   //  failure
7815
7816            //  validate Local0 Number value
7817            If (LNotEqual (Local0, 3))  //  Number value 3
7818                {   Return (7)  }   //  failure
7819
7820            Store ("And(Match(DerefOf(Index(TIM0,0)),... PASS", Debug)
7821
7822
7823            //  again, validate following produces a nested package
7824            Store (DerefOf (Index (TIM0, 1, )), Local4)
7825
7826            //  save Local4 object type value into Local2
7827            Store (ObjectType (Local4), Local2)
7828
7829            //  validate Local4 is a Package
7830            If (LNotEqual (Local2, 4))  //  Package type is 4
7831                {   Return (8)  }   //  failure
7832
7833            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7834
7835
7836            //  again, validate following produces a nested package
7837            Store (DerefOf (Index (TIM0, 1, )), Local4)
7838
7839            //  save Local4 object type value into Local2
7840            Store (ObjectType (Local4), Local2)
7841
7842            //  validate Local4 is a Package
7843            If (LNotEqual (Local2, 4))  //  Package type is 4
7844                {   Return (9)  }   //  failure
7845
7846            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7847
7848
7849            //  test nested DerefOf(Index) operators
7850            Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
7851
7852            //  save Local1 object type value into Local2
7853            Store (ObjectType (Local1), Local2)
7854
7855            //  validate Local1 is a Number
7856            If (LNotEqual (Local2, 1))  //  Number type is 1
7857                {   Return (10) }   //  failure
7858
7859            //  zero indicates pass, non-zero is an error code
7860            If (LNotEqual (Local1, 0))
7861                {   Return (11) }   //  failure
7862
7863            Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS", Debug)
7864
7865
7866            //  again, validate following produces a nested package
7867            Store (DerefOf (Index (TIM0, 1, )), Local4)
7868
7869            //  save Local4 object type value into Local2
7870            Store (ObjectType (Local4), Local2)
7871
7872            //  validate Local4 is a Package
7873            If (LNotEqual (Local2, 4))  //  Package type is 4
7874                {   Return (12) }   //  failure
7875
7876            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7877
7878
7879            //  retest nested DerefOf(Index) operators
7880            Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
7881
7882            //  save Local1 object type value into Local2
7883            Store (ObjectType (Local1), Local2)
7884
7885            //  validate Local1 is a Number
7886            If (LNotEqual (Local2, 1))  //  Number type is 1
7887                {   Return (13) }   //  failure
7888
7889            //  zero indicates pass, non-zero is an error code
7890            If (LNotEqual (Local1, 0))
7891                {   Return (14) }   //  failure
7892
7893            Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again", Debug)
7894
7895
7896            //  again, validate following produces a nested package
7897            Store (DerefOf (Index (TIM0, 1, )), Local4)
7898
7899            //  save Local4 object type value into Local2
7900            Store (ObjectType (Local4), Local2)
7901
7902            //  validate Local4 is a Package
7903            If (LNotEqual (Local2, 4))  //  Package type is 4
7904                {   Return (15) }   //  failure
7905
7906            Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7907
7908
7909            Return (0)  //  pass
7910        }   //  TEST
7911    }   // MTCH
7912
7913//
7914// test WhileBrk.asl
7915//
7916//  This code tests the Break term and While term
7917//
7918//  Syntax of Break term
7919//      BreakTerm := Break
7920//  The break operation causes the current package execution to complete.
7921//
7922//  Syntax of While Term
7923//      WhileTerm   := While(
7924//          Predicate   //TermArg=>Integer
7925//      ) {TermList}
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.
7929//
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
7932//  a halt.
7933//
7934    Device (WHLB)
7935    {
7936        Name (CNT0, 0)
7937        Name (CNT1, 0)
7938
7939        Method (TEST)
7940        {
7941            //  Check Break statement nested in If nested in While nested in
7942            //  While only exits inner-most While loop
7943            Store (0, CNT0)
7944
7945            While (LLess (CNT0, 4))
7946            {
7947                Store (0, CNT1)
7948                While (LLess (CNT1, 10))
7949                {
7950                    if (LEqual (CNT1, 1))
7951                    {
7952                        Break       //  exit encompassing loop
7953                    }
7954
7955                    Increment (CNT1)
7956                }
7957
7958                If (LNotEqual (CNT1, 1))
7959                {
7960                    //  failure
7961                    Return (7)
7962                }
7963
7964                Increment (CNT0)
7965            }
7966
7967            //  Verify Break only exited inner-most While loop
7968
7969            If (LNotEqual (CNT0, 4))
7970            {
7971                //  failure
7972                Return (8)
7973            }
7974
7975            Store ("While/While/If/Break PASS", Debug)
7976
7977            Store ("++++++++ WhileBrk Test", Debug)
7978
7979            //  Check Break statement nested in While
7980            Store (0, CNT0)
7981
7982            While (LLess (CNT0, 10))
7983            {
7984                Break       //  exit encompassing package
7985                Increment (CNT0)
7986            }
7987
7988            If (LNotEqual (CNT0, 0))    //  instruction after Break executed
7989            {
7990                Return (4)
7991            }
7992
7993
7994            Store (0, CNT0)
7995
7996            //  Test While Term
7997            While (LLess (CNT0, 10))
7998            {
7999                Increment (CNT0)
8000            }
8001
8002            //  Check if the while loop was executed until the condition is satisfied.
8003            If (LNotEqual (CNT0, 10))
8004            {
8005                Return (1)
8006            }
8007
8008
8009            //  While loop in a reverse order
8010            While (LGreater (CNT0, 0))
8011            {
8012                Decrement (CNT0)
8013            }
8014
8015            //  Check if the while loop was executed until the condition is satisfied.
8016            If (LNotEqual (CNT0, 0))
8017            {
8018                Return (2)
8019            }
8020
8021
8022            Store ("While/Break PASS", Debug)
8023
8024
8025            //  Check Break statement nested in If nested in While
8026            Store (0, CNT0)
8027
8028            While (LLess (CNT0, 10))
8029            {
8030                if (LEqual (CNT0, 5))
8031                {
8032                    Break       //  exit encompassing Package (If)
8033
8034                    //  if we execute the next instruction,
8035                    //  Break did not exit the loop
8036                    Store (20, CNT0)    //  exit While loop with value larger
8037                                            //  than above
8038                }
8039
8040                Increment (CNT0)    //  check if Break exited both If and While
8041            }   //  While
8042
8043            If (LGreater (CNT0, 19))
8044            {   //  instruction after Break inside IfOp executed
8045                Return (5)
8046            }
8047
8048            //
8049            // Break will exit out of the while loop, therefore
8050            //  the CNT0 counter should still Increment until 5
8051            //
8052            If (LNotEqual (CNT0, 5))
8053            {   //  instruction after Break inside WhileOp executed
8054                Return (6)
8055            }
8056            Store ("While/If/Break PASS", Debug)
8057
8058
8059            //  All the conditions passed
8060            Return (0)
8061        }   //  TEST
8062    }   //  WHLB
8063
8064
8065//
8066// test IndexOp2.asl
8067//
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.
8071//
8072// MTL NOTE: This test has been modified slightly from the original test
8073//  to take into account ACPI specification limitations.
8074//
8075    Scope (\_SB)    //  System Bus
8076    {   //  _SB system bus
8077
8078        Device (MEM)
8079        {   //  MEM
8080            Name (_HID, 0x010CD041)
8081            Name (_STA, 0x0F)
8082
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
8089                SMD3,   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
8096
8097            OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000)
8098            Field (SRAM, AnyAcc, NoLock, Preserve)
8099            {   //  Field:  SRAM overlay
8100                    ,   0x34000,    //  skip
8101                IEAX,   0x20,
8102                IEBX,   0x20,
8103                IECX,   0x20,
8104                IEDX,   0x20,
8105                IESI,   0x20,
8106                IEDI,   0x20,
8107                IEBP,   0x20,
8108                    ,   0x20,
8109                OEAX,   0x20,
8110                OEBX,   0x20,
8111                OECX,   0x20,
8112                OEDX,   0x20,
8113                OESI,   0x20,
8114                OEDI,   0x20,
8115                OEBP,   0x20,
8116                    ,   0x618,  //  skip
8117                ACST,   1,
8118                BES1,   1,
8119                BES2,   1,
8120                    ,   5,          //  skip
8121                BMN1,   0x68,
8122                BSN1,   0x58,
8123                BTP1,   0x48,
8124                BPU1,   0x20,
8125                BDC1,   0x20,
8126                BLF1,   0x20,
8127                BTC1,   0x20,
8128                BDV1,   0x20,
8129                BST1,   0x20,
8130                BPR1,   0x20,
8131                BRC1,   0x20,
8132                BPV1,   0x20,
8133                    ,   0x20,
8134                BCW1,   0x20,
8135                BCL1,   0x20,
8136                BG11,   0x20,
8137                BG21,   0x20,
8138                BOI1,   0x20,
8139                    ,   0x530,  //  skip
8140                BMN2,   0x68,
8141                BSN2,   0x58,
8142                BTP2,   0x48,
8143                BPU2,   0x20,
8144                BDC2,   0x20,
8145                BLF2,   0x20,
8146                BTC2,   0x20,
8147                BDV2,   0x20,
8148                BST2,   0x20,
8149                BPR2,   0x20,
8150                BRC2,   0x20,
8151                BPV2,   0x20,
8152                    ,   0x20,
8153                BCW2,   0x20,
8154                BCL2,   0x20,
8155                BG12,   0x20,
8156                BG22,   0x20,
8157                BOI2,   0x20,
8158                    ,   0x518,  //  skip
8159                AC01,   0x10,
8160                AC11,   0x10,
8161                PSV1,   0x10,
8162                CRT1,   0x10,
8163                TMP1,   0x10,
8164                AST1,   0x10,
8165                AC21,   0x10,
8166                AC31,   0x10,
8167                AC02,   0x10,
8168                AC12,   0x10,
8169                PSV2,   0x10,
8170                CRT2,   0x10,
8171                TMP2,   0x10,
8172                AST2,   0x10,
8173                AC22,   0x10,
8174                AC32,   0x10,
8175                AC03,   0x10,
8176                AC13,   0x10,
8177                PSV3,   0x10,
8178                CRT3,   0x10,
8179                TMP3,   0x10,
8180                AST3,   0x10,
8181                AC23,   0x10,
8182                AC33,   0x10,
8183                    ,   0x80,       //  skip
8184                TMPF,   0x10,
8185                    ,   0x570,  //  skip
8186                FANH,   1,
8187                FANL,   7,
8188                TF11,   1,
8189                TF21,   1,
8190                TF31,   1,
8191                    ,   1,
8192                TF10,   1,
8193                TF20,   1,
8194                TF30,   1,
8195                    ,   1,
8196                TP11,   1,
8197                TP21,   1,
8198                TP31,   1,
8199                    ,   0x6D,   //  109
8200                GP50,   1,
8201                GP51,   1,
8202                GP52,   1,
8203                GP53,   1,
8204                    ,   4,
8205                GP60,   1,
8206                GP61,   1,
8207                GP62,   1,
8208                GP63,   1,
8209                GP64,   1,
8210                GP65,   1,
8211                GP66,   1,
8212                    ,   1,
8213                GP70,   1,
8214                GP71,   1,
8215                GP72,   1,
8216                GP73,   1,
8217                GP74,   1,
8218                GP75,   1,
8219                GP76,   1,
8220                    ,   1,
8221                WED0,   1,
8222                WED1,   1,
8223                WED2,   1,
8224                WED3,   1,
8225                WED4,   1,
8226                    ,   3,
8227                SBL0,   1,
8228                SBL1,   1,
8229                SBL2,   1,
8230                SBL3,   1,
8231                    ,   4,
8232                LIDS,   1,
8233                VALF,   1,
8234                    ,   2,
8235                DCKI,   1,
8236                DCKF,   1,
8237                BT1F,   1,
8238                BT2F,   1,
8239                    ,   0x7D0,  //  skip
8240                HKCD,   8,
8241                    ,   8,
8242                DLID,   0x20,
8243                DSRN,   0x20,
8244                    ,   0x20,
8245                BDID,   0x20,
8246                DSPW,   1,
8247                VGAF,   1,
8248                VWE0,   1,
8249                VWE1,   1,
8250                PPSC,   1,
8251                SPSC,   1,
8252                EWLD,   1,
8253                EWPS,   1,
8254                    ,   0x1768, //  skip
8255                PRES,   0x8000
8256            }   //  Field:  SRAM overlay
8257        }   //  MEM
8258
8259        Device (BAT1)
8260        {   //  BAT1
8261            Name (_HID, EISAID ("PNP0C0A"))     //  Control Method Battey ID
8262            Name (_UID, 1)
8263            Name (_PCL, Package (1) {\_SB})
8264
8265            Method (_STA)
8266            {   //  _STA
8267                If (\_SB.MEM.BES1)
8268                    {   Return (0x1F)   }   //  battery present
8269                Else
8270                    {   Return (0x0F)   }   //  battery not present
8271            }   //  _STA
8272
8273            Method (_BIF,, Serialized)
8274            {   //  _BIF
8275                Name (BUFR, Package (13)    {})
8276
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))
8290
8291                Return (BUFR)
8292            }   //  _BIF
8293        }   //  BAT1
8294
8295        Device (IDX2)
8296        {
8297            Method (B2IB,, Serialized)
8298            {   //  B2IB:   store from Buffer into Index'ed Buffer
8299
8300                Name (SRCB, Buffer ()   {"Short Buffer"})   //  12 characters plus NULL
8301
8302                Name (DEST, Buffer ()                           //  62 characters plus NULL
8303                    {"Destination buffer that is longer than the short source buffer"})
8304
8305
8306                //  verify object type returned by Index(Buffer,Element,)
8307
8308                Store (Index (DEST, 2, ), Local1)
8309                Store (ObjectType (Local1), Local2)
8310
8311                If (LNotEqual (Local2, 14))     //  Buffer Field is type 14
8312                {
8313                    //  Local2 indicates Local1 is not a Buffer Field
8314
8315                    Return (0x61)
8316                }
8317
8318                //  verify object type and value returned by DerefOf(Index(Buffer,Element,))
8319                //  should return Number containing element value
8320
8321                Store (DerefOf (Local1), Local3)
8322                Store (ObjectType (Local3), Local4)
8323
8324                If (LNotEqual (Local4, 1))          //  Number is type 1
8325                {
8326                    //  Local2 indicates Local1 is not a Number
8327                    Return (0x62)
8328                }
8329                Else
8330                {
8331                    If (LNotEqual (Local3, 0x73))       //  expect 's' element from DEST
8332                    {
8333                        Return (0x63)
8334                    }
8335                }
8336
8337                Store ("DerefOf(Index(Buffer,,)) PASS", Debug)
8338
8339
8340                //
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
8345                //
8346                // Overwrite DEST contents, at buffer position 2 [only]
8347
8348                Store (SRCB, Index (DEST, 2, ))
8349
8350                //
8351                // Check that the next byte is not changed
8352                //
8353                Store (DerefOf (Index (DEST, 3, )), Local0)
8354                If (LNotEqual (Local0, 0x74))       //  't'
8355                {
8356                    //  DEST element is not matching original value
8357                    If (LEqual (Local0, 0x68))
8358                    {
8359                        //  DEST element was altered to 'h'
8360                        Return (0x68)
8361                    }
8362                    Else
8363                    {
8364                        // DEST element is an unknown value
8365                        Return (0x69)
8366                    }
8367                }
8368
8369                //
8370                // Check that the elements beyond the SRCB buffer copy
8371                //  have not been altered.
8372                //
8373                Store (DerefOf (Index (DEST, 14)), Local0)
8374
8375                //
8376                // This should be an 'f'.
8377                //
8378                If (LNotEqual (Local0, 0x66))
8379                {
8380                    //  DEST element was zero'd by buffer copy
8381                    If (LEqual (Local0, 0))
8382                    {
8383                        //  DEST element is zero
8384                        Return (0x6A)
8385                    }
8386                    Else
8387                    {
8388                        //  DEST element is unknown value
8389                        Return (0x6B)
8390                    }
8391                }
8392
8393                Store ("Store(SRCB,Index(Buffer,,)) PASS", Debug)
8394
8395                //
8396                //  verify altering SRCB does NOT alter DEST
8397                //
8398                Store (0x6A, Index (SRCB, 1))   //  SRCB = "Sjort Buffer"
8399
8400                Store (DerefOf (Index (SRCB, 1)), Local0)
8401
8402                If (LNotEqual (Local0, 0x6A))       //  'j'
8403                {
8404                    //  SRCB element is unaltered
8405                    Return (0x71)
8406                }
8407
8408                Store (DerefOf (Index (DEST, 3)), Local0) // DEST = "Destination buffer that...
8409
8410                If (LNotEqual (Local0, 0x74))       //  't'
8411                {
8412                    //  DEST element is altered
8413                    If (LEqual (Local0, 0x6A))  //  'j'
8414                    {
8415                        //  SRCB change altered DEST element
8416                        Return (0x72)
8417                    }
8418                    Else
8419                    {
8420                        //  DEST element is unknown value
8421                        Return (0x73)
8422                    }
8423                }
8424
8425                //  verify altering DEST does NOT alter SRCB
8426
8427                Store (0x6B, Index (DEST, 4, )) //  DEST = "DeSkination buffer..."
8428
8429                Store (DerefOf (Index (DEST, 4, )), Local0)
8430
8431                If (LNotEqual (Local0, 0x6B))       //  'k'
8432                {
8433                    //  DEST element is unaltered
8434                    Return (0x74)
8435                }
8436
8437                Store (DerefOf (Index (SRCB, 2, )), Local0)
8438
8439                If (LNotEqual (Local0, 0x6F))       //  'o'
8440                {   //  SRC element is altered
8441                    If (LEqual (Local0, 0x6B))  //  'k'
8442                    {
8443                        //  DEST change altered SRCB element
8444                        Return (0x75)
8445                    }
8446                    Else
8447                    {
8448                        //  SRCB element is unknown value
8449                        Return (0x76)
8450                    }
8451                }
8452
8453                Store ("SRCB and DEST independent PASS", Debug)
8454
8455
8456                // verify string can be written to Index target/destination
8457                // Only FIRST byte is written
8458
8459                Store ("New Buff", Index (DEST, 2, ))   //  DEST = "DeNkination buffer..."
8460
8461                Store (DerefOf (Index (DEST, 2, )), Local0)
8462
8463                If (LNotEqual (Local0, 0x4E))       //  'N'
8464                {
8465                    //  DEST element is unaltered
8466                    Return (0x81)
8467                }
8468
8469                Store (DerefOf (Index (DEST, 6, )), Local0)
8470
8471                If (LNotEqual (Local0, 0x61))       //  'a'
8472                {
8473                    //  DEST element is unaltered
8474                    Return (0x82)
8475                }
8476
8477                Store (DerefOf (Index (DEST, 10, )), Local0)
8478
8479                If (LNotEqual (Local0, 0x6E))       //  'n'
8480                {
8481                    //  DEST element is unaltered
8482                    Return (0x83)
8483                }
8484
8485                Store ("Store(String,Index) PASS", Debug)
8486
8487
8488                Return (0)  //  pass
8489            }   //  B2IB:   store from Buffer into Index'ed Buffer
8490
8491            Method (FB2P,, Serialized)
8492            {   //  FB2P:   store from Field Buffer into Index'ed Package
8493                Name (DEST, Package (2) {})
8494
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)
8500
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))
8504
8505                //  validate DEST contents
8506                Store (DerefOf (Index (DEST, 0, )), Local0)
8507                Store (DerefOf (Index (DEST, 1, )), Local1)
8508
8509                //  verify Local0 and Local1 are Buffers
8510                Store (ObjectType (Local0), Local2)
8511                if (LNotEqual (Local2, 3))  //  Buffer type is 3
8512                {
8513                    Return (0x11)
8514                }
8515
8516                Store (ObjectType (Local1), Local3)
8517                if (LNotEqual (Local3, 3))  //  Buffer type is 3
8518                {
8519                    Return (0x12)
8520                }
8521
8522                //  validate DEST buffer contents
8523                Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 0)), Local4)
8524                If (LNotEqual (Local4, 0x67))
8525                {
8526                    Return (0x13)
8527                }
8528
8529                Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 1)), Local4)
8530                If (LNotEqual (Local4, 0x45))
8531                {
8532                    Return (0x14)
8533                }
8534
8535                Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 4)), Local4)
8536                If (LNotEqual (Local4, 0xEF))
8537                {
8538                    Return (0x15)
8539                }
8540
8541                Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 5, )), Local4)
8542                If (LNotEqual (Local4, 0xCD))
8543                {
8544                    Return (0x16)
8545                }
8546
8547                Store ("Store(Mem,PkgElement) PASS", Debug)
8548
8549
8550                //  validate changing source \_SB.MEM.SMD* does not impact DEST
8551                Store (0x12345678, \_SB.MEM.SMD0)
8552
8553                Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 0, )), Local5)
8554                If (LNotEqual (Local5, 0x67))
8555                {
8556                    Return (0x21)
8557                }
8558
8559                Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 1, )), Local5)
8560                If (LNotEqual (Local5, 0x45))
8561                {
8562                    Return (0x22)
8563                }
8564
8565                //  validate changing DEST does not impact source \_SB.MEM.SMD*
8566                Store (0x30, Index (DerefOf (Index (DEST, 0)), 0))
8567
8568                Store (DerefOf(Index (DerefOf (Index (DEST, 0)), 0)), Local5)
8569                If (LNotEqual (Local5, 0x30))
8570                {
8571                    Return (0x23)
8572                }
8573
8574                //
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
8579                //
8580                Store (\_SB.MEM.SMD0, Local5)
8581
8582                If(LNotEqual(Local5, 0x12345678))
8583                {
8584                    Return (0x24)
8585                }
8586
8587                Store ("Mem and Pkg independent PASS", Debug)
8588
8589
8590                Return (0)
8591            }   //  FB2P:   store from Field Buffer into Index'ed Package
8592
8593            Method (TEST)
8594            {
8595                Store ("++++++++ IndexOp2 Test", Debug)
8596
8597                //  store _BIF package return value into Local0
8598
8599                Store (\_SB.BAT1._BIF, Local0)
8600
8601                //  save Local0 object type value into Local1
8602                Store (ObjectType (Local0), Local1)
8603
8604                //  validate Local0 is a Package
8605                If (LNotEqual (Local1, 4))  //  Package type is 4
8606                {
8607                    //  failure
8608                    Return (2)
8609                }
8610
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)
8615
8616                //  call B2IB (store from Buffer into Index'ed Buffer)
8617                Store (B2IB, Local2)    //  Local2 is B2IB return value
8618
8619                //  save Local2 object type value into Local3
8620                Store (ObjectType (Local2), Local3)
8621
8622                //  validate Local2 is a Number
8623                If (LNotEqual (Local3, 1))  //  Number type is 1
8624                {
8625                    //  failure
8626                    Return (4)
8627                }
8628
8629                //  zero indicates pass, non-zero is an error code
8630                If (LNotEqual (Local2, 0))
8631                {
8632                    //  return B2IB error code
8633                    Return (Local2)
8634                }
8635
8636                //  call FB2P (store from Field Buffer into Index'ed Package)
8637                Store (FB2P, Local2)    //  Local2 is FB2P return value
8638
8639                //  save Local2 object type value into Local3
8640                Store (ObjectType (Local2), Local3)
8641
8642                //  validate Local2 is a Number
8643                If (LNotEqual (Local3, 1))  //  Number type is 1
8644                {
8645                    //  failure
8646                    Return (5)
8647                }
8648
8649                //  zero indicates pass, non-zero is an error code
8650                If (LNotEqual (Local2, 0))
8651                {
8652                    //  return FB2P error code
8653                    Return (Local2)
8654                }
8655
8656
8657                Return (0)
8658            }   //  TEST
8659        }   //  IDX2:   Test device name
8660    }   //  _SB system bus
8661
8662//
8663// test SizeOf.asl
8664//
8665//  Test for SizeOf
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;
8671//          package;
8672//          buffer, package, and string package elements
8673//
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.
8677//
8678    Device (SIZO)
8679    {
8680        //  SAR0 control method validates SizeOf(Arg)
8681        //      SAR0 should only be called by SARG
8682        Method (SAR0, 2)
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
8688
8689            //  Store first string size (Arg0) into Local7
8690            Store (SizeOf (Arg0), Local0)
8691
8692            //  save Local0 object type value into Local1
8693            Store (ObjectType (Local0), Local1)
8694
8695            //  validate Local0 is a Number
8696            If (LNotEqual (Local1, 1))      //  Number type is 1
8697                {   Return (0x21)   }
8698
8699            //  If strings are not of equal size, return error code
8700            If (LNotEqual (Local0, Arg1))
8701                {   Return (0x22)   }
8702
8703            Return (0)
8704        }   //  SAR0:   SizeOf(Arg) test control method
8705
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)
8713            {
8714                BUFR,
8715                "String2",
8716                STR0,
8717                PKG0
8718            })  //  PKG1
8719
8720            Name (PKG2, Package (4)
8721            {
8722                Buffer (15) {},
8723                "String 1",
8724                Package (2) {}
8725            })  //  PKG2
8726
8727            //  Namespace entry buffer reference
8728            Store (SAR0 (BUFR, 12), Local0)
8729
8730            //  save Local0 object type value into Local1
8731            Store (ObjectType (Local0), Local1)
8732
8733            //  validate Local0 is a Number
8734            If (LNotEqual (Local1, 1))      //  Number type is 1
8735            {
8736                Return (0x23)
8737            }
8738
8739            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8740            {
8741                Return (Local0)
8742            }
8743
8744            Store ("SizeOf(Arg=BUFR) PASS", Debug)
8745
8746
8747            //  Namespace entry package reference
8748            Store (SAR0 (PKG0, 4), Local0)
8749
8750            //  save Local0 object type value into Local1
8751            Store (ObjectType (Local0), Local1)
8752
8753            //  validate Local0 is a Number
8754            If (LNotEqual (Local1, 1))      //  Number type is 1
8755            {
8756                Return (0x24)
8757            }
8758
8759            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8760            {
8761                Return (Local0)
8762            }
8763
8764            Store ("SizeOf(Arg=PKG0) PASS", Debug)
8765
8766
8767            //  Namespace entry string reference
8768            Store (SAR0 (STR0, 6), Local0)
8769
8770            //  save Local0 object type value into Local1
8771            Store (ObjectType (Local0), Local1)
8772
8773            //  validate Local0 is a Number
8774            If (LNotEqual (Local1, 1))      //  Number type is 1
8775            {
8776                Return (0x25)
8777            }
8778
8779            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8780            {
8781                Return (Local0)
8782            }
8783
8784            Store ("SizeOf(Arg=STR0) PASS", Debug)
8785
8786
8787            //  direct string reference
8788            Store (SAR0 ("String", 6), Local0)
8789
8790            //  save Local0 object type value into Local1
8791            Store (ObjectType (Local0), Local1)
8792
8793            //  validate Local0 is a Number
8794            If (LNotEqual (Local1, 1))      //  Number type is 1
8795            {
8796                Return (0x26)
8797            }
8798
8799            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8800            {
8801                Return (Local0)
8802            }
8803
8804            Store ("SizeOf(Arg=String) PASS", Debug)
8805
8806            Store (0x55, Index (BUF1, 2))
8807
8808            /****************************************************
8809            //
8810            // This section is commented because it is illegal to
8811            //  perform a SizeOf operation on a Buffer Field
8812            //
8813            //  Namespace BufferField reference
8814            Store (SAR0 (Index (BUFR, 2, ), 10), Local0)
8815
8816            //  save Local0 object type value into Local1
8817            Store (ObjectType (Local0), Local1)
8818
8819            //  validate Local0 is a Number
8820            If (LNotEqual (Local1, 1))      //  Number type is 1
8821                {   Return (0x27)   }
8822
8823            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8824                {   Return (Local0) }
8825
8826            Store ("SizeOf(Arg=BufferField) PASS", Debug)
8827            ****************************************************/
8828
8829            //  Namespace BufferPackageElement reference
8830            //
8831            Store (SAR0 (Index(PKG1, 0), 12), Local0)
8832
8833            //  save Local0 object type value into Local1
8834            Store (ObjectType (Local0), Local1)
8835
8836            //  validate Local0 is a Number
8837            If (LNotEqual (Local1, 1))      //  Number type is 1
8838            {
8839                Return (0x28)
8840            }
8841
8842            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8843            {
8844                Return (Local0)
8845            }
8846
8847            Store ("SizeOf(Arg=PackageBuffer NTE Reference Element) PASS", Debug)
8848
8849
8850            //  Namespace StringPackageElement reference
8851            Store (SAR0 (Index (PKG1, 1, ), 7), Local0)
8852
8853            //  save Local0 object type value into Local1
8854            Store (ObjectType (Local0), Local1)
8855
8856            //  validate Local0 is a Number
8857            If (LNotEqual (Local1, 1))      //  Number type is 1
8858            {
8859                Return (0x29)
8860            }
8861
8862            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8863            {
8864                Return (Local0)
8865            }
8866
8867            Store ("SizeOf(Arg=Package String Element) PASS", Debug)
8868
8869
8870            //  Namespace StringPackageElement reference
8871            Store (SAR0 (Index (PKG1, 2, ), 6), Local0)
8872
8873            //  save Local0 object type value into Local1
8874            Store (ObjectType (Local0), Local1)
8875
8876            //  validate Local0 is a Number
8877            If (LNotEqual (Local1, 1))      //  Number type is 1
8878            {
8879                Return (0x2A)
8880            }
8881
8882            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8883            {
8884                Return (Local0)
8885            }
8886
8887            Store ("SizeOf(Arg=Package String NTE Reference Element) PASS", Debug)
8888
8889
8890            //  Namespace PackagePackageElement reference
8891            Store (SAR0 (Index (PKG1, 3, ), 4), Local0)
8892
8893            //  save Local0 object type value into Local1
8894            Store (ObjectType (Local0), Local1)
8895
8896            //  validate Local0 is a Number
8897            If (LNotEqual (Local1, 1))      //  Number type is 1
8898            {
8899                Return (0x2B)
8900            }
8901
8902            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8903            {
8904                Return (Local0)
8905            }
8906
8907            Store ("SizeOf(Arg=Package Package NTE Reference Element) PASS", Debug)
8908
8909            // Package Buffer Element
8910            Store (SAR0 (Index (PKG2, 0), 15), Local0)
8911
8912            //  save Local0 object type value into Local1
8913            Store (ObjectType (Local0), Local1)
8914
8915            //  validate Local0 is a Number
8916            If (LNotEqual (Local1, 1))      //  Number type is 1
8917            {
8918                Return (0x2B)
8919            }
8920
8921            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8922            {
8923                Return (Local0)
8924            }
8925
8926            Store ("SizeOf(Arg=Package Buffer Element) PASS", Debug)
8927
8928            // Package String Element
8929            Store (SAR0 (Index (PKG2, 1), 8), Local0)
8930
8931            //  save Local0 object type value into Local1
8932            Store (ObjectType (Local0), Local1)
8933
8934            //  validate Local0 is a Number
8935            If (LNotEqual (Local1, 1))      //  Number type is 1
8936            {
8937                Return (0x2B)
8938            }
8939
8940            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8941            {
8942                Return (Local0)
8943            }
8944
8945            Store ("SizeOf(Arg=Package String Element) PASS", Debug)
8946
8947            // Package Package Element
8948            Store (SAR0 (Index (PKG2, 2), 2), Local0)
8949
8950            //  save Local0 object type value into Local1
8951            Store (ObjectType (Local0), Local1)
8952
8953            //  validate Local0 is a Number
8954            If (LNotEqual (Local1, 1))      //  Number type is 1
8955            {
8956                Return (0x2B)
8957            }
8958
8959            If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8960            {
8961                Return (Local0)
8962            }
8963
8964            Store ("SizeOf(Arg=Package Package Element) PASS", Debug)
8965
8966            Store ("SizeOf(Arg) PASS", Debug)
8967
8968            Return (0)
8969        }   //  SARG:   SizeOf(Arg) test control method
8970
8971        Method (SBUF,, Serialized)
8972        {   //  SBUF:   SizeOf(Buffer) test control method
8973            Name (BUFR, Buffer (12) {})
8974
8975            //  store size of BUFR buffer into Local0
8976            Store (SizeOf (BUFR), Local0)
8977
8978            //  save Local0 object type value into Local1
8979            Store (ObjectType (Local0), Local1)
8980
8981            //  validate Local0 is a Number
8982            If (LNotEqual (Local1, 1))      //  Number type is 1
8983            {
8984                Return (0x31)
8985            }
8986
8987            If (LNotEqual (Local0, 12))     //  BUFR size is 12
8988            {
8989                Return (0x32)
8990            }
8991
8992            Store ("SizeOf(BUFR) PASS", Debug)
8993
8994            Return (0)
8995        }   //  SBUF:   SizeOf(Buffer) test control method
8996
8997
8998        /****************************************************
8999        //
9000        // This section is commented because it is illegal to
9001        //  perform a SizeOf operation on a Buffer Field
9002        //
9003        Method (SIND)
9004        {   //  SIND:   SizeOf(Index(,,)) test control method
9005            Name (BUFR, Buffer (12) {})
9006
9007            //  store size of Index(BUFR,2,) buffer into Local0
9008            Store (SizeOf (Index (BUFR, 2, )), Local0)
9009
9010            //  save Local0 object type value into Local1
9011            Store (ObjectType (Local0), Local1)
9012
9013            //  validate Local0 is a Number
9014            If (LNotEqual (Local1, 1))      //  Number type is 1
9015            {
9016                Return (0x41)
9017            }
9018
9019            If (LNotEqual (Local0, 10))     //  12 - 2 = 10
9020            {
9021                Return (0x42)
9022            }
9023
9024            Store ("SizeOf(Index(BUFR,,)) PASS", Debug)
9025
9026            //  TBD:    strings and packages
9027
9028            Return (0)
9029        }   //  SIND:   SizeOf(Index(,,)) test control method
9030        ****************************************************/
9031
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
9037
9038
9039            //  store BUFR Buffer into Local2
9040            Store (BUFR, Local2)
9041
9042            //  store size of BUFR buffer into Local0
9043            Store (SizeOf (Local2), Local0)
9044
9045            //  save Local0 object type value into Local1
9046            Store (ObjectType (Local0), Local1)
9047
9048            //  validate Local0 is a Number
9049            If (LNotEqual (Local1, 1))      //  Number type is 1
9050            {
9051                Return (0x51)
9052            }
9053
9054            If (LNotEqual (Local0, 12)) //  BUFR size is 12
9055            {
9056                Return (0x52)
9057            }
9058
9059            Store ("SizeOf(Local2=Buffer) PASS", Debug)
9060
9061
9062            //  store STR0 string into Local2
9063            Store (STR0, Local2)
9064
9065            //  store size of STR0 buffer into Local0
9066            Store (SizeOf (Local2), Local0)
9067
9068            //  save Local0 object type value into Local1
9069            Store (ObjectType (Local0), Local1)
9070
9071            //  validate Local0 is a Number
9072            If (LNotEqual (Local1, 1))      //  Number type is 1
9073            {
9074                Return (0x53)
9075            }
9076
9077            If (LNotEqual (Local0, 6))      //  STR0 size is 6
9078            {
9079                Return (0x54)
9080            }
9081
9082            Store ("SizeOf(Local2=String) PASS", Debug)
9083
9084
9085            //  store PKG0 Package into Local2
9086            Store (PKG0, Local2)
9087
9088            //  store size of PKG0 buffer into Local0
9089            Store (SizeOf (Local2), Local0)
9090
9091            //  save Local0 object type value into Local1
9092            Store (ObjectType (Local0), Local1)
9093
9094            //  validate Local0 is a Number
9095            If (LNotEqual (Local1, 1))      //  Number type is 1
9096            {
9097                Return (0x55)
9098            }
9099
9100            If (LNotEqual (Local0, 4))      //  PKG0 size is 4
9101            {
9102                Return (0x56)
9103            }
9104
9105            Store ("SizeOf(Local2=Package) PASS", Debug)
9106
9107
9108            Return (0)
9109        }   //  SLOC:   SizeOf(Local) test control method
9110
9111        Method (TEST)
9112        {
9113            Store ("++++++++ SizeOf Test", Debug)
9114
9115            //  Store current operating system string into Local0
9116            Store (_OS, Local0)
9117
9118            Store (SizeOf (_OS), Local3)
9119
9120            //  save Local3 object type value into Local4
9121            Store (ObjectType (Local3), Local4)
9122
9123            //  validate Local3 is a Number
9124            If (LNotEqual (Local4, 1))  //  Number type is 1
9125            {
9126                //  failure
9127                Return (0x61)
9128            }
9129
9130            //  Store current operating system string into Local0
9131            //  This verifies above SizeOf(_OS) did not corrupt ACPI namespace
9132            Store (_OS, Local0)
9133
9134            //  Store SARG [Validate SizeOf(Arg)] return value into Local1
9135            Store (SARG, Local1)
9136
9137            //  save Local1 object type value into Local2
9138            Store (ObjectType (Local1), Local2)
9139
9140            //  validate Local1 is a Number
9141            If (LNotEqual (Local2, 1))  //  Number type is 1
9142            {
9143                //  failure
9144                Return (0x62)
9145            }
9146
9147            //  zero indicates pass, non-zero is an error code
9148            If (LNotEqual (Local1, 0))
9149            {
9150                //  return SARG error code
9151                Return (Local1)
9152            }
9153
9154
9155            //  Store SBUF [Validate SizeOf(Buffer)] return value into Local1
9156            Store (SBUF, Local1)
9157
9158            //  save Local1 object type value into Local2
9159            Store (ObjectType (Local1), Local2)
9160
9161            //  validate Local1 is a Number
9162            If (LNotEqual (Local2, 1))  //  Number type is 1
9163            {
9164                //  failure
9165                Return (0x63)
9166            }
9167
9168            //  zero indicates pass, non-zero is an error code
9169            If (LNotEqual (Local1, 0))
9170            {
9171                //  return SBUF error code
9172                Return (Local1)
9173            }
9174
9175            /****************************************************
9176            //
9177            // This section is commented because it is illegal to
9178            //  perform a SizeOf operation on a Buffer Field
9179            //
9180            //  Store SIND [verify SizeOf(Index(,,))] return value into Local1
9181            Store (SIND, Local1)
9182
9183            //  save Local1 object type value into Local2
9184            Store (ObjectType (Local1), Local2)
9185
9186            //  validate Local1 is a Number
9187            If (LNotEqual (Local2, 1))  //  Number type is 1
9188            {
9189                //  failure
9190                Return (0x64)
9191            }
9192
9193            //  zero indicates pass, non-zero is an error code
9194            If (LNotEqual (Local1, 0))
9195            {
9196                //  return SARG error code
9197                Return (Local1)
9198            }
9199            ****************************************************/
9200
9201            //  Store SLOC [verify SizeOf(Local)] return value into Local1
9202            Store (SLOC, Local1)
9203
9204            //  save Local1 object type value into Local2
9205            Store (ObjectType (Local1), Local2)
9206
9207            //  validate Local1 is a Number
9208            If (LNotEqual (Local2, 1))  //  Number type is 1
9209            {
9210                //  failure
9211                Return (0x65)
9212            }
9213
9214            //  zero indicates pass, non-zero is an error code
9215            If (LNotEqual (Local1, 0))
9216            {
9217                //  return SLOC error code
9218                Return (Local1)
9219            }
9220
9221
9222            //  TBD:    SizeOf (METH) -- where METH control method returns
9223            //              buffer, BufferField, string, package, package element
9224
9225
9226            Return (0)
9227        }   //  TEST
9228    }   //  SIZO
9229
9230//
9231// test SmiShare.asl
9232//
9233    Scope (\_SB)    //  System Bus
9234    {   //  _SB system bus
9235        //  Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
9236        OperationRegion(RAM1, SystemMemory, 0x400000, 0xA)
9237
9238        Field (RAM1, AnyAcc, NoLock, Preserve)
9239        {
9240            BI1T, 1,        // Create some bits in memory to access
9241            BI2T, 2,
9242            BI3T, 3,
9243            LST2, 2
9244        }   //  End Field RAM1
9245
9246        Field (RAM1, WordAcc, NoLock, WriteAsZeros)
9247        {
9248            WRD, 16
9249        }   //  End 2nd Field RAM1
9250
9251        Field (RAM1, ByteAcc, NoLock, WriteAsOnes)
9252        {
9253            BYTE, 8
9254        }   //  End 3rd Field RAM1
9255
9256        Field (RAM1, ByteAcc, NoLock, Preserve)
9257        {
9258            SMIC, 8,
9259            SMID, 8
9260        }
9261
9262        Device (MBIT)
9263        {
9264            Method (_INI)
9265            {
9266                Store (0, BI1T)
9267                Store (3, BI2T)
9268                Store (7, BI3T)
9269                Store (0, LST2)
9270            }   //  End _INI Method
9271        }   //  End Device MBIT
9272
9273        Device (MWRD)
9274        {
9275            Method (_INI)
9276            {
9277                Store (0, WRD)
9278            }   //  End _INI Method
9279        }   //  End Device MWRD
9280
9281        Device (MBYT)
9282        {
9283            Method (_INI)
9284            {
9285                Store (0, BYTE)
9286                Store (0xC, SMIC)
9287                Store (0xD, SMID)
9288            }   //  End _INI Method
9289        }   //  End Device MBYT
9290
9291    /*
9292        //  Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
9293        OperationRegion(\RAM1, SystemMemory, 0x400000, 0xA)
9294
9295        Field (\RAM1, AnyAcc, NoLock, Preserve)
9296        {
9297            BI1T, 1,        // Create some bits in memory to access
9298            BI2T, 2,
9299            BI3T, 3,
9300            LST2, 2
9301        }   //  End Field RAM1
9302
9303        Field (\RAM1, WordAcc, NoLock, WriteAsZeros)
9304        {
9305            WRD, 16
9306        }   //  End 2nd Field RAM1
9307
9308        Field (\RAM1, ByteAcc, NoLock, WriteAsOnes)
9309        {
9310            BYTE, 8
9311        }   //  End 3rd Field RAM1
9312
9313        Field (\RAM1, ByteAcc, NoLock, Preserve)
9314        {
9315            SMIC, 8,
9316            SMID, 8
9317        }
9318    */
9319        Method (SMIX)
9320        {
9321            Return (BYTE)
9322        }   //  End SMIX
9323
9324        Method (EVNT)
9325        {
9326            Store (SMIX, Local0)
9327
9328            Notify (\_SB_, 0x29)
9329            If (And (Local0, 0x01))
9330            {   Notify (\_SB_.SMIS, 0x21)}
9331
9332            If (And (Local0, 0x02))
9333            {   Notify (\_SB_.SMIS, 0x22)}
9334
9335            If (And (Local0, 0x04))
9336            {   Notify (\_SB_.SMIS, 0x24)}
9337
9338            If (And (Local0, 0x08))
9339            {   Notify (\_SB_.SMIS, 0x28)}
9340
9341        }   //  End Method EVNT
9342
9343        Method (NTFY)
9344        {
9345            Notify (\_SB_, 1)
9346            Notify (\_TZ_.TZ1, 2)
9347            Notify (\_PR_.CPU0, 3)
9348
9349            Notify (\_SB_, 0x81)
9350            Notify (\_TZ_.TZ1, 0x82)
9351            Notify (\_PR_.CPU0, 0x83)
9352        }
9353
9354        Device (SMIS)
9355        {
9356            Method (BINK)
9357            {
9358                Store (0, Local0)               //  Zero out Local0
9359
9360                If (LNotEqual (SMID, 0xD))
9361                {   Or (0x80, Local0, Local0)}
9362
9363                If (LNotEqual (SMIC, 0xC))
9364                {   Or (0x40, Local0, Local0)}
9365
9366                If (LNotEqual (BYTE, 0))
9367                {   Or (0x20, Local0, Local0)}
9368
9369                If (LNotEqual (WRD, 0))
9370                {   Or (0x10, Local0, Local0)}
9371
9372                If (LNotEqual (LST2, 0))
9373                {   Or (0x8, Local0, Local0)}
9374
9375                If (LNotEqual (BI3T, 0x7))
9376                {   Or (0x4, Local0, Local0)}
9377
9378                If (LNotEqual (BI2T, 0x3))
9379                {   Or (0x2, Local0, Local0)}
9380
9381                If (LNotEqual (BI1T, 0))
9382                {   Or (0x1, Local0, Local0)}
9383
9384                Return (Local0)
9385            }   //  End Method BINK
9386
9387            Method (TEST)
9388            {
9389                Store ("++++++++ SmiShare Test", Debug)
9390
9391                //  Expect EVNT to generate Notify value we just previously
9392                //  stored in BYTE
9393
9394                Store (0x20, BYTE)
9395                EVNT ()
9396                Store (0x21, BYTE)
9397                EVNT ()
9398                Store (0x22, BYTE)
9399                EVNT ()
9400                Store (0x23, BYTE)
9401                EVNT ()
9402
9403                NTFY ()
9404                Return (0)  //  pass
9405            }   //  End Method TEST
9406        }   //  Device SMIS
9407
9408        Device(CNDT)
9409        {
9410            Method(TEST)
9411            {
9412                If (ECOK)
9413                {
9414                    return("Broken")
9415                }
9416                Else
9417                {
9418                    return("Works")
9419                }
9420            }
9421
9422            Method(ECOK)
9423            {
9424                Return(0x0)
9425            }
9426        }
9427
9428    }   //  _SB system bus
9429
9430
9431/* Test a very big buffer */
9432
9433    Name(WQAB, Buffer(6756)
9434    {
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,
10280    })  // END MBUF
10281
10282} //end DefinitionBlock
10283