diff options
Diffstat (limited to 'tests/aslts/src/runtime/collections/Identity2MS')
44 files changed, 37877 insertions, 0 deletions
diff --git a/tests/aslts/src/runtime/collections/Identity2MS/Makefile b/tests/aslts/src/runtime/collections/Identity2MS/Makefile new file mode 100644 index 000000000..9efadc5b6 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/Makefile @@ -0,0 +1,7 @@ +# Identity2MS + +MDIRS = \ + abbu + +TOP= ../../../.. +include $(TOP)/Makefile.switch diff --git a/tests/aslts/src/runtime/collections/Identity2MS/README b/tests/aslts/src/runtime/collections/Identity2MS/README new file mode 100644 index 000000000..ec15bd3d3 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/README @@ -0,0 +1,21 @@ + +CONTENTS + + tests to prove identity of ACPICA to MS + +abbu + + Tests applicable to both AcpiExec and MS-abbu utilities + + Interface of these tests allows them both to be run + by AcpiExec utility as elements of ASLTS test suite + and by abbu utility under MS. + + Due to the current incomplete implementation of ACPI + by MS the entire ASLTS test suite can't simply be run + by abbu utility under MS. + + This test case is intended to accumulate tests which + exercise and verify the fundamental ACPI features. + The tests should succeed on both AcpiExec and abbu + and thus prove identity of ACPICA and MS. diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/DECL.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/DECL.asl new file mode 100644 index 000000000..488b1040c --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/DECL.asl @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* +in progress: + +Do these: +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++++ 1) clean up the current set of tests ++++ 2) Make automatically aslst_abbu.aml which include the original common.asl and ehandle.asl files ++++ 3) introduce 'stack' directory for the stuff from ns8 ++++ 4) slways should be place in POUT for lines below: + OUTP(":STST:Identity2MS:abbu:mmmm:FAIL:Errors # 12 34 56 78:") + OUTP(":STST:Identity2MS:abbu:mmmm:PASS:") + Store("******** POUT exceeded ********, number of lost messages:", Index(POUT, Local0)) ++++ 3) do the method examples and run points for each of the enumerated by 'Stuff not working under MS' + +4) add the tests of namespace test case with the root names \_SB.d000.p000 ... +10) do ns6 + ..... +11) develop the test to achieve cover, do methodically other urgent tests inside abbu +12) complete the namespace test case +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +13) fix bug of m01e + * + */ + +/* + * Common declarations + */ + +/* + * Broke ACPICA (m01e) + * + * 0 - blocks execution + */ +Name(fix0, 1) // blocks m01e +Name(fix1, 1) // causes break of path for ACPICA + +/* + * Do additional checking + */ +Name(chk0, 0) // use it for those which break execution on MS (should be 0 for run on MS) +Name(chk1, 1) // use it for those which don't break execution on MS +Name(chk2, 0) // use it for those which break execution while re-bootin on MS + +Name(prt0, 0) // conditional OUTP printing + +Name(SLC0, 0) // modification of SCLK + +/* + * Initialization of msfail + */ +Method(IIN1) +{ + if (run4) { + Store(1, y262) + Store(1, y275) + Store(1, SLC0) + Store(0, SLCK) + } else { + OUTP("WARNING: don't forget to check run4 !!!!!!!!!!") + + Store(0, SLC0) + if (SLCK) { + Store(1, SLC0) + } + } + + if (ABUU) { + Store(0, chk0) + Store(1, chk1) + Store(0, chk2) + Store(0, fix0) + Store(0, fix1) + } else { + Store(1, chk0) + Store(1, chk1) + Store(1, chk2) + Store(1, fix0) + Store(0, fix1) + } +} + +Include("./run_points.asl") + +// NameSpace + +// Initial +Include("./initial/ns_in00.asl") +Include("./initial/ns_in10.asl") +Include("./initial/ns_in20.asl") +Include("./initial/ns_in30.asl") +Include("./initial/ns_in40.asl") +Include("./initial/ns_in50.asl") + +// Device +// Include("./device/ns_dv00.asl") +Include("./device/device.asl") + +// Include("./ns3.asl") +Include("./ns4.asl") +Include("./ns6.asl") + +// Miscellaneous + +Include("./misc/ms0.asl") +Include("./misc/ms1.asl") + +// MsFail + +Include("./MsFail/msfail.asl") + + +// Specific initialization of abbu + +// Reset to the initial state +Method(RST8) +{ + Store(0, ERRS) + Store(0, RMRC) +} + +// Specific initialization of abbu +Method(IIN0) +{ + // Reset to the initial state + RST8() + + // Reset POUT service to the initial state + RST9() + + // Initialization of msfail + IIN1() +} + +// Conditional output +Method(OUTC, 1) +{ + if (prt0) { + OUTP(arg0) + } +} + +// Run the tests + +Method(MAIN) { + + // Initialization + STRT(0) + + // Specific initialization of abbu + IIN0() + + // Run verification methods + Include("./RUN.asl") + + // Final actions + Store(FNSH(), Local7) + + if (ABUU) { + Return(POUT) + } + Return(Local7) +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/DECL_ABBU.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/DECL_ABBU.asl new file mode 100644 index 000000000..70eb606f3 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/DECL_ABBU.asl @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// All declarations to compile for abbu + +Include("../../../../runtime/cntl/abbu_common.asl") +Include("../../../../runtime/cntl/runmode.asl") +Include("../../../../runtime/cntl/runpoint.asl") +Include("./device/device_abbu.asl") +Include("./method/mt0_abbu.asl") +Include("./recursion/rec_abbu.asl") +Include("./DECL.asl") diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/DECL_ASLTS.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/DECL_ASLTS.asl new file mode 100644 index 000000000..ab998fde5 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/DECL_ASLTS.asl @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// All declarations to compile for AcpiExec + +Include("../../../../runtime/cntl/DECL.asl") +Include("./device/device_aslts.asl") +Include("./method/mt0_aslts.asl") +Include("./recursion/rec_aslts.asl") +Include("./DECL.asl") diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/MAIN.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/MAIN.asl new file mode 100644 index 000000000..304db57ab --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/MAIN.asl @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests applicable to both AcpiExec and MS-abbu utilities + */ +DefinitionBlock("extra.aml", "DSDT", 0x1, "INTEL", "ABCDE", 0x1) +{ + Scope(\_SB) + { + Device(ABBU) + { + Name(_HID, "ACPIABBU") + Method(ENBL) + { + Return(Zero) + } + + Method(TEST) + { + Return(Zero) + } + + Method(TST) + { + Return(TSTS) + } + + /* Definitions of common use */ + + /* + * AI00: + * + * The abbu utility provides some restricted amount of elements of POUT, + * it is not the constant number of elements of Package (!), not good interface, + * but looks like some restricted amount of memory. When that variable number of + * elements is exceeded, abbu returns FAILURE which we can't differentiate from + * the actual failure of MS being examined. So, don't use the big AI00 to be sure + * that returned FAILURE, if any, is not caused by the mentioned fact. + */ + Name (AI00, 17) // MAX + Name (POUT, Package(17) {}) + + Name (AI01, 0) // current OUT + Name (AI02, 0) // counter of lost POUT messages + Name (AI07, 0) // print once only the end-message + Name (AI08, 0) // total number of messages + + Method(OUUP, 2) + { + /* Last 6 lines are reserved for the test run summary and end-message */ + Subtract(AI00, 6, Local0) + + if (LLess(AI01, Local0)) { + Store(arg0, Index(POUT, AI01)) + Increment(AI01) + } else { + /* Last 2 lines are reserved for the end-message */ + Subtract(AI00, 2, Local0) + if (LAnd(arg1, LLess(AI01, Local0))) { + Store(arg0, Index(POUT, AI01)) + Increment(AI01) + } else { + if (LNot(AI07)) { + Store(1, AI07) + Subtract(AI00, 2, Local0) + Store("******** POUT exceeded ********", Index(POUT, Local0)) + } + } + } + + /* Last element of POUT is the total number of messages */ + + Increment(AI08) + Subtract(AI00, 1, Local0) + Store(AI08, Index(POUT, Local0)) + } + + Method(OUTP, 1) + { + OUUP(arg0, 0) + } + + /* + * Reset POUT service to the initial state + */ + Method(RST9) + { + Name(lpN0, 0) + Name(lpC0, 0) + + Store (0, AI01) + Store (0, AI02) + Store (0, AI07) + Store (0, AI08) + + Store(AI00, lpN0) + Store(0, lpC0) + While (lpN0) { + Store(" ", Index(POUT, lpC0)) + Decrement(lpN0) + Increment(lpC0) + } + + Subtract(AI00, 2, Local0) + Store("Total number of messages:", Index(POUT, Local0)) + Increment(Local0) + Store(0, Index(POUT, Local0)) + } + +// ====================================================== // +// ====================================================== // +// ====================================================== // + +/* Definitions relative to the subject */ + +Include("./DECL_ABBU.asl") + +// ====================================================== // +// ====================================================== // +// ====================================================== // + + + Name(TSTS, Package() + { + "ENBL", + "TEST", + "TST_", + "MAIN", + "IN00", + }) + } + } + Method(MAIN) + { + Return (\_SB_.ABBU.MAIN()) + } + Method(MN00) + { + Return (\_SB_.ABBU.MN00()) + } + Method(MN01) + { + Return (\_SB_.ABBU.MN01()) + } +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/MAIN_ASLTS.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/MAIN_ASLTS.asl new file mode 100644 index 000000000..107570b15 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/MAIN_ASLTS.asl @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * For AcpiExec only (not abbu) + * + * Tests applicable to both AcpiExec and MS-abbu utilities + */ +DefinitionBlock("extra_aslts.aml", "DSDT", 0x2, "INTEL", "ABCDE", 0x1) +{ + + Include("./DECL_ASLTS.asl") + + /* Definitions of common use */ + + Name (POUT, Package(1) {"EMPTY"}) + Method(OUTP, 1) + { + Store(arg0, Debug) + } + Method(RST9) + { + } + + Scope(\_SB) + { + Device(ABBU) + { + Name(_HID, "ACPIABBU") + Method(ENBL) + { + Return(Zero) + } + + Method(TEST) + { + Return(Zero) + } + + Method(TST) + { + Return(TSTS) + } + +// ====================================================== // +// ====================================================== // +// ====================================================== // + +/* Definitions inside _SB relative to the subject */ + +// ====================================================== // +// ====================================================== // +// ====================================================== // + + + Name(TSTS, Package() + { + "ENBL", + "TEST", + "TST_", + }) + } + } +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/Makefile b/tests/aslts/src/runtime/collections/Identity2MS/abbu/Makefile new file mode 100644 index 000000000..eb3b08734 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/Makefile @@ -0,0 +1,8 @@ +# abbu + +ASLMODADD= MAIN_ASLTS +AMLMOD= extra extra_aslts +COLL= ../.. + +TOP= $(COLL)/../../.. +include $(COLL)/Makefile.install diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/MsFail/msfail.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/MsFail/msfail.asl new file mode 100644 index 000000000..820c38b84 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/MsFail/msfail.asl @@ -0,0 +1,1897 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Accumulate features which don't work on MS + * + * This should help to adapt tests to MS + * + * Stuff not working under MS: + * + * 1) Mod + * 2) Concatenate + * 3) CopyObject + * 4) POUT - is restricted by abbu, apparently, by byte-size(!), + * not by the number of elements (!), and ABBU reports Failure in + * that case not distinguishable from failures of MS being examined. + * 5) Return (Add(i000, m001())) -- !! but this works: Return (Add(Local7, m006())) + * 6) Arg instead of i000 (in m001): + * Store(0x07000000, arg1) + * Return (Add(arg1, m007())) + * 7) LNotEqual(bf00, 0x80) : bf00 - Buffer Field + * + * 8) (?) Buffer Field by arg -- doesn't work (?) (see xxx) + * 9) Field passed by arg -- doesn't work (see m30c) + * 10) Bank Field passed by arg -- doesn't work (see m30d): + * 11) Index Field passed by arg -- doesn't work (see m30e): + * + * 12) write access to element of String by Index/DerefOf + * 13) Stack overflow on about 10-12 method calls depth, + * call methods chain is restricted by ~11 + * 14) Named element of Package is, perhaps, not implemented by MS, + * i000 in Package(){i000} is, on MS, the same as Package(){"i000"}, + * (see ns1.asl for example). + * 15) Stack (resource) overflow depends very much on other + * reasons, not only the depth of method calls. + * So, trying to wrap methods of ns0.asl into one parent method + * decreases the available number of levels by more than 4 levels. + * 16) Internal objects of methods on MS consume some internal + * resources of ACPI MS interpreter. Pulling some internal objects + * of that method helps to prevent breakage of MS interpreter. + */ + +Name(z161, 161) + +/* + * Named Integer i000 + */ + +/* + * CopyObject + * + * fail + */ +Method(mf00) +{ + Name(ts, "mf00") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + + /* Breaks on this command itself */ + CopyObject(i000, i001) + + if (chk0) { + if (LNotEqual(i001, 0xabcd0000)) { + err(ts, z161, 0x001, 0, 0, i001, 0xabcd0000) + } + } + + Return(POUT) +} + +/* + * Concatenate + * + * success/fail + */ +Method(mf01) +{ + Name(ts, "mf01") + Name(s000, "qwertyuiop") + Name(s001, "_sdfghjkl") + + /* Doesn't break on this command itself */ + Concatenate(s000, s001, Local0) + + OUTP(Local0) + + if (chk0) { + /* This LNotEqual breaks */ + if (LNotEqual(Local0, "qwertyuiop_sdfghjkl")) { + err(ts, z161, 0x004, 0, 0, Local0, "qwertyuiop_sdfghjkl") + } + } + + Return(POUT) +} + +/* + * LEqual of Strings + * + * fail + */ +Method(mf02) +{ + Name(ts, "mf02") + Name(s000, "qwertyuiop") + Name(s001, "_sdfghjkl") + + LEqual("qwerty", "sdfghj") + + if (chk0) { + /* This LNotEqual breaks */ + if (LEqual("qwerty", "sdfghj")) { + err(ts, z161, 0x004, 0, 0, "qwerty", "sdfghj") + } + } + + Return(POUT) +} + +/* + * Return (Add(i000, m001())) + * + * success + */ +Method(mf03) +{ + Name(ts, "mf03") + Name(i000, 0x12340001) + + Method(m000) + { + Method(m001) + { + Method(m002) + { + Return (1) + } + Return (Add(i000, m002())) + } + Return (Add(i000, m001())) + } + + m000() + + if (chk1) { + Store(m000(), Local0) + if (LNotEqual(Local0, 0x24680003)) { + err(ts, z161, 0x007, 0, 0, Local0, 0x24680003) + } + } + + Return(POUT) +} + +/* + * Store to uninitialized ArgX (no value passed by that ArgX) + * + * Store(0x00001000, arg6) + * Return (Add(arg6, m007())) + * + * fail + */ +Method(mf04) +{ + Name(ts, "mf04") + Name(i000, 0xabcd0000) + + Method(m000) + { + Store(0x00001001, arg6) + Return (Add(arg6, 5)) + } + + Method(m001) + { + // With this line commented works: + // Store(0x00001001, arg6) + + Store(0x00001001, arg6) + + // Doesnt work: + // Return (Add(arg6, 5)) + // Return (0) + } + + m001() + + if (chk0) { + Store(m000(), Local0) + if (LNotEqual(Local0, 0x1006)) { + err(ts, z161, 0x00a, 0, 0, Local0, 0x1006) + } + CH03(ts, z161, 0x00b, 0, 0) + } + + Return(POUT) +} + +/* + * Store to initialized ArgX (ArgX is passed with Constant Integer) + * + * Store(0x00001000, arg0) + * Return (Add(arg0, m007(0xabcd0000))) + * + * succeeded + */ +Method(mf05) +{ + Name(ts, "mf05") + + Method(m000, 1) + { + Store(0x00001001, arg0) + Return (Add(arg0, 5)) + } + + m000(0xabcd0000) + + if (chk1) { + Store(m000(0xabcd0000), Local0) + if (LNotEqual(Local0, 0x1006)) { + err(ts, z161, 0x00a, 0, 0, Local0, 0x1006) + } + } + + Return(POUT) +} + +/* + * Store to initialized ArgX (ArgX is passed with Named Integer) + * + * Store(0x00001000, arg0) + * Return (Add(arg0, m007(i000))) + * + * succeeded + */ +Method(mf06) +{ + Name(ts, "mf06") + Name(i000, 0xabcd0000) + + Method(m000, 1) + { + Store(0x00001001, arg0) + Return (Add(arg0, 5)) + } + + Store(m000(i000), Local0) + + if (chk1) { + if (LNotEqual(Local0, 0x1006)) { + err(ts, z161, 0x00a, 0, 0, Local0, 0x1006) + } + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z161, 0x00a, 0, 0, i000, 0xabcd0000) + } + } + + Return(POUT) +} + +/* + * Store to initialized ArgX (ArgX is passed with Integer by LocalX) + * + * Store(0x00001000, arg0) + * Return (Add(arg0, m007(i000))) + * + * succeeded + */ +Method(mf07) +{ + Name(ts, "mf07") + + Method(m000, 1) + { + Store(0x00001001, arg0) + Return (Add(arg0, 5)) + } + + Store(0xabcd0000, Local7) + Store(m000(Local7), Local0) + + if (chk1) { + if (LNotEqual(Local0, 0x1006)) { + err(ts, z161, 0x00a, 0, 0, Local0, 0x1006) + } + if (LNotEqual(Local7, 0xabcd0000)) { + err(ts, z161, 0x00a, 0, 0, Local7, 0xabcd0000) + } + } + + Return(POUT) +} + +/* + * LNotEqual(bf00, 0x80) + * bf00 -- Buffer Field + * + * fail + */ +Method(mf08) +{ + Name(ts, "mf08") + Name(pr, 1) + Name(i001, 0) + Name(b000, Buffer(9) {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}) + CreateField(b000, 0, 8, bf00) + + // Doesn't work + LNotEqual(bf00, 0x80) + + if (chk0) { + + // Works + Store(bf00, Local0) + + // Doesn't work (!) too: + LNotEqual(Local0, 0x80) + + // Doesn't work (!) too: + Store(Local0, Local1) + LNotEqual(Local1, 0x80) + + // Works + if (pr) { + OUTP(Local0) + OUTP(bf00) + } + + // Works + Store(0x80, bf00) + + // Works + if (pr) { + // There is ok: + OUTP(bf00) + } + + Store(0x80, bf00) + + if (LNotEqual(bf00, 0x80)) { + err(ts, z161, 0x00d, 0, 0, bf00, 0x80) + } + + } /* if(chk0) */ + + Return(POUT) +} + +/* + * Write access to element of String by Index operator + * + * fail + */ +Method(mf09) +{ + Name(ts, "mf09") + Name(s000, "qqqqqqqqqqqqqq") + + Store(0x38, Index(s000, 0)) + + if (chk0) { + Store(DerefOf(Index(s000, 0)), Local0) + if (LNotEqual(Local0, 0x38)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x38) + } + } + + Return(POUT) +} + +/* + * Field passed by agrX doesn't work + * + * success + */ +Method(mf0a) +{ + Name(ts, "mf0a") + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000, 32 } + + Method(m000, 1) + { + Method(m001, 1) + { + Store(0x00000020, arg0) + Return (Add(arg0, 5)) + } + + Add(arg0, 1, Local0) + + Store(Local0, arg0) + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Method(m001, 1) + { + Method(m001, 1) + { + Return (Add(arg0, 5)) + } + + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Store(0x12345678, f000) + Store(m000(f000), Local0) + if (chk1) { + if (LNotEqual(Local0, 0x1234569e)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x1234569e) + } + if (LNotEqual(f000, 0x12345678)) { + err(ts, z161, 0x010, 0, 0, f000, 0x12345678) + } + } + + Store(0x12345675, f000) + Store(m001(f000), Local0) + if (chk1) { + if (LNotEqual(Local0, 0x2468acef)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x2468acef) + } + if (LNotEqual(f000, 0x12345675)) { + err(ts, z161, 0x010, 0, 0, f000, 0x12345675) + } + } + + Return(POUT) +} + +/* + * Bank Field passed by agrX doesn't work + * + * succeeded + */ +Method(mf0b) +{ + Name(ts, "mf0b") + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + BankField(r000, f001, 0, ByteAcc, NoLock, Preserve) { bnk0, 32 } + + Method(m000, 1) + { + Method(m001, 1) + { + Store(0x00000020, arg0) + Return (Add(arg0, 5)) + } + + Add(arg0, 1, Local0) + + Store(Local0, arg0) + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Method(m001, 1) + { + Method(m001, 1) + { + Return (Add(arg0, 5)) + } + + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Store(0x12345678, bnk0) + Store(m000(bnk0), Local0) + if (chk1) { + if (LNotEqual(Local0, 0x1234569e)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x1234569e) + } + if (LNotEqual(bnk0, 0x12345678)) { + err(ts, z161, 0x010, 0, 0, bnk0, 0x12345678) + } + } + + Store(0x12345675, bnk0) + Store(m001(bnk0), Local0) + if (chk1) { + if (LNotEqual(Local0, 0x2468acef)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x2468acef) + } + if (LNotEqual(bnk0, 0x12345675)) { + err(ts, z161, 0x010, 0, 0, bnk0, 0x12345675) + } + } + + Return(POUT) +} + +/* + * Index Field passed by agrX doesn't work + * + * succeeded + */ +Method(mf0c) +{ + Name(ts, "mf0c") + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + IndexField(f000, f001, ByteAcc, NoLock, Preserve) { if00, 32 } + + Method(m000, 1) + { + Method(m001, 1) + { + Store(0x00000020, arg0) + Return (Add(arg0, 5)) + } + + Add(arg0, 1, Local0) + + Store(Local0, arg0) + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Method(m001, 1) + { + Method(m001, 1) + { + Return (Add(arg0, 5)) + } + + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Store(0x12345678, if00) + Store(m000(if00), Local0) + if (chk1) { + if (LNotEqual(Local0, 0x12121238)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x12121238) + } + if (LNotEqual(if00, 0x12121212)) { + err(ts, z161, 0x010, 0, 0, if00, 0x12121212) + } + } + + Store(0x12345675, if00) + Store(m001(if00), Local0) + if (chk1) { + if (LNotEqual(Local0, 0x24242429)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x24242429) + } + if (LNotEqual(if00, 0x12121212)) { + err(ts, z161, 0x010, 0, 0, if00, 0x12121212) + } + } + + Return(POUT) +} + +/* + * Buffer Field passed by agrX + * + * fail + */ +Method(mf0d) +{ + Name(ts, "mf0d") + Name(b000, Buffer(16) {}) + CreateField(b000, 5, 32, bf00) + + Method(m000, 1) + { + Method(m001, 1) + { + Store(0x00000020, arg0) + Return (Add(arg0, 5)) + } + + Add(arg0, 1, Local0) + + Store(Local0, arg0) + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Store(0x12345678, bf00) + Store(m000(bf00), Local0) + if (chk0) { + if (LNotEqual(Local0, 0x1234569e)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x1234569e) + } + if (LNotEqual(bf00, 0x12345678)) { + err(ts, z161, 0x010, 0, 0, bf00, 0x12345678) + } + } + + Return(POUT) +} + +/* + * Buffer Field passed by agrX + * + * fail + */ +Method(mf0e) +{ + Name(ts, "mf0e") + Name(b000, Buffer(16) {}) + CreateField(b000, 5, 32, bf00) + + Method(m001, 1) + { + Method(m001, 1) + { + Return (Add(arg0, 5)) + } + + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Store(0x12345675, bf00) + Store(m001(bf00), Local0) + if (chk0) { + if (LNotEqual(Local0, 0x2468acef)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x2468acef) + } + if (LNotEqual(bf00, 0x12345675)) { + err(ts, z161, 0x010, 0, 0, bf00, 0x12345675) + } + } + + Return(POUT) +} + +/* + * Buffer Field passed by agrX + * + * fail + */ +Method(mf0f) +{ + Name(ts, "mf0f") + Name(b000, Buffer(16) {}) + CreateField(b000, 5, 32, bf00) + + Method(m000, 1) + { + Method(m001, 1) + { + Store(0x00000020, arg0) + Return (Add(arg0, 5)) + } + + Add(arg0, 1, Local0) + + Store(Local0, arg0) + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Method(m001, 1) + { + Method(m001, 1) + { + Return (Add(arg0, 5)) + } + + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Store(0x12345678, bf00) + Store(m000(bf00), Local0) + if (chk0) { + if (LNotEqual(Local0, 0x1234569e)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x1234569e) + } + if (LNotEqual(bf00, 0x12345678)) { + err(ts, z161, 0x010, 0, 0, bf00, 0x12345678) + } + } + + Store(0x12345675, bf00) + Store(m001(bf00), Local0) + if (chk0) { + if (LNotEqual(Local0, 0x2468acef)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x2468acef) + } + if (LNotEqual(bf00, 0x12345675)) { + err(ts, z161, 0x010, 0, 0, bf00, 0x12345675) + } + } + + Return(POUT) +} + +/* + * Buffer Field passed by agrX + * + * fail + */ +Method(mf10) +{ + Name(ts, "mf10") + Name(b000, Buffer(16) {}) + CreateField(b000, 0, 32, bf00) + + Method(m000, 1) + { + Return (arg0) + } + + // Ok + OUTP(b000) + + // This write works correctly: + Store(0x12345678, bf00) + + // Succeeds: + Store(m000(bf00), Local0) + + // Breaks: + // LNotEqual(Local0, 0x12345678) + + // Breaks: + // Add(Local0, 0) + + // Breaks: + // Add(bf00, 0) + + // Ok + OUTP(b000) + + if (LNotEqual(Local0, 0x12345678)) { + err(ts, z161, 0x010, 0, 0, Local0, 0x12345678) + } + if (LNotEqual(bf00, 0x12345678)) { + err(ts, z161, 0x010, 0, 0, bf00, 0x12345678) + } + + Return(POUT) +} + +/* + * LEqual of Buffers + * + * fail + */ +Method(mf11) +{ + Name(ts, "mf11") + Name(b000, Buffer(4) {0x10, 0x11, 0x12, 0x13}) + Name(b001, Buffer(4) {0x10, 0x11, 0x12, 0x13}) + + LEqual(b000, b001) + + Return(POUT) +} + +/* + * Method calculation stack overflow + * + * If remove one level the test succeeds + * + * fail + */ +Method(mf12) +{ + Name(ts, "mf12") + + Name(i000, 0) + Name(i001, 0) + Name(i002, 0) + Name(i003, 0) + Name(i004, 0) + Name(i005, 0) + Name(i006, 0) + Name(i007, 0) + Name(i008, 0) + Name(i009, 0) + Name(i00a, 0) + Name(i00b, 0) + Name(i00c, 0) + + Method(m000) + { + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + Method(m009) + { + Method(m00a) + { + Method(m00b) + { + Method(m00c) + { + Store(0xabcd000c, i00c) + } + Store(0xabcd000b, i00b) + m00c() + } + Store(0xabcd000a, i00a) + m00b() + } + Store(0xabcd0009, i009) + m00a() + } + Store(0xabcd0008, i008) + m009() + } + Store(0xabcd0007, i007) + m008() + } + Store(0xabcd0006, i006) + m007() + } + Store(0xabcd0005, i005) + m006() + } + Store(0xabcd0004, i004) + m005() + } + Store(0xabcd0003, i003) + m004() + } + Store(0xabcd0002, i002) + m003() + } + Store(0xabcd0001, i001) + m002() + } + Store(0xabcd0000, i000) + m001() + } + + /* + * If remove one level the test succeeds + */ + m000() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z161, 0x012, 0, 0, i000, 0xabcd0000) + } + if (LNotEqual(i001, 0xabcd0001)) { + err(ts, z161, 0x013, 0, 0, i001, 0xabcd0001) + } + if (LNotEqual(i002, 0xabcd0002)) { + err(ts, z161, 0x014, 0, 0, i002, 0xabcd0002) + } + if (LNotEqual(i003, 0xabcd0003)) { + err(ts, z161, 0x015, 0, 0, i003, 0xabcd0003) + } + if (LNotEqual(i004, 0xabcd0004)) { + err(ts, z161, 0x016, 0, 0, i004, 0xabcd0004) + } + if (LNotEqual(i005, 0xabcd0005)) { + err(ts, z161, 0x017, 0, 0, i005, 0xabcd0005) + } + if (LNotEqual(i006, 0xabcd0006)) { + err(ts, z161, 0x018, 0, 0, i006, 0xabcd0006) + } + if (LNotEqual(i007, 0xabcd0007)) { + err(ts, z161, 0x019, 0, 0, i007, 0xabcd0007) + } + if (LNotEqual(i008, 0xabcd0008)) { + err(ts, z161, 0x01a, 0, 0, i008, 0xabcd0008) + } + if (LNotEqual(i009, 0xabcd0009)) { + err(ts, z161, 0x01b, 0, 0, i009, 0xabcd0009) + } + if (LNotEqual(i00a, 0xabcd000a)) { + err(ts, z161, 0x01c, 0, 0, i00a, 0xabcd000a) + } + if (LNotEqual(i00b, 0xabcd000b)) { + err(ts, z161, 0x01d, 0, 0, i00b, 0xabcd000b) + } + if (LNotEqual(i00c, 0xabcd000c)) { + err(ts, z161, 0x01d, 0, 0, i00c, 0xabcd000c) + } + + Return(POUT) +} + +/* + * Method calculation stack overflow + * + * If remove one level the test succeeds + * + * fail + */ +Method(mf13) +{ + Name(ts, "mf13") + + Name(i000, 0) + Name(i001, 0) + Name(i002, 0) + Name(i003, 0) + Name(i004, 0) + Name(i005, 0) + Name(i006, 0) + Name(i007, 0) + Name(i008, 0) + Name(i009, 0) + Name(i00a, 0) + Name(i00b, 0) + Name(i00c, 0) + Name(i00d, 0) + Name(i00e, 0) + Name(i00f, 0) + Name(i010, 0) + + + Method(m000) + { + Store(0xabcd0000, i000) + } + Method(m001) + { + Store(0xabcd0001, i001) + m000() + } + Method(m002) + { + Store(0xabcd0002, i002) + m001() + } + Method(m003) + { + Store(0xabcd0003, i003) + m002() + } + Method(m004) + { + Store(0xabcd0004, i004) + m003() + } + Method(m005) + { + Store(0xabcd0005, i005) + m004() + } + Method(m006) + { + Store(0xabcd0006, i006) + m005() + } + Method(m007) + { + Store(0xabcd0007, i007) + m006() + } + Method(m008) + { + Store(0xabcd0008, i008) + m007() + } + Method(m009) + { + Store(0xabcd0009, i009) + m008() + } + Method(m00a) + { + Store(0xabcd000a, i00a) + m009() + } + Method(m00b) + { + Store(0xabcd000b, i00b) + m00a() + } + Method(m00c) + { + Store(0xabcd000c, i00c) + m00b() + } + Method(m00d) + { + Store(0xabcd000d, i00d) + m00c() + } + Method(m00e) + { + Store(0xabcd000e, i00e) + m00d() + } + Method(m00f) + { + Store(0xabcd000f, i00f) + m00e() + } + Method(m010) + { + Store(0xabcd0010, i010) + m00f() + } + + + /* + * If remove one level the test succeeds + */ + m010() + + + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z161, 0x012, 0, 0, i000, 0xabcd0000) + } + if (LNotEqual(i001, 0xabcd0001)) { + err(ts, z161, 0x013, 0, 0, i001, 0xabcd0001) + } + if (LNotEqual(i002, 0xabcd0002)) { + err(ts, z161, 0x014, 0, 0, i002, 0xabcd0002) + } + if (LNotEqual(i003, 0xabcd0003)) { + err(ts, z161, 0x015, 0, 0, i003, 0xabcd0003) + } + if (LNotEqual(i004, 0xabcd0004)) { + err(ts, z161, 0x016, 0, 0, i004, 0xabcd0004) + } + if (LNotEqual(i005, 0xabcd0005)) { + err(ts, z161, 0x017, 0, 0, i005, 0xabcd0005) + } + if (LNotEqual(i006, 0xabcd0006)) { + err(ts, z161, 0x018, 0, 0, i006, 0xabcd0006) + } + if (LNotEqual(i007, 0xabcd0007)) { + err(ts, z161, 0x019, 0, 0, i007, 0xabcd0007) + } + if (LNotEqual(i008, 0xabcd0008)) { + err(ts, z161, 0x01a, 0, 0, i008, 0xabcd0008) + } + if (LNotEqual(i009, 0xabcd0009)) { + err(ts, z161, 0x01b, 0, 0, i009, 0xabcd0009) + } + if (LNotEqual(i00a, 0xabcd000a)) { + err(ts, z161, 0x01c, 0, 0, i00a, 0xabcd000a) + } + if (LNotEqual(i00b, 0xabcd000b)) { + err(ts, z161, 0x01d, 0, 0, i00b, 0xabcd000b) + } + if (LNotEqual(i00c, 0xabcd000c)) { + err(ts, z161, 0x01d, 0, 0, i00c, 0xabcd000c) + } + if (LNotEqual(i00d, 0xabcd000d)) { + err(ts, z161, 0x01d, 0, 0, i00d, 0xabcd000d) + } + if (LNotEqual(i00e, 0xabcd000e)) { + err(ts, z161, 0x01d, 0, 0, i00e, 0xabcd000e) + } + if (LNotEqual(i00f, 0xabcd000f)) { + err(ts, z161, 0x01d, 0, 0, i00f, 0xabcd000f) + } + if (LNotEqual(i010, 0xabcd0010)) { + err(ts, z161, 0x01d, 0, 0, i010, 0xabcd0010) + } + + Return(POUT) +} + +/* + * Check Timer + * + * fail + */ +Method(mf14) +{ + Name(ts, "mf14") + Name(i000, 0) + + Store(Timer, i000) + OUTP(i000) + + Return(POUT) +} + +/* + * Mod + * + * fail + */ +Method(mf15) +{ + Name(ts, "mf15") + + Store(0x1234567d, Local1) + Store(8, Local2) + + /* This Mod breaks */ + Mod(Local1, Local2, Local0) + + OUTP(Local0) + + if (chk0) { + if (LNotEqual(Local0, 5)) { + err(ts, z161, 0x004, 0, 0, Local0, 5) + } + } + + Return(POUT) +} + +/* + * Return (Package) + * + * success + */ +Method(mf16) +{ + Name(ts, "mf16") + + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0003}) + + Method(m000, 1) + { + Return (arg0) + } + + Store(m000(p000), Local0) + Store(DerefOf(Index(Local0, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z161, 0x006, 0, 0, Local0, 0xabcd0001) + } + + Return(POUT) +} + +/* + * Return (Package) + * + * success + */ +Method(mf17) +{ + Name(ts, "mf17") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0003}) + + Method(m000) + { + Name(pp00, Package() {0xabcd0000, 0xabcd0001, 0xabcd0003}) + + Return (pp00) + } + + Store(m000(), Local0) + Store(DerefOf(Index(Local0, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z161, 0x006, 0, 0, Local0, 0xabcd0001) + } + + Return(POUT) +} + +/* + * LEqual (String, String) + * + * fail + */ +Method(mf18) +{ + Name(ts, "mf18") + Name(s000, "qwertyuiop") + Name(s001, "qwertyuiop") + + LEqual(s000, s001) + + if (chk0) { + Store(LEqual(s000, s001), Local0) + if (LNot(Local0)) { + err(ts, z161, 0x006, 0, 0, Local0, Ones) + } + } + + Return(POUT) +} + +/* + * LEqual (Buffer, Buffer) + * + * fail + */ +Method(mf19) +{ + Name(ts, "mf19") + Name(b000, Buffer(4) {0x10, 0x11, 0x12, 0x13}) + Name(b001, Buffer(4) {0x10, 0x11, 0x12, 0x13}) + + LEqual(b000, b001) + + if (chk0) { + Store(LEqual(b000, b001), Local0) + if (LNot(Local0)) { + err(ts, z161, 0x006, 0, 0, Local0, Ones) + } + } + + Return(POUT) +} + +/* + * Store (Package, Package) + * + * fail + */ +Method(mf1a) +{ + Name(ts, "mf1a") + + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0003}) + Name(pp00, Package(3) {}) + + Store(p000, pp00) + + if (chk0) { + Store(DerefOf(Index(pp00, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z161, 0x006, 0, 0, Local0, 0xabcd0001) + } + } + + Return(POUT) +} + +/* + * Add (String, String) + * + * fail + */ +Method(mf1b) +{ + Name(ts, "mf1b") + Name(s000, "12345678") + Name(s001, "56789012") + + Add(s000, s001) + + if (chk0) { + Store(Add(s000, s001), Local0) + if (LNotEqual(Local0, 0x68ACE68A)) { + err(ts, z161, 0x006, 0, 0, Local0, 0x68ACE68A) + } + } + + Return(POUT) +} + +/* + * Add (Buffer, Buffer) + * + * fail + */ +Method(mf1c) +{ + Name(ts, "mf1c") + Name(b000, Buffer(4) {0x10, 0x11, 0x12, 0x13}) + Name(b001, Buffer(4) {0x24, 0x35, 0x46, 0x57}) + + Add(b000, b001) + + if (chk0) { + Store(Add(b000, b001), Local0) + if (LNotEqual(Local0, 0x6A584634)) { + err(ts, z161, 0x006, 0, 0, Local0, 0x6A584634) + } + } + + Return(POUT) +} + +/* + * LEqual (Field, ....) + * + * success + */ +Method(mf1d) +{ + Name(ts, "mf1d") + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) {f000,32} + + Store(0xabcd0000, f000) + + LEqual(f000, 0xabcd0000) + + Store(LEqual(f000, 0xabcd0000), Local0) + if (LNot(Local0)) { + err(ts, z161, 0x006, 0, 0, Local0, Ones) + } + + Return(POUT) +} + +/* + * LEqual (Field, ....) + * + * success + */ +Method(mf1e) +{ + Name(ts, "mf1e") + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) {f000,32} + + Store(0xabcd0000, f000) + + Method(m000, 1) + { + Store(LEqual(arg0, 0xabcd0000), Local0) + Return (Local0) + } + + m000(f000) + + Store(m000(f000), Local0) + if (LNot(Local0)) { + err(ts, z161, 0x006, 0, 0, Local0, Ones) + } + + Return(POUT) +} + +/* + * LNotEqual (Field, ....) + * + * success + */ +Method(mf1f) +{ + Name(ts, "mf1f") + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) {f000,32} + + Store(0xabcd0000, f000) + + Method(m000, 1) + { + if (LNotEqual(arg0, 0xabcd0000)) { + err(ts, z161, 0x007, 0, 0, arg0, 0xabcd0000) + } + } + + m000(f000) + + Return(POUT) +} + +/* + * Add (Field, .......) + * + * success + */ +Method(mf20) +{ + Name(ts, "mf20") + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) {f000,32} + + Store(0xabcd0000, f000) + + Add(f000, 0x12) + + Store(Add(f000, 0x12), Local0) + if (LNotEqual(Local0, 0xabcd0012)) { + err(ts, z161, 0x006, 0, 0, Local0, 0xabcd0012) + } + + Return(POUT) +} + +/* + * Add (Field, .......) + * + * success + */ +Method(mf21) +{ + Name(ts, "mf21") + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) {f000,32} + + Store(0xabcd0000, f000) + + Method(m000, 1) + { + Store(Add(arg0, 0x12), Local0) + Return (Local0) + } + + m000(f000) + + Store(m000(f000), Local0) + if (LNotEqual(Local0, 0xabcd0012)) { + err(ts, z161, 0x006, 0, 0, Local0, 0xabcd0012) + } + + Return(POUT) +} + +/* + * LNotEqual (Index Field, ....) + * + * success + */ +Method(mf22) +{ + Name(ts, "mf22") + OperationRegion(r003, SystemMemory, 0x180, 0x080) + Field(r003, ByteAcc, NoLock, Preserve) {f004,32, f005,32} + IndexField(f004, f005, ByteAcc, NoLock, Preserve) {if02,32} + + Store(0xabcd0000, if02) + + Method(m000, 1) + { + if (LNotEqual(arg0, 0xabababab)) { + err(ts, z161, 0x007, 0, 0, arg0, 0xabababab) + } + } + + m000(if02) + + Return(POUT) +} + +/* + * Two the same simultaneously (Index Field, ....) + * + * success + */ +Method(mf23) +{ + Name(ts, "mf23") + OperationRegion(r003, SystemMemory, 0x180, 0x080) + Field(r003, ByteAcc, NoLock, Preserve) {f004,32, f005,32} + IndexField(f004, f005, ByteAcc, NoLock, Preserve) {if02,32} + + Store(0xabcd0000, if02) + + Method(m000, 2) + { + if (LNotEqual(arg0, 0xabababab)) { + err(ts, z161, 0x007, 0, 0, arg0, 0xabababab) + } + if (LNotEqual(arg1, 0xabababab)) { + err(ts, z161, 0x007, 0, 0, arg1, 0xabababab) + } + } + + m000(if02, if02) + + Return(POUT) +} + +/* + * Two the same simultaneously (Index Field, ....) + * + * success + */ +Method(mf24) +{ + Name(ts, "mf24") + OperationRegion(r003, SystemMemory, 0x180, 0x080) + Field(r003, ByteAcc, NoLock, Preserve) {f004,32, f005,32} + IndexField(f004, f005, ByteAcc, NoLock, Preserve) {if02,32} + + Store(0xabcd0000, if02) + + Method(m001, 1) + { + if (LNotEqual(arg0, 0xabababab)) { + err(ts, z161, 0x007, 0, 0, arg0, 0xabababab) + } + Return (arg0) + } + Method(m002, 2) + { + if (LNotEqual(arg0, 0xabababab)) { + err(ts, z161, 0x007, 0, 0, arg0, 0xabababab) + } + if (LNotEqual(arg1, 0xabababab)) { + err(ts, z161, 0x007, 0, 0, arg1, 0xabababab) + } + Return (arg1) + } + + Store(m001(if02), Local0) + Store(m002(if02, if02), Local0) + + Return(POUT) +} + +/* + * Store (Device, Local) + * + * succeed + */ +Method(mf25) +{ + Name(ts, "mf25") + Device(d000) { Name(id00, 0xabcd0005) } + + Store(d000, Local1) + + Store(ObjectType(Local1), Local0) + if (LNotEqual(Local0, c00e)) { + err(ts, z161, 0x000, 0, 0, Local0, c00e) + } + + Return(POUT) +} + +/* + * Store (Event, Local) + * + * success + */ +Method(mf27) +{ + Name(ts, "mf27") + Event(e000) + + Store(e000, Local1) + + Store(ObjectType(Local1), Local0) + if (LNotEqual(Local0, c00f)) { + err(ts, z161, 0x000, 0, 0, Local0, c00f) + } + + Return(POUT) +} + +/* + * Store (Mutex, Local) + * + * success + */ +Method(mf28) +{ + Name(ts, "mf28") + Mutex(mx00, 0) + + Store(mx00, Local1) + + Store(ObjectType(Local1), Local0) + if (LNotEqual(Local0, c011)) { + err(ts, z161, 0x000, 0, 0, Local0, c011) + } + + Return(POUT) +} + +/* + * Store (Event, Local) + * + * success + */ +Method(mf29, 1) +{ + Name(ts, "mf29") + Event(e000) + + Store(e000, arg0) + + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c00f)) { + err(ts, z161, 0x000, 0, 0, Local0, c00f) + } + + Return(POUT) +} + +/* + * Store (Mutex, Local) + * + * success + */ +Method(mf2a, 1) +{ + Name(ts, "mf2a") + Mutex(mx00, 0) + + Store(mx00, arg0) + + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c011)) { + err(ts, z161, 0x000, 0, 0, Local0, c011) + } + + Return(POUT) +} + +/* + * Store (Device, Local) + * Store (another type object, into the same Local) + * + * fail + */ +Method(mf2b) +{ + Name(ts, "mf2b") + Device(d000) { Name(id00, 0xabcd0005) } + + Store(d000, Local1) + Store(0, Local1) + + if (chk0) { + Store(d000, Local1) + Store(ObjectType(Local1), Local0) + if (LNotEqual(Local0, c00e)) { + err(ts, z161, 0x000, 0, 0, Local0, c00e) + } + } + + Return(POUT) +} + +/* + * Store (Device, Arg) + * Store (another type object, into the same Arg) + * + * fail + */ +Method(mf2c, 1) +{ + Name(ts, "mf2c") + Device(d000) { Name(id00, 0xabcd0005) } + + Store(d000, arg0) + Store(0, arg0) + + if (chk0) { + Store(d000, arg0) + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c00e)) { + err(ts, z161, 0x000, 0, 0, Local0, c00e) + } + } + + Return(POUT) +} + + +Method(msf0) +{ + SRMT("mf00") + if (chk0) { + mf00() + } else { + BLCK() + } + SRMT("mf01") + mf01() + SRMT("mf02") + if (chk0) { + mf02() + } else { + BLCK() + } + SRMT("mf03") + mf03() + SRMT("mf04") + if (LAnd(chk0, y275)) { + mf04() + } else { + BLCK() + } + SRMT("mf05") + mf05() + SRMT("mf06") + mf06() + SRMT("mf07") + mf07() + SRMT("mf08") + if (chk0) { + mf08() + } else { + BLCK() + } + SRMT("mf09") + if (chk0) { + mf09() + } else { + BLCK() + } + SRMT("mf0a") + mf0a() + SRMT("mf0b") + mf0b() + SRMT("mf0c") + mf0c() + SRMT("mf0d") + if (chk0) { + mf0d() + } else { + BLCK() + } + SRMT("mf0e") + if (chk0) { + mf0e() + } else { + BLCK() + } + SRMT("mf0f") + if (chk0) { + mf0f() + } else { + BLCK() + } + SRMT("mf10") + if (chk0) { + mf10() + } else { + BLCK() + } + SRMT("mf11") + if (chk0) { + mf11() + } else { + BLCK() + } + SRMT("mf12") + if (chk0) { + mf12() + } else { + BLCK() + } + SRMT("mf13") + if (chk0) { + mf13() + } else { + BLCK() + } + SRMT("mf14") + if (chk0) { + mf14() + } else { + BLCK() + } + SRMT("mf15") + if (chk0) { + mf15() + } else { + BLCK() + } + SRMT("mf16") + mf16() + SRMT("mf17") + mf17() + SRMT("mf18") + if (chk0) { + mf18() + } else { + BLCK() + } + SRMT("mf19") + if (chk0) { + mf19() + } else { + BLCK() + } + SRMT("mf1a") + if (chk0) { + mf1a() + } else { + BLCK() + } + SRMT("mf1b") + if (chk0) { + mf1b() + } else { + BLCK() + } + SRMT("mf1c") + if (chk0) { + mf1c() + } else { + BLCK() + } + SRMT("mf1d") + mf1d() + SRMT("mf1e") + mf1e() + SRMT("mf1f") + mf1f() + SRMT("mf20") + mf20() + SRMT("mf21") + mf21() + SRMT("mf22") + mf22() + SRMT("mf23") + mf23() + SRMT("mf24") + mf24() + SRMT("mf25") + if (SLC0) { + mf25() + } else { + BLCK() + } + SRMT("mf26") + if (LAnd(SLC0, chk0)) { + mf26() + } else { + BLCK() + } + SRMT("mf27") + if (SLC0) { + mf27() + } else { + BLCK() + } + SRMT("mf28") + if (SLC0) { + mf28() + } else { + BLCK() + } + SRMT("mf29") + if (SLC0) { + mf29(0) + } else { + BLCK() + } + SRMT("mf2a") + if (SLC0) { + mf2a(0) + } else { + BLCK() + } + SRMT("mf2b") + if (LAnd(SLC0, chk0)) { + mf2b() + } else { + BLCK() + } + SRMT("mf2c") + if (LAnd(SLC0, chk0)) { + mf2c(0) + } else { + BLCK() + } +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/RUN.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/RUN.asl new file mode 100644 index 000000000..d8f8f4acd --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/RUN.asl @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests applicable to both AcpiExec and MS-abbu utilities + */ + +if (STTT("Tests applicable to both AcpiExec and MS-abbu utilities", TCLT, 0, W019)) { + + /* + * The NameSpace tests + */ + + /* Initial */ + ini0() + ini1() + ini2() + ini3() + ini4() + ini5() + + // Device +// dev0() +// mdfe() +// mdff() + + // Method + mtff() + + /* + * Miscellaneous + */ + msff() + msfe() + + /* + * Accumulate features which don't work on MS + */ + msf0() + + // Recursion + mrff() +} +FTTT() diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/SPEC b/tests/aslts/src/runtime/collections/Identity2MS/abbu/SPEC new file mode 100644 index 000000000..0b4a7aea1 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/SPEC @@ -0,0 +1,103 @@ +/* + * Access to elements of combined objects + * + * Device + * Power Resource + * Processor + * Thermal Zone + * Method (access to internal objects of method, + * in case that access is generated not from + * inside that method looks incorrect) + * + * All available ways to access internal + * elements of combined objects are these: + * + * - by name (2-4 below): + * + * 1) ABCD - through the all tree (search rules apply) + * 2) ^...^ABCD - N parents up (search rules do not apply) + * 3) XYZ.ABCD - in current scope only (search rules do not apply) + * 4) \XYZ.ABCD - absolute path (search rules do not apply) + * - pass to Local, Arg, immediately to expressions, etc.. + * + * - by RefOf/DerefOf: + * + * RefOf(d000.i000) + * + * ??????????????????????????????????????????? + * + * - by Index/DerefOf: + * + * Index(d000.p000) + * + * ??????????????????????????????????????????? + * + * - by Fields: + * + * Field + * Index Field + * Bank Field + * Buffer Field + * + * Creating fields features: + * - on the same level + * - inside deeper level (inside call to another level method) + * - parent object is on global/local level + * - parent object is inside some compound type object + * Usage fields features: + * - pass by Arg to method + * - Store/Copy intermediately to Local + * - Store/Copy intermediately to Arg (affectively local) + * - Store/Copy intermediately to Named + * - Store/Copy intermediately to Named of compound object + * - pass immediately to expressions + * Note: don't check there the Implicit Conversion Rules + * + * - Method invocations: + * + * - pass to methods (7,6,...) objects of different type + * - in other checkings pass to method not only the object + * immediately participating in checking but also other + * objects including: + * - parent object of element of package, + * - parent object of element of Field, + * - parent object of IRef Reference, + * - parent object of ORef Reference, + * - original compound object of all other type objects above, + * - pass the same object (see above too) to method by several parameters, + * - etc. + * + * There is no way to specify by ASL code accessing + * elements of combined object in case that combined + * object is represented by: + * + * - ArgX + * - LocalX + * - another Named object where the combined + * object has been copied by CopyObject (see Note below) + * + * Note: if the target object where the combined object is + * copied contains some same name object as source object + * then we can expect that after CopyObject operation that + * object will contain new value the same as in source object + * (exotic case of CopyObject usage). + * I will not verify this case, at least now. + * + * So, there is no much sence to verify behaviour of: + * + * - RefOf to combined object + * - combined object passed by Arg to method + * - combined object Stored/CopyObject to LocalX + * - combined object Stored/CopyObject to ArgX (effective local) + * - combined object Stored/CopyObject to NamedX + * - combined object as element of Package + * + * Exotic (could be done ever): + * All the possible checkings can be implemented (ASL coded) + * to check the behaviour of the object substituted by the + * CopyObject instead of the original one. + * At that the substituted object can be 1) of the same type + * and have a) all the elements the original has and b) not + * all of them are present in the copy and 2) be object of + * some another type than original. + */ diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/ToDo.txt b/tests/aslts/src/runtime/collections/Identity2MS/abbu/ToDo.txt new file mode 100644 index 000000000..d835bed25 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/ToDo.txt @@ -0,0 +1,55 @@ +remained: +======== + + * Device + * Power Resource + * Processor + * Thermal Zone + * Method + +Fields in all type applications +String - do it in main_aslts.asl part +Local & Arg - effectively local, -- what is the behaviour when some type value is passed to it + +Scope +Alias + +m000(int,str,buf,pkg,dev,pwr,pr,tz,mth) +expressions + +======================================================= +// Types, as returned by ObjectType +Name(c008, 0) // Uninitialized +Name(c009, 1) // Integer +Name(c00a, 2) // String +Name(c00b, 3) // Buffer +Name(c00c, 4) // Package +Name(c00d, 5) // Field Unit +Name(c00e, 6) // Device +Name(c00f, 7) // Event +Name(c010, 8) // Method +Name(c011, 9) // Mutex +Name(c012, 10) // Operation Region +Name(c013, 11) // Power Resource +Name(c014, 12) // Processor +Name(c015, 13) // Thermal Zone +Name(c016, 14) // Buffer Field +Name(c017, 15) // DDB Handle +Name(c018, 16) // Debug Object +Name(c019, 17) // LOCAL_REGION_FIELD +Name(c01a, 18) // LOCAL_BANK_FIELD +Name(c01b, 19) // LOCAL_INDEX_FIELD +Name(c01c, 20) // LOCAL_REFERENCE +Name(c01d, 21) // LOCAL_ALIAS +Name(c01e, 22) // LOCAL_METHOD_ALIAS +Name(c01f, 23) // LOCAL_NOTIFY +Name(c020, 24) // LOCAL_ADDRESS_HANDLER +Name(c021, 25) // LOCAL_RESOURCE +Name(c022, 26) // LOCAL_RESOURCE_FIELD +Name(c023, 27) // LOCAL_SCOPE +Name(c024, 28) // LOCAL_EXTRA +Name(c025, 29) // LOCAL_DATA +Name(c027, 30) // Number of different types +========== + +Put all abbu-demos into this test case diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/0_WARNING.HTM b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/0_WARNING.HTM new file mode 100644 index 000000000..660898b43 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/0_WARNING.HTM @@ -0,0 +1 @@ +<html><head><style>td{font-family:Arial;font-size:10pt}</style></head><table cellpadding=0 cellspacing=0><tr><td background=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/toptile.gif><IMG SRC=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/SI-alert-header.gif></td><td background=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/toptile.gif><IMG SRC=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/infosec-header.gif align=right></td></tr><tr><td colspan=2><table><tr><td><img src=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/globe-blocked.gif></td><td><font color=red size=4><b><br>BLOCKED FILE ALERT!</b></font><p>The attachment 'ABBU.EXE' has been blocked because it is a disallowed file type. The attachment has been replaced by this message.</p><p>If you feel you have received this message in error and are an Intel employee, then please contact the <a href=http://servicedesk.intel.com>Global Service Desk</a>.</p><p>More Information:</p><p>If you are an Intel employee and internal to the Intel network, visit <a href=http://secure.intel.com/infosec/response_services/pc+and+network+protection/email+security/email+security.htm>Secure Intel</a> to learn more about E-mail attachment options.</p><p>If you are not an Intel employee, please contact your Intel sponsor for additional information.<br> </p></td></tr></table></td></tr><tr><td bgcolor=0860a8><a href=http://it.intel.com><img src=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/istg-footer.gif border=0></a></td><td bgcolor=0860a8 align=right><font color=white>Copyright © Intel Corporation, 2002-2006. All rights reserved.</font></td></tr><tr><td colspan=2 align=right><font color=#666666>*Other names and brands may be claimed as the property of others.<br>**Intel is not responsible for content of sites outside our intranet.</font></td></tr></table></html>
\ No newline at end of file diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/1_WARNING.HTM b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/1_WARNING.HTM new file mode 100644 index 000000000..255b7ed11 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/1_WARNING.HTM @@ -0,0 +1 @@ +<html><head><style>td{font-family:Arial;font-size:10pt}</style></head><table cellpadding=0 cellspacing=0><tr><td background=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/toptile.gif><IMG SRC=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/SI-alert-header.gif></td><td background=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/toptile.gif><IMG SRC=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/infosec-header.gif align=right></td></tr><tr><td colspan=2><table><tr><td><img src=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/globe-blocked.gif></td><td><font color=red size=4><b><br>BLOCKED FILE ALERT!</b></font><p>The attachment 'ABBU.INF' has been blocked because it is a disallowed file type. The attachment has been replaced by this message.</p><p>If you feel you have received this message in error and are an Intel employee, then please contact the <a href=http://servicedesk.intel.com>Global Service Desk</a>.</p><p>More Information:</p><p>If you are an Intel employee and internal to the Intel network, visit <a href=http://secure.intel.com/infosec/response_services/pc+and+network+protection/email+security/email+security.htm>Secure Intel</a> to learn more about E-mail attachment options.</p><p>If you are not an Intel employee, please contact your Intel sponsor for additional information.<br> </p></td></tr></table></td></tr><tr><td bgcolor=0860a8><a href=http://it.intel.com><img src=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/istg-footer.gif border=0></a></td><td bgcolor=0860a8 align=right><font color=white>Copyright © Intel Corporation, 2002-2006. All rights reserved.</font></td></tr><tr><td colspan=2 align=right><font color=#666666>*Other names and brands may be claimed as the property of others.<br>**Intel is not responsible for content of sites outside our intranet.</font></td></tr></table></html>
\ No newline at end of file diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/2_WARNING.HTM b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/2_WARNING.HTM new file mode 100644 index 000000000..3d983fa98 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/2_WARNING.HTM @@ -0,0 +1 @@ +<html><head><style>td{font-family:Arial;font-size:10pt}</style></head><table cellpadding=0 cellspacing=0><tr><td background=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/toptile.gif><IMG SRC=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/SI-alert-header.gif></td><td background=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/toptile.gif><IMG SRC=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/infosec-header.gif align=right></td></tr><tr><td colspan=2><table><tr><td><img src=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/globe-blocked.gif></td><td><font color=red size=4><b><br>BLOCKED FILE ALERT!</b></font><p>The attachment 'ABBU.SYS' has been blocked because it is a disallowed file type. The attachment has been replaced by this message.</p><p>If you feel you have received this message in error and are an Intel employee, then please contact the <a href=http://servicedesk.intel.com>Global Service Desk</a>.</p><p>More Information:</p><p>If you are an Intel employee and internal to the Intel network, visit <a href=http://secure.intel.com/infosec/response_services/pc+and+network+protection/email+security/email+security.htm>Secure Intel</a> to learn more about E-mail attachment options.</p><p>If you are not an Intel employee, please contact your Intel sponsor for additional information.<br> </p></td></tr></table></td></tr><tr><td bgcolor=0860a8><a href=http://it.intel.com><img src=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/istg-footer.gif border=0></a></td><td bgcolor=0860a8 align=right><font color=white>Copyright © Intel Corporation, 2002-2006. All rights reserved.</font></td></tr><tr><td colspan=2 align=right><font color=#666666>*Other names and brands may be claimed as the property of others.<br>**Intel is not responsible for content of sites outside our intranet.</font></td></tr></table></html>
\ No newline at end of file diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/3_WARNING.HTM b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/3_WARNING.HTM new file mode 100644 index 000000000..50be110e9 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/3_WARNING.HTM @@ -0,0 +1 @@ +<html><head><style>td{font-family:Arial;font-size:10pt}</style></head><table cellpadding=0 cellspacing=0><tr><td background=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/toptile.gif><IMG SRC=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/SI-alert-header.gif></td><td background=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/toptile.gif><IMG SRC=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/infosec-header.gif align=right></td></tr><tr><td colspan=2><table><tr><td><img src=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/globe-blocked.gif></td><td><font color=red size=4><b><br>BLOCKED FILE ALERT!</b></font><p>The attachment 'ACPIDUMP.EXE' has been blocked because it is a disallowed file type. The attachment has been replaced by this message.</p><p>If you feel you have received this message in error and are an Intel employee, then please contact the <a href=http://servicedesk.intel.com>Global Service Desk</a>.</p><p>More Information:</p><p>If you are an Intel employee and internal to the Intel network, visit <a href=http://secure.intel.com/infosec/response_services/pc+and+network+protection/email+security/email+security.htm>Secure Intel</a> to learn more about E-mail attachment options.</p><p>If you are not an Intel employee, please contact your Intel sponsor for additional information.<br> </p></td></tr></table></td></tr><tr><td bgcolor=0860a8><a href=http://it.intel.com><img src=http://intel.speedera.net/xcache.intel.com/Remediation/Images/Email/Block/istg-footer.gif border=0></a></td><td bgcolor=0860a8 align=right><font color=white>Copyright © Intel Corporation, 2002-2006. All rights reserved.</font></td></tr><tr><td colspan=2 align=right><font color=#666666>*Other names and brands may be claimed as the property of others.<br>**Intel is not responsible for content of sites outside our intranet.</font></td></tr></table></html>
\ No newline at end of file diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/AslCompiler.pdf b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/AslCompiler.pdf Binary files differnew file mode 100644 index 000000000..d674be592 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/AslCompiler.pdf diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/DSDT.AML b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/DSDT.AML Binary files differnew file mode 100644 index 000000000..6b16dc814 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/DSDT.AML diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/DSDT.TAB b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/DSDT.TAB Binary files differnew file mode 100644 index 000000000..3d33af177 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/DSDT.TAB diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/DSDT.dsl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/DSDT.dsl new file mode 100644 index 000000000..501dfbaff --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/DSDT.dsl @@ -0,0 +1,9656 @@ +/* + * Intel ACPI Component Architecture + * AML Disassembler version 20021002 + * + * Disassembly of DSDT.AML, Wed Aug 30 20:30:19 2006 + */ +DefinitionBlock ("DSDT.aml", "DSDT", 1, "IBM ", "TP-T20 ", 100930080) +{ + Scope (\_PR) + { + Processor (CPU, 0x01, 0x00001010, 0x06) {} + } + + Scope (\_SB) + { + Device (LNKA) + { + Name (_HID, EisaId ("PNP0C0F")) + Name (_UID, 0x01) + Method (_STA, 0, NotSerialized) + { + If (LNot (VPIR (\_SB.PCI0.ISA.PIRA))) + { + Return (0x09) + } + Else + { + Return (0x0B) + } + } + + Name (_PRS, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11} + }) + Method (_DIS, 0, NotSerialized) + { + Or (\_SB.PCI0.ISA.PIRA, 0x80, \_SB.PCI0.ISA.PIRA) + } + + Method (_CRS, 0, NotSerialized) + { + Name (BUFA, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {} + }) + CreateWordField (BUFA, 0x01, IRA1) + And (\_SB.PCI0.ISA.PIRA, 0x8F, Local0) + If (VPIR (Local0)) + { + Store (ShiftLeft (One, Local0), IRA1) + } + + Return (BUFA) + } + + Method (_SRS, 1, NotSerialized) + { + CreateWordField (Arg0, 0x01, IRA2) + FindSetRightBit (IRA2, Local0) + And (\_SB.PCI0.ISA.PIRA, 0x70, Local1) + Or (Local1, Decrement (Local0), Local1) + Store (Local1, \_SB.PCI0.ISA.PIRA) + } + } + + Device (LNKB) + { + Name (_HID, EisaId ("PNP0C0F")) + Name (_UID, 0x02) + Method (_STA, 0, NotSerialized) + { + If (LNot (VPIR (\_SB.PCI0.ISA.PIRB))) + { + Return (0x09) + } + Else + { + Return (0x0B) + } + } + + Name (_PRS, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11} + }) + Method (_DIS, 0, NotSerialized) + { + Or (\_SB.PCI0.ISA.PIRB, 0x80, \_SB.PCI0.ISA.PIRB) + } + + Method (_CRS, 0, NotSerialized) + { + Name (BUFB, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {} + }) + CreateWordField (BUFB, 0x01, IRB1) + And (\_SB.PCI0.ISA.PIRB, 0x8F, Local0) + If (VPIR (Local0)) + { + Store (ShiftLeft (One, Local0), IRB1) + } + + Return (BUFB) + } + + Method (_SRS, 1, NotSerialized) + { + CreateWordField (Arg0, 0x01, IRB2) + FindSetRightBit (IRB2, Local0) + And (\_SB.PCI0.ISA.PIRB, 0x70, Local1) + Or (Local1, Decrement (Local0), Local1) + Store (Local1, \_SB.PCI0.ISA.PIRB) + } + } + + Device (LNKC) + { + Name (_HID, EisaId ("PNP0C0F")) + Name (_UID, 0x03) + Method (_STA, 0, NotSerialized) + { + If (LNot (VPIR (\_SB.PCI0.ISA.PIRC))) + { + Return (0x09) + } + Else + { + Return (0x0B) + } + } + + Name (_PRS, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11} + }) + Method (_DIS, 0, NotSerialized) + { + Or (\_SB.PCI0.ISA.PIRC, 0x80, \_SB.PCI0.ISA.PIRC) + } + + Method (_CRS, 0, NotSerialized) + { + Name (BUFC, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {} + }) + CreateWordField (BUFC, 0x01, IRC1) + And (\_SB.PCI0.ISA.PIRC, 0x8F, Local0) + If (VPIR (Local0)) + { + Store (ShiftLeft (One, Local0), IRC1) + } + + Return (BUFC) + } + + Method (_SRS, 1, NotSerialized) + { + CreateWordField (Arg0, 0x01, IRC2) + FindSetRightBit (IRC2, Local0) + And (\_SB.PCI0.ISA.PIRC, 0x70, Local1) + Or (Local1, Decrement (Local0), Local1) + Store (Local1, \_SB.PCI0.ISA.PIRC) + } + } + + Device (LNKD) + { + Name (_HID, EisaId ("PNP0C0F")) + Name (_UID, 0x04) + Method (_STA, 0, NotSerialized) + { + If (LNot (VPIR (\_SB.PCI0.ISA.PIRD))) + { + Return (0x09) + } + Else + { + Return (0x0B) + } + } + + Name (_PRS, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11} + }) + Method (_DIS, 0, NotSerialized) + { + Or (\_SB.PCI0.ISA.PIRD, 0x80, \_SB.PCI0.ISA.PIRD) + } + + Method (_CRS, 0, NotSerialized) + { + Name (BUFD, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {} + }) + CreateWordField (BUFD, 0x01, IRD1) + And (\_SB.PCI0.ISA.PIRD, 0x8F, Local0) + If (VPIR (Local0)) + { + Store (ShiftLeft (One, Local0), IRD1) + } + + Return (BUFD) + } + + Method (_SRS, 1, NotSerialized) + { + CreateWordField (Arg0, 0x01, IRD2) + FindSetRightBit (IRD2, Local0) + And (\_SB.PCI0.ISA.PIRD, 0x70, Local1) + Or (Local1, Decrement (Local0), Local1) + Store (Local1, \_SB.PCI0.ISA.PIRD) + } + } + + Method (VPIR, 1, NotSerialized) + { + Store (One, Local0) + If (And (Arg0, 0x80)) + { + Store (Zero, Local0) + } + Else + { + And (Arg0, 0x0F, Local1) + If (LLess (Local1, 0x03)) + { + Store (Zero, Local0) + } + Else + { + If (LOr (LEqual (Local1, 0x08), LEqual (Local1, 0x0D))) + { + Store (Zero, Local0) + } + } + } + + Return (Local0) + } + + Device (MEM) + { + Name (_HID, EisaId ("PNP0C01")) + Name (ME98, ResourceTemplate () + { + Memory32Fixed (ReadWrite, 0x00000000, 0x000A0000) + Memory32Fixed (ReadOnly, 0x000E0000, 0x00020000) + Memory32Fixed (ReadWrite, 0x00100000, 0x01EE0000) + Memory32Fixed (ReadOnly, 0xFFF80000, 0x00080000) + }) + CreateDWordField (ME98, 0x1C, MEB0) + CreateDWordField (ME98, 0x20, MEL0) + Name (MGAP, ResourceTemplate () + { + Memory32Fixed (ReadOnly, 0x00000000, 0x00000000) + }) + CreateDWordField (MGAP, 0x04, MGPB) + CreateDWordField (MGAP, 0x08, MGPL) + Name (MEMS, ResourceTemplate () + { + Memory32Fixed (ReadWrite, 0x00000000, 0x000A0000) + Memory32Fixed (ReadOnly, 0x000C0000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000C4000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000C8000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000CC000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000D0000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000D4000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000D8000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000DC000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000E0000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000E4000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000E8000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000EC000, 0x00000000) + Memory32Fixed (ReadOnly, 0x000F0000, 0x00010000) + Memory32Fixed (ReadWrite, 0x00100000, 0x01EE0000) + Memory32Fixed (ReadOnly, 0xFFF80000, 0x00080000) + }) + CreateDWordField (MEMS, 0x14, MC0L) + CreateDWordField (MEMS, 0x20, MC4L) + CreateDWordField (MEMS, 0x2C, MC8L) + CreateDWordField (MEMS, 0x38, MCCL) + CreateDWordField (MEMS, 0x44, MD0L) + CreateDWordField (MEMS, 0x50, MD4L) + CreateDWordField (MEMS, 0x5C, MD8L) + CreateDWordField (MEMS, 0x68, MDCL) + CreateDWordField (MEMS, 0x74, ME0L) + CreateDWordField (MEMS, 0x80, ME4L) + CreateDWordField (MEMS, 0x8C, ME8L) + CreateDWordField (MEMS, 0x98, MECL) + CreateBitField (MEMS, 0x78, MC0W) + CreateBitField (MEMS, 0xD8, MC4W) + CreateBitField (MEMS, 0x0138, MC8W) + CreateBitField (MEMS, 0x0198, MCCW) + CreateBitField (MEMS, 0x01F8, MD0W) + CreateBitField (MEMS, 0x0258, MD4W) + CreateBitField (MEMS, 0x02B8, MD8W) + CreateBitField (MEMS, 0x0318, MDCW) + CreateBitField (MEMS, 0x0378, ME0W) + CreateBitField (MEMS, 0x03D8, ME4W) + CreateBitField (MEMS, 0x0438, ME8W) + CreateBitField (MEMS, 0x0498, MECW) + CreateDWordField (MEMS, 0xAC, MEB1) + CreateDWordField (MEMS, 0xB0, MEL1) + Method (_CRS, 0, NotSerialized) + { + If (\W98F) + { + Subtract (\MEMX, MEB0, MEL0) + Store (\GGAP (0x00), MGPB) + Store (\GGAP (0x01), MGPL) + If (LAnd (MGPB, MGPL)) + { + Subtract (SizeOf (ME98), 0x02, Local0) + Name (MBF0, Buffer (Local0) {}) + Add (Local0, SizeOf (MGAP), Local0) + Name (MBF1, Buffer (Local0) {}) + Store (ME98, MBF0) + Concatenate (MBF0, MGAP, MBF1) + Return (MBF1) + } + Else + { + Return (ME98) + } + } + + And (\_SB.PCI0.PAM1, 0x03, Local0) + If (Local0) + { + Store (0x4000, MC0L) + If (And (Local0, 0x02)) + { + Store (0x01, MC0W) + } + } + + And (\_SB.PCI0.PAM1, 0x30, Local0) + If (Local0) + { + Store (0x4000, MC4L) + If (And (Local0, 0x20)) + { + Store (0x01, MC4W) + } + } + + And (\_SB.PCI0.PAM2, 0x03, Local0) + If (Local0) + { + Store (0x4000, MC8L) + If (And (Local0, 0x02)) + { + Store (0x01, MC8W) + } + } + + And (\_SB.PCI0.PAM2, 0x30, Local0) + If (Local0) + { + Store (0x4000, MCCL) + If (And (Local0, 0x20)) + { + Store (0x01, MCCW) + } + } + + And (\_SB.PCI0.PAM3, 0x03, Local0) + If (Local0) + { + Store (0x4000, MD0L) + If (And (Local0, 0x02)) + { + Store (0x01, MD0W) + } + } + + And (\_SB.PCI0.PAM3, 0x30, Local0) + If (Local0) + { + Store (0x4000, MD4L) + If (And (Local0, 0x20)) + { + Store (0x01, MD4W) + } + } + + And (\_SB.PCI0.PAM4, 0x03, Local0) + If (Local0) + { + Store (0x4000, MD8L) + If (And (Local0, 0x02)) + { + Store (0x01, MD8W) + } + } + + And (\_SB.PCI0.PAM4, 0x30, Local0) + If (Local0) + { + Store (0x4000, MDCL) + If (And (Local0, 0x20)) + { + Store (0x01, MDCW) + } + } + + And (\_SB.PCI0.PAM5, 0x03, Local0) + If (Local0) + { + Store (0x4000, ME0L) + If (And (Local0, 0x02)) + { + Store (0x01, ME0W) + } + } + + And (\_SB.PCI0.PAM5, 0x30, Local0) + If (Local0) + { + Store (0x4000, ME4L) + If (And (Local0, 0x20)) + { + Store (0x01, ME4W) + } + } + + And (\_SB.PCI0.PAM6, 0x03, Local0) + If (Local0) + { + Store (0x4000, ME8L) + If (And (Local0, 0x02)) + { + Store (0x01, ME8W) + } + } + + And (\_SB.PCI0.PAM6, 0x30, Local0) + If (Local0) + { + Store (0x4000, MECL) + If (And (Local0, 0x20)) + { + Store (0x01, MECW) + } + } + + Subtract (\MEMX, MEB1, MEL1) + Return (MEMS) + } + } + + Device (LID) + { + Name (_HID, EisaId ("PNP0C0D")) + Method (_LID, 0, NotSerialized) + { + If (\H8DR) + { + Return (\_SB.PCI0.ISA.EC.HPLD) + } + Else + { + If (And (\RBEC (0x36), 0x04)) + { + Return (0x01) + } + Else + { + Return (0x00) + } + } + } + + Method (_PRW, 0, NotSerialized) + { + If (LAnd (\W98F, LNot (\WMEF))) + { + Return (Package (0x02) + { + 0x0B, + 0x04 + }) + } + Else + { + Return (Package (0x02) + { + 0x0B, + 0x03 + }) + } + } + + Method (_PSW, 1, NotSerialized) + { + If (\H8DR) + { + If (Arg0) + { + Store (One, \_SB.PCI0.ISA.EC.HWLO) + } + Else + { + Store (Zero, \_SB.PCI0.ISA.EC.HWLO) + } + } + Else + { + If (Arg0) + { + \MBEC (0x32, 0xFF, 0x04) + } + Else + { + \MBEC (0x32, 0xFB, 0x00) + } + } + } + } + + Device (SLPB) + { + Name (_HID, EisaId ("PNP0C0E")) + Method (_PRW, 0, NotSerialized) + { + If (LAnd (\W98F, LNot (\WMEF))) + { + Return (Package (0x02) + { + 0x0B, + 0x04 + }) + } + Else + { + Return (Package (0x02) + { + 0x0B, + 0x03 + }) + } + } + + Method (_PSW, 1, NotSerialized) + { + If (\H8DR) + { + If (Arg0) + { + Store (0x01, \_SB.PCI0.ISA.EC.HWFN) + } + Else + { + Store (0x00, \_SB.PCI0.ISA.EC.HWFN) + } + } + Else + { + If (Arg0) + { + \MBEC (0x32, 0xFF, 0x10) + } + Else + { + \MBEC (0x32, 0xEF, 0x00) + } + } + } + } + + Device (PCI0) + { + Name (_ADR, 0x00) + Name (_HID, EisaId ("PNP0A03")) + OperationRegion (X000, PCI_Config, 0x00, 0x0100) + Field (X000, DWordAcc, NoLock, Preserve) + { + Offset (0x59), + PAM0, 8, + PAM1, 8, + PAM2, 8, + PAM3, 8, + PAM4, 8, + PAM5, 8, + PAM6, 8, + DRB0, 8, + DRB1, 8, + DRB2, 8, + DRB3, 8, + DRB4, 8, + DRB5, 8, + DRB6, 8, + DRB7, 8, + Offset (0x7A), + CREN, 1, + Offset (0x7B) + } + + Name (_PRW, Package (0x02) + { + 0x0B, + 0x04 + }) + Method (_PSW, 1, NotSerialized) + { + EPSW (0x01, Arg0) + } + + Name (PMEE, 0x00) + Method (EPSW, 2, NotSerialized) + { + If (Arg1) + { + Or (PMEE, Arg0, Local0) + } + Else + { + And (PMEE, Not (Arg0), Local0) + } + + Store (Local0, PMEE) + If (\H8DR) + { + If (Local0) + { + Store (0x01, \_SB.PCI0.ISA.EC.HWPM) + } + Else + { + Store (0x00, \_SB.PCI0.ISA.EC.HWPM) + } + } + Else + { + If (Local0) + { + \MBEC (0x32, 0xFF, 0x01) + } + Else + { + \MBEC (0x32, 0xFE, 0x00) + } + } + + If (Local0) + { + Store (0x01, \_SB.PCI0.ISA.WOLE) + } + Else + { + Store (0x00, \_SB.PCI0.ISA.WOLE) + } + } + + Name (_CRS, ResourceTemplate () + { + WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, + 0x0000, + 0x0000, + 0x00FF, + 0x0000, + 0x0100) + IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08) + WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000, + 0x0000, + 0x0CF7, + 0x0000, + 0x0CF8) + WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, + 0x0000, + 0x0D00, + 0xFFFF, + 0x0000, + 0xF300) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000A0000, + 0x000BFFFF, + 0x00000000, + 0x00020000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000C0000, + 0x000C3FFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000C4000, + 0x000C7FFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000C8000, + 0x000CBFFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000CC000, + 0x000CFFFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000D0000, + 0x000D3FFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000D4000, + 0x000D7FFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000D8000, + 0x000DBFFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000DC000, + 0x000DFFFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000E0000, + 0x000E3FFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000E4000, + 0x000E7FFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000E8000, + 0x000EBFFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x000EC000, + 0x000EFFFF, + 0x00000000, + 0x00004000) + DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, + 0x00000000, + 0x00100000, + 0xFFDFFFFF, + 0x00000000, + 0xFFD00000) + }) + CreateDWordField (_CRS, 0x68, C0LN) + CreateDWordField (_CRS, 0x82, C4LN) + CreateDWordField (_CRS, 0x9C, C8LN) + CreateDWordField (_CRS, 0xB6, CCLN) + CreateDWordField (_CRS, 0xD0, D0LN) + CreateDWordField (_CRS, 0xEA, D4LN) + CreateDWordField (_CRS, 0x0104, D8LN) + CreateDWordField (_CRS, 0x011E, DCLN) + CreateDWordField (_CRS, 0x0138, E0LN) + CreateDWordField (_CRS, 0x0152, E4LN) + CreateDWordField (_CRS, 0x016C, E8LN) + CreateDWordField (_CRS, 0x0186, ECLN) + CreateDWordField (_CRS, 0x0194, XXMN) + CreateDWordField (_CRS, 0x0198, XXMX) + CreateDWordField (_CRS, 0x01A0, XXLN) + Method (_INI, 0, NotSerialized) + { + If (LEqual (\SCMP (\_OS, "Microsoft Windows"), Zero)) + { + Store (One, \W98F) + } + Else + { + If (LEqual (\SCMP (\_OS, "Microsoft Windows NT"), Zero)) + { + Store (One, \WNTF) + } + Else + { + If (LEqual (\SCMP (\_OS, "Microsoft WindowsME: Millennium Edition"), Zero)) + { + Store (One, \WMEF) + Store (One, \W98F) + } + } + } + + Multiply (DRB7, 0x00800000, Local0) + Store (Local0, \MEMX) + Store (Local0, XXMN) + Add (Subtract (XXMX, XXMN), 0x01, XXLN) + If (And (PAM1, 0x03)) + { + Store (0x00, C0LN) + } + + If (And (PAM1, 0x30)) + { + Store (0x00, C4LN) + } + + If (And (PAM2, 0x03)) + { + Store (0x00, C8LN) + } + + If (And (PAM2, 0x30)) + { + Store (0x00, CCLN) + } + + If (And (PAM3, 0x03)) + { + Store (0x00, D0LN) + } + + If (And (PAM3, 0x30)) + { + Store (0x00, D4LN) + } + + If (And (PAM4, 0x03)) + { + Store (0x00, D8LN) + } + + If (And (PAM4, 0x30)) + { + Store (0x00, DCLN) + } + + If (And (PAM5, 0x03)) + { + Store (0x00, E0LN) + } + + If (And (PAM5, 0x30)) + { + Store (0x00, E4LN) + } + + If (And (PAM6, 0x03)) + { + Store (0x00, E8LN) + } + + If (And (PAM6, 0x30)) + { + Store (0x00, ECLN) + } + + \_SB.PCI0.ISA.GPPM () + If (\GCHK ()) + { + Store (0x01, \GVEN) + } + } + + Name (_PRT, Package (0x07) + { + Package (0x04) + { + 0x0001FFFF, + 0x00, + \_SB.LNKA, + 0x00 + }, + + Package (0x04) + { + 0x0002FFFF, + 0x00, + \_SB.LNKA, + 0x00 + }, + + Package (0x04) + { + 0x0002FFFF, + 0x01, + \_SB.LNKB, + 0x00 + }, + + Package (0x04) + { + 0x0003FFFF, + 0x00, + \_SB.LNKC, + 0x00 + }, + + Package (0x04) + { + 0x0003FFFF, + 0x01, + \_SB.LNKD, + 0x00 + }, + + Package (0x04) + { + 0x0005FFFF, + 0x00, + \_SB.LNKA, + 0x00 + }, + + Package (0x04) + { + 0x0007FFFF, + 0x03, + \_SB.LNKD, + 0x00 + } + }) + Device (IDE0) + { + Name (_ADR, 0x00070001) + OperationRegion (X140, PCI_Config, 0x40, 0x10) + Field (X140, DWordAcc, NoLock, Preserve) + { + XPT0, 1, + XPI0, 1, + XPP0, 1, + XPD0, 1, + XPT1, 1, + XPI1, 1, + XPP1, 1, + XPD1, 1, + XPRT, 2, + , 2, + XPIS, 2, + XPSE, 1, + XPE, 1, + XST0, 1, + XSI0, 1, + XSP0, 1, + XSD0, 1, + XST1, 1, + XSI1, 1, + XSP1, 1, + XSD1, 1, + XSRT, 2, + , 2, + XSIS, 2, + XSSE, 1, + XSE, 1, + XVRT, 2, + XVIS, 2, + Offset (0x05), + Offset (0x08), + XEP0, 1, + XEP1, 1, + XES0, 1, + XES1, 1, + Offset (0x09), + Offset (0x0A), + XUP0, 2, + , 2, + XUP1, 2, + Offset (0x0B), + XUS0, 2, + , 2, + XUS1, 2, + Offset (0x0C) + } + + Device (PRIM) + { + Name (_ADR, 0x00) + Method (_GTM, 0, NotSerialized) + { + Subtract (0x05, XPIS, Local0) + Subtract (0x04, XPRT, Local1) + Add (Local0, Local1, Local0) + Multiply (0x1E, Local0, Local0) + If (LGreater (Local0, 0xF0)) + { + Store (0x0384, Local0) + } + + If (XEP0) + { + Store (0x11, Local4) + If (LEqual (XUP0, 0x00)) + { + Store (0x78, Local1) + } + Else + { + If (LEqual (XUP0, 0x01)) + { + Store (0x50, Local1) + } + Else + { + Store (0x3C, Local1) + } + } + } + Else + { + Store (0x10, Local4) + Store (Local0, Local1) + } + + If (XPI0) + { + Or (Local4, 0x02, Local4) + } + + If (XPSE) + { + Subtract (0x05, XVIS, Local2) + Subtract (0x04, XVRT, Local3) + Add (Local2, Local3, Local2) + Multiply (0x1E, Local2, Local2) + If (LGreater (Local2, 0xF0)) + { + Store (0x0384, Local2) + } + + If (XEP1) + { + Or (Local4, 0x04, Local4) + If (LEqual (XUP1, 0x00)) + { + Store (0x78, Local3) + } + Else + { + If (LEqual (XUP1, 0x01)) + { + Store (0x50, Local3) + } + Else + { + Store (0x3C, Local3) + } + } + } + Else + { + Store (Local2, Local3) + } + } + Else + { + Store (0x00, Local2) + Store (0x00, Local3) + } + + If (XPI1) + { + Or (Local4, 0x08, Local4) + } + + Store (Local0, \GTP0) + Store (Local1, \GTD0) + Store (Local2, \GTP1) + Store (Local3, \GTD1) + Store (Local4, \GTMF) + Return (\BGTM) + } + + Method (_STM, 3, NotSerialized) + { + CreateDWordField (Arg0, 0x00, STP0) + CreateDWordField (Arg0, 0x04, STD0) + CreateDWordField (Arg0, 0x08, STP1) + CreateDWordField (Arg0, 0x0C, STD1) + CreateDWordField (Arg0, 0x10, STMF) + If (SizeOf (Arg1)) + { + CreateWordField (Arg1, 0x01, PMZR) + If (PMZR) + { + Store (One, Local5) + } + Else + { + Store (Zero, Local5) + } + } + Else + { + Store (Zero, Local5) + } + + If (Local5) + { + If (\W98F) + { + CreateWordField (Arg1, 0x66, PM51) + CreateWordField (Arg1, 0x6A, PM53) + CreateWordField (Arg1, 0x7C, PM62) + CreateWordField (Arg1, 0x7E, PM63) + CreateWordField (Arg1, 0x80, PM64) + CreateWordField (Arg1, 0x82, PM65) + CreateWordField (Arg1, 0x88, PM68) + CreateWordField (Arg1, 0xB0, PM88) + Store (\UDMA (PM53, PM88), Local0) + If (LGreater (Local0, 0x03)) + { + Store (0x03, Local0) + } + + Store (\MDMA (PM53, PM63, PM62, PM65), Local1) + Store (\MPIO (PM53, PM64, PM51, PM68), Local2) + Store (\MPI4 (Local1, Local2), Local3) + } + Else + { + Store (\MPIB (And (STMF, 0x02), STP0), Local2) + Store (\UDMB (And (STMF, 0x01), STD0), Local0) + Store (\MP4B (Local2), Local3) + Store (Local3, Local1) + } + + Store (\MTIM (Local3, Local2, And (PMZR, 0x80)), Local4) + If (And (Local4, 0x01)) + { + Store (One, XPT0) + } + + If (And (Local4, 0x02)) + { + Store (One, XPI0) + } + + If (And (Local4, 0x04)) + { + Store (One, XPP0) + } + + If (And (Local4, 0x08)) + { + Store (One, XPD0) + } + + Store (\MISP (Local3), XPIS) + Store (\MRTC (Local3), XPRT) + If (Local0) + { + Store (One, XEP0) + Store (\MUCT (Local0), XUP0) + } + Else + { + Store (Zero, XEP0) + Store (Zero, XUP0) + } + + Store (\MHDM (Local0, Local1), \HDM0) + Store (\MHPI (Local2), \HPI0) + } + + If (SizeOf (Arg2)) + { + CreateWordField (Arg2, 0x01, PS00) + If (PS00) + { + Store (One, Local5) + } + Else + { + Store (Zero, Local5) + } + } + Else + { + Store (Zero, Local5) + } + + If (Local5) + { + If (\W98F) + { + CreateWordField (Arg2, 0x66, PS51) + CreateWordField (Arg2, 0x6A, PS53) + CreateWordField (Arg2, 0x7C, PS62) + CreateWordField (Arg2, 0x7E, PS63) + CreateWordField (Arg2, 0x80, PS64) + CreateWordField (Arg2, 0x82, PS65) + CreateWordField (Arg2, 0x88, PS68) + CreateWordField (Arg2, 0xB0, PS88) + Store (\UDMA (PS53, PS88), Local0) + If (LGreater (Local0, 0x03)) + { + Store (0x03, Local0) + } + + Store (\MDMA (PS53, PS63, PS62, PS65), Local1) + Store (\MPIO (PS53, PS64, PS51, PS68), Local2) + Store (\MPI4 (Local1, Local2), Local3) + } + Else + { + Store (\MPIB (And (STMF, 0x08), STP1), Local2) + Store (\UDMB (And (STMF, 0x04), STD1), Local0) + Store (\MP4B (Local2), Local3) + Store (Local3, Local1) + } + + Store (One, XPSE) + Store (\MTIM (Local3, Local2, And (PS00, 0x80)), Local4) + If (And (Local4, 0x01)) + { + Store (One, XPT1) + } + + If (And (Local4, 0x02)) + { + Store (One, XPI1) + } + + If (And (Local4, 0x04)) + { + Store (One, XPP1) + } + + If (And (Local4, 0x08)) + { + Store (One, XPD1) + } + + Store (\MISP (Local3), XVIS) + Store (\MRTC (Local3), XVRT) + If (Local0) + { + Store (One, XEP1) + Store (\MUCT (Local0), XUP1) + } + Else + { + Store (Zero, XEP1) + Store (Zero, XUP1) + } + + Store (\MHDM (Local0, Local1), \HDM1) + Store (\MHDM (Local0, Local1), \CDM1) + Store (\MHPI (Local2), \HPI1) + Store (\MHPI (Local2), \CPI1) + } + } + + Device (MSTR) + { + Name (_ADR, 0x00) + Method (_GTF, 0, NotSerialized) + { + Return (\ICM0) + } + } + } + + Device (SCND) + { + Name (_ADR, 0x01) + Method (_GTM, 0, NotSerialized) + { + Subtract (0x05, XSIS, Local0) + Subtract (0x04, XSRT, Local1) + Add (Local0, Local1, Local0) + Multiply (0x1E, Local0, Local0) + If (LGreater (Local0, 0xF0)) + { + Store (0x0384, Local0) + } + + If (XES0) + { + Store (0x11, Local2) + If (LEqual (XUS0, 0x00)) + { + Store (0x78, Local1) + } + Else + { + If (LEqual (XUS0, 0x01)) + { + Store (0x50, Local1) + } + Else + { + Store (0x3C, Local1) + } + } + } + Else + { + Store (0x10, Local2) + Store (Local0, Local1) + } + + If (XSI0) + { + Or (Local2, 0x02, Local2) + } + + Store (Local0, \GTP0) + Store (Local1, \GTD0) + Store (Zero, \GTP1) + Store (Zero, \GTD1) + Store (Local2, \GTMF) + Return (\BGTM) + } + + Method (_STM, 3, NotSerialized) + { + CreateDWordField (Arg0, 0x00, STP0) + CreateDWordField (Arg0, 0x04, STD0) + CreateDWordField (Arg0, 0x08, STP1) + CreateDWordField (Arg0, 0x0C, STD1) + CreateDWordField (Arg0, 0x10, STMF) + If (SizeOf (Arg1)) + { + CreateWordField (Arg1, 0x01, SM00) + If (SM00) + { + Store (One, Local5) + } + Else + { + Store (Zero, Local5) + } + } + Else + { + Store (Zero, Local5) + } + + If (Local5) + { + If (\W98F) + { + CreateWordField (Arg1, 0x66, SM51) + CreateWordField (Arg1, 0x6A, SM53) + CreateWordField (Arg1, 0x7C, SM62) + CreateWordField (Arg1, 0x7E, SM63) + CreateWordField (Arg1, 0x80, SM64) + CreateWordField (Arg1, 0x82, SM65) + CreateWordField (Arg1, 0x88, SM68) + CreateWordField (Arg1, 0xB0, SM88) + Store (\UDMA (SM53, SM88), Local0) + If (LGreater (Local0, 0x03)) + { + Store (0x03, Local0) + } + + Store (\MDMA (SM53, SM63, SM62, SM65), Local1) + Store (\MPIO (SM53, SM64, SM51, SM68), Local2) + Store (\MPI4 (Local1, Local2), Local3) + } + Else + { + Store (\MPIB (And (STMF, 0x02), STP0), Local2) + Store (\UDMB (And (STMF, 0x01), STD0), Local0) + Store (\MP4B (Local2), Local3) + Store (Local3, Local1) + } + + Store (\MTIM (Local3, Local2, And (SM00, 0x80)), Local4) + If (And (Local4, 0x01)) + { + Store (One, XST0) + } + + If (And (Local4, 0x02)) + { + Store (One, XSI0) + } + + If (And (Local4, 0x04)) + { + Store (One, XSP0) + } + + If (And (Local4, 0x08)) + { + Store (One, XSD0) + } + + Store (\MISP (Local3), XSIS) + Store (\MRTC (Local3), XSRT) + If (Local0) + { + Store (One, XES0) + Store (\MUCT (Local0), XUS0) + } + Else + { + Store (Zero, XES0) + Store (Zero, XUS0) + } + + Store (\MHDM (Local0, Local1), \HDM2) + Store (\MHDM (Local0, Local1), \CDM2) + Store (\MHPI (Local2), \HPI2) + Store (\MHPI (Local2), \CPI2) + Store (MHDM (Local0, Local1), \DDM2) + Store (MHPI (Local2), \DPI2) + } + } + + Device (MSTR) + { + Name (_ADR, 0x00) + Method (_GTF, 0, NotSerialized) + { + Store (\_SB.PCI0.ISA.EC.GUID (), Local0) + If (LEqual (Local0, 0x06)) + { + Return (\ICM2) + } + + Store (Zero, Local1) + If (LEqual (Local0, 0x0B)) + { + Store (One, Local1) + } + + If (LEqual (Local0, 0x03)) + { + Store (One, Local1) + } + + If (LEqual (Local0, 0x0A)) + { + Store (One, Local1) + } + + If (Local1) + { + Store (\GCDT (0x00), \DTF2) + Store (\GCDT (0x01), \DTA2) + Return (\DCM2) + } + Else + { + Return (\ICC2) + } + } + } + } + } + + Device (PM00) + { + Name (_ADR, 0x00070003) + OperationRegion (X3DR, PCI_Config, 0x5C, 0x20) + Field (X3DR, DWordAcc, NoLock, Preserve) + { + , 1, + , 2, + , 1, + , 1, + , 2, + Offset (0x01), + , 2, + , 15, + , 1, + , 3, + XA0E, 1, + XM0E, 1, + XPE, 1, + X09A, 16, + X09M, 4, + , 1, + X09E, 3, + , 1, + XPA, 2, + , 1, + XFA, 1, + XFE, 1, + , 1, + Offset (0x08), + Offset (0x0B), + XU1A, 3, + XU1E, 1, + XU2A, 3, + XU2E, 1, + X12A, 16, + X12M, 4, + X12E, 1, + Offset (0x0F), + Offset (0x10), + X12O, 32, + X13A, 16, + X13M, 4, + X13E, 1, + Offset (0x17), + Offset (0x18), + X13O, 32, + Offset (0x20) + } + + OperationRegion (SMBC, PCI_Config, 0xD2, 0x01) + Field (SMBC, ByteAcc, NoLock, Preserve) + { + SBHE, 1, + SBIS, 3 + } + + OperationRegion (GLEN, SystemIO, 0x1020, 0x02) + Field (GLEN, WordAcc, NoLock, Preserve) + { + , 15, + BLEN, 1 + } + } + + Device (USB) + { + Name (_ADR, 0x00070002) + Method (_PSW, 1, NotSerialized) + { + Noop + } + + Name (_PRW, Package (0x02) + { + 0x08, + 0x01 + }) + } + + Device (AGP) + { + Name (_ADR, 0x00010000) + Name (_PRT, Package (0x02) + { + Package (0x04) + { + 0xFFFF, + 0x00, + \_SB.LNKA, + 0x00 + }, + + Package (0x04) + { + 0xFFFF, + 0x01, + \_SB.LNKB, + 0x00 + } + }) + Name (EDX1, Buffer (0x80) + { + 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, + 0x24, 0x4D, 0x55, 0x0A, 0x01, 0x01, 0x01, 0x01, + 0x23, 0x09, 0x01, 0x02, 0x80, 0x21, 0x18, 0x00, + 0xEA, 0x0D, 0xFB, 0xA0, 0x57, 0x47, 0x98, 0x27, + 0x12, 0x4D, 0x51, 0xA1, 0x08, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x19, + 0x00, 0x40, 0x41, 0x00, 0x26, 0x30, 0x18, 0x88, + 0x36, 0x00, 0x0E, 0xCB, 0x10, 0x00, 0x00, 0x1A, + 0x00, 0x00, 0x00, 0xFC, 0x00, 0x54, 0x68, 0x69, + 0x6E, 0x6B, 0x50, 0x61, 0x64, 0x20, 0x4C, 0x43, + 0x44, 0x20, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x31, + 0x30, 0x32, 0x34, 0x78, 0x37, 0x36, 0x38, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33 + }) + Name (EDX2, Buffer (0x0100) + { + 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, + 0x24, 0x4D, 0x55, 0x0A, 0x01, 0x01, 0x01, 0x01, + 0x23, 0x09, 0x01, 0x02, 0x80, 0x21, 0x18, 0x00, + 0xEA, 0x0D, 0xFB, 0xA0, 0x57, 0x47, 0x98, 0x27, + 0x12, 0x4D, 0x51, 0xA1, 0x08, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x19, + 0x00, 0x40, 0x41, 0x00, 0x26, 0x30, 0x18, 0x88, + 0x36, 0x00, 0x0E, 0xCB, 0x10, 0x00, 0x00, 0x1A, + 0x00, 0x00, 0x00, 0xFC, 0x00, 0x54, 0x68, 0x69, + 0x6E, 0x6B, 0x50, 0x61, 0x64, 0x20, 0x4C, 0x43, + 0x44, 0x20, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x31, + 0x30, 0x32, 0x34, 0x78, 0x37, 0x36, 0x38, 0x20, + 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }) + Name (EDT1, Buffer (0x80) + { + 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, + 0xC1, 0xD0, 0xFE, 0x09, 0x01, 0x01, 0x01, 0x01, + 0x23, 0x09, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, + 0xEA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xA1, 0x08, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x31, 0x58, 0x1C, 0x20, 0x28, 0x80, + 0x01, 0x00, 0xF6, 0xB8, 0x00, 0x00, 0x00, 0x1A, + 0x00, 0x00, 0x00, 0xFC, 0x00, 0x54, 0x68, 0x69, + 0x6E, 0x6B, 0x50, 0x61, 0x64, 0x20, 0x54, 0x56, + 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59 + }) + Name (EDT2, Buffer (0x0100) + { + 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, + 0xC1, 0xD0, 0xFE, 0x09, 0x01, 0x01, 0x01, 0x01, + 0x23, 0x09, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, + 0xEA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xA1, 0x08, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x31, 0x58, 0x1C, 0x20, 0x28, 0x80, + 0x01, 0x00, 0xF6, 0xB8, 0x00, 0x00, 0x00, 0x1A, + 0x00, 0x00, 0x00, 0xFC, 0x00, 0x54, 0x68, 0x69, + 0x6E, 0x6B, 0x50, 0x61, 0x64, 0x20, 0x54, 0x56, + 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }) + Mutex (MDGS, 0x07) + Name (VDEE, 0x01) + Name (VDDA, Buffer (0x02) {}) + CreateBitField (VDDA, 0x00, VUPC) + CreateBitField (VDDA, 0x01, VQDL) + CreateBitField (VDDA, 0x02, VQDC) + CreateBitField (VDDA, 0x03, VQDT) + CreateBitField (VDDA, 0x04, VQDD) + CreateBitField (VDDA, 0x05, VSDL) + CreateBitField (VDDA, 0x06, VSDC) + CreateBitField (VDDA, 0x07, VSDT) + CreateBitField (VDDA, 0x08, VSDD) + CreateBitField (VDDA, 0x0A, MSWT) + CreateBitField (VDDA, 0x0B, VWST) + CreateBitField (VDDA, 0x0D, VPWR) + Device (VID) + { + Name (_ADR, 0x00) + Name (_S1D, 0x01) + Name (_S3D, 0x03) + Method (_INI, 0, NotSerialized) + { + \VUPS (0x02) + Store (\VCDL, VQDL) + Store (\VCDC, VQDC) + Store (\VCDT, VQDT) + Store (\VCDD, VQDD) + } + + Method (_PS0, 0, NotSerialized) + { + Store (0x01, VPWR) + } + + Method (_PS1, 0, NotSerialized) + { + Store (0x00, VPWR) + } + + Method (_PS2, 0, NotSerialized) + { + Store (0x00, VPWR) + } + + Method (_PS3, 0, NotSerialized) + { + Store (0x00, VPWR) + } + + Method (VSWT, 0, NotSerialized) + { + \VUPS (0x80) + If (LNot (\VCIN)) + { + Store (0x01, Local0) + Store (0x00, Local2) + If (\VCDT) + { + Or (0x04, Local2, Local2) + } + + If (\VCDL) + { + Add (0x01, Local0, Local0) + } + + If (\VCDC) + { + Add (0x02, Local0, Local0) + } + + If (LEqual (0x04, Local0)) + { + Store (0x01, Local1) + } + Else + { + Store (Local0, Local1) + } + + Or (Local2, Local1, Local1) + ASWT (Local1, 0x01) + } + } + + Method (VLOC, 1, NotSerialized) + { + If (VPWR) + { + If (Arg0) + { + \VUPS (0x81) + If (LNot (VCSS)) + { + If (LNot (\VCDL)) + { + ASWT (0x01, 0x00) + \VNRS (0x01) + } + } + } + } + } + + Method (_DOS, 1, NotSerialized) + { + If (LEqual (Arg0, 0x02)) + { + Store (0x01, Local0) + While (Local0) + { + Acquire (MDGS, 0xFFFF) + If (LEqual (0x00, MSWT)) + { + Store (0x01, MSWT) + Store (0x00, Local0) + Store (Arg0, VDEE) + } + + Release (MDGS) + Sleep (0x01) + } + } + Else + { + Acquire (MDGS, 0xFFFF) + If (LEqual (VDEE, 0x02)) + { + Store (0x00, MSWT) + } + + If (LGreater (Arg0, 0x02)) + { + Store (0x01, VDEE) + } + Else + { + Store (Arg0, VDEE) + } + + Release (MDGS) + } + } + + Method (_DOD, 0, NotSerialized) + { + Return (Package (0x03) + { + 0x00010110, + 0x00010100, + 0x00010200 + }) + } + + Method (ASWT, 2, NotSerialized) + { + If (LEqual (0x01, VDEE)) + { + \VSDS (Arg0, 0x01) + } + Else + { + Store (0x01, Local0) + While (Local0) + { + Acquire (MDGS, 0xFFFF) + If (LEqual (0x00, MSWT)) + { + Store (0x00, Local0) + If (And (0x01, Arg1)) + { + Store (0x01, VUPC) + } + Else + { + Store (0x00, VUPC) + } + + If (And (0x01, Arg0)) + { + Store (0x01, VQDL) + } + Else + { + Store (0x00, VQDL) + } + + If (And (0x02, Arg0)) + { + Store (0x01, VQDC) + } + Else + { + Store (0x00, VQDC) + } + + If (And (0x04, Arg0)) + { + Store (0x01, VQDT) + } + Else + { + Store (0x00, VQDT) + } + } + + Release (MDGS) + Sleep (0x01) + } + + If (And (0x02, Arg1)) + { + Notify (\_SB.PCI0.AGP.VID, 0x81) + } + Else + { + Notify (\_SB.PCI0.AGP.VID, 0x80) + } + } + } + + Method (VDSW, 1, NotSerialized) + { + If (LNot (Arg0)) + { + ASWT (0x01, 0x00) + \VNRS (0x05) + } + } + + Device (LCD0) + { + Name (_ADR, 0x0110) + Method (_DCS, 0, NotSerialized) + { + \VUPS (0x00) + If (\VCDL) + { + Return (0x1F) + } + Else + { + Return (0x1D) + } + } + + Method (_DDC, 1, NotSerialized) + { + If (LEqual (\VLID, 0x02)) + { + If (LEqual (Arg0, 0x01)) + { + Return (EDX1) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (EDX2) + } + } + } + } + + Method (_DGS, 0, NotSerialized) + { + Return (VQDL) + } + + Method (_DSS, 1, NotSerialized) + { + And (Arg0, 0x01, VSDL) + If (And (Arg0, 0x80000000)) + { + If (And (Arg0, 0x40000000)) + { + DSWT (0x02) + } + Else + { + DSWT (0x01) + } + } + } + } + + Device (CRT0) + { + Name (_ADR, 0x0100) + Method (_DCS, 0, NotSerialized) + { + \VUPS (0x01) + If (\VCSS) + { + If (\VCDC) + { + Return (0x1F) + } + Else + { + Return (0x1D) + } + } + Else + { + If (\VCDC) + { + Return (0x0F) + } + Else + { + Return (0x0D) + } + } + } + + Method (_DDC, 1, NotSerialized) + { + \VDDC () + If (LEqual (Arg0, 0x01)) + { + Return (\DDC1) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (\DDC2) + } + Else + { + Return (0x00) + } + } + } + + Method (_DGS, 0, NotSerialized) + { + Return (VQDC) + } + + Method (_DSS, 1, NotSerialized) + { + And (Arg0, 0x01, VSDC) + If (And (Arg0, 0x80000000)) + { + If (And (Arg0, 0x40000000)) + { + DSWT (0x02) + } + Else + { + DSWT (0x01) + } + } + } + } + + Device (TV0) + { + Name (_ADR, 0x0200) + Method (_DCS, 0, NotSerialized) + { + \VUPS (0x00) + If (\VCDT) + { + Return (0x1F) + } + Else + { + Return (0x1D) + } + } + + Method (_DDC, 1, NotSerialized) + { + If (LEqual (Arg0, 0x01)) + { + Return (EDT1) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (EDT2) + } + } + } + + Method (_DGS, 0, NotSerialized) + { + Return (VQDT) + } + + Method (_DSS, 1, NotSerialized) + { + And (Arg0, 0x01, VSDT) + If (And (Arg0, 0x80000000)) + { + If (And (Arg0, 0x40000000)) + { + DSWT (0x02) + } + Else + { + DSWT (0x01) + } + } + } + } + + Method (DSWT, 1, NotSerialized) + { + If (VSDL) + { + Store (0x01, Local0) + } + Else + { + Store (0x00, Local0) + } + + If (VSDC) + { + Or (0x02, Local0, Local0) + } + + If (Local0) + { + If (VUPC) + { + \VSDS (Local0, Arg0) + } + } + Else + { + Noop + } + } + } + } + + Device (ISA) + { + Name (_ADR, 0x00070000) + OperationRegion (PIRQ, PCI_Config, 0x60, 0x60) + Field (PIRQ, AnyAcc, NoLock, Preserve) + { + PIRA, 8, + PIRB, 8, + PIRC, 8, + PIRD, 8, + SIRQ, 8, + Offset (0x16), + CH00, 3, + , 4, + FE00, 1, + CH01, 3, + , 4, + FE01, 1, + Offset (0x22), + P21E, 3, + Offset (0x23), + Offset (0x50), + , 1, + , 1, + , 1, + , 1, + GCR4, 1, + , 1, + , 1, + Offset (0x51), + , 1, + , 1, + , 1, + , 1, + GCRC, 1, + , 1, + , 1, + Offset (0x52), + , 1, + , 1, + , 1, + , 1, + , 1, + , 1, + SUS2, 1, + Offset (0x54), + Offset (0x60) + } + + Device (SIO) + { + Name (_HID, EisaId ("PNP0C02")) + Name (_UID, 0x00) + Name (_STA, 0x0B) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0022, 0x0022, 0x01, 0x01) + IO (Decode16, 0x0092, 0x0092, 0x01, 0x01) + IO (Decode16, 0x00B2, 0x00B2, 0x01, 0x02) + IO (Decode16, 0x1000, 0x1000, 0x01, 0x40) + IO (Decode16, 0x1040, 0x1040, 0x01, 0x10) + IO (Decode16, 0xFE00, 0xFE00, 0x01, 0x10) + }) + } + + Device (PIC) + { + Name (_HID, EisaId ("PNP0000")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0020, 0x0020, 0x01, 0x02) + IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02) + IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02) + IRQNoFlags () {2} + }) + } + + Device (TIMR) + { + Name (_HID, EisaId ("PNP0100")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0040, 0x0040, 0x01, 0x04) + IRQNoFlags () {0} + }) + } + + Device (DMAC) + { + Name (_HID, EisaId ("PNP0200")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0000, 0x0000, 0x01, 0x10) + IO (Decode16, 0x0080, 0x0080, 0x01, 0x10) + IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20) + DMA (Compatibility, BusMaster, Transfer8) {4} + }) + } + + Device (SPKR) + { + Name (_HID, EisaId ("PNP0800")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0061, 0x0061, 0x01, 0x01) + }) + } + + Device (FPU) + { + Name (_HID, EisaId ("PNP0C04")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x10) + IRQNoFlags () {13} + }) + } + + Device (RTC) + { + Name (_HID, EisaId ("PNP0B00")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0070, 0x0070, 0x01, 0x04) + IRQNoFlags () {8} + }) + } + + Device (KBD) + { + Name (_HID, EisaId ("PNP0303")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0060, 0x0060, 0x01, 0x01) + IO (Decode16, 0x0064, 0x0064, 0x01, 0x01) + IRQNoFlags () {1} + }) + } + + Device (MOU) + { + Name (_HID, EisaId ("IBM3780")) + Name (_CID, 0x130FD041) + Name (_CRS, ResourceTemplate () + { + IRQNoFlags () {12} + }) + } + + Device (PMGA) + { + Name (_HID, EisaId ("PNP0C02")) + Name (_UID, 0x02) + Name (_STA, 0x0B) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x15E0, 0x15E0, 0x01, 0x10) + }) + } + + OperationRegion (IMGA, SystemIO, 0x15EC, 0x04) + Field (IMGA, ByteAcc, NoLock, Preserve) + { + IND0, 8, + DAT0, 8, + IND1, 8, + DAT1, 8 + } + + IndexField (IND0, DAT0, ByteAcc, NoLock, Preserve) + { + Offset (0x7F), + ACI, 8 + } + + IndexField (IND1, DAT1, ByteAcc, NoLock, Preserve) + { + , 4, + VDPW, 1, + CBPW, 1, + BREN, 1, + Offset (0x01), + Offset (0x07), + , 2, + SSBY, 1, + Offset (0x08), + Offset (0x21), + , 1, + , 1, + BTON, 1, + , 1, + Offset (0x22), + Offset (0x2D), + BUSC, 1, + BUSD, 1, + SCIS, 1, + SCIR, 2, + SLCK, 1, + WOLE, 1, + Offset (0x2E) + } + + Method (HBEN, 0, NotSerialized) + { + If (\GLPW ()) + { + Store (0x01, BREN) + } + } + + Method (HBDS, 0, NotSerialized) + { + If (\GLPW ()) + { + Store (0x00, BREN) + } + } + + PowerResource (PSER, 0x00, 0x0000) + { + Method (_STA, 0, NotSerialized) + { + Return (XOr (SSBY, 0x01)) + } + + Method (_ON, 0, NotSerialized) + { + Store (0x00, SSBY) + } + + Method (_OFF, 0, NotSerialized) + { + Store (0x01, SSBY) + } + } + + Device (SPIO) + { + Name (_HID, EisaId ("PNP0C02")) + Name (_UID, 0x01) + Name (_STA, 0x0B) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x002E, 0x002E, 0x01, 0x02) + }) + } + + OperationRegion (NCFG, SystemIO, 0x2E, 0x02) + Field (NCFG, ByteAcc, NoLock, Preserve) + { + INDX, 8, + DATA, 8 + } + + IndexField (INDX, DATA, ByteAcc, NoLock, Preserve) + { + FER, 8, + FAR, 8, + PTR, 8, + FCR, 8, + PCR, 8, + Offset (0x06), + PMC, 8, + TUP, 8, + SID, 8, + ASC, 8, + S0LA, 8, + S0CF, 8, + S1LA, 8, + S1CF, 8, + Offset (0x10), + S0HA, 8, + S1HA, 8, + SCF0, 8, + Offset (0x18), + SCF1, 8, + Offset (0x1B), + PNP0, 8, + PNP1, 8, + Offset (0x40), + SCF2, 8, + PNP2, 8, + PBAL, 8, + PBAH, 8, + U1AL, 8, + U1AH, 8, + U2AL, 8, + U2AH, 8, + FBAL, 8, + FBAH, 8, + SBAL, 8, + SBAH, 8, + IRQ1, 8, + IRQ2, 8, + IRQ3, 8, + PNP3, 8, + SCF3, 8, + CLK, 8 + } + + PowerResource (PSIO, 0x00, 0x0000) + { + Name (PSTS, 0x01) + Method (_STA, 0, NotSerialized) + { + Return (PSTS) + } + + Method (_ON, 0, NotSerialized) + { + And (PTR, 0xFE, PTR) + Store (0x01, PSTS) + } + + Method (_OFF, 0, NotSerialized) + { + Store (0x00, PSTS) + } + } + + Device (FDC) + { + Name (_HID, EisaId ("PNP0700")) + Name (_PR0, Package (0x01) + { + PSIO + }) + Method (_STA, 0, NotSerialized) + { + Store (\_SB.PCI0.PM00.XFE, Local0) + If (Local0) + { + Return (0x0F) + } + Else + { + Return (0x0D) + } + } + + Method (_DIS, 0, NotSerialized) + { + And (PNP2, 0x80, PNP2) + Store (Zero, \_SB.PCI0.PM00.XFE) + } + + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06) + IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01) + IRQNoFlags () {6} + DMA (Compatibility, NotBusMaster, Transfer8) {2} + }) + Name (_PRS, ResourceTemplate () + { + IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06) + IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01) + IRQNoFlags () {6} + DMA (Compatibility, NotBusMaster, Transfer8) {2} + }) + Method (_SRS, 1, NotSerialized) + { + And (FBAL, 0x01, Local0) + Or (Local0, 0xFC, FBAL) + And (FBAH, 0x03, FBAH) + And (PNP2, 0x80, Local0) + Or (Local0, 0x36, PNP2) + If (And (FER, 0x08, Local1)) {} + Else + { + Or (FER, 0x08, FER) + } + + Store (Zero, \_SB.PCI0.PM00.XFA) + Store (One, \_SB.PCI0.PM00.XFE) + If (LEqual (\_SB.PCI0.ISA.EC.BDEV, 0x0D)) + { + \SFDD (0x00) + } + Else + { + \SFDD (0x01) + } + } + } + + Device (UART) + { + Name (_HID, EisaId ("PNP0501")) + Name (_EJD, "_SB.PCI0.DOCK") + Name (_PR0, Package (0x02) + { + PSIO, + PSER + }) + Name (_PRW, Package (0x02) + { + 0x0B, + 0x03 + }) + Method (_PSW, 1, NotSerialized) + { + If (\H8DR) + { + If (Arg0) + { + Store (0x01, \_SB.PCI0.ISA.EC.HWRI) + } + Else + { + Store (0x00, \_SB.PCI0.ISA.EC.HWRI) + } + } + Else + { + If (Arg0) + { + \MBEC (0x32, 0xFF, 0x40) + } + Else + { + \MBEC (0x32, 0xBF, 0x00) + } + } + } + + Method (_STA, 0, NotSerialized) + { + If (And (FER, 0x02)) + { + Return (0x0F) + } + Else + { + Return (0x0D) + } + } + + Method (_DIS, 0, NotSerialized) + { + And (FER, 0xFD, FER) + Store (Zero, \_SB.PCI0.PM00.XU1E) + } + + Method (_CRS, 0, NotSerialized) + { + Name (BUFF, ResourceTemplate () + { + IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08) + IRQNoFlags () {4} + }) + CreateWordField (BUFF, 0x02, U1MN) + CreateWordField (BUFF, 0x04, U1MX) + CreateWordField (BUFF, 0x09, U1IQ) + ShiftLeft (And (U1AL, 0xFE), 0x02, Local0) + Store (Local0, U1MN) + Store (Local0, U1MX) + If (And (PNP1, 0x01)) + { + Store (0x08, U1IQ) + } + + Return (BUFF) + } + + Name (_PRS, ResourceTemplate () + { + StartDependentFn (0x00, 0x00) + { + IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08) + IRQNoFlags () {4} + } + StartDependentFn (0x01, 0x00) + { + IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08) + IRQNoFlags () {3} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08) + IRQNoFlags () {4} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08) + IRQNoFlags () {3} + } + EndDependentFn () + }) + Method (_SRS, 1, NotSerialized) + { + CreateWordField (Arg0, 0x02, IOAR) + CreateWordField (Arg0, 0x09, IRQM) + If (LEqual (IOAR, 0x03F8)) + { + Store (0xFE, Local0) + Store (0x00, Local1) + } + Else + { + If (LEqual (IOAR, 0x02F8)) + { + Store (0xBE, Local0) + Store (0x01, Local1) + } + Else + { + If (LEqual (IOAR, 0x03E8)) + { + Store (0xFA, Local0) + Store (0x07, Local1) + } + Else + { + If (LEqual (IOAR, 0x02E8)) + { + Store (0xBA, Local0) + Store (0x05, Local1) + } + Else + { + Fatal (0x02, 0x90000002, 0x00) + } + } + } + } + + And (U1AH, 0x03, U1AH) + And (U1AL, 0x01, Local2) + Or (Local0, Local2, U1AL) + Store (Local1, \_SB.PCI0.PM00.XU1A) + And (PNP1, 0xF0, Local0) + If (LEqual (IRQM, 0x10)) + { + Or (Local0, 0x04, Local0) + } + Else + { + If (LEqual (IRQM, 0x08)) + { + Or (Local0, 0x03, Local0) + } + Else + { + Fatal (0x02, 0x90000002, 0x00) + } + } + + Store (Local0, PNP1) + Or (FER, 0x02, FER) + Store (One, \_SB.PCI0.PM00.XU1E) + } + } + + Name (PPMD, 0x00) + Name (PPDR, 0x00) + Method (GPPM, 0, NotSerialized) + { + Store (\GPAR (), Local0) + And (Local0, 0x03, PPMD) + ShiftRight (And (Local0, 0x04), 0x02, PPDR) + } + + Device (LPT) + { + Name (_HID, EisaId ("PNP0400")) + Name (_EJD, "_SB.PCI0.DOCK") + Name (_PR0, Package (0x01) + { + PSIO + }) + Method (_STA, 0, NotSerialized) + { + If (LEqual (PPMD, 0x03)) + { + Return (Zero) + } + Else + { + If (And (FER, 0x01)) + { + Return (0x0F) + } + Else + { + Return (0x0D) + } + } + } + + Method (_DIS, 0, NotSerialized) + { + And (FER, 0xFE, FER) + Store (Zero, \_SB.PCI0.PM00.XPE) + } + + Method (_CRS, 0, NotSerialized) + { + Name (BUFF, ResourceTemplate () + { + IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04) + IRQNoFlags () {7} + }) + CreateWordField (BUFF, 0x02, L1MN) + CreateWordField (BUFF, 0x04, L1MX) + CreateByteField (BUFF, 0x06, L1AL) + CreateByteField (BUFF, 0x07, L1LN) + CreateWordField (BUFF, 0x09, L1IQ) + If (LEqual (PPMD, 0x03)) + { + Store (0x00, L1MN) + Store (0x00, L1MX) + Store (0x00, L1AL) + Store (0x00, L1LN) + Store (0x00, L1IQ) + Return (BUFF) + } + + And (PBAL, 0xFF, Local0) + If (LEqual (Local0, 0xEF)) {} + Else + { + If (LEqual (Local0, 0xDE)) + { + Store (0x0378, L1MN) + Store (0x0378, L1MX) + Store (0x08, L1LN) + } + Else + { + If (LEqual (Local0, 0x9E)) + { + Store (0x0278, L1MN) + Store (0x0278, L1MX) + Store (0x08, L1LN) + } + } + } + + And (PNP0, 0xF0, Local1) + If (LEqual (Local1, 0x00)) + { + Store (0x00, L1IQ) + } + Else + { + If (LEqual (Local1, 0x50)) + { + Store (0x20, L1IQ) + } + } + + Return (BUFF) + } + + Method (_PRS, 0, NotSerialized) + { + If (PPMD) + { + Return (PEPP) + } + Else + { + Return (PLPT) + } + } + + Name (PLPT, ResourceTemplate () + { + StartDependentFnNoPri () + { + IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04) + IRQNoFlags () {7} + } + StartDependentFnNoPri () + { + IO (Decode16, 0x0378, 0x0378, 0x01, 0x08) + IRQNoFlags () {7} + } + StartDependentFnNoPri () + { + IO (Decode16, 0x0278, 0x0278, 0x01, 0x08) + IRQNoFlags () {5} + } + StartDependentFnNoPri () + { + IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04) + IRQNoFlags () {} + } + StartDependentFnNoPri () + { + IO (Decode16, 0x0378, 0x0378, 0x01, 0x08) + IRQNoFlags () {} + } + StartDependentFnNoPri () + { + IO (Decode16, 0x0278, 0x0278, 0x01, 0x08) + IRQNoFlags () {} + } + EndDependentFn () + }) + Name (PEPP, ResourceTemplate () + { + StartDependentFnNoPri () + { + IO (Decode16, 0x0378, 0x0378, 0x01, 0x08) + IRQNoFlags () {5,7} + } + StartDependentFnNoPri () + { + IO (Decode16, 0x0278, 0x0278, 0x01, 0x08) + IRQNoFlags () {5,7} + } + EndDependentFn () + }) + Method (_SRS, 1, NotSerialized) + { + CreateWordField (Arg0, 0x02, IOAR) + CreateWordField (Arg0, 0x09, IRQM) + If (LEqual (IOAR, 0x03BC)) + { + Store (0xEF, Local0) + Store (0x00, Local1) + } + Else + { + If (LEqual (IOAR, 0x0378)) + { + Store (0xDE, Local0) + Store (0x01, Local1) + } + Else + { + If (LEqual (IOAR, 0x0278)) + { + Store (0x9E, Local0) + Store (0x02, Local1) + } + Else + { + Fatal (0x02, 0x90000002, 0x00) + } + } + } + + And (PBAH, 0x03, Local2) + Store (Local2, PBAH) + Store (Local0, PBAL) + Store (Local1, \_SB.PCI0.PM00.XPA) + And (PNP0, 0x0F, Local0) + If (LEqual (IRQM, 0x20)) + { + Or (Local0, 0x50, Local0) + } + Else + { + If (LEqual (IRQM, 0x80)) + { + Or (Local0, 0x70, Local0) + } + Else + { + If (LEqual (IRQM, Zero)) {} + } + } + + Store (Local0, PNP0) + If (LEqual (PPMD, 0x00)) + { + And (PCR, 0xFA, Local0) + If (PPDR) + { + Or (PTR, 0x80, Local1) + } + Else + { + And (PTR, 0x7F, Local1) + } + } + Else + { + If (LEqual (PPMD, 0x01)) + { + And (PCR, 0xF9, Local0) + Or (Local0, 0x01, Local0) + } + Else + { + And (PCR, 0xFB, Local0) + Or (Local0, 0x03, Local0) + } + + And (PTR, 0x7F, Local1) + } + + Store (Local0, PCR) + Store (Local1, PTR) + Or (FER, 0x01, FER) + Store (One, \_SB.PCI0.PM00.XPE) + } + } + + Device (ECP) + { + Name (_HID, EisaId ("PNP0401")) + Name (_EJD, "_SB.PCI0.DOCK") + Name (_PR0, Package (0x01) + { + PSIO + }) + Method (_STA, 0, NotSerialized) + { + If (LEqual (PPMD, 0x03)) + { + If (And (FER, 0x01)) + { + Return (0x0F) + } + Else + { + Return (0x0D) + } + } + Else + { + Return (Zero) + } + } + + Method (_DIS, 0, NotSerialized) + { + And (FER, 0xFE, FER) + Store (Zero, \_SB.PCI0.PM00.XPE) + } + + Method (_CRS, 0, NotSerialized) + { + Name (BUFF, ResourceTemplate () + { + IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04) + IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x03) + IRQNoFlags () {7} + DMA (Compatibility, NotBusMaster, Transfer8) {3} + }) + CreateWordField (BUFF, 0x02, ECN0) + CreateWordField (BUFF, 0x04, ECX0) + CreateByteField (BUFF, 0x06, ECA0) + CreateByteField (BUFF, 0x07, ECL0) + CreateWordField (BUFF, 0x0A, ECN1) + CreateWordField (BUFF, 0x0C, ECX1) + CreateByteField (BUFF, 0x0E, ECA1) + CreateByteField (BUFF, 0x0F, ECL1) + CreateWordField (BUFF, 0x11, ECIQ) + CreateWordField (BUFF, 0x14, ECDQ) + If (LNot (LEqual (PPMD, 0x03))) + { + Store (0x00, ECN0) + Store (0x00, ECX0) + Store (0x00, ECA0) + Store (0x00, ECL0) + Store (0x00, ECN1) + Store (0x00, ECX1) + Store (0x00, ECA1) + Store (0x00, ECL1) + Store (0x00, ECIQ) + Store (0x00, ECDQ) + Return (BUFF) + } + + And (PBAL, 0xFF, Local0) + If (LEqual (Local0, 0xEF)) + { + Store (0x03BC, Local1) + } + Else + { + If (LEqual (Local0, 0xDE)) + { + Store (0x0378, Local1) + Store (0x08, ECL0) + } + Else + { + If (LEqual (Local0, 0x9E)) + { + Store (0x0278, Local1) + Store (0x08, ECL0) + } + } + } + + Store (Local1, ECN0) + Store (Local1, ECX0) + Add (Local1, 0x0400, ECN1) + Add (Local1, 0x0400, ECX1) + And (PNP0, 0xF0, Local1) + If (LEqual (Local1, 0x50)) + { + Store (0x20, ECIQ) + } + Else + { + If (LEqual (Local1, 0x70)) {} + Else + { + Store (0x00, ECIQ) + } + } + + And (SCF1, 0x38, Local2) + If (LEqual (Local2, 0x00)) + { + Store (0x00, ECDQ) + } + Else + { + If (LEqual (Local2, 0x08)) + { + Store (0x01, ECDQ) + } + Else + { + If (LEqual (Local2, 0x10)) + { + Store (0x02, ECDQ) + } + Else + { + If (LEqual (Local2, 0x20)) {} + Else + { + Store (0x00, ECDQ) + } + } + } + } + + Return (BUFF) + } + + Name (_PRS, ResourceTemplate () + { + StartDependentFnNoPri () + { + IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04) + IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x03) + IRQNoFlags () {7} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFnNoPri () + { + IO (Decode16, 0x0378, 0x0378, 0x01, 0x08) + IO (Decode16, 0x0778, 0x0778, 0x01, 0x03) + IRQNoFlags () {7} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFnNoPri () + { + IO (Decode16, 0x0278, 0x0278, 0x01, 0x08) + IO (Decode16, 0x0678, 0x0678, 0x01, 0x03) + IRQNoFlags () {5} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + EndDependentFn () + }) + Method (_SRS, 1, NotSerialized) + { + CreateWordField (Arg0, 0x02, IOAR) + CreateWordField (Arg0, 0x11, IRQM) + CreateByteField (Arg0, 0x14, DMAM) + If (LEqual (IOAR, 0x03BC)) + { + Store (0xEF, Local0) + Store (0x00, Local1) + } + Else + { + If (LEqual (IOAR, 0x0378)) + { + Store (0xDE, Local0) + Store (0x01, Local1) + } + Else + { + If (LEqual (IOAR, 0x0278)) + { + Store (0x9E, Local0) + Store (0x02, Local1) + } + Else + { + Fatal (0x02, 0x90000002, 0x00) + } + } + } + + And (PBAH, 0x03, Local2) + Store (Local2, PBAH) + Store (Local0, PBAL) + Store (Local1, \_SB.PCI0.PM00.XPA) + And (PNP0, 0x0F, Local0) + If (LEqual (IRQM, 0x20)) + { + Or (Local0, 0x50, Local0) + } + Else + { + If (LEqual (IRQM, 0x80)) + { + Or (Local0, 0x70, Local0) + } + } + + Store (Local0, PNP0) + And (SCF1, 0xC7, Local1) + If (LEqual (DMAM, 0x01)) + { + Or (Local1, 0x08, Local1) + } + Else + { + If (LEqual (DMAM, 0x02)) + { + Or (Local1, 0x10, Local1) + } + Else + { + If (LEqual (DMAM, 0x08)) + { + Or (Local1, 0x20, Local1) + } + } + } + + Store (Local1, SCF1) + And (PCR, 0xFE, Local0) + Or (Local0, 0x04, PCR) + Or (FER, 0x01, FER) + Store (One, \_SB.PCI0.PM00.XPE) + And (PCR, 0xFB, PCR) + \ECPP () + } + } + + Device (FIR) + { + Name (_HID, EisaId ("IBM0071")) + Name (_CID, 0x1105D041) + Name (_PR0, Package (0x01) + { + PSIO + }) + Method (_STA, 0, NotSerialized) + { + If (And (FER, 0x04)) + { + Return (0x0F) + } + Else + { + Return (0x0D) + } + } + + Method (_DIS, 0, NotSerialized) + { + And (SCF2, 0x5F, SCF2) + And (FER, 0xFB, FER) + Store (Zero, \_SB.PCI0.PM00.XU2E) + } + + Method (_CRS, 0, NotSerialized) + { + Name (BUFF, ResourceTemplate () + { + IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08) + IRQNoFlags () {4} + DMA (Compatibility, NotBusMaster, Transfer8) {3} + }) + CreateWordField (BUFF, 0x02, IRMN) + CreateWordField (BUFF, 0x04, IRMX) + CreateWordField (BUFF, 0x09, IRIQ) + CreateByteField (BUFF, 0x0C, IRDR) + ShiftLeft (And (U2AL, 0xFE), 0x02, Local0) + Store (Local0, IRMN) + Store (Local0, IRMX) + If (LEqual (And (PNP1, 0xF0), 0x70)) + { + Store (0x80, IRIQ) + } + Else + { + If (LEqual (And (PNP1, 0xF0), 0x50)) + { + Store (0x20, IRIQ) + } + Else + { + If (LEqual (And (PNP1, 0xF0), 0x40)) + { + Store (0x10, IRIQ) + } + Else + { + If (LEqual (And (PNP1, 0xF0), 0x30)) + { + Store (0x08, IRIQ) + } + Else + { + Store (0x00, IRIQ) + } + } + } + } + + And (PNP3, 0x07, Local1) + If (LEqual (Local1, 0x00)) + { + Store (0x00, IRDR) + } + Else + { + If (LEqual (Local1, 0x01)) + { + Store (0x01, IRDR) + } + Else + { + If (LEqual (Local1, 0x02)) + { + Store (0x02, IRDR) + } + Else + { + If (LEqual (Local1, 0x04)) + { + Store (0x08, IRDR) + } + Else + { + Store (Zero, IRDR) + } + } + } + } + + Return (BUFF) + } + + Name (_PRS, ResourceTemplate () + { + StartDependentFn (0x00, 0x00) + { + IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08) + IRQNoFlags () {4} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFn (0x01, 0x00) + { + IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08) + IRQNoFlags () {3} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08) + IRQNoFlags () {4} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08) + IRQNoFlags () {3} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08) + IRQNoFlags () {3,5,7} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08) + IRQNoFlags () {4,5,7} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08) + IRQNoFlags () {3,5,7} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08) + IRQNoFlags () {4,5,7} + DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08) + IRQNoFlags () {4} + DMA (Compatibility, NotBusMaster, Transfer8) {} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08) + IRQNoFlags () {3} + DMA (Compatibility, NotBusMaster, Transfer8) {} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08) + IRQNoFlags () {4} + DMA (Compatibility, NotBusMaster, Transfer8) {} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08) + IRQNoFlags () {3} + DMA (Compatibility, NotBusMaster, Transfer8) {} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08) + IRQNoFlags () {3,5,7} + DMA (Compatibility, NotBusMaster, Transfer8) {} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08) + IRQNoFlags () {4,5,7} + DMA (Compatibility, NotBusMaster, Transfer8) {} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08) + IRQNoFlags () {3,5,7} + DMA (Compatibility, NotBusMaster, Transfer8) {} + } + StartDependentFn (0x02, 0x00) + { + IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08) + IRQNoFlags () {4,5,7} + DMA (Compatibility, NotBusMaster, Transfer8) {} + } + EndDependentFn () + }) + Method (_SRS, 1, NotSerialized) + { + CreateWordField (Arg0, 0x02, IRIO) + CreateWordField (Arg0, 0x09, IRIQ) + CreateByteField (Arg0, 0x0C, IRDR) + If (LEqual (IRIO, 0x03F8)) + { + Store (0xFE, Local0) + Store (0x00, Local1) + } + Else + { + If (LEqual (IRIO, 0x02F8)) + { + Store (0xBE, Local0) + Store (0x01, Local1) + } + Else + { + If (LEqual (IRIO, 0x03E8)) + { + Store (0xFA, Local0) + Store (0x07, Local1) + } + Else + { + If (LEqual (IRIO, 0x02E8)) + { + Store (0xBA, Local0) + Store (0x05, Local1) + } + Else + { + Fatal (0x02, 0x90000002, 0x00) + } + } + } + } + + And (U2AH, 0x03, U2AH) + And (U2AL, 0x01, Local2) + Or (Local0, Local2, U2AL) + Store (Local1, \_SB.PCI0.PM00.XU2A) + And (PNP1, 0x0F, Local0) + If (LEqual (IRIQ, 0x80)) + { + Or (Local0, 0x70, Local0) + } + Else + { + If (LEqual (IRIQ, 0x20)) + { + Or (Local0, 0x50, Local0) + } + Else + { + If (LEqual (IRIQ, 0x10)) + { + Or (Local0, 0x40, Local0) + } + Else + { + If (LEqual (IRIQ, 0x08)) + { + Or (Local0, 0x30, Local0) + } + Else + { + Fatal (0x02, 0x90000002, 0x00) + } + } + } + } + + Store (Local0, PNP1) + If (LEqual (IRDR, 0x00)) + { + Store (0x00, Local0) + } + Else + { + If (LEqual (IRDR, 0x01)) + { + Store (0x01, Local0) + } + Else + { + If (LEqual (IRDR, 0x02)) + { + Store (0x02, Local0) + } + Else + { + If (LEqual (IRDR, 0x08)) + { + Store (0x04, Local0) + } + Else + { + Fatal (0x02, 0x90000002, 0x00) + } + } + } + } + + And (PNP3, 0xC0, Local1) + Or (Local1, Local0, PNP3) + Or (FER, 0x04, FER) + Store (One, \_SB.PCI0.PM00.XU2E) + Or (SCF2, 0xA0, SCF2) + } + } + + Device (EC) + { + Name (_HID, EisaId ("PNP0C09")) + Name (_GPE, 0x09) + Name (_GLK, 0x01) + Method (_REG, 2, NotSerialized) + { + If (LEqual (Arg0, 0x03)) + { + Store (Arg1, \H8DR) + } + } + + OperationRegion (ECOR, EmbeddedControl, 0x00, 0x0100) + Field (ECOR, ByteAcc, Lock, Preserve) + { + , 1, + HCGA, 1, + , 1, + , 1, + , 1, + , 1, + HCAC, 1, + Offset (0x01), + , 1, + BTCM, 1, + , 1, + , 1, + , 1, + HCAD, 1, + BTPC, 1, + Offset (0x02), + Offset (0x03), + Offset (0x04), + , 1, + , 1, + , 1, + , 1, + , 1, + , 1, + , 1, + Offset (0x05), + HSPA, 1, + , 1, + , 1, + , 1, + , 1, + , 1, + , 1, + Offset (0x06), + HSUN, 8, + HSRP, 8, + HACC, 8, + Offset (0x0A), + Offset (0x0B), + Offset (0x0C), + HLCL, 8, + HLBL, 8, + HLMS, 8, + HICA, 8, + HAM0, 8, + HAM1, 8, + HAM2, 8, + HAM3, 8, + HAM4, 8, + HAM5, 8, + HAM6, 8, + HAM7, 8, + HAM8, 8, + HAM9, 8, + HAMA, 8, + HAMB, 8, + HAMC, 8, + HAMD, 8, + HAME, 8, + HAMF, 8, + HT00, 1, + HT01, 1, + HT02, 1, + , 4, + HT0E, 1, + HT10, 1, + HT11, 1, + HT12, 1, + , 4, + HT1E, 1, + HT20, 1, + HT21, 1, + HT22, 1, + , 4, + HT2E, 1, + HT30, 1, + HT31, 1, + HT32, 1, + , 4, + HT3E, 1, + HT40, 1, + HT41, 1, + HT42, 1, + , 4, + HT4E, 1, + HT50, 1, + HT51, 1, + HT52, 1, + , 4, + HT5E, 1, + HT60, 1, + HT61, 1, + HT62, 1, + , 4, + HT6E, 1, + HT70, 1, + HT71, 1, + HT72, 1, + , 4, + HT7E, 1, + HDID, 8, + Offset (0x2A), + Offset (0x2B), + HT0H, 8, + HT0L, 8, + HT1H, 8, + HT1L, 8, + HFSP, 8, + , 5, + , 1, + HMUT, 1, + Offset (0x31), + Offset (0x32), + HWPM, 1, + HWLB, 1, + HWLO, 1, + HWDK, 1, + HWFN, 1, + HWBT, 1, + HWRI, 1, + HWBU, 1, + Offset (0x34), + , 1, + , 1, + , 1, + , 1, + , 1, + , 1, + , 1, + Offset (0x35), + Offset (0x36), + , 1, + BTWK, 1, + HPLD, 1, + , 1, + HPAC, 1, + BTST, 1, + Offset (0x37), + HPBU, 1, + , 1, + , 1, + , 1, + , 1, + , 1, + , 1, + HPNF, 1, + HB0L, 4, + , 1, + HB0C, 1, + HB0D, 1, + HB0A, 1, + HB1L, 4, + , 1, + HB1C, 1, + HB1D, 1, + HB1A, 1, + HCMU, 1, + , 1, + , 1, + , 1, + HCSL, 2, + , 1, + Offset (0x3B), + , 1, + KBLT, 1, + BTPW, 1, + BTDT, 1, + Offset (0x3C), + Offset (0x3D), + Offset (0x3E), + Offset (0x46), + Offset (0x47), + , 4, + , 1, + , 1, + , 1, + Offset (0x48), + , 4, + Offset (0x49), + Offset (0x4A), + Offset (0x4C), + Offset (0x4E), + HWAK, 8, + Offset (0x50), + Offset (0x75), + Offset (0x78), + TMP0, 8, + TMP1, 8, + TMP2, 8, + TMP3, 8, + TMP4, 8, + TMP5, 8, + TMP6, 8, + TMP7, 8, + Offset (0x82), + CP4E, 8, + HFNI, 8, + HKBD, 1, + HPHT, 1, + Offset (0x85), + Offset (0xC0), + Offset (0xC2), + Offset (0xC4), + Offset (0xD0), + Offset (0xE0), + Offset (0xE8), + Offset (0xEA), + Offset (0xEB), + Offset (0xEC), + , 1, + , 1, + , 2, + , 1, + , 1, + , 1, + Offset (0xED), + , 1, + Offset (0xEE), + , 4, + Offset (0xEF), + Offset (0xF0), + Offset (0xF8), + Offset (0x100) + } + + Method (_INI, 0, NotSerialized) + { + If (\H8DR) + { + Store (One, HCAC) + Store (Zero, HWFN) + Store (One, HWLB) + Store (Zero, HWLO) + And (HAM5, 0x3F, HAM5) + } + Else + { + \MBEC (0x00, 0xFF, 0x40) + \MBEC (0x32, 0xEB, 0x02) + \MBEC (0x15, 0x3F, 0x00) + } + + If (\H8DR) + { + Store (0x00, HSPA) + } + Else + { + \MBEC (0x05, 0xFE, 0x00) + } + + Store (GUID (), BDEV) + GHKS () + \_SB.PCI0.ISA.EC.HKEY.BTIN () + } + + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0062, 0x0062, 0x01, 0x01) + IO (Decode16, 0x0066, 0x0066, 0x01, 0x01) + }) + Method (GUID, 0, NotSerialized) + { + Store (GDEV (0x00), Local0) + If (LEqual (Local0, 0x0F)) + { + If (\H8DR) + { + If (HB1A) + { + Store (0x10, Local0) + } + } + Else + { + If (And (\RBEC (0x39), 0x80)) + { + Store (0x10, Local0) + } + } + } + + Return (Local0) + } + + Mutex (MDEV, 0x07) + Method (GDEV, 1, NotSerialized) + { + Acquire (MDEV, 0xFFFF) + If (\H8DR) + { + And (HAM7, 0xFE, HAM7) + } + Else + { + \MBEC (0x17, 0xFE, 0x00) + } + + And (Arg0, 0x03, \_SB.PCI0.PM00.EID) + And (ShiftRight (Arg0, 0x02), 0x01, \_SB.PCI0.PM00.EID2) + If (\H8DR) + { + Or (HDID, 0x80, HDID) + Store (0x20, Local1) + While (LAnd (Local1, And (HDID, 0x80))) + { + Sleep (0x01) + Decrement (Local1) + } + + Store (HDID, Local2) + } + Else + { + \MBEC (0x28, 0xFF, 0x80) + Store (0x20, Local1) + While (LAnd (Local1, And (\RBEC (0x28), 0x80))) + { + Sleep (0x01) + Decrement (Local1) + } + + Store (\RBEC (0x28), Local2) + } + + If (And (Local2, 0x80)) + { + Store (0xFF, Local2) + } + + Store (0x00, \_SB.PCI0.PM00.EID) + Store (0x00, \_SB.PCI0.PM00.EID2) + Sleep (0x64) + If (\H8DR) + { + Or (HAM7, 0x01, HAM7) + } + Else + { + \MBEC (0x17, 0xFF, 0x01) + } + + Release (MDEV) + Return (Local2) + } + + Mutex (LEDM, 0x07) + Method (SYSL, 2, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + Store (0x01, Local0) + } + Else + { + If (LEqual (Arg0, 0x01)) + { + Store (0x80, Local0) + } + Else + { + Return (0x00) + } + } + + Acquire (LEDM, 0xFFFF) + If (LAnd (\H8DR, LNot (\W98F))) + { + Store (Local0, HLMS) + If (LEqual (Arg1, 0x00)) + { + Store (0x00, HLBL) + Store (0x00, HLCL) + } + Else + { + If (LEqual (Arg1, 0x01)) + { + Store (0x00, HLBL) + Store (Local0, HLCL) + } + Else + { + If (LEqual (Arg1, 0x02)) + { + Store (Local0, HLBL) + Store (Local0, HLCL) + } + Else + { + } + } + } + } + Else + { + \WBEC (0x0E, Local0) + If (LEqual (Arg1, 0x00)) + { + \WBEC (0x0D, 0x00) + \WBEC (0x0C, 0x00) + } + Else + { + If (LEqual (Arg1, 0x01)) + { + \WBEC (0x0D, 0x00) + \WBEC (0x0C, Local0) + } + Else + { + If (LEqual (Arg1, 0x02)) + { + \WBEC (0x0D, Local0) + \WBEC (0x0C, Local0) + } + } + } + } + + Sleep (0x0A) + Release (LEDM) + } + + Name (BAON, 0x00) + Name (WBON, 0x00) + Method (BEEP, 1, NotSerialized) + { + If (LGreater (Arg0, 0x11)) + { + Return (0x01) + } + Else + { + If (LAnd (\H8DR, LNot (\W98F))) + { + If (LEqual (Arg0, 0x00)) + { + If (BAON) + { + If (WBON) + { + Store (0x08, HSRP) + Store (0x03, HSUN) + } + Else + { + Store (0x00, HSRP) + Store (Arg0, HSUN) + } + + Store (0x00, BAON) + } + } + Else + { + If (LEqual (Arg0, 0x0F)) + { + Store (0x08, HSRP) + Store (0x01, BAON) + Store (Arg0, HSUN) + } + Else + { + If (BAON) + { + If (LEqual (Arg0, 0x11)) + { + Store (0x00, WBON) + } + Else + { + If (LEqual (Arg0, 0x10)) + { + If (HMUT) {} + Else + { + Store (0x01, WBON) + } + } + } + } + Else + { + If (LEqual (Arg0, 0x11)) + { + If (WBON) + { + Store (0x00, HSRP) + Store (0x00, HSUN) + Store (0x00, WBON) + } + } + Else + { + If (LEqual (Arg0, 0x10)) + { + If (HMUT) {} + Else + { + Store (0x01, WBON) + Store (0x08, HSRP) + Store (0x03, HSUN) + } + } + Else + { + If (WBON) + { + If (LEqual (Arg0, 0x07)) + { + Store (0x00, WBON) + } + Else + { + If (LEqual (Arg0, 0x03)) + { + Store (0x00, WBON) + If (LEqual (\SPS, 0x04)) {} + Else + { + Store (0x00, HSRP) + Store (0x00, HSUN) + Sleep (0x64) + Store (0x07, HSUN) + Sleep (0x012C) + } + } + Else + { + Store (0x00, HSRP) + Store (0x00, HSUN) + Sleep (0xC8) + Store (Arg0, HSUN) + Sleep (0xC8) + If (LEqual (Arg0, 0x04)) + { + Store (0x00, WBON) + } + + If (LEqual (Arg0, 0x05)) + { + Store (0x00, WBON) + } + + If (WBON) + { + Store (0x08, HSRP) + Store (0x03, HSUN) + } + } + } + } + Else + { + Store (Arg0, HSUN) + If (LEqual (Arg0, 0x03)) + { + Sleep (0x012C) + } + + If (LEqual (Arg0, 0x07)) + { + Sleep (0x01F4) + } + } + } + } + } + } + } + } + Else + { + If (LEqual (Arg0, 0x00)) + { + If (BAON) + { + If (WBON) + { + \WBEC (0x07, 0x08) + \WBEC (0x06, 0x03) + } + Else + { + \WBEC (0x07, 0x00) + \WBEC (0x06, Arg0) + } + + Store (0x00, BAON) + } + } + Else + { + If (LEqual (Arg0, 0x0F)) + { + \WBEC (0x07, 0x08) + Store (0x01, BAON) + \WBEC (0x06, Arg0) + } + Else + { + If (BAON) + { + If (LEqual (Arg0, 0x11)) + { + Store (0x00, WBON) + } + Else + { + If (LEqual (Arg0, 0x10)) + { + If (HMUT) {} + Else + { + Store (0x01, WBON) + } + } + } + } + Else + { + If (LEqual (Arg0, 0x11)) + { + If (WBON) + { + \WBEC (0x07, 0x00) + \WBEC (0x06, 0x00) + Store (0x00, WBON) + } + } + Else + { + If (LEqual (Arg0, 0x10)) + { + If (And (0x40, \RBEC (0x30))) {} + Else + { + Store (0x01, WBON) + \WBEC (0x07, 0x08) + \WBEC (0x06, 0x03) + } + } + Else + { + If (WBON) + { + If (LEqual (Arg0, 0x07)) + { + Store (0x00, WBON) + } + Else + { + If (LEqual (Arg0, 0x03)) + { + Store (0x00, WBON) + If (LEqual (\SPS, 0x04)) {} + Else + { + \WBEC (0x07, 0x00) + \WBEC (0x06, 0x00) + Sleep (0x64) + \WBEC (0x06, 0x07) + Sleep (0x012C) + } + } + Else + { + \WBEC (0x07, 0x00) + \WBEC (0x06, 0x00) + Sleep (0xC8) + \WBEC (0x06, Arg0) + Sleep (0xC8) + If (LEqual (Arg0, 0x04)) + { + Store (0x00, WBON) + } + + If (LEqual (Arg0, 0x05)) + { + Store (0x00, WBON) + } + + If (WBON) + { + \WBEC (0x07, 0x08) + \WBEC (0x06, 0x03) + } + } + } + } + Else + { + \WBEC (0x06, Arg0) + If (LEqual (Arg0, 0x03)) + { + Sleep (0x012C) + } + + If (LEqual (Arg0, 0x05)) + { + Sleep (0xC8) + } + + If (LEqual (Arg0, 0x07)) + { + Sleep (0x01F4) + } + } + } + } + } + } + } + } + } + } + + Method (EVNT, 1, NotSerialized) + { + If (\H8DR) + { + If (Arg0) + { + Or (HAM7, 0x01, HAM7) + Or (HAM5, 0x04, HAM5) + } + Else + { + And (HAM7, 0xFE, HAM7) + And (HAM5, 0xFB, HAM5) + } + } + Else + { + If (Arg0) + { + \MBEC (0x17, 0xFF, 0x01) + \MBEC (0x15, 0xFF, 0x04) + If (\W98F) + { + \WBEC (0x18, 0xFF) + } + } + Else + { + \MBEC (0x17, 0xFE, 0x00) + \MBEC (0x15, 0xFB, 0x00) + If (\W98F) + { + \WBEC (0x18, 0x00) + } + } + } + } + + Method (_Q12, 0, NotSerialized) + { + \_SB.PCI0.ISA.EC.HKEY.MHKQ (0x1003) + } + + Method (_Q13, 0, NotSerialized) + { + If (\_SB.PCI0.ISA.EC.VDHK) + { + \_SB.PCI0.ISA.EC.HKEY.MHKQ (0x1004) + } + Else + { + Notify (\_SB.SLPB, 0x80) + } + } + + Method (_Q16, 0, NotSerialized) + { + \_SB.PCI0.AGP.VID.VSWT () + } + + Method (_Q17, 0, NotSerialized) + { + If (LNot (\WNTF)) + { + VEXP () + } + } + + Method (_Q1B, 0, NotSerialized) + { + \_SB.PCI0.ISA.EC.HKEY.MHKQ (0x100C) + } + + Method (_Q1F, 0, NotSerialized) + { + \LGHT (0x02) + } + + Method (_Q26, 0, NotSerialized) + { + \_SB.PCI0.ISA.HBDS () + Sleep (0x01F4) + Notify (AC, 0x00) + Notify (\_TZ.THM0, 0x80) + If (\GVEN) + { + \GVIL (0x00) + } + } + + Method (_Q27, 0, NotSerialized) + { + \_SB.PCI0.ISA.HBEN () + Sleep (0x01F4) + Notify (AC, 0x00) + Notify (\_TZ.THM0, 0x80) + If (\GVEN) + { + \GVIL (0x01) + } + } + + Method (_Q2A, 0, NotSerialized) + { + \_SB.PCI0.AGP.VID.VLOC (0x01) + \_SB.PCI0.ISA.EC.HKEY.MHKQ (0x5002) + Notify (\_SB.LID, 0x80) + } + + Method (_Q2B, 0, NotSerialized) + { + \_SB.PCI0.ISA.EC.HKEY.MHKQ (0x5001) + \LGHT (0x00) + Notify (\_SB.LID, 0x80) + } + + Method (_Q3D, 0, NotSerialized) + { + \FERR () + } + + Method (_Q48, 0, NotSerialized) + { + If (\GVEN) + { + \GVIL (0x04) + } + } + + Method (_Q49, 0, NotSerialized) + { + If (\GVEN) + { + \GVIL (0x05) + } + } + + Method (_Q7F, 0, NotSerialized) + { + Fatal (0x01, 0x80000001, 0x00) + } + + Method (_Q20, 0, NotSerialized) + { + Notify (BAT0, 0x80) + Notify (BAT1, 0x80) + } + + Method (_Q21, 0, NotSerialized) + { + Notify (BAT0, 0x80) + Notify (BAT1, 0x80) + } + + Method (_Q22, 0, NotSerialized) + { + Notify (BAT0, 0x80) + Notify (BAT1, 0x80) + } + + Method (_Q23, 0, NotSerialized) + { + Store (HB0A, Local0) + If (XOr (^BAT0.B0ST, Local0)) + { + Store (Local0, ^BAT0.B0ST) + Notify (BAT0, 0x81) + } + Else + { + Notify (BAT0, 0x80) + } + + Store (HB1A, Local0) + If (XOr (^BAT1.B1ST, Local0)) + { + Store (Local0, ^BAT1.B1ST) + _Q38 () + } + Else + { + If (LAnd (^BAT1.XB1S, Local0)) + { + Notify (BAT1, 0x80) + } + } + } + + Method (_Q24, 0, NotSerialized) + { + Notify (BAT0, 0x80) + } + + Method (_Q25, 0, NotSerialized) + { + Notify (BAT1, 0x80) + } + + Name (BT0I, Package (0x0D) + { + 0x00, + 0x00, + 0x00, + 0x01, + 0x2A30, + 0x00, + 0x00, + 0x01, + 0x01, + "ThinkPad Battery", + "", + "LION", + "IBM Corporation " + }) + Name (BT0P, Package (0x04) {}) + Name (BT0J, 0x00) + Device (BAT0) + { + Name (_HID, EisaId ("PNP0C0A")) + Name (_UID, 0x00) + Name (_PCL, Package (0x01) + { + \_SB + }) + Name (B0ST, 0x00) + Method (_STA, 0, NotSerialized) + { + If (\H8DR) + { + Store (HB0A, B0ST) + } + Else + { + If (And (\RBEC (0x38), 0x80)) + { + Store (0x01, B0ST) + } + Else + { + Store (0x00, B0ST) + } + } + + If (B0ST) + { + Return (0x1F) + } + Else + { + Return (0x0F) + } + } + + Method (_BIF, 0, NotSerialized) + { + AI2C () + Store (0x0A, Local6) + Store (0x01, Local5) + While (LAnd (Local5, Local6)) + { + If (HB0A) + { + Store (I2RB (Zero, 0x01, 0x10), Local7) + If (LOr (LEqual (HMBC, 0x1C), Local7)) + { + Store (0x00, Local5) + } + Else + { + Sleep (0x03E8) + Decrement (Local6) + Store (0x8080, Local7) + } + } + Else + { + Store (0x00, Local6) + Store (0x00, Local7) + } + } + + If (LOr (Local7, Local5)) + { + Store (0x00, Index (BT0I, 0x00)) + Store (0xFFFFFFFF, Index (BT0I, 0x01)) + Store (0x00, Index (BT0I, 0x05)) + Store (0x00, Index (BT0I, 0x06)) + Store (0xFFFFFFFF, Index (BT0I, 0x02)) + } + Else + { + Store (HBPU, Index (BT0I, 0x00)) + Store (HBRC, Local0) + Store (Local0, Index (BT0I, 0x01)) + Store (Divide (Local0, 0x14, ), Index (BT0I, 0x05)) + Store (Divide (Local0, 0x64, ), Index (BT0I, 0x06)) + Store (HBFC, Index (BT0I, 0x02)) + Store (Divide (HBFC, 0x64, ), BT0J) + } + + RI2C () + If (Local7) {} + Return (BT0I) + } + + Method (_BST, 0, NotSerialized) + { + AI2C () + Store (I2RB (Zero, 0x01, 0x10), Local7) + If (LOr (LNot (LEqual (HMBC, 0x1C)), Local7)) + { + Store (0x00, Index (BT0P, 0x03)) + Store (0x00, Index (BT0P, 0x02)) + Store (0x00, Index (BT0P, 0x01)) + Store (0x04, Index (BT0P, 0x00)) + } + Else + { + Store (HBVL, Local0) + Store (Local0, Index (BT0P, 0x03)) + Store (Add (HBCC, BT0J), Local1) + If (LNot (LLess (Local1, HBFC))) + { + Store (HBFC, Index (BT0P, 0x02)) + } + Else + { + Store (Local1, Index (BT0P, 0x02)) + } + + Store (HBEC, Local1) + If (LNot (LLess (Local1, 0x8000))) + { + Store (Subtract (0x00010000, Local1), Local2) + } + Else + { + Store (Local1, Local2) + } + + If (HBPU) + { + Store (Local2, Index (BT0P, 0x01)) + } + Else + { + Multiply (Local0, Local2, Local1) + Store (Divide (Local1, 0x03E8, ), Index (BT0P, 0x01)) + } + + If (HB0C) + { + Store (0x02, Index (BT0P, 0x00)) + } + Else + { + If (HB0D) + { + Store (0x01, Index (BT0P, 0x00)) + } + Else + { + Store (0x00, Index (BT0P, 0x00)) + } + } + + If (HB0L) {} + Else + { + Or (DerefOf (Index (BT0P, 0x00)), 0x04, Index (BT0P, 0x00)) + } + } + + RI2C () + Return (BT0P) + } + + Method (_BTP, 1, NotSerialized) + { + And (HAM4, 0xEF, HAM4) + If (Arg0) + { + Subtract (Arg0, BT0J, Local1) + If (LNot (DerefOf (Index (BT0I, 0x00)))) + { + Divide (Local1, 0x0A, Local0, Local1) + } + + And (Local1, 0xFF, HT0L) + And (ShiftRight (Local1, 0x08), 0xFF, HT0H) + Or (HAM4, 0x10, HAM4) + } + } + } + + Name (BT1I, Package (0x0D) + { + 0x00, + 0x00, + 0x00, + 0x01, + 0x2A30, + 0x00, + 0x00, + 0x01, + 0x01, + "ThinkPad Battery", + "", + "LION", + "IBM Corporation " + }) + Name (BT1P, Package (0x04) {}) + Name (BT1J, 0x00) + Device (BAT1) + { + Name (_HID, EisaId ("PNP0C0A")) + Name (_UID, 0x01) + Name (_PCL, Package (0x01) + { + \_SB + }) + Name (B1ST, 0x00) + Name (XB1S, 0x01) + Method (_STA, 0, NotSerialized) + { + If (\H8DR) + { + Store (HB1A, B1ST) + } + Else + { + If (And (\RBEC (0x39), 0x80)) + { + Store (0x01, B1ST) + } + Else + { + Store (0x00, B1ST) + } + } + + If (B1ST) + { + If (XB1S) + { + Return (0x1F) + } + Else + { + If (\WNTF) + { + Return (0x00) + } + Else + { + Return (0x1F) + } + } + + Return (0x1F) + } + Else + { + If (\WNTF) + { + Return (0x00) + } + Else + { + Return (0x0F) + } + } + } + + Method (_BIF, 0, NotSerialized) + { + AI2C () + Store (0x0A, Local6) + Store (0x01, Local5) + While (LAnd (Local5, Local6)) + { + If (HB1A) + { + Store (I2RB (Zero, 0x01, 0x11), Local7) + If (LOr (LEqual (HMBC, 0x1C), Local7)) + { + Store (0x00, Local5) + } + Else + { + Sleep (0x03E8) + Decrement (Local6) + Store (0x8080, Local7) + } + } + Else + { + Store (0x00, Local6) + Store (0x00, Local7) + } + } + + If (LOr (Local7, Local5)) + { + Store (0x00, Index (BT1I, 0x00)) + Store (0xFFFFFFFF, Index (BT1I, 0x01)) + Store (0x00, Index (BT1I, 0x05)) + Store (0x00, Index (BT1I, 0x06)) + Store (0xFFFFFFFF, Index (BT1I, 0x02)) + } + Else + { + Store (HBPU, Index (BT1I, 0x00)) + Store (HBRC, Local0) + Store (Local0, Index (BT1I, 0x01)) + Store (Divide (Local0, 0x14, ), Index (BT1I, 0x05)) + Store (Divide (Local0, 0x64, ), Index (BT1I, 0x06)) + Store (HBFC, Index (BT1I, 0x02)) + Store (Divide (HBFC, 0x64, ), BT1J) + } + + RI2C () + If (Local7) {} + Return (BT1I) + } + + Method (_BST, 0, NotSerialized) + { + AI2C () + Store (I2RB (Zero, 0x01, 0x11), Local7) + If (LOr (LNot (LEqual (HMBC, 0x1C)), Local7)) + { + Store (0x00, Index (BT1P, 0x03)) + Store (0x00, Index (BT1P, 0x02)) + Store (0x00, Index (BT1P, 0x01)) + Store (0x04, Index (BT1P, 0x00)) + } + Else + { + Store (HBVL, Local0) + Store (Local0, Index (BT1P, 0x03)) + Store (Add (HBCC, BT1J), Local1) + If (LNot (LLess (Local1, HBFC))) + { + Store (HBFC, Index (BT1P, 0x02)) + } + Else + { + Store (Local1, Index (BT1P, 0x02)) + } + + Store (HBEC, Local1) + If (LNot (LLess (Local1, 0x8000))) + { + Store (Subtract (0x00010000, Local1), Local2) + } + Else + { + Store (Local1, Local2) + } + + If (HBPU) + { + Store (Local2, Index (BT1P, 0x01)) + } + Else + { + Multiply (Local0, Local2, Local1) + Store (Divide (Local1, 0x03E8, ), Index (BT1P, 0x01)) + } + + If (HB1C) + { + Store (0x02, Index (BT1P, 0x00)) + } + Else + { + If (HB1D) + { + Store (0x01, Index (BT1P, 0x00)) + } + Else + { + Store (0x00, Index (BT1P, 0x00)) + } + } + + If (HB1L) {} + Else + { + Or (DerefOf (Index (BT1P, 0x00)), 0x04, Index (BT1P, 0x00)) + } + } + + RI2C () + Return (BT1P) + } + + Method (_BTP, 1, NotSerialized) + { + And (HAM4, 0xDF, HAM4) + If (Arg0) + { + Subtract (Arg0, BT1J, Local1) + If (LNot (DerefOf (Index (BT1I, 0x00)))) + { + Divide (Local1, 0x0A, Local0, Local1) + } + + And (Local1, 0xFF, HT1L) + And (ShiftRight (Local1, 0x08), 0xFF, HT1H) + Or (HAM4, 0x20, HAM4) + } + } + } + + Device (AC) + { + Name (_HID, "ACPI0003") + Name (_UID, 0x00) + Name (_PCL, Package (0x01) + { + \_SB + }) + Method (_PSR, 0, NotSerialized) + { + Return (HPAC) + } + + Method (_STA, 0, NotSerialized) + { + Return (0x0F) + } + } + + Scope (\_SB.PCI0.ISA.EC) + { + Field (ECOR, ByteAcc, Lock, Preserve) + { + Offset (0x50), + HMPR, 8, + HMST, 5, + , 1, + HMAR, 1, + HMDN, 1, + HMAD, 8, + HMCM, 8, + HMDT, 8, + Offset (0x74), + HMBC, 8 + } + + Field (ECOR, ByteAcc, Lock, Preserve) + { + Offset (0x54), + HBPU, 8, + Offset (0x56), + HBST, 8, + HBID, 4, + Offset (0x58), + HBRC, 32, + HBFC, 32, + HBCC, 32, + HBVL, 16, + HBEC, 16, + HBBT, 16, + HBNF, 16, + HBTC, 16, + HBCT, 16, + Offset (0x74), + Offset (0x100) + } + + Field (ECOR, ByteAcc, Lock, Preserve) + { + Offset (0x54), + HBTS, 8, + HBAF, 1, + Offset (0x56), + HBSD, 16, + HBDT, 16, + HBH0, 16, + HBL0, 16, + HBH1, 16, + HBL1, 16, + HBH2, 16, + HBL2, 16 + } + + Field (ECOR, ByteAcc, Lock, Preserve) + { + Offset (0x54), + HF_Z, 8, + HF_D, 8, + HZIP, 8, + HDVD, 8, + HHFD, 8, + HF_H, 8, + HHDD, 8, + HADP, 8, + HLS, 8, + HF_C, 8, + HCRW, 8, + HCD, 8, + HR01, 8, + HFDD, 8, + HIMP, 8, + HNON, 8 + } + + Mutex (I2CM, 0x07) + Method (AI2C, 0, NotSerialized) + { + Return (Acquire (I2CM, 0xFFFF)) + } + + Method (RI2C, 0, NotSerialized) + { + Release (I2CM) + } + + Method (I2CR, 3, NotSerialized) + { + AI2C () + Store (Arg0, HCSL) + If (HCAD) + { + Or (ShiftLeft (Arg1, 0x01), 0x01, HMAD) + } + Else + { + Store (Arg1, HMAD) + } + + Store (Arg2, HMCM) + Store (0x07, HMPR) + Store (CHKS (), Local7) + If (Local7) + { + Store (Local7, Local0) + } + Else + { + Store (HMDT, Local0) + } + + RI2C () + Return (Local0) + } + + Method (I2CW, 4, NotSerialized) + { + AI2C () + Store (Arg0, HCSL) + If (HCAD) + { + Or (ShiftLeft (Arg1, 0x01), 0x01, HMAD) + } + Else + { + Store (Arg1, HMAD) + } + + Store (Arg2, HMCM) + Store (Arg3, HMDT) + Store (0x06, HMPR) + Store (CHKS (), Local0) + RI2C () + Return (Local0) + } + + Method (I2RB, 3, NotSerialized) + { + Store (Arg0, HCSL) + If (HCAD) + { + Store (ShiftLeft (Arg1, 0x01), HMAD) + } + Else + { + Store (Arg1, HMAD) + } + + Store (Arg2, HMCM) + Store (0x0B, HMPR) + Return (CHKS ()) + } + + Method (I2WB, 4, NotSerialized) + { + Store (Arg0, HCSL) + If (HCAD) + { + Store (ShiftLeft (Arg1, 0x01), HMAD) + } + Else + { + Store (Arg1, HMAD) + } + + Store (Arg2, HMCM) + Store (Arg3, HMBC) + Store (0x0A, HMPR) + Return (CHKS ()) + } + + Method (CHKS, 0, NotSerialized) + { + Store (0x03E8, Local0) + While (HMPR) + { + Sleep (0x01) + Decrement (Local0) + If (LNot (Local0)) + { + Return (0x8080) + } + } + + If (HMDN) + { + If (HMST) + { + Return (Or (0x8000, HMST)) + } + Else + { + Return (Zero) + } + } + Else + { + Return (0x8081) + } + } + } + + Name (VDHK, 0x00) + Method (GHKS, 0, NotSerialized) + { + Store (\GHKY (), VDHK) + } + + Device (HKEY) + { + Name (_HID, EisaId ("IBM0068")) + Method (_STA, 0, NotSerialized) + { + If (VDHK) + { + Return (0x0F) + } + Else + { + Return (0x00) + } + } + + Name (DHKC, 0x00) + Name (DHKB, 0x01) + Mutex (XDHK, 0x07) + Name (DHKH, 0x00) + Name (DHKW, 0x00) + Name (DHKS, 0x00) + Name (DHKD, 0x00) + Method (MHKS, 0, NotSerialized) + { + Notify (\_SB.SLPB, 0x80) + } + + Method (MHKC, 1, NotSerialized) + { + Store (Arg0, DHKC) + } + + Method (MHKP, 0, NotSerialized) + { + Acquire (XDHK, 0xFFFF) + If (DHKW) + { + Store (DHKW, Local1) + Store (Zero, DHKW) + } + Else + { + If (DHKD) + { + Store (DHKD, Local1) + Store (Zero, DHKD) + } + Else + { + If (DHKS) + { + Store (DHKS, Local1) + Store (Zero, DHKS) + } + Else + { + Store (DHKH, Local1) + Store (Zero, DHKH) + } + } + } + + Release (XDHK) + Return (Local1) + } + + Method (MHKE, 1, NotSerialized) + { + Store (Arg0, DHKB) + Acquire (XDHK, 0xFFFF) + Store (Zero, DHKH) + Store (Zero, DHKW) + Store (Zero, DHKS) + Store (Zero, DHKD) + Release (XDHK) + } + + Method (MHKQ, 1, NotSerialized) + { + If (DHKB) + { + If (DHKC) + { + Acquire (XDHK, 0xFFFF) + If (LLess (Arg0, 0x1000)) {} + Else + { + If (LLess (Arg0, 0x2000)) + { + Store (Arg0, DHKH) + } + Else + { + If (LLess (Arg0, 0x3000)) + { + Store (Arg0, DHKW) + } + Else + { + If (LLess (Arg0, 0x4000)) + { + Store (Arg0, DHKS) + } + Else + { + If (LLess (Arg0, 0x5000)) + { + Store (Arg0, DHKD) + } + Else + { + If (LLess (Arg0, 0x6000)) + { + Store (Arg0, DHKH) + } + Else + { + } + } + } + } + } + } + + Release (XDHK) + If (LEqual (DHKH, 0x1003)) + { + \LGHT (0x00) + } + + Notify (HKEY, 0x80) + } + Else + { + If (LEqual (Arg0, 0x1004)) + { + Notify (\_SB.SLPB, 0x80) + } + } + } + } + + Method (XGWT, 0, NotSerialized) + { + \VUPS (0x80) + If (\WNTF) + { + Store (0x00, Local0) + If (\VCDL) + { + Or (0x01, Local0, Local0) + } + + If (\VCDC) + { + Or (0x02, Local0, Local0) + } + + If (\VCDT) + { + Or (0x04, Local0, Local0) + } + + Return (Local0) + } + Else + { + Return (0xFFFF) + } + } + + Method (XSWT, 1, NotSerialized) + { + If (\WNTF) + { + And (0x03, Arg0, Local0) + If (Local0) + { + \_SB.PCI0.AGP.VID.ASWT (Local0, 0x01) + } + } + Else + { + Return (0xFFFF) + } + } + + Method (MHKB, 1, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + \_SB.PCI0.ISA.EC.BEEP (0x11) + } + Else + { + If (LEqual (Arg0, 0x01)) + { + \_SB.PCI0.ISA.EC.BEEP (0x10) + } + Else + { + } + } + } + + Method (MHKX, 0, NotSerialized) + { + If (\_SB.PCI0.ISA.FDC.DCFD) + { + Return (0x01) + } + Else + { + Return (0x03) + } + } + } + } + } + + Device (CBS0) + { + Name (_ADR, 0x00020000) + OperationRegion (CBUS, PCI_Config, 0x00, 0x0100) + Field (CBUS, DWordAcc, NoLock, Preserve) + { + Offset (0x40), + SVID, 16, + SSID, 16, + LGDC, 32, + Offset (0x80), + SYSC, 32, + MCTL, 8, + Offset (0x91), + CCTL, 8, + Offset (0x93), + DIAG, 8 + } + + Method (_INI, 0, NotSerialized) + { + Store (Zero, LGDC) + And (CCTL, 0x7F, CCTL) + Or (SYSC, 0x01, SYSC) + If (LNot (And (_ADR, 0xFFFF))) + { + And (MCTL, 0x83, BMCL) + } + } + + Name (BMCL, 0x00) + Name (PWRS, 0x00) + Method (_PSC, 0, NotSerialized) + { + Return (PWRS) + } + + Method (_PS0, 0, NotSerialized) + { + PWUP () + Store (0x00, PWRS) + } + + Method (_PS3, 0, NotSerialized) + { + Store (0x03, PWRS) + PWDN () + } + + Method (PWDN, 0, NotSerialized) + { + If (LAnd (\_SB.PCI0.CBS0.PWRS, \_SB.PCI0.CBS1.PWRS)) + { + If (LNot (And (_ADR, 0xFFFF))) + { + And (MCTL, 0x83, BMCL) + And (MCTL, 0xFC, Local0) + Or (Local0, 0x80, MCTL) + } + Else + { + \_SB.PCI0.CBS0.PWDN () + } + } + } + + Method (PWUP, 0, NotSerialized) + { + If (LAnd (\_SB.PCI0.CBS0.PWRS, \_SB.PCI0.CBS1.PWRS)) + { + If (LNot (And (_ADR, 0xFFFF))) + { + And (MCTL, 0x7C, Local0) + Or (Local0, BMCL, MCTL) + } + Else + { + \_SB.PCI0.CBS0.PWUP () + } + } + } + } + + Device (CBS1) + { + Name (_ADR, 0x00020001) + OperationRegion (CBUS, PCI_Config, 0x00, 0x0100) + Field (CBUS, DWordAcc, NoLock, Preserve) + { + Offset (0x40), + SVID, 16, + SSID, 16, + LGDC, 32, + Offset (0x80), + SYSC, 32, + MCTL, 8, + Offset (0x91), + CCTL, 8, + Offset (0x93), + DIAG, 8 + } + + Method (_INI, 0, NotSerialized) + { + Store (Zero, LGDC) + And (CCTL, 0x7F, CCTL) + Or (SYSC, 0x01, SYSC) + If (LNot (And (_ADR, 0xFFFF))) + { + And (MCTL, 0x83, BMCL) + } + } + + Name (BMCL, 0x00) + Name (PWRS, 0x00) + Method (_PSC, 0, NotSerialized) + { + Return (PWRS) + } + + Method (_PS0, 0, NotSerialized) + { + PWUP () + Store (0x00, PWRS) + } + + Method (_PS3, 0, NotSerialized) + { + Store (0x03, PWRS) + PWDN () + } + + Method (PWDN, 0, NotSerialized) + { + If (LAnd (\_SB.PCI0.CBS0.PWRS, \_SB.PCI0.CBS1.PWRS)) + { + If (LNot (And (_ADR, 0xFFFF))) + { + And (MCTL, 0x83, BMCL) + And (MCTL, 0xFC, Local0) + Or (Local0, 0x80, MCTL) + } + Else + { + \_SB.PCI0.CBS0.PWDN () + } + } + } + + Method (PWUP, 0, NotSerialized) + { + If (LAnd (\_SB.PCI0.CBS0.PWRS, \_SB.PCI0.CBS1.PWRS)) + { + If (LNot (And (_ADR, 0xFFFF))) + { + And (MCTL, 0x7C, Local0) + Or (Local0, BMCL, MCTL) + } + Else + { + \_SB.PCI0.CBS0.PWUP () + } + } + } + } + + Device (DOCK) + { + Name (_ADR, 0x00040000) + Method (_BDN, 0, NotSerialized) + { + Return (GDID ()) + } + + Method (_UID, 0, NotSerialized) + { + Return (GDSR ()) + } + + Name (_PRT, Package (0x06) + { + Package (0x04) + { + 0xFFFF, + 0x00, + \_SB.LNKA, + 0x00 + }, + + Package (0x04) + { + 0xFFFF, + 0x01, + \_SB.LNKB, + 0x00 + }, + + Package (0x04) + { + 0xFFFF, + 0x02, + \_SB.LNKC, + 0x00 + }, + + Package (0x04) + { + 0xFFFF, + 0x03, + \_SB.LNKD, + 0x00 + }, + + Package (0x04) + { + 0x0001FFFF, + 0x00, + \_SB.LNKB, + 0x00 + }, + + Package (0x04) + { + 0x0002FFFF, + 0x00, + \_SB.LNKC, + 0x00 + } + }) + Method (_REG, 2, NotSerialized) + { + If (LEqual (Arg0, 0x02)) + { + If (Arg1) + { + Sleep (0x19) + And (\_SB.PCI0.ISA.SIRQ, 0x3F, \_SB.PCI0.ISA.SIRQ) + } + + \_SB.PCI0.DOCK.CBS2.DREG (0x02, Arg1) + \_SB.PCI0.DOCK.CBS3.DREG (0x02, Arg1) + \_SB.PCI0.DOCK.IDE1.DREG (0x02, Arg1) + If (Arg1) + { + Or (\_SB.PCI0.ISA.SIRQ, 0xC0, \_SB.PCI0.ISA.SIRQ) + Stall (0x64) + And (\_SB.PCI0.ISA.SIRQ, 0xBF, \_SB.PCI0.ISA.SIRQ) + LTCY () + } + } + } + + Method (_INI, 0, NotSerialized) + { + If (GDID ()) + { + PPEN (0x00) + PPIN () + PPEN (0x01) + If (\W98F) + { + _REG (0x02, 0x01) + } + + DATT (0x00, 0x00) + DATT (0x01, 0x01) + } + Else + { + DATT (0x00, 0x01) + DATT (0x01, 0x00) + } + + DDWK (0x00) + } + + Method (_STA, 0, NotSerialized) + { + If (\W98F) + { + If (DFLG (0x02, 0x08)) + { + \_SB.PCI0.ISA.EC.HKEY.MHKQ (DHKE) + Notify (\_SB.PCI0.DOCK, 0x01) + DFLG (0x01, 0x08) + } + } + + \_SB.PCI0.DOCK.WURQ () + If (LEqual (GDID (), 0x4A004D24)) + { + Store (0x0F, Local0) + } + Else + { + If (LNot (\W98F)) + { + Store (0x00, Local0) + } + Else + { + Store (0x0C, Local0) + } + } + + Return (Local0) + } + + Name (_PRW, Package (0x02) + { + 0x0B, + 0x04 + }) + Method (_PSW, 1, NotSerialized) + { + EPSW (0x02, Arg0) + } + + Name (DIDB, 0xFFFFFFFF) + Method (DPTS, 1, NotSerialized) + { + If (LAnd (LNot (LLess (Arg0, 0x01)), LNot (LGreater (Arg0, 0x04)))) + { + DFLG (0x00, 0x0100) + Store (0x00, DHKE) + If (DFLG (0x02, 0x02)) + { + Store (0x00, DOID) + DFLG (0x01, 0x02) + } + + If (GDID ()) + { + DDWK (0x01) + If (LEqual (Arg0, 0x01)) + { + SSU2 (0x01) + } + + If (LEqual (Arg0, 0x04)) + { + Store (0x01, \_SB.PCI0.ISA.SLCK) + } + } + Else + { + DDWK (0x00) + } + + Store (GDID (), DIDB) + } + } + + Method (DWAK, 1, NotSerialized) + { + Store (0xFFFFFFFF, DOID) + If (LAnd (LNot (LLess (Arg0, 0x01)), LNot (LGreater (Arg0, 0x04)))) + { + If (LNot (LEqual (DIDB, 0x00))) + { + If (LNot (LEqual (GDID (), 0x00))) + { + PPEN (0x00) + PPIN () + If (\W98F) + { + _REG (0x02, 0x01) + PPEN (0x01) + } + + ShiftLeft (Arg0, 0x08, DHKE) + If (DFLG (0x02, 0x08)) + { + Or (DHKE, 0x2004, DHKE) + If (LNot (\W98F)) + { + \_SB.PCI0.ISA.EC.HKEY.MHKQ (DHKE) + Notify (\_SB.PCI0.DOCK, 0x03) + DFLG (0x01, 0x08) + } + } + Else + { + If (LEqual (\_SB.PCI0.DOCK.GDID (), 0x4A004D24)) + { + Notify (\_SB.PCI0.DOCK.IDE1, 0x00) + } + + If (LEqual (Arg0, 0x04)) + { + \DHDP (0x03) + } + } + } + Else + { + Notify (\_SB.PCI0.DOCK, 0x00) + \DHDP (0x00) + } + } + Else + { + If (LNot (LEqual (GDID (), 0x00))) + { + If (\_SB.PCI0.ISA.BUSC) + { + _INI () + If (LNot (\W98F)) + { + PPEN (0x00) + } + } + + Notify (\_SB.PCI0.DOCK, 0x00) + } + } + + DDWK (0x00) + Store (0x00, \_SB.PCI0.ISA.SLCK) + DFLG (0x01, 0x0100) + If (LEqual (Arg0, 0x01)) + { + SSU2 (0x00) + } + + If (\WMEF) + { + DFLG (0x01, 0x02) + } + } + } + + Method (_DCK, 1, NotSerialized) + { + If (Arg0) + { + BCON (0x01) + Sleep (0x4B) + PPIN () + If (LEqual (\_SB.PCI0.DOCK.GDID (), 0x4A004D24)) + { + If (\W98F) + { + \DHDP (0x01) + } + Else + { + \DHDP (0x04) + } + } + + If (\W98F) + { + PPEN (0x01) + _REG (0x02, 0x01) + } + + DATT (0x00, 0x00) + DATT (0x01, 0x01) + If (\GVEN) + { + \GVIL (0x02) + } + } + Else + { + DFLG (0x00, 0x02) + \DHDP (0x00) + If (\W98F) + { + _REG (0x02, 0x00) + } + + PPUB (0x00) + DATT (0x00, 0x01) + DATT (0x01, 0x00) + If (\GVEN) + { + \GVIL (0x03) + } + } + + \_SB.PCI0.AGP.VID.VDSW (Arg0) + Return (0x01) + } + + Method (_EJ0, 1, NotSerialized) + { + If (DFLG (0x02, 0x02)) + { + If (Arg0) + { + BCON (0x00) + WUIN () + Store (0x00, DOID) + Store (0x00, \_SB.PCI0.ISA.FDC.DCFD) + Store (0x01, \_SB.PCI0.ISA.FDC.XFDS) + } + + DFLG (0x01, 0x02) + } + } + + Method (_EJ4, 1, NotSerialized) + { + Store (0x00, \_SB.PCI0.ISA.FDC.DCFD) + } + + Name (DOID, 0xFFFFFFFF) + Name (DHKE, 0x00) + Name (WUCT, 0x00) + Mutex (WUDM, 0x07) + Method (WURQ, 0, NotSerialized) + { + If (And (DHKE, 0x2004)) + { + If (LEqual (GDID (), 0x00)) + { + Acquire (WUDM, 0xFFFF) + If (LNot (Decrement (WUCT))) + { + Store (0x01, Local0) + } + Else + { + Store (0x00, Local0) + } + + Release (WUDM) + If (Local0) + { + Store (0x00, DHKE) + \_SB.PCI0.ISA.EC.HKEY.MHKQ (0x4003) + } + } + } + } + + Method (WUIN, 0, NotSerialized) + { + Acquire (WUDM, 0xFFFF) + If (\WNTF) + { + Store (0x21, WUCT) + } + Else + { + Store (0x01, WUCT) + } + + Release (WUDM) + } + + Method (GDID, 0, NotSerialized) + { + If (LEqual (DOID, 0xFFFFFFFF)) + { + Store (RDID (), DOID) + } + + If (\WMEF) + { + Store (DOID, DIDB) + } + + Return (DOID) + } + + Method (GDSR, 0, NotSerialized) + { + Return (RDSR ()) + } + + Method (RDID, 0, NotSerialized) + { + Store (\_SB.PCI0.ISA.EC.GDEV (0x02), Local0) + If (And (Local0, 0x07)) + { + Return (0x00) + } + + If (LNot (\H8DR)) + { + Return (\GDCK (0x02)) + } + + Store (0x10, Local0) + Store (0x00, Local1) + Store (0x00, Local2) + Store (0x00, Local3) + Store (0x00, Local4) + While (Local0) + { + Store (EEPR (Local2), Local1) + If (LAnd (LNot (LEqual (Local1, 0x8080)), LNot (LEqual (Local1, 0x8018)))) + { + If (LEqual (And (Local1, 0x8000), 0x8000)) + { + Return (0x00) + } + Else + { + If (LLess (Local2, 0x09)) + { + If (LAnd (LLess (Local2, 0x08), LGreater (Local2, 0x03))) + { + Or (Local3, ShiftLeft (Local1, Multiply (Subtract (Local2, 0x04), 0x08)), Local3) + } + + Add (Local4, Local1, Local4) + Store (0x10, Local0) + Increment (Local2) + } + Else + { + If (LEqual (Local2, 0x09)) + { + If (LNot (And (Add (Local4, Local1), 0xFF))) + { + Return (Local3) + } + Else + { + Return (0x00) + } + } + } + } + } + + Decrement (Local0) + } + + Return (0x00) + } + + Method (RDSR, 0, NotSerialized) + { + If (LEqual (GDID (), 0x00)) + { + Return (0x00) + } + + If (LNot (\H8DR)) + { + Return (\GDCK (0x01)) + } + + Store (0x10, Local0) + Store (0x00, Local1) + Store (0x00, Local2) + Store (0x00, Local3) + Store (0x00, Local4) + While (Local0) + { + Store (EEPR (Local2), Local1) + If (LAnd (LNot (LEqual (Local1, 0x8080)), LNot (LEqual (Local1, 0x8018)))) + { + If (LEqual (And (Local1, 0x8000), 0x8000)) + { + Return (0x00) + } + Else + { + If (LLess (Local2, 0x09)) + { + If (LLess (Local2, 0x04)) + { + Or (Local3, ShiftLeft (Local1, Multiply (Local2, 0x08)), Local3) + } + + Add (Local4, Local1, Local4) + Store (0x10, Local0) + Increment (Local2) + } + Else + { + If (LEqual (Local2, 0x09)) + { + If (LNot (And (Add (Local4, Local1), 0xFF))) + { + Return (Local3) + } + Else + { + Return (0x00) + } + } + } + } + } + + Decrement (Local0) + } + + Return (0x00) + } + + Method (EEPR, 1, NotSerialized) + { + Store (0x00, \_SB.PCI0.ISA.EC.HCAC) + Or (\_SB.PCI0.ISA.ACI, 0x01, \_SB.PCI0.ISA.ACI) + Store (\_SB.PCI0.ISA.EC.I2CR (0x00, 0x51, Arg0), Local0) + And (\_SB.PCI0.ISA.ACI, 0xFE, \_SB.PCI0.ISA.ACI) + Store (0x01, \_SB.PCI0.ISA.EC.HCAC) + Return (Local0) + } + + Name (FLAG, 0x00) + Method (DFLG, 2, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + Or (FLAG, Arg1, FLAG) + } + + If (LEqual (Arg0, 0x01)) + { + And (FLAG, Not (Arg1), FLAG) + } + + If (And (FLAG, Arg1)) + { + Return (0x01) + } + Else + { + Return (0x00) + } + } + + Method (DATT, 2, NotSerialized) + { + Store (0x00, Local0) + If (LEqual (Arg0, 0x00)) + { + If (LEqual (Arg1, 0x01)) + { + If (\H8DR) + { + Or (\_SB.PCI0.ISA.EC.HAM6, 0x80, \_SB.PCI0.ISA.EC.HAM6) + } + Else + { + \MBEC (0x16, 0xFF, 0x80) + } + } + + If (LEqual (Arg1, 0x00)) + { + If (\H8DR) + { + And (\_SB.PCI0.ISA.EC.HAM6, 0x7F, \_SB.PCI0.ISA.EC.HAM6) + } + Else + { + \MBEC (0x16, 0x7F, 0x00) + } + } + + If (LEqual (Arg1, 0x02)) + { + If (\H8DR) + { + If (And (\_SB.PCI0.ISA.EC.HAM6, 0x80)) + { + Store (0x01, Local0) + } + } + Else + { + If (And (\RBEC (0x16), 0x80)) + { + Store (0x01, Local0) + } + } + } + } + + If (LEqual (Arg0, 0x01)) + { + If (LEqual (Arg1, 0x01)) + { + If (\H8DR) + { + Or (\_SB.PCI0.ISA.EC.HAMA, 0x01, \_SB.PCI0.ISA.EC.HAMA) + } + Else + { + \MBEC (0x1A, 0xFF, 0x01) + } + } + + If (LEqual (Arg1, 0x00)) + { + If (\H8DR) + { + And (\_SB.PCI0.ISA.EC.HAMA, 0xFE, \_SB.PCI0.ISA.EC.HAMA) + } + Else + { + \MBEC (0x1A, 0xFE, 0x00) + } + } + + If (LEqual (Arg1, 0x02)) + { + If (\H8DR) + { + If (And (\_SB.PCI0.ISA.EC.HAMA, 0x01)) + { + Store (0x01, Local0) + } + } + Else + { + If (And (\RBEC (0x1A), 0x01)) + { + Store (0x01, Local0) + } + } + } + } + + Return (Local0) + } + + Method (DDWK, 1, NotSerialized) + { + Store (0x00, Local0) + If (LEqual (Arg0, 0x01)) + { + If (\H8DR) + { + Store (One, \_SB.PCI0.ISA.EC.HWDK) + } + Else + { + \MBEC (0x32, 0xFF, 0x08) + } + } + + If (LEqual (Arg0, 0x00)) + { + If (\H8DR) + { + Store (Zero, \_SB.PCI0.ISA.EC.HWDK) + } + Else + { + \MBEC (0x32, 0xF7, 0x00) + } + } + + If (LEqual (Arg0, 0x02)) + { + If (\H8DR) + { + If (\_SB.PCI0.ISA.EC.HWDK) + { + Store (0x01, Local0) + } + } + Else + { + If (And (\RBEC (0x32), 0x08)) + { + Store (0x01, Local0) + } + } + } + + Return (Local0) + } + + Method (DGPE, 0, NotSerialized) + { + If (\WMEF) + { + DFLG (0x00, 0x0100) + } + + If (DFLG (0x02, 0x0100)) + { + DFLG (0x00, 0x08) + } + Else + { + Or (DHKE, 0x2004, DHKE) + If (\W98F) + { + Notify (\_SB.PCI0.DOCK, 0x01) + } + Else + { + \_SB.PCI0.ISA.EC.HKEY.MHKQ (DHKE) + Notify (\_SB.PCI0.DOCK, 0x03) + } + } + } + + Event (DEVT) + Method (BCON, 1, NotSerialized) + { + If (LAnd (Arg0, \_SB.PCI0.ISA.BUSC)) + { + Return (0x00) + } + + If (LAnd (LNot (Arg0), \_SB.PCI0.ISA.BUSD)) + { + Return (0x00) + } + + Store (DATT (0x00, 0x02), Local0) + DATT (0x00, 0x01) + Reset (DEVT) + If (Arg0) + { + Sleep (0xC8) + Store (0x00, \_SB.PCI0.ISA.BUSD) + Store (0x01, \_SB.PCI0.ISA.BUSC) + } + Else + { + Store (0x00, \_SB.PCI0.ISA.BUSC) + Store (0x01, \_SB.PCI0.ISA.BUSD) + } + + Wait (DEVT, 0xFFFF) + If (LNot (Local0)) + { + DATT (0x00, 0x00) + } + } + + Method (LTCY, 0, NotSerialized) + { + If (LEqual (GDID (), 0x4A004D24)) + { + LDEV (0x00) + LDEV (0x01) + LCBS (0x02) + } + } + + Method (LDEV, 1, NotSerialized) + { + Or (0x80000000, ShiftLeft (\RPCI (0x80002019), 0x10), Local0) + Or (Local0, ShiftLeft (Arg0, 0x0B), Local0) + Store (0x00, Local1) + While (LLess (Local1, 0x08)) + { + Or (Local0, ShiftLeft (Local1, 0x08), Local2) + Store (\RPCI (Or (Local2, 0x02)), Local3) + Store (\RPCI (Or (Local2, 0x03)), Local4) + If (LOr (LNot (LEqual (Local3, 0xFF)), LNot (LEqual (Local4, 0xFF)))) + { + Store (\RPCI (Or (Local2, 0x0E)), Local5) + If (LNot (Local5)) + { + Store (\RPCI (Or (Local2, 0x3E)), Local6) + If (LNot (LGreater (Local6, 0x08))) + { + Store (0x40, Local7) + } + Else + { + If (LNot (LGreater (Local6, 0x1F))) + { + Store (Multiply (Local6, 0x08), Local7) + } + Else + { + Store (0xD0, Local7) + } + } + + \WPCI (Or (Local2, 0x0D), Local7) + \WPCI (Or (Local2, 0x0C), 0x08) + } + } + + Increment (Local1) + } + } + + Method (LCBS, 1, NotSerialized) + { + Or (0x80000000, ShiftLeft (\RPCI (0x80002019), 0x10), Local0) + Or (Local0, ShiftLeft (Arg0, 0x0B), Local0) + Store (0x00, Local1) + While (LLess (Local1, 0x02)) + { + Or (Local0, ShiftLeft (Local1, 0x08), Local2) + \WPCI (Or (Local2, 0x0C), 0x08) + \WPCI (Or (Local2, 0x0D), 0x40) + \WPCI (Or (Local2, 0x1B), 0x80) + Increment (Local1) + } + } + + Method (SSU2, 1, NotSerialized) + { + If (Arg0) + { + Store (0x01, \_SB.PCI0.PM00.S2DS) + Store (0x01, \_SB.PCI0.ISA.SUS2) + } + Else + { + Store (0x00, \_SB.PCI0.ISA.SUS2) + Store (0x00, \_SB.PCI0.PM00.S2DS) + } + } + + Scope (\_SB.PCI0.ISA.EC) + { + Method (_Q37, 0, NotSerialized) + { + If (\_SB.PCI0.ISA.SCIS) + { + Store (\_SB.PCI0.ISA.SCIR, Local0) + If (LEqual (Local0, 0x00)) + { + If (LNot (\_SB.PCI0.DOCK.GDID ())) + { + Store (0xFFFFFFFF, \_SB.PCI0.DOCK.DOID) + Notify (\_SB.PCI0.DOCK, 0x00) + } + } + + If (LAnd (LEqual (Local0, 0x02), \_SB.PCI0.ISA.BUSC)) + { + Signal (\_SB.PCI0.DOCK.DEVT) + } + + If (LAnd (LEqual (Local0, 0x03), \_SB.PCI0.ISA.BUSD)) + { + Signal (\_SB.PCI0.DOCK.DEVT) + } + + Store (0x00, \_SB.PCI0.ISA.SCIS) + } + } + + Method (_Q50, 0, NotSerialized) + { + If (\_SB.PCI0.DOCK.GDID ()) + { + If (\W98F) + { + Notify (\_SB.PCI0.DOCK, 0x01) + } + Else + { + Notify (\_SB.PCI0.DOCK, 0x03) + } + } + } + } + + OperationRegion (PPBR, PCI_Config, 0x00, 0x0100) + Field (PPBR, DWordAcc, NoLock, Preserve) + { + Offset (0x40), + SVID, 16, + SSID, 16, + Offset (0x66), + SDCL, 8, + PDCL, 8, + Offset (0x6C), + SCAD, 8, + BUFC, 8, + Offset (0x6F), + CLKR, 8, + Offset (0x76), + PG0D, 1, + PG1D, 1, + PG2D, 1, + PG3D, 1, + SG0D, 1, + SG1D, 1, + SG2D, 1, + SG3D, 1, + PG0O, 1, + PG1O, 1, + PG2O, 1, + PG3O, 1, + SG0O, 1, + SG1O, 1, + SG2O, 1, + SG3O, 1, + Offset (0x79), + SIRQ, 8, + ARMK, 8 + } + + Method (PPIN, 0, NotSerialized) + { + Or (ShiftRight (0x00040000, 0x05), 0x80000000, Local0) + Store (\RPCI (Or (Local0, 0x84)), Local1) + If (LAnd (Local1, 0x03)) + { + \WPCI (Or (Local0, 0x84), And (Local1, 0xFC)) + Sleep (0x0A) + } + + If (\W98F) + { + \WPCI (Or (Local0, 0x1C), 0xF0) + \WPCI (Or (Local0, 0x1D), 0x00) + \WPCI (Or (Local0, 0x20), 0xF0) + \WPCI (Or (Local0, 0x21), 0xFF) + \WPCI (Or (Local0, 0x22), 0x00) + \WPCI (Or (Local0, 0x23), 0x00) + \WPCI (Or (Local0, 0x24), 0xF0) + \WPCI (Or (Local0, 0x25), 0xFF) + \WPCI (Or (Local0, 0x26), 0x00) + \WPCI (Or (Local0, 0x27), 0x00) + } + + \WPCI (Or (Local0, 0x19), 0x08) + \WPCI (Or (Local0, 0x1A), 0x0E) + \WPCI (Or (Local0, 0x0C), 0x08) + \WPCI (Or (Local0, 0x0D), 0x40) + \WPCI (Or (Local0, 0x1B), 0x44) + Store (0x1014, SVID) + Store (0xE3, SSID) + Or (And (SDCL, 0x00), 0x01, SDCL) + Or (And (PDCL, 0x00), 0x01, PDCL) + Or (And (SCAD, 0x02), 0xB0, SCAD) + Or (And (BUFC, 0x00), 0x1F, BUFC) + Or (And (CLKR, 0x00), 0x0C, CLKR) + Or (And (SIRQ, 0x00), 0x23, SIRQ) + Or (And (ARMK, 0x00), 0x38, ARMK) + PPFD () + PPUB (0x01) + PPMX () + } + + Method (PPEN, 1, NotSerialized) + { + Or (0x80000000, ShiftRight (0x00040000, 0x05), Local0) + If (Arg0) + { + \MPCI (Or (Local0, 0x04), 0xFF, 0x07) + } + Else + { + \MPCI (Or (Local0, 0x04), 0xF8, 0x00) + } + } + + Method (PPRS, 0, NotSerialized) + { + Or (0x80000000, ShiftRight (0x00040000, 0x05), Local0) + \MPCI (Or (Local0, 0x3E), 0xFF, 0x40) + Sleep (0x64) + \MPCI (Or (Local0, 0x3E), 0xBF, 0x00) + } + + Method (PPFD, 0, NotSerialized) + { + Store (0x01, SG1D) + If (LEqual (\_SB.PCI0.ISA.EC.GDEV (0x03), 0x0D)) + { + Store (0x01, \_SB.PCI0.ISA.FDC.DCFD) + Store (0x01, SG1O) + } + Else + { + Store (0x00, \_SB.PCI0.ISA.FDC.DCFD) + Store (0x00, SG1O) + } + } + + Method (PPUB, 1, NotSerialized) + { + Store (0x00, SG3D) + If (Arg0) + { + Store (0x00, PG3O) + } + Else + { + Store (0x01, PG3O) + } + + Store (0x01, PG3D) + } + + Method (PPMX, 0, NotSerialized) + { + Store (\RPCI (Or (0x80000019, ShiftRight (0x00040000, 0x05))), Local0) + Or (0x80000000, ShiftLeft (Local0, 0x10), Local0) + Store (0x04, Local1) + Store (0x00, Local2) + While (Local1) + { + Decrement (Local1) + ShiftLeft (Local2, 0x08, Local2) + Or (Local2, \RPCI (Or (Local0, Local1)), Local2) + } + + If (LEqual (Local2, 0x00213388)) + { + Or (SDCL, 0x04, SDCL) + } + } + + Device (IDE1) + { + Name (_ADR, 0x00010000) + OperationRegion (IDEC, PCI_Config, 0x00, 0x0100) + Field (IDEC, DWordAcc, NoLock, Preserve) + { + Offset (0x4F), + , 2, + ENCL, 1, + Offset (0x50), + Offset (0x51), + , 2, + PRMC, 1, + SNDC, 1, + Offset (0x52), + XCMT, 8, + , 6, + XAR0, 2, + XDRR, 4, + XDRW, 4, + Offset (0x73), + XUDM, 1, + , 1, + XUDC, 1, + , 1, + XUDT, 2, + Offset (0x74) + } + + Method (DREG, 2, NotSerialized) + { + If (LEqual (Arg0, 0x02)) + { + If (Arg1) + { + If (LEqual (\_SB.PCI0.DOCK.GDID (), 0x4A004D24)) + { + If (LNot (And (\_SB.PCI0.DOCK.SCAD, 0x02))) + { + Store (0x01, PRMC) + Store (0x01, SNDC) + } + } + + If (\W98F) + { + RAID () + } + } + } + } + + Method (RAID, 0, NotSerialized) + { + Store (0x01, ENCL) + Store (\RPCI (Or (0x80000019, ShiftRight (0x00040000, 0x05))), Local0) + Or (0x80000000, ShiftLeft (Local0, 0x10), Local0) + Or (Local0, ShiftRight (_ADR, 0x05), Local0) + Or (Local0, ShiftLeft (And (_ADR, 0x07), 0x08), Local0) + \WPCI (Or (Local0, 0x0A), 0x04) + Store (0x00, ENCL) + } + + Method (_STA, 0, NotSerialized) + { + Store (0x00, Local0) + If (LEqual (\_SB.PCI0.DOCK.GDID (), 0x4A004D24)) + { + If (LNot (And (\_SB.PCI0.DOCK.SCAD, 0x02))) + { + Store (0x0F, Local0) + } + } + + Return (Local0) + } + + Device (PRIM) + { + Name (_ADR, 0x00) + Method (_GTM, 0, NotSerialized) + { + Store (0x12, Local4) + If (XCMT) + { + If (XDRR) + { + If (LEqual (XDRR, 0x0F)) + { + Store (0x01, Local0) + } + Else + { + Add (0x01, XDRR, Local0) + } + } + Else + { + Store (0x10, Local0) + } + + If (XDRW) + { + Store (XDRW, Local1) + } + Else + { + Store (0x10, Local1) + } + + Add (Local0, Local1, Local0) + Multiply (0x1E, Local0, Local0) + If (LGreater (Local0, 0xF0)) + { + Store (0x0384, Local0) + } + + Store (Local0, Local1) + } + Else + { + Store (0x00, Local0) + } + + Store (Local0, Local1) + If (XUDM) + { + Or (Local4, 0x01, Local4) + If (XUDC) + { + Add (XUDT, 0x01, Local1) + Multiply (0x0F, Local1, Local1) + } + Else + { + Add (XUDT, 0x01, Local1) + Multiply (0x1E, Local1, Local1) + If (LEqual (Local1, 0x5A)) + { + Store (0x50, Local1) + } + } + } + + Store (Local0, \GTP0) + Store (Local1, \GTD0) + Store (0x00, \GTP1) + Store (0x00, \GTD1) + Store (Local4, \GTMF) + Return (\BGTM) + } + + Method (_STM, 3, NotSerialized) + { + CreateDWordField (Arg0, 0x00, STP0) + CreateDWordField (Arg0, 0x04, STD0) + CreateDWordField (Arg0, 0x08, STP1) + CreateDWordField (Arg0, 0x0C, STD1) + CreateDWordField (Arg0, 0x10, STMF) + If (SizeOf (Arg1)) + { + CreateWordField (Arg1, 0x01, DM00) + If (DM00) + { + Store (One, Local5) + } + Else + { + Store (Zero, Local5) + } + } + Else + { + Store (Zero, Local5) + } + + If (Local5) + { + If (W98F) + { + CreateWordField (Arg1, 0x66, DM51) + CreateWordField (Arg1, 0x6A, DM53) + CreateWordField (Arg1, 0x7C, DM62) + CreateWordField (Arg1, 0x7E, DM63) + CreateWordField (Arg1, 0x80, DM64) + CreateWordField (Arg1, 0x82, DM65) + CreateWordField (Arg1, 0x88, DM68) + CreateWordField (Arg1, 0xB0, DM88) + Store (\UDMA (DM53, DM88), Local0) + Store (\MDMA (DM53, DM63, DM62, DM65), Local1) + Store (\MPIO (DM53, DM64, DM51, DM68), Local2) + } + Else + { + Store (\MPIB (And (STMF, 0x02), STP0), Local2) + Store (\UDMB (And (STMF, 0x01), STD0), Local0) + Store (\MDMB (STD0), Local1) + } + + Store (And (DM00, 0x80), \IDKS) + Store (\CART (Local2), XAR0) + Store (\CCMD (Local2), XCMT) + Store (\CDRW (Local1, Local2), Local3) + And (Local3, 0x0F, XDRR) + ShiftRight (Local3, 0x04, XDRW) + If (Local0) + { + Store (0x01, XUDM) + If (LNot (LGreater (Local0, 0x03))) + { + Store (0x00, XUDC) + } + Else + { + Store (0x01, XUDC) + } + + Store (\CUDC (Local0), XUDT) + } + + Store (\MHDM (Local0, Local1), \HDM3) + Store (\MHDM (Local0, Local1), \CDM3) + Store (\MHPI (Local2), \HPI3) + Store (\MHPI (Local2), \CPI3) + } + } + + Device (MSTR) + { + Name (_ADR, 0x00) + Method (_GTF, 0, NotSerialized) + { + If (\IDKS) + { + Return (\ICC3) + } + Else + { + Return (\ICM3) + } + } + } + } + } + + Device (CBS2) + { + Name (_ADR, 0x00020000) + Method (_STA, 0, NotSerialized) + { + If (LEqual (\_SB.PCI0.DOCK.GDID (), 0x4A004D24)) + { + Return (0x0F) + } + Else + { + Return (0x00) + } + } + + Method (DREG, 2, NotSerialized) + { + If (LAnd (LEqual (Arg0, 0x02), LEqual (Arg1, 0x01))) + { + If (LEqual (\_SB.PCI0.DOCK.GDID (), 0x4A004D24)) + { + ICFG () + } + } + } + + OperationRegion (CBUS, PCI_Config, 0x00, 0x0100) + Field (CBUS, DWordAcc, NoLock, Preserve) + { + Offset (0x44), + LGDC, 32, + Offset (0x80), + SYSC, 32, + Offset (0x8C), + MULR, 32, + RSTS, 8, + CCTL, 8, + DCTL, 8, + DIAG, 8 + } + + Method (ICFG, 0, NotSerialized) + { + Store (RPCI (Or (0x80000019, ShiftRight (0x00040000, 0x05))), Local0) + Or (0x80000000, ShiftLeft (Local0, 0x10), Local0) + Or (Local0, ShiftRight (_ADR, 0x05), Local0) + Or (Local0, ShiftLeft (And (_ADR, 0x07), 0x08), Local0) + \WPCI (Or (Local0, 0x0C), 0x08) + \WPCI (Or (Local0, 0x0D), 0xA8) + \WPCI (Or (Local0, 0x1B), 0x80) + Or (And (LGDC, 0x00), 0x00, LGDC) + Or (And (SYSC, 0x00FFFF00), 0x2864C077, SYSC) + Or (And (MULR, 0x00), 0x1002, MULR) + Or (And (RSTS, 0x00), 0xC0, RSTS) + Or (And (CCTL, 0x7B), 0x02, CCTL) + Or (And (DCTL, 0x00), 0x66, DCTL) + Or (And (DIAG, 0x1E), 0x40, DIAG) + } + } + + Device (CBS3) + { + Name (_ADR, 0x00020001) + Method (_STA, 0, NotSerialized) + { + If (LEqual (\_SB.PCI0.DOCK.GDID (), 0x4A004D24)) + { + Return (0x0F) + } + Else + { + Return (0x00) + } + } + + Method (DREG, 2, NotSerialized) + { + If (LAnd (LEqual (Arg0, 0x02), LEqual (Arg1, 0x01))) + { + If (LEqual (\_SB.PCI0.DOCK.GDID (), 0x4A004D24)) + { + ICFG () + } + } + } + + OperationRegion (CBUS, PCI_Config, 0x00, 0x0100) + Field (CBUS, DWordAcc, NoLock, Preserve) + { + Offset (0x44), + LGDC, 32, + Offset (0x80), + SYSC, 32, + Offset (0x8C), + MULR, 32, + RSTS, 8, + CCTL, 8, + DCTL, 8, + DIAG, 8 + } + + Method (ICFG, 0, NotSerialized) + { + Store (RPCI (Or (0x80000019, ShiftRight (0x00040000, 0x05))), Local0) + Or (0x80000000, ShiftLeft (Local0, 0x10), Local0) + Or (Local0, ShiftRight (_ADR, 0x05), Local0) + Or (Local0, ShiftLeft (And (_ADR, 0x07), 0x08), Local0) + \WPCI (Or (Local0, 0x0C), 0x08) + \WPCI (Or (Local0, 0x0D), 0xA8) + \WPCI (Or (Local0, 0x1B), 0x80) + Or (And (LGDC, 0x00), 0x00, LGDC) + Or (And (SYSC, 0x00FFFF00), 0x2864C077, SYSC) + Or (And (MULR, 0x00), 0x1002, MULR) + Or (And (RSTS, 0x00), 0xC0, RSTS) + Or (And (CCTL, 0x7B), 0x02, CCTL) + Or (And (DCTL, 0x00), 0x66, DCTL) + Or (And (DIAG, 0x1E), 0x40, DIAG) + } + } + } + } + + Scope (\_SB.PCI0.ISA.EC) + { + Name (BDEV, 0x00) + Name (BSTS, 0x00) + Name (BHKE, 0x00) + Name (BXCN, 0x00) + Method (_Q2C, 0, NotSerialized) + { + If (LEqual (BSTS, 0x00)) + { + Store (GUID (), BDEV) + If (BXCN) + { + NXRE (BDEV) + } + Else + { + NBRE (BDEV) + } + } + } + + Method (_Q2D, 0, NotSerialized) + { + Store (GUID (), BDEV) + If (BXCN) + { + NXRC (BDEV) + } + Else + { + NBIN (BDEV) + } + } + + Method (_Q38, 0, NotSerialized) + { + Store (GUID (), Local0) + If (LAnd (BDEV, LNot (LEqual (Local0, BDEV)))) + { + If (LEqual (Local0, 0x0F)) + { + BDIS () + If (BXCN) + { + Store (BDEV, Local0) + Store (0x0F, BDEV) + NXEJ (Local0) + } + Else + { + NBEJ (BDEV) + Store (Local0, BDEV) + } + } + Else + { + If (HPBU) + { + If (BXCN) + { + Store (Local0, BDEV) + NXIN (Local0) + } + } + Else + { + Store (Local0, BDEV) + If (BXCN) + { + NXRC (Local0) + } + Else + { + NBIN (Local0) + } + } + } + } + } + + Method (NBRE, 1, NotSerialized) + { + If (LEqual (Arg0, 0x0D)) + { + Notify (\_SB.PCI0.ISA.FDC.FDD0, 0x03) + } + + If (LLess (Arg0, 0x0C)) + { + Notify (\_SB.PCI0.IDE0.SCND.MSTR, 0x03) + } + + If (LEqual (Arg0, 0x10)) + { + If (LOr (HPAC, HB0A)) + { + If (\WNTF) + { + Notify (\_SB.PCI0.ISA.EC.BAT1, 0x03) + } + } + Else + { + BLED (0x02, 0x01) + BEEP (0x0F) + Store (0x02, BSTS) + } + } + } + + Method (NBEJ, 1, NotSerialized) + { + If (LEqual (BSTS, 0x00)) + { + If (LEqual (Arg0, 0x0D)) + { + Notify (\_SB.PCI0.ISA.FDC.FDD0, 0x01) + } + + If (LLess (Arg0, 0x0C)) + { + Notify (\_SB.PCI0.IDE0.SCND.MSTR, 0x01) + } + + If (LEqual (Arg0, 0x10)) + { + If (\WNTF) + { + Notify (\_SB.PCI0.ISA.EC.BAT1, 0x01) + } + Else + { + Notify (\_SB.PCI0.ISA.EC.BAT1, 0x81) + } + } + } + + BLED (0x00, 0x00) + BEEP (0x00) + Store (0x00, BSTS) + } + + Method (NBIN, 1, NotSerialized) + { + If (LEqual (Arg0, 0x0D)) + { + BEN (0x00) + \SFDD (0x00) + BLED (0x02, 0x00) + Notify (\_SB.PCI0.ISA.FDC.FDD0, 0x01) + } + + If (LLess (Arg0, 0x0C)) + { + If (LEqual (Arg0, 0x06)) + { + BEN (0x02) + } + Else + { + BEN (0x01) + } + + BLED (0x02, 0x00) + Notify (\_SB.PCI0.IDE0.SCND.MSTR, 0x01) + } + + If (LEqual (Arg0, 0x10)) + { + BLED (0x02, 0x00) + If (\WNTF) + { + Store (0x01, \_SB.PCI0.ISA.EC.BAT1.XB1S) + Notify (\_SB.PCI0.ISA.EC.BAT1, 0x01) + } + Else + { + Notify (\_SB.PCI0.ISA.EC.BAT1, 0x81) + } + } + + BEEP (0x00) + Store (0x00, BSTS) + } + + Method (BEJ0, 1, NotSerialized) + { + If (Arg0) + { + BDIS () + BLED (0x00, 0x00) + \BHDP (0x00) + Store (0x01, BSTS) + If (BHKE) + { + Store (0x00, BHKE) + \_SB.PCI0.ISA.EC.HKEY.MHKQ (0x3003) + } + } + Else + { + BLED (0x02, 0x00) + Store (0x00, BSTS) + } + } + + Method (BEJ3, 1, NotSerialized) + { + If (Arg0) + { + Store (0x83, BF_Z) + Store (0x83, BF_D) + Store (0x83, BZIP) + Store (0x83, BDVD) + Store (0x83, BHFD) + Store (0x83, BF_H) + Store (0x83, BHDD) + Store (0x83, BLS) + Store (0x83, BF_C) + Store (0x83, BCRW) + Store (0x83, BCD) + Store (0x83, BFDD) + BDIS () + Store (0x01, BSTS) + } + Else + { + Store (0x81, BF_Z) + Store (0x81, BF_D) + Store (0x81, BZIP) + Store (0x81, BDVD) + Store (0x81, BHFD) + Store (0x81, BF_H) + Store (0x81, BHDD) + Store (0x81, BLS) + Store (0x81, BF_C) + Store (0x81, BCRW) + Store (0x81, BCD) + Store (0x81, BFDD) + Store (0x00, BSTS) + } + } + + Method (BPTS, 1, NotSerialized) + { + If (LOr (LEqual (Arg0, 0x00), LNot (LLess (Arg0, 0x05)))) {} + Else + { + If (LNot (LEqual (BSTS, 0x00))) + { + Store (0x0F, BDEV) + Store (0x00, BSTS) + } + + Store (0x00, BHKE) + If (LNot (LEqual (BDEV, 0x0F))) + { + BLDT (0x00) + BUWK (0x01) + } + Else + { + BLDT (0x01) + BUWK (0x00) + } + } + } + + Method (BWAK, 1, NotSerialized) + { + If (LOr (LEqual (Arg0, 0x00), LNot (LLess (Arg0, 0x05)))) {} + Else + { + BUWK (0x00) + Store (GUID (), Local0) + If (LGreater (Local0, 0x0E)) + { + BDIS () + } + + \_SB.PCI0.ISA.FDC._INI () + If (LNot (LEqual (Local0, 0x0D))) + { + If (LEqual (\_SB.PCI0.ISA.FDC.FD0S, \_SB.PCI0.ISA.EC.HPNF)) + { + Notify (\_SB.PCI0.ISA.FDC.FDD0, 0x01) + } + } + + If (LEqual (BSTS, 0x00)) + { + If (LNot (LEqual (Local0, BDEV))) + { + If (BXCN) + { + Store (Local0, BDEV) + NXRC (Local0) + } + Else + { + NBEJ (BDEV) + Store (Local0, BDEV) + NBIN (Local0) + } + } + Else + { + If (LNot (LEqual (Local0, 0x0F))) + { + BLED (0x02, 0x00) + If (HPBU) + { + Or (ShiftLeft (Arg0, 0x08), 0x2005, BHKE) + \_SB.PCI0.ISA.EC.HKEY.MHKQ (BHKE) + If (LNot (LGreater (Arg0, 0x02))) {} + Else + { + If (BXCN) + { + NXRE (Local0) + } + Else + { + NBRE (Local0) + } + } + } + } + } + } + } + } + + Method (BDIS, 0, NotSerialized) + { + \SFDD (0x01) + Store (0x00, \_SB.PCI0.IDE0.XSI0) + Store (0x01, \_SB.PCI0.ISA.GCRC) + Store (0x01, \_SB.PCI0.PM00.ULON) + Store (0x01, \_SB.PCI0.PM00.CSON) + } + + Method (BEN, 1, NotSerialized) + { + If (LNot (LOr (\_SB.PCI0.PM00.ULON, \_SB.PCI0.PM00.CSON))) + { + Return (0x00) + } + + If (Arg0) + { + Store (0x00, \_SB.PCI0.IDE0.XSE) + Stall (0x05) + } + + Store (0x00, \_SB.PCI0.PM00.URST) + Store (0x00, \_SB.PCI0.PM00.ULON) + Store (0x00, \_SB.PCI0.PM00.CSON) + Sleep (0x0F) + If (Arg0) + { + Store (0x00, \_SB.PCI0.ISA.GCRC) + Store (0x01, \_SB.PCI0.IDE0.XSE) + Stall (0x2D) + } + + Store (0x01, \_SB.PCI0.PM00.URST) + Sleep (0x14) + If (Arg0) + { + Sleep (0x0190) + If (LEqual (Arg0, 0x02)) + { + Sleep (0x07D0) + } + } + } + + Method (BSTA, 1, NotSerialized) + { + If (\_SB.PCI0.PM00.CSON) + { + Return (0x00) + } + + Store (GUID (), Local0) + If (LEqual (Arg0, 0x00)) + { + Return (LEqual (Local0, 0x0D)) + } + + If (LEqual (Arg0, 0x01)) + { + Return (LLess (Local0, 0x0D)) + } + + Return (0x00) + } + + Method (BLED, 2, NotSerialized) + { + If (\H8DR) + { + Acquire (LEDM, 0xFFFF) + Store (0x18, HLMS) + If (Arg1) + { + Store (0x18, HLBL) + } + Else + { + Store (0x00, HLBL) + } + + If (LEqual (Arg0, 0x00)) + { + Store (0x00, HLCL) + } + Else + { + If (LEqual (Arg0, 0x01)) + { + Store (0x08, HLCL) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Store (0x10, HLCL) + } + Else + { + } + } + } + + Sleep (0x0A) + Release (LEDM) + } + } + + Name (BF_Z, 0x83) + Name (BF_D, 0x83) + Name (BZIP, 0x83) + Name (BDVD, 0x83) + Name (BHFD, 0x83) + Name (BF_H, 0x83) + Name (BHDD, 0x83) + Name (BADP, 0x00) + Name (BLS, 0x83) + Name (BF_C, 0x83) + Name (BCRW, 0x83) + Name (BCD, 0x83) + Name (BR01, 0x00) + Name (BFDD, 0x83) + Name (BIMP, 0x00) + Name (BNON, 0x83) + Method (BLDT, 1, NotSerialized) + { + AI2C () + If (Arg0) + { + Store (BF_Z, HF_Z) + Store (BF_D, HF_D) + Store (BZIP, HZIP) + Store (BDVD, HDVD) + Store (BHFD, HHFD) + Store (BF_H, HF_H) + Store (BHDD, HHDD) + Store (BADP, HADP) + Store (BLS, HLS) + Store (BF_C, HF_C) + Store (BCRW, HCRW) + Store (BCD, HCD) + Store (BR01, HR01) + Store (BFDD, HFDD) + Store (BIMP, HIMP) + Store (BNON, HNON) + } + Else + { + Store (0x81, HF_Z) + Store (0x81, HF_D) + Store (0x81, HZIP) + Store (0x81, HDVD) + Store (0x81, HHFD) + Store (0x81, HF_H) + Store (0x81, HHDD) + Store (0x00, HADP) + Store (0x81, HLS) + Store (0x81, HF_C) + Store (0x81, HCRW) + Store (0x81, HCD) + Store (0x00, HR01) + Store (0x81, HFDD) + Store (0x00, HIMP) + Store (0x81, HNON) + } + + Store (I2WB (Zero, 0x01, 0x09, 0x10), Local7) + RI2C () + If (Local7) + { + Fatal (0x01, 0x80000003, Local7) + } + } + + Method (BUWK, 1, NotSerialized) + { + If (\H8DR) + { + If (Arg0) + { + Store (0x01, \_SB.PCI0.ISA.EC.HWBU) + } + Else + { + Store (0x00, \_SB.PCI0.ISA.EC.HWBU) + } + } + Else + { + If (Arg0) + { + \MBEC (0x32, 0xFF, 0x80) + } + Else + { + \MBEC (0x32, 0x7F, 0x00) + } + } + } + + Method (NXRE, 1, NotSerialized) + { + If (LEqual (Arg0, 0x0F)) + { + BLED (0x00, 0x00) + Store (0x00, BSTS) + } + + If (LEqual (Arg0, 0x0D)) + { + BLED (0x02, 0x01) + Notify (\_SB.SWAP, 0x83) + } + + If (LLess (Arg0, 0x0C)) + { + BLED (0x02, 0x01) + Notify (\_SB.SWAP, 0x83) + } + + If (LEqual (Arg0, 0x10)) + { + If (LOr (HPAC, HB0A)) + { + BLED (0x02, 0x01) + Notify (\_SB.SWAP, 0x83) + } + Else + { + BLED (0x02, 0x01) + BEEP (0x0F) + Store (0x02, BSTS) + } + } + } + + Method (NXRC, 1, NotSerialized) + { + If (LEqual (Arg0, 0x0D)) + { + BLED (0x02, 0x00) + BEN (0x00) + \SFDD (0x00) + Notify (\_SB.SWAP, 0x80) + } + + If (LLess (Arg0, 0x0C)) + { + BLED (0x02, 0x00) + If (LEqual (Arg0, 0x06)) + { + BEN (0x02) + } + Else + { + BEN (0x01) + } + + Notify (\_SB.SWAP, 0x80) + } + + If (LEqual (Arg0, 0x10)) + { + Notify (\_SB.PCI0.ISA.EC.BAT1, 0x81) + BLED (0x02, 0x00) + Notify (\_SB.SWAP, 0x80) + } + + BEEP (0x00) + Store (0x00, BSTS) + } + + Method (NXEJ, 1, NotSerialized) + { + If (LEqual (Arg0, 0x10)) + { + Notify (\_SB.PCI0.ISA.EC.BAT1, 0x81) + } + + Notify (\_SB.SWAP, 0x82) + BLED (0x00, 0x00) + BEEP (0x00) + Store (0x00, BSTS) + } + + Method (NXIN, 1, NotSerialized) + { + Notify (\_SB.SWAP, 0x81) + } + } + + Scope (\_SB) + { + Device (SWAP) + { + Name (_HID, EisaId ("IBM0069")) + Method (_STA, 0, NotSerialized) + { + If (\WMEF) + { + Return (0x0F) + } + Else + { + Return (0x00) + } + } + + Method (XCNN, 1, NotSerialized) + { + Store (Arg0, \_SB.PCI0.ISA.EC.BXCN) + Return (0x09) + } + + Method (XSWP, 0, NotSerialized) + { + Return (0x01) + } + + Method (XEJ0, 1, NotSerialized) + { + Store (0x00, \_SB.PCI0.ISA.EC.BAT1.B1ST) + \_SB.PCI0.ISA.EC.BEJ0 (Arg0) + } + + Method (XEJ3, 1, NotSerialized) + { + Store (0x00, \_SB.PCI0.ISA.EC.BAT1.B1ST) + \_SB.PCI0.ISA.EC.BEJ3 (Arg0) + } + + Method (XDID, 0, NotSerialized) + { + Name (XPCK, Package (0x06) + { + 0x00, + 0x00, + 0xFFFFFFFF, + 0xFFFFFFFF, + 0xFFFFFFFF, + 0x00 + }) + Store (\_SB.PCI0.ISA.EC.BDEV, Local0) + Store (Local0, Index (XPCK, 0x00)) + If (LLess (Local0, 0x0C)) + { + Store (\_SB.PCI0.IDE0._ADR, Index (XPCK, 0x02)) + Store (\_SB.PCI0.IDE0.SCND._ADR, Index (XPCK, 0x03)) + Store (\_SB.PCI0.IDE0.SCND.MSTR._ADR, Index (XPCK, 0x04)) + } + + If (LEqual (Local0, 0x0D)) + { + Store (\_SB.PCI0.ISA.FDC._HID, Index (XPCK, 0x02)) + Store (\_SB.PCI0.ISA.FDC.FDD0._ADR, Index (XPCK, 0x04)) + } + + If (LEqual (Local0, 0x10)) + { + Store (\_SB.PCI0.ISA.EC.BAT1._HID, Index (XPCK, 0x02)) + Store (\_SB.PCI0.ISA.EC.BAT1._UID, Index (XPCK, 0x04)) + } + + Store (XOr (\_SB.PCI0.PM00.CSON, 0x01), Index (XPCK, 0x05)) + Return (XPCK) + } + + Method (XSTM, 1, NotSerialized) + { + Name (XDMY, Buffer (0x14) {}) + \_SB.PCI0.IDE0.SCND._STM (XDMY, Arg0, 0x00) + } + + Method (XGTF, 0, NotSerialized) + { + Return (\_SB.PCI0.IDE0.SCND.MSTR._GTF ()) + } + } + } + + Scope (\_SB.PCI0.IDE0.SCND.MSTR) + { + Method (_EJ0, 1, NotSerialized) + { + \_SB.PCI0.ISA.EC.BEJ0 (Arg0) + } + + Method (_STA, 0, NotSerialized) + { + If (\_SB.PCI0.ISA.EC.BSTA (0x01)) + { + Return (0x0F) + } + Else + { + Return (0x00) + } + } + } + + Scope (\_SB.PCI0.ISA.FDC) + { + Method (_INI, 0, NotSerialized) + { + Store (0x00, \_SB.PCI0.ISA.FDC.XFDS) + If (\H8DR) + { + Or (\_SB.PCI0.ISA.EC.HAMA, 0x0C, \_SB.PCI0.ISA.EC.HAMA) + } + Else + { + \MBEC (0x1A, 0xFF, 0x0C) + } + } + + Name (FDEB, Buffer (0x14) + { + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00 + }) + CreateByteField (FDEB, 0x00, FD0S) + Name (XFDS, 0x00) + Name (DCFD, 0x00) + Method (_FDE, 0, NotSerialized) + { + If (LOr (\_SB.PCI0.ISA.EC.BSTA (0x00), DCFD)) + { + Store (0x01, FD0S) + } + Else + { + If (LOr (\_SB.PCI0.ISA.EC.HPNF, XFDS)) + { + Store (0x00, FD0S) + } + Else + { + Store (0x01, FD0S) + } + } + + Return (FDEB) + } + + Device (FDD0) + { + Name (_ADR, 0x00) + Name (_EJD, "_SB.PCI0.DOCK") + Method (_EJ0, 1, NotSerialized) + { + If (\_SB.PCI0.ISA.EC.BSTA (0x00)) + { + \_SB.PCI0.ISA.EC.BEJ0 (Arg0) + } + Else + { + If (DCFD) {} + Else + { + Store (0x01, XFDS) + } + } + } + + Name (_FDI, Package (0x10) + { + 0x00, + 0x04, + 0x4F, + 0x12, + 0x01, + 0xDF, + 0x02, + 0x25, + 0x02, + 0x12, + 0x1B, + 0xFF, + 0x6C, + 0xF6, + 0x0F, + 0x05 + }) + } + } + + Scope (\_SB.PCI0.ISA.EC) + { + Method (_Q52, 0, NotSerialized) + { + If (\_SB.PCI0.ISA.FDC.XFDS) + { + Store (0x00, \_SB.PCI0.ISA.FDC.XFDS) + } + Else + { + If (LOr (\_SB.PCI0.ISA.EC.BSTA (0x00), \_SB.PCI0.ISA.FDC.DCFD)) {} + Else + { + Notify (\_SB.PCI0.ISA.FDC.FDD0, 0x01) + } + } + } + + Method (_Q53, 0, NotSerialized) + { + Store (0x00, \_SB.PCI0.ISA.FDC.XFDS) + If (LOr (\_SB.PCI0.ISA.EC.BSTA (0x00), \_SB.PCI0.ISA.FDC.DCFD)) {} + Else + { + Notify (\_SB.PCI0.ISA.FDC.FDD0, 0x01) + } + } + } + + Scope (\_SB.PCI0.ISA.EC.BAT1) + { + Method (_EJ0, 1, NotSerialized) + { + Store (0x00, B1ST) + Store (0x00, XB1S) + \_SB.PCI0.ISA.EC.BEJ0 (Arg0) + } + } + + Scope (\_SB.PCI0.ISA.EC) + { + Method (_Q1C, 0, NotSerialized) + { + \VOLD () + } + + Method (_Q1D, 0, NotSerialized) + { + \VOLU () + } + + Method (_Q1E, 0, NotSerialized) + { + \VOLM () + } + } + + Scope (\_SB.PCI0.ISA.EC) + { + Method (_Q14, 0, NotSerialized) + { + \BRIU () + } + + Method (_Q15, 0, NotSerialized) + { + \BRID () + } + } + + Scope (\_SB.PCI0.ISA.EC) + { + Method (_Q19, 0, NotSerialized) + { + \TPKY () + } + } + + Scope (\_SB.PCI0.ISA.EC.HKEY) + { + Name (BTID, 0x00) + Name (BTFG, 0x00) + Method (GULP, 0, NotSerialized) + { + Store (0x00, Local0) + If (LEqual (BTID, 0x01)) + { + Or (Local0, 0x01, Local0) + } + + If (PWRS ()) + { + Or (Local0, 0x02, Local0) + } + + If (And (BTFG, 0x01)) + { + Or (Local0, 0x04, Local0) + } + + Return (Local0) + } + + Method (SULP, 1, NotSerialized) + { + If (And (Arg0, 0x02)) + { + PWRC (0x01) + } + Else + { + PWRC (0x00) + } + + If (And (Arg0, 0x04)) + { + Or (BTFG, 0x01, BTFG) + \GBTH (0x02) + } + Else + { + And (BTFG, Not (0x01), BTFG) + \GBTH (0x03) + } + + Return (GULP ()) + } + + Method (BTIN, 0, NotSerialized) + { + Store (\GBTH (0x00), BTID) + If (\GBTH (0x01)) + { + Or (BTFG, 0x01, BTFG) + } + + ATCH (0x01) + PBTN (0x01) + MODE (0x01) + } + + Method (BTPS, 1, NotSerialized) + { + PBTN (0x00) + If (LEqual (BTID, 0x01)) + { + If (LNot (And (BTFG, 0x01))) + { + PWRC (0x00) + } + } + + If (PWRS ()) + { + Or (BTFG, 0x02, BTFG) + } + Else + { + And (BTFG, Not (0x02), BTFG) + } + } + + Method (BTWK, 1, NotSerialized) + { + PBTN (0x01) + If (And (BTFG, 0x02)) + { + PWRC (0x01) + } + } + + Method (PWRC, 1, NotSerialized) + { + If (Arg0) + { + If (\H8DR) + { + Store (One, \_SB.PCI0.ISA.EC.BTPW) + } + Else + { + \MBEC (0x3B, 0xFF, 0x04) + } + } + Else + { + If (\H8DR) + { + Store (Zero, \_SB.PCI0.ISA.EC.BTPW) + } + Else + { + \MBEC (0x3B, 0xFB, 0x00) + } + } + } + + Method (ATCH, 1, NotSerialized) + { + If (Arg0) + { + If (\H8DR) + { + Store (Zero, \_SB.PCI0.ISA.EC.BTDT) + } + Else + { + \MBEC (0x3B, 0xF7, 0x00) + } + } + Else + { + If (\H8DR) + { + Store (One, \_SB.PCI0.ISA.EC.BTDT) + } + Else + { + \MBEC (0x3B, 0xFF, 0x08) + } + } + } + + Method (MODE, 1, NotSerialized) + { + If (Arg0) + { + If (\H8DR) + { + Store (One, \_SB.PCI0.ISA.EC.BTCM) + } + Else + { + \MBEC (0x01, 0xFF, 0x02) + } + } + Else + { + If (\H8DR) + { + Store (Zero, \_SB.PCI0.ISA.EC.BTCM) + } + Else + { + \MBEC (0x01, 0xFD, 0x00) + } + } + } + + Method (PBTN, 1, NotSerialized) + { + If (Arg0) + { + If (\H8DR) + { + Store (One, \_SB.PCI0.ISA.EC.BTPC) + } + Else + { + \MBEC (0x01, 0xFF, 0x40) + } + } + Else + { + If (\H8DR) + { + Store (Zero, \_SB.PCI0.ISA.EC.BTPC) + } + Else + { + \MBEC (0x01, 0xBF, 0x00) + } + } + } + + Method (PWRS, 0, NotSerialized) + { + If (\H8DR) + { + Store (\_SB.PCI0.ISA.EC.BTPW, Local0) + } + Else + { + Store (ShiftRight (And (\RBEC (0x3B), 0x04), 0x02), Local0) + } + + Return (Local0) + } + + Method (ATCS, 0, NotSerialized) + { + If (\H8DR) + { + Store (\_SB.PCI0.ISA.EC.BTDT, Local0) + } + Else + { + Store (ShiftRight (And (\RBEC (0x3B), 0x08), 0x03), Local0) + } + + XOr (Local0, 0x01, Local0) + Return (Local0) + } + + Method (WAKS, 0, NotSerialized) + { + If (\H8DR) + { + Store (\_SB.PCI0.ISA.EC.BTWK, Local0) + } + Else + { + Store (ShiftRight (And (\RBEC (0x36), 0x02), 0x01), Local0) + } + + Return (Local0) + } + + Method (BTAT, 2, NotSerialized) + { + Store (0x00, Local0) + If (LEqual (Arg0, 0x00)) + { + If (LEqual (Arg1, 0x01)) + { + If (\H8DR) + { + Or (\_SB.PCI0.ISA.EC.HAMA, 0x10, \_SB.PCI0.ISA.EC.HAMA) + } + Else + { + \MBEC (0x1A, 0xFF, 0x10) + } + } + + If (LEqual (Arg1, 0x00)) + { + If (\H8DR) + { + And (\_SB.PCI0.ISA.EC.HAMA, 0xEF, \_SB.PCI0.ISA.EC.HAMA) + } + Else + { + \MBEC (0x1A, 0xEF, 0x00) + } + } + + If (LEqual (Arg1, 0x02)) + { + If (\H8DR) + { + If (And (\_SB.PCI0.ISA.EC.HAMA, 0x10)) + { + Store (0x01, Local0) + } + } + Else + { + If (And (\RBEC (0x1A), 0x10)) + { + Store (0x01, Local0) + } + } + } + } + + If (LEqual (Arg0, 0x01)) + { + If (LEqual (Arg1, 0x01)) + { + If (\H8DR) + { + Or (\_SB.PCI0.ISA.EC.HAMA, 0x20, \_SB.PCI0.ISA.EC.HAMA) + } + Else + { + \MBEC (0x1A, 0xFF, 0x20) + } + } + + If (LEqual (Arg1, 0x00)) + { + If (\H8DR) + { + And (\_SB.PCI0.ISA.EC.HAMA, 0xDF, \_SB.PCI0.ISA.EC.HAMA) + } + Else + { + \MBEC (0x1A, 0xDF, 0x00) + } + } + + If (LEqual (Arg1, 0x02)) + { + If (\H8DR) + { + If (And (\_SB.PCI0.ISA.EC.HAMA, 0x20)) + { + Store (0x01, Local0) + } + } + Else + { + If (And (\RBEC (0x1A), 0x20)) + { + Store (0x01, Local0) + } + } + } + } + + Return (Local0) + } + } + } + + Name (\_S0, Package (0x04) + { + 0x05, + 0x05, + 0x00, + 0x00 + }) + Name (\_S1, Package (0x04) + { + 0x04, + 0x04, + 0x00, + 0x00 + }) + Name (\_S3, Package (0x04) + { + 0x01, + 0x01, + 0x00, + 0x00 + }) + Name (\_S4, Package (0x04) + { + 0x07, + 0x07, + 0x00, + 0x00 + }) + Name (\_S5, Package (0x04) + { + 0x07, + 0x07, + 0x00, + 0x00 + }) + Method (\_PTS, 1, NotSerialized) + { + If (LEqual (Arg0, \SPS)) + { + Store (0x00, Local0) + } + Else + { + If (LOr (LEqual (Arg0, 0x00), LNot (LLess (Arg0, 0x06)))) + { + Store (0x00, Local0) + } + Else + { + Store (0x01, Local0) + } + } + + If (Local0) + { + Store (Arg0, \SPS) + \_SB.PCI0.ISA.EC.HKEY.MHKE (0x00) + \_SB.PCI0.ISA.EC.EVNT (0x00) + If (\_SB.PCI0.ISA.EC.KBLT) + { + \LGHT (0x00) + } + + If (LEqual (Arg0, 0x01)) + { + Store (0x01, \_SB.PCI0.PM00.BLEN) + Store (0x00, \_SB.PCI0.ISA.EC.HCAC) + Or (\_SB.PCI0.ISA.ACI, 0x01, \_SB.PCI0.ISA.ACI) + Store (\_SB.PCI0.ISA.EC.HFNI, \FNID) + Store (0x00, \_SB.PCI0.ISA.EC.HFNI) + } + + If (LEqual (Arg0, 0x02)) + { + Store (One, \_SB.PCI0.PM00.BLEN) + Store (One, \_SB.PCI0.CREN) + } + + If (LEqual (Arg0, 0x03)) + { + \VVPD () + Store (One, \_SB.PCI0.PM00.BLEN) + } + + If (LEqual (Arg0, 0x04)) + { + \WOLP () + \TRAP (0x04, 0x01) + } + + If (LEqual (Arg0, 0x05)) + { + \TRAP (0x05, 0x01) + } + + If (LNot (LEqual (Arg0, 0x05))) + { + Store (One, \_SB.PCI0.ISA.EC.HCMU) + Store (0x00, \_SB.PCI0.ISA.EC.HFSP) + \_SB.PCI0.DOCK.DPTS (Arg0) + \_SB.PCI0.ISA.EC.BPTS (Arg0) + } + + \_SB.PCI0.ISA.EC.HKEY.BTPS (Arg0) + } + } + + Name (WAKI, Package (0x02) + { + 0x00, + 0x00 + }) + Method (\_WAK, 1, NotSerialized) + { + If (LOr (LEqual (Arg0, 0x00), LNot (LLess (Arg0, 0x05)))) + { + Return (WAKI) + } + + Store (Zero, \SPS) + Store (Zero, \_SB.PCI0.PM00.BLEN) + Store (Zero, \_SB.PCI0.CREN) + Store (Zero, \_SB.PCI0.ISA.EC.HCMU) + Store (0x80, \_SB.PCI0.ISA.EC.HFSP) + \_SB.PCI0.ISA.EC.EVNT (0x01) + \_SB.PCI0.ISA.EC.HKEY.MHKE (0x01) + If (LEqual (Arg0, 0x01)) + { + And (\_SB.PCI0.ISA.ACI, 0xFE, \_SB.PCI0.ISA.ACI) + Store (0x01, \_SB.PCI0.ISA.EC.HCAC) + Store (\_SB.PCI0.ISA.EC.HFNI, \FNID) + } + + If (LEqual (Arg0, 0x02)) {} + If (LEqual (Arg0, 0x03)) {} + If (LEqual (Arg0, 0x04)) + { + If (\W98F) + { + Notify (\_SB.SLPB, 0x02) + } + + If (\WMEF) + { + \_SB.PCI0.ISA.EC.BEEP (0x05) + } + + If (LNot (\W98F)) + { + Store (0x00, \_SB.PCI0.ISA.EC.HSPA) + } + } + + \_SB.PCI0.DOCK.DWAK (Arg0) + \_SB.PCI0.ISA.EC.BWAK (Arg0) + \_SB.PCI0.ISA.EC.HKEY.BTWK (Arg0) + Notify (\_TZ.THM0, 0x80) + \VNRS (0x01) + \VSLD (\_SB.LID._LID ()) + If (LAnd (\W98F, LNot (\WMEF))) + { + Notify (\_SB.PCI0.USB, 0x01) + } + + If (LLess (Arg0, 0x04)) + { + If (LOr (And (\_SB.PCI0.ISA.EC.CP4E, 0x02), And (\RRBF, 0x02))) + { + ShiftLeft (Arg0, 0x08, Local0) + Store (Or (0x2013, Local0), Local0) + \_SB.PCI0.ISA.EC.HKEY.MHKQ (Local0) + } + } + + Store (Zero, \RRBF) + Return (WAKI) + } + + Scope (\_SI) + { + Method (_SST, 1, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + \_SB.PCI0.ISA.EC.SYSL (0x00, 0x00) + \_SB.PCI0.ISA.EC.SYSL (0x01, 0x00) + } + + If (LEqual (Arg0, 0x01)) + { + If (LOr (\SPS, \WNTF)) + { + \_SB.PCI0.ISA.EC.BEEP (0x05) + } + + \_SB.PCI0.ISA.EC.SYSL (0x00, 0x01) + \_SB.PCI0.ISA.EC.SYSL (0x01, 0x00) + } + + If (LEqual (Arg0, 0x02)) + { + \_SB.PCI0.ISA.EC.SYSL (0x00, 0x01) + \_SB.PCI0.ISA.EC.SYSL (0x01, 0x02) + } + + If (LEqual (Arg0, 0x03)) + { + If (LGreater (\SPS, 0x03)) + { + \_SB.PCI0.ISA.EC.BEEP (0x07) + } + Else + { + If (LEqual (\SPS, 0x03)) + { + \_SB.PCI0.ISA.EC.BEEP (0x03) + } + Else + { + \_SB.PCI0.ISA.EC.BEEP (0x04) + } + } + + If (LEqual (\SPS, 0x03)) + { + \_SB.PCI0.ISA.EC.SYSL (0x00, 0x00) + } + Else + { + \_SB.PCI0.ISA.EC.SYSL (0x00, 0x01) + } + + \_SB.PCI0.ISA.EC.SYSL (0x01, 0x01) + } + + If (LEqual (Arg0, 0x04)) + { + \_SB.PCI0.ISA.EC.BEEP (0x03) + \_SB.PCI0.ISA.EC.SYSL (0x01, 0x02) + } + } + } + + Scope (\_GPE) + { + Method (_L0B, 0, NotSerialized) + { + Store (\_SB.PCI0.ISA.EC.HWAK, Local0) + Sleep (0x0A) + Store (Local0, \RRBF) + If (And (Local0, 0x01)) + { + If (And (\_SB.PCI0.PMEE, 0x01)) + { + Notify (\_SB.PCI0, 0x02) + } + + If (And (\_SB.PCI0.PMEE, 0x02)) + { + Notify (\_SB.PCI0.DOCK, 0x02) + } + } + + If (And (Local0, 0x02)) {} + If (And (Local0, 0x04)) + { + If (\W98F) + { + Notify (\_SB.SLPB, 0x02) + } + Else + { + Notify (\_SB.LID, 0x02) + } + } + + If (And (Local0, 0x08)) + { + \_SB.PCI0.DOCK.DGPE () + Notify (\_SB.SLPB, 0x02) + } + + If (And (Local0, 0x10)) + { + Notify (\_SB.SLPB, 0x02) + } + + If (And (Local0, 0x40)) + { + Notify (\_SB.PCI0.ISA.UART, 0x02) + } + + If (And (Local0, 0x80)) + { + Notify (\_SB.SLPB, 0x02) + } + } + } + + Scope (\_TZ) + { + ThermalZone (THM0) + { + Name (_CRT, 0x0E76) + Name (_PSL, Package (0x01) + { + \_PR.CPU + }) + Name (_PSV, 0x0E3F) + Name (_TC1, 0x05) + Name (_TC2, 0x02) + Name (_TSP, 0x0258) + Method (_TMP, 0, NotSerialized) + { + If (\H8DR) + { + Store (\_SB.PCI0.ISA.EC.TMP0, Local0) + } + Else + { + Store (\RBEC (0x78), Local0) + } + + Return (C2K (Local0)) + } + } + + Method (C2K, 1, NotSerialized) + { + Add (Multiply (Arg0, 0x0A), 0x0AAC, Local0) + If (LNot (LGreater (Local0, 0x0AAC))) + { + Store (0x0BB8, Local0) + } + + If (LNot (LLess (Local0, 0x0FAC))) + { + Store (0x0BB8, Local0) + } + + Return (Local0) + } + } + + Scope (\_SB.PCI0.ISA.EC) + { + Method (_Q40, 0, NotSerialized) + { + Notify (\_TZ.THM0, 0x80) + } + } + + OperationRegion (MNVS, SystemMemory, 0x0FFFF000, 0x1000) + Field (MNVS, DWordAcc, NoLock, Preserve) + { + Offset (0xF00), + HDHD, 8, + HDSE, 8, + Offset (0xF03), + Offset (0xF04), + Offset (0xF08), + Offset (0xF0C), + Offset (0xF10), + VCDL, 1, + VCDC, 1, + VCDT, 1, + VCDD, 1, + , 1, + VCSS, 1, + VCDB, 1, + VCIN, 1, + Offset (0xF12), + VLID, 4, + Offset (0xF14) + } + + Field (MNVS, ByteAcc, NoLock, Preserve) + { + Offset (0xE00), + DDC1, 1024, + Offset (0xF00) + } + + Field (MNVS, ByteAcc, NoLock, Preserve) + { + Offset (0xE00), + DDC2, 2048 + } + + OperationRegion (SMI0, SystemIO, 0xFE00, 0x02) + Field (SMI0, ByteAcc, NoLock, Preserve) + { + APMC, 8 + } + + Field (MNVS, AnyAcc, NoLock, Preserve) + { + Offset (0xFC0), + CMD, 8, + ERR, 32, + PAR0, 32, + PAR1, 32, + PAR2, 32, + PAR3, 32 + } + + Mutex (MSMI, 0x07) + Method (SMI, 5, NotSerialized) + { + Acquire (MSMI, 0xFFFF) + Store (Arg0, CMD) + Store (Arg1, PAR0) + Store (Arg2, PAR1) + Store (Arg3, PAR2) + Store (Arg4, PAR3) + Store (0x00, APMC) + While (LEqual (ERR, 0x01)) + { + Sleep (0x64) + Store (0x00, APMC) + } + + Store (PAR0, Local0) + Release (MSMI) + Return (Local0) + } + + Method (RPCI, 1, NotSerialized) + { + Return (SMI (0x80, 0x00, Arg0, 0x00, 0x00)) + } + + Method (WPCI, 2, NotSerialized) + { + SMI (0x80, 0x01, Arg0, Arg1, 0x00) + } + + Method (MPCI, 3, NotSerialized) + { + SMI (0x80, 0x02, Arg0, Arg1, Arg2) + } + + Method (RBEC, 1, NotSerialized) + { + Return (SMI (0x81, 0x00, Arg0, 0x00, 0x00)) + } + + Method (WBEC, 2, NotSerialized) + { + SMI (0x81, 0x01, Arg0, Arg1, 0x00) + } + + Method (MBEC, 3, NotSerialized) + { + SMI (0x81, 0x02, Arg0, Arg1, Arg2) + } + + Method (TRAP, 2, NotSerialized) + { + SMI (0x82, Arg0, Arg1, 0x00, 0x00) + } + + Method (FERR, 0, NotSerialized) + { + SMI (0x83, 0x00, 0x00, 0x00, 0x00) + } + + Method (GFDD, 0, NotSerialized) + { + Return (SMI (0x84, 0x00, 0x00, 0x00, 0x00)) + } + + Method (SFDD, 1, NotSerialized) + { + SMI (0x84, 0x01, Arg0, 0x00, 0x00) + } + + Method (DHDP, 1, NotSerialized) + { + Return (SMI (0x85, Arg0, 0x00, 0x00, 0x00)) + } + + Method (VOLU, 0, NotSerialized) + { + SMI (0x86, 0x00, 0x00, 0x00, 0x00) + } + + Method (VOLD, 0, NotSerialized) + { + SMI (0x86, 0x01, 0x00, 0x00, 0x00) + } + + Method (VOLM, 0, NotSerialized) + { + SMI (0x86, 0x02, 0x00, 0x00, 0x00) + } + + Method (TPKY, 0, NotSerialized) + { + SMI (0x86, 0x03, 0x00, 0x00, 0x00) + } + + Method (BRIU, 0, NotSerialized) + { + SMI (0x86, 0x04, 0x00, 0x00, 0x00) + } + + Method (BRID, 0, NotSerialized) + { + SMI (0x86, 0x05, 0x00, 0x00, 0x00) + } + + Method (SNMB, 0, NotSerialized) + { + SMI (0x86, 0x06, 0x00, 0x00, 0x00) + } + + Method (SMUT, 0, NotSerialized) + { + SMI (0x86, 0x07, 0x00, 0x00, 0x00) + } + + Method (ESYB, 1, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + SMI (0x86, 0x03, 0x00, 0x00, 0x00) + } + Else + { + SMI (0x86, 0x08, Decrement (Arg0), 0x00, 0x00) + } + } + + Method (DSEP, 0, NotSerialized) + { + SMI (0x86, 0x09, 0x00, 0x00, 0x00) + } + + Method (VEXP, 0, NotSerialized) + { + SMI (0x87, 0x00, 0x00, 0x00, 0x00) + } + + Method (VUPS, 1, NotSerialized) + { + SMI (0x88, Arg0, 0x00, 0x00, 0x00) + } + + Method (VSDS, 2, NotSerialized) + { + SMI (0x89, Arg0, Arg1, 0x00, 0x00) + } + + Method (VDDC, 0, NotSerialized) + { + SMI (0x8A, 0x00, 0x00, 0x00, 0x00) + } + + Method (VVPD, 0, NotSerialized) + { + SMI (0x94, 0x00, 0x00, 0x00, 0x00) + } + + Method (GVIL, 1, NotSerialized) + { + SMI (0x8B, Arg0, 0x00, 0x00, 0x00) + } + + Method (GCHK, 0, NotSerialized) + { + Return (SMI (0x8B, 0x06, 0x00, 0x00, 0x00)) + } + + Method (LGHT, 1, NotSerialized) + { + SMI (0x8C, Arg0, 0x00, 0x00, 0x00) + } + + Method (GPAR, 0, NotSerialized) + { + Return (SMI (0x8D, 0x00, 0x00, 0x00, 0x00)) + } + + Method (GDCK, 1, NotSerialized) + { + \_SB.PCI0.ISA.EC.AI2C () + Store (SMI (0x8E, Arg0, 0x00, 0x00, 0x00), Local0) + \_SB.PCI0.ISA.EC.RI2C () + Return (Local0) + } + + Method (GGAP, 1, NotSerialized) + { + Return (SMI (0x8F, Arg0, 0x00, 0x00, 0x00)) + } + + Method (GHKY, 0, NotSerialized) + { + Store (SMI (0x90, 0x00, 0x00, 0x00, 0x00), Local0) + Return (And (ShiftRight (Local0, 0x04), 0x01)) + } + + Method (GCDT, 1, NotSerialized) + { + Return (SMI (0x91, Arg0, 0x00, 0x00, 0x00)) + } + + Method (GBTH, 1, NotSerialized) + { + Return (SMI (0x92, Arg0, 0x00, 0x00, 0x00)) + } + + Method (BHDP, 1, NotSerialized) + { + Return (SMI (0x93, Arg0, 0x00, 0x00, 0x00)) + } + + Method (VNRS, 1, NotSerialized) + { + Return (SMI (0x95, Arg0, 0x00, 0x00, 0x00)) + } + + Method (GLPW, 0, NotSerialized) + { + Return (SMI (0x96, 0x00, 0x00, 0x00, 0x00)) + } + + Method (GTPS, 0, NotSerialized) + { + Return (SMI (0x97, 0x00, 0x00, 0x00, 0x00)) + } + + Method (VSLD, 1, NotSerialized) + { + Return (SMI (0x99, Arg0, 0x00, 0x00, 0x00)) + } + + Method (CBRI, 0, NotSerialized) + { + SMI (0x9A, 0x00, 0x00, 0x00, 0x00) + } + + Method (WOLP, 0, NotSerialized) + { + SMI (0x9B, 0x00, 0x00, 0x00, 0x00) + } + + Method (ECPP, 0, NotSerialized) + { + SMI (0x9C, 0x00, 0x00, 0x00, 0x00) + } + + Scope (\_SB.PCI0.PM00) + { + OperationRegion (GPOR, SystemIO, 0x1034, 0x04) + Field (GPOR, ByteAcc, NoLock, Preserve) + { + , 1, + Offset (0x01), + MSON, 1, + , 1, + URST, 1, + EID2, 1, + EID, 2, + CSON, 1, + , 4, + IPDR, 1, + , 1, + S2DS, 1, + , 1, + ULON, 1, + , 7 + } + } + + Name (ICM0, Buffer (0x1C) + { + 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x03, 0x00, + 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 0x00, 0x00, + 0x00, 0x00, 0xA0, 0xEF + }) + CreateByteField (ICM0, 0x0F, HDM0) + CreateByteField (ICM0, 0x16, HPI0) + Name (ICM1, Buffer (0x1C) + { + 0x02, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xB0, 0xF5, 0x03, 0x00, + 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 0x00, 0x00, + 0x00, 0x00, 0xB0, 0xEF + }) + CreateByteField (ICM1, 0x0F, HDM1) + CreateByteField (ICM1, 0x16, HPI1) + Name (ICC1, Buffer (0x0E) + { + 0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, + 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF + }) + CreateByteField (ICC1, 0x01, CDM1) + CreateByteField (ICC1, 0x08, CPI1) + Name (IDKM, 0x00) + Name (ICM2, Buffer (0x1C) + { + 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x03, 0x00, + 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 0x00, 0x00, + 0x00, 0x00, 0xA0, 0xEF + }) + CreateByteField (ICM2, 0x0F, HDM2) + CreateByteField (ICM2, 0x16, HPI2) + Name (ICC2, Buffer (0x0E) + { + 0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, + 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF + }) + CreateByteField (ICC2, 0x01, CDM2) + CreateByteField (ICC2, 0x08, CPI2) + Name (DCM2, Buffer (0x1C) + { + 0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, + 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xA0, 0xE3, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xA0, 0xE3 + }) + CreateByteField (DCM2, 0x01, DDM2) + CreateByteField (DCM2, 0x08, DPI2) + CreateByteField (DCM2, 0x0F, DTA2) + CreateByteField (DCM2, 0x16, DTF2) + Name (IDKS, 0x00) + Name (ICM3, Buffer (0x1C) + { + 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x03, 0x00, + 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 0x00, 0x00, + 0x00, 0x00, 0xA0, 0xEF + }) + CreateByteField (ICM3, 0x0F, HDM3) + CreateByteField (ICM3, 0x16, HPI3) + Name (ICC3, Buffer (0x0E) + { + 0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, + 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF + }) + CreateByteField (ICC3, 0x01, CDM3) + CreateByteField (ICC3, 0x08, CPI3) + Name (BGTM, Buffer (0x14) {}) + CreateDWordField (BGTM, 0x00, GTP0) + CreateDWordField (BGTM, 0x04, GTD0) + CreateDWordField (BGTM, 0x08, GTP1) + CreateDWordField (BGTM, 0x0C, GTD1) + CreateDWordField (BGTM, 0x10, GTMF) + Method (UDMA, 2, NotSerialized) + { + If (And (Arg0, 0x04)) + { + If (And (Arg1, 0x10)) + { + Return (0x05) + } + Else + { + If (And (Arg1, 0x08)) + { + Return (0x04) + } + Else + { + If (And (Arg1, 0x04)) + { + Return (0x03) + } + Else + { + If (And (Arg1, 0x02)) + { + Return (0x02) + } + Else + { + If (And (Arg1, 0x01)) + { + Return (0x01) + } + Else + { + Return (0x00) + } + } + } + } + } + } + Else + { + Return (0x00) + } + } + + Method (UDMB, 2, NotSerialized) + { + If (Arg0) + { + If (LGreater (Arg1, 0x1E)) + { + If (LGreater (Arg1, 0x2D)) + { + If (LGreater (Arg1, 0x3C)) + { + If (LGreater (Arg1, 0x50)) + { + Return (0x01) + } + Else + { + Return (0x02) + } + } + Else + { + Return (0x03) + } + } + Else + { + Return (0x04) + } + } + Else + { + Return (0x05) + } + } + Else + { + Return (0x00) + } + } + + Method (MDMA, 4, NotSerialized) + { + If (And (Arg0, 0x02)) + { + If (And (Arg1, 0x04)) + { + If (LNot (LGreater (Arg3, 0x78))) + { + Return (0x03) + } + Else + { + If (LNot (LGreater (Arg3, 0xB4))) + { + Return (0x02) + } + Else + { + If (LNot (LGreater (Arg3, 0xF0))) + { + Return (0x01) + } + Else + { + Return (0x00) + } + } + } + } + Else + { + If (And (Arg1, 0x02)) + { + If (LNot (LGreater (Arg3, 0xB4))) + { + Return (0x02) + } + Else + { + If (LNot (LGreater (Arg3, 0xF0))) + { + Return (0x01) + } + Else + { + Return (0x00) + } + } + } + Else + { + If (And (Arg2, 0x04)) + { + If (LNot (LGreater (Arg3, 0xF0))) + { + Return (0x01) + } + Else + { + Return (0x00) + } + } + Else + { + Return (0x00) + } + } + } + } + Else + { + Return (0x00) + } + } + + Method (MDMB, 1, NotSerialized) + { + If (LGreater (Arg0, 0x78)) + { + If (LGreater (Arg0, 0x96)) + { + Return (0x01) + } + Else + { + Return (0x02) + } + } + Else + { + Return (0x03) + } + } + + Method (MPIO, 4, NotSerialized) + { + If (And (Arg0, 0x02)) + { + If (And (Arg1, 0x02)) + { + If (LNot (LGreater (Arg3, 0x78))) + { + Return (0x04) + } + Else + { + If (LNot (LGreater (Arg3, 0xB4))) + { + Return (0x03) + } + Else + { + If (LNot (LGreater (Arg3, 0xF0))) + { + Return (0x02) + } + Else + { + Return (0x00) + } + } + } + } + Else + { + If (And (Arg1, 0x01)) + { + If (LNot (LGreater (Arg3, 0xB4))) + { + Return (0x03) + } + Else + { + If (LNot (LGreater (Arg3, 0xF0))) + { + Return (0x02) + } + Else + { + Return (0x00) + } + } + } + Else + { + If (LEqual (Arg2, 0x02)) + { + Return (0x01) + } + Else + { + Return (0x00) + } + } + } + } + Else + { + If (LEqual (Arg2, 0x02)) + { + Return (0x01) + } + Else + { + Return (0x00) + } + } + } + + Method (MPIB, 2, NotSerialized) + { + If (LGreater (Arg1, 0x78)) + { + If (LGreater (Arg1, 0xB4)) + { + If (LGreater (Arg1, 0xF0)) + { + Return (0x00) + } + Else + { + If (Arg0) + { + Return (0x02) + } + Else + { + Return (0x01) + } + } + } + Else + { + Return (0x03) + } + } + Else + { + Return (0x04) + } + } + + Method (MPI4, 2, NotSerialized) + { + If (Arg0) + { + If (LEqual (Arg0, 0x01)) + { + Return (0x01) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (0x02) + } + Else + { + If (LEqual (Arg1, 0x03)) + { + Return (0x02) + } + Else + { + Return (0x03) + } + } + } + } + Else + { + If (LLess (Arg1, 0x02)) + { + Return (Arg1) + } + Else + { + Return (Decrement (Arg1)) + } + } + } + + Method (MP4B, 1, NotSerialized) + { + If (LNot (LGreater (Arg0, 0x01))) + { + Return (Arg0) + } + Else + { + Return (Decrement (Arg0)) + } + } + + Method (MTIM, 3, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + Store (0x00, Local5) + } + Else + { + If (LEqual (Arg0, 0x01)) + { + If (LLess (Arg1, 0x02)) + { + Store (0x01, Local5) + } + Else + { + Store (0x03, Local5) + } + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Store (0x03, Local5) + } + Else + { + Store (0x03, Local5) + } + } + + If (LEqual (Arg1, 0x00)) + { + Or (Local5, 0x08, Local5) + } + } + + If (Arg2) + { + And (Local5, 0xFB, Local5) + } + Else + { + Or (Local5, 0x04, Local5) + } + + Return (Local5) + } + + Method (MISP, 1, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + Return (0x00) + } + Else + { + If (LEqual (Arg0, 0x01)) + { + Return (0x01) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (0x02) + } + Else + { + Return (0x02) + } + } + } + } + + Method (MRTC, 1, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + Return (0x00) + } + Else + { + If (LEqual (Arg0, 0x01)) + { + Return (0x00) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (0x01) + } + Else + { + Return (0x03) + } + } + } + } + + Method (MUCT, 1, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + Return (0x00) + } + Else + { + If (LEqual (Arg0, 0x01)) + { + Return (0x00) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (0x01) + } + Else + { + Return (0x02) + } + } + } + } + + Method (CART, 1, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + Return (0x02) + } + Else + { + Return (0x01) + } + } + + Method (CCMD, 1, NotSerialized) + { + If (LEqual (Arg0, 0x04)) + { + Return (0x3F) + } + Else + { + If (LEqual (Arg0, 0x03)) + { + Return (0x32) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (0xAF) + } + Else + { + If (LEqual (Arg0, 0x01)) + { + Return (0xA2) + } + Else + { + Return (0xA9) + } + } + } + } + } + + Method (CDRW, 2, NotSerialized) + { + If (LEqual (Arg0, 0x01)) + { + Store (0x88, Local0) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Store (0x31, Local0) + } + Else + { + If (LEqual (Arg0, 0x03)) + { + Store (0x3F, Local0) + } + Else + { + Store (0xFFFFFFFF, Local0) + } + } + } + + If (LEqual (Arg1, 0x00)) + { + Store (0x6D, Local1) + } + Else + { + If (LEqual (Arg1, 0x01)) + { + Store (0x43, Local1) + } + Else + { + If (LEqual (Arg1, 0x02)) + { + Store (0x43, Local1) + } + Else + { + If (LEqual (Arg1, 0x03)) + { + Store (0x32, Local1) + } + Else + { + Store (0x3F, Local1) + } + } + } + } + + If (LGreater (CCYC (Local0), CCYC (Local1))) + { + Return (Local0) + } + Else + { + Return (Local1) + } + } + + Method (CCYC, 1, NotSerialized) + { + And (Arg0, 0x0F, Local0) + ShiftRight (Arg0, 0x04, Local1) + If (Local0) + { + If (LEqual (Local0, 0x0F)) + { + Store (0x01, Local0) + } + Else + { + Increment (Local0) + } + } + Else + { + Store (0x10, Local0) + } + + If (LNot (Local1)) + { + Store (0x10, Local1) + } + + Add (Local0, Local1, Local0) + Multiply (Local0, 0x1E, Local0) + Return (Local0) + } + + Method (CUDC, 1, NotSerialized) + { + If (LEqual (Arg0, 0x01)) + { + Return (0x03) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (0x02) + } + Else + { + If (LEqual (Arg0, 0x03)) + { + Return (0x01) + } + Else + { + If (LEqual (Arg0, 0x04)) + { + Return (0x02) + } + Else + { + Return (0x01) + } + } + } + } + } + + Method (MHDM, 2, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + If (LEqual (Arg1, 0x00)) + { + Return (0x00) + } + Else + { + If (LEqual (Arg1, 0x01)) + { + Return (0x12) + } + Else + { + If (LEqual (Arg1, 0x02)) + { + Return (0x21) + } + Else + { + Return (0x22) + } + } + } + } + Else + { + If (LEqual (Arg0, 0x01)) + { + Return (0x40) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (0x41) + } + Else + { + If (LEqual (Arg0, 0x03)) + { + Return (0x42) + } + Else + { + If (LEqual (Arg0, 0x04)) + { + Return (0x43) + } + Else + { + Return (0x44) + } + } + } + } + } + } + + Method (MHPI, 1, NotSerialized) + { + If (LEqual (Arg0, 0x00)) + { + Return (0x00) + } + Else + { + If (LEqual (Arg0, 0x01)) + { + Return (0x01) + } + Else + { + If (LEqual (Arg0, 0x02)) + { + Return (0x00) + } + Else + { + If (LEqual (Arg0, 0x03)) + { + Return (0x0B) + } + Else + { + Return (0x0C) + } + } + } + } + } + + Method (MIN, 2, NotSerialized) + { + If (LLess (Arg0, Arg1)) + { + Return (Arg0) + } + Else + { + Return (Arg1) + } + } + + Method (SLEN, 1, NotSerialized) + { + Return (SizeOf (Arg0)) + } + + Method (S2BF, 1, Serialized) + { + Add (SLEN (Arg0), One, Local0) + Name (BUFF, Buffer (Local0) {}) + Store (Arg0, BUFF) + Return (BUFF) + } + + Method (SCMP, 2, NotSerialized) + { + Store (S2BF (Arg0), Local0) + Store (S2BF (Arg1), Local1) + Store (Zero, Local4) + Store (SLEN (Arg0), Local5) + Store (SLEN (Arg1), Local6) + Store (MIN (Local5, Local6), Local7) + While (LLess (Local4, Local7)) + { + Store (DerefOf (Index (Local0, Local4)), Local2) + Store (DerefOf (Index (Local1, Local4)), Local3) + If (LGreater (Local2, Local3)) + { + Return (One) + } + Else + { + If (LLess (Local2, Local3)) + { + Return (Ones) + } + } + + Increment (Local4) + } + + If (LLess (Local4, Local5)) + { + Return (One) + } + Else + { + If (LLess (Local4, Local6)) + { + Return (Ones) + } + Else + { + Return (Zero) + } + } + } + + Name (SPS, 0x00) + Name (W98F, 0x00) + Name (WNTF, 0x00) + Name (WMEF, 0x00) + Name (H8DR, 0x00) + Name (MEMX, 0x00) + Name (GVEN, 0x00) + Name (FNID, 0x00) + Name (RRBF, 0x00) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/INSTALL.TXT b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/INSTALL.TXT new file mode 100644 index 000000000..e43f1dbe1 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/UTILITY/INSTALL.TXT @@ -0,0 +1,77 @@ +cd C:\Documents and Settings\pva\My Documents\acpi\wk\grammar\ABBU\utility +========================================================================== + +Install instructions for ACPI CA BlackBox Utility on Windows XP. + +- Copy everything into a target directory + +- Run the ACPI BlackBox Utility (abbu.exe) + +- Select Options | Dump DSDT AML to get the current DSDT.AML file + +- Use AcpiDump to convert the AML file to a readable format (acpidump DSDT.AML) + The default output name is "dsdt.dsl". + +- Create a file extra.asl with the following: + +DefinitionBlock("extra.aml", "DSDT", 0x1, "INTEL", "ABCDE", 0x1) +{ + Scope(\_SB) + { + Device(ABBU) + { + Name(_HID, "ACPIABBU") + Method(ENBL) + { + Return(Zero) + } + + Method(TEST) + { + Return(Zero) + } + + // List all test names here, separated by commas + // It provides a convenient list of tests available on the platform + Name(TSTS, Package() + { + "ENBL", + "TEST" + }) + } + } +} + +NOTE: The closing bracket of the DefinitionBlock MUST come after the closing bracket of this SB scope. + Also, this is a minimum injected code sample. Added Methods to test specific DSDT functions found + in the DSDT.ASL file created earlier. + +- Use iasl.exe to compile EXTRA.ASL to create EXTRA.AML. Use the -i switch to ignore errors + +- Run abbu.exe and press the 'Modify DSDT...' button + +- Point the Original DSDT path to DSDT.AML - It should be pointing to the file already + +- Point the Injected code path to EXTRA.AML - It should be pointing to the file already + +- Reboot + +- Windows XP should find your new device and want to load a driver. + Point it to the directory into which you copied the abbu.sys and abbu.inf files + +- Using the abbu.exe in the target directory: + - Use the 'Connect Driver' button to connect to the driver + - Use the 'Execute Ctrl Method' button to open a dialog box and enter a Method name (i.e. TEST) + - The driver will return a DWORD only with the results in the output box. + +Use Method(TEST) as a template to create new methods. + +TO UNINSTALL: +============= +- Use Device Manager to uninstall the 'Intel ACPI Black Box Utlity Control Device' under 'System Devices' + +- Use Regedit and delete the following Keys: + - HKLM\System\CurrentControlSet\Services\Acpi\Parameters\DSDT + - HKLM\System\CurrentControlSet\Services\ABBU + +- Delete \Windows\System32\Drivers\abbu.sys diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/Info.txt b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/Info.txt new file mode 100644 index 000000000..f6a52a8f1 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/Info.txt @@ -0,0 +1 @@ +The tests of this 'device' directory are just started, in progress.
\ No newline at end of file diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/device.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/device.asl new file mode 100644 index 000000000..bef63116e --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/device.asl @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +Name(z174, 174) + +/* + * Exotic case of CopyObject usage + */ +Method(md00) +{ + Name(ts, "md00") + Device(d000) { + Name(i000, 0xabcd0000) + Name(i001, 0x11111111) + } + Device(d001) { + Name(i000, 0xabcd0001) + } + ThermalZone(tz00) { + Name(i000, 0xabcd0002) + Name(i002, 0x22222222) + } + + if (LNotEqual(d000.i000, 0xabcd0000)) { + err(ts, z174, 0x000, 0, 0, d000.i000, 0xabcd0000) + } + + CopyObject(d001, d000) + if (LNotEqual(d000.i000, 0xabcd0001)) { + err(ts, z174, 0x001, 0, 0, d000.i000, 0xabcd0001) + } + + CopyObject(tz00, d000) + if (LNotEqual(d000.i000, 0xabcd0002)) { + err(ts, z174, 0x002, 0, 0, d000.i000, 0xabcd0002) + } + + CH03(ts, z174, 0x003, 0, 0) + Store(d000.i001, Local0) + CH04(ts, 0, 0xff, z174, 0x004, 0, 0) + +// Rejected by ASL compiler +// if (LNotEqual(d000.i002, 0x22222222)) { +// err(ts, z174, 0x005, 0, 0, d000.i002, 0x22222222) +// } +} + +Method(mdff) +{ + SRMT("md00") + if (chk0) { + md00() + } else { + BLCK() + } +} +Method(mdfe) +{ + SRMT("dvf2") + dvf2() +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/device_abbu.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/device_abbu.asl new file mode 100644 index 000000000..f7b56d045 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/device_abbu.asl @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Aplicable for abbu only + */ + +Name(z172, 172) + +Method(dvf2) +{ + Name(ts, "dvf2") + Device(d000) { + Name(i000, 0x00000001) + } + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Return (0xabcd0000) + } + Return (Add(\_SB_.ABBU.dvf2.d000.i000, m003())) + } + Return (Add(\_SB_.ABBU.dvf2.d000.i000, m002())) + } + + Store(Add(\_SB_.ABBU.dvf2.d000.i000, m001()), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z172, 0x001, 0, 0, Local0, 0xabcd0003) + } +} + +/* + * Named object as element of Package + * + * Named element of Package, perhaps, is not implemented by MS, + * i000 in Package(){i000} is, on MS, the same as Package(){"i000"}. + * + * fail + */ +Method(mf26) +{ + Name(ts, "mf26") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + Name(i002, 0xabcd0002) + Name(i003, 0xabcd0003) + + Name(ii00, 0x11112222) + + Name(p000, Package() { + i000, + i001, + i002, + "i000", + \_SB_.ABBU.mf26.i003, + 0xabcd0004 + }) + + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(arg0, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x001, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(arg0, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x002, 0, 0, Local0, 0xabcd0002) + } + Store(DerefOf(Index(arg0, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z164, 0x003, 0, 0, Local0, "i000") + } + Store(DerefOf(Index(arg0, 4)), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z164, 0x004, 0, 0, Local0, 0xabcd0003) + } + Store(DerefOf(Index(arg0, 5)), Local0) + if (LNotEqual(Local0, 0xabcd0004)) { + err(ts, z164, 0x004, 0, 0, Local0, 0xabcd0004) + } + + Store(ii00, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x005, 0, 0, Local0, 0x11112222) + } + } + + if (0) { + Store(DerefOf(Index(p000, 0)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 1)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 2)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 3)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 4)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 5)), Local0) + OUTP(Local0) + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x006, 0, 0, Local0, 0x11112222) + } + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x007, 0, 0, Local0, 0xabcd0001) + } + + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x008, 0, 0, Local0, 0xabcd0002) + } + + Store(DerefOf(Index(p000, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z164, 0x009, 0, 0, Local0, "i000") + } + + Store(DerefOf(Index(p000, 4)), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z164, 0x00a, 0, 0, Local0, 0xabcd0003) + } + + Store(DerefOf(Index(p000, 5)), Local0) + if (LNotEqual(Local0, 0xabcd0004)) { + err(ts, z164, 0x004, 0, 0, Local0, 0xabcd0004) + } +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/device_aslts.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/device_aslts.asl new file mode 100644 index 000000000..1e564b5d3 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/device_aslts.asl @@ -0,0 +1,153 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Aplicable for AcpiExec only + */ + +Name(z173, 173) + +Method(dvf2) +{ + Name(ts, "dvf2") + Device(d000) { + Name(i000, 0x00000001) + } + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Return (0xabcd0000) + } + Return (Add(\dvf2.d000.i000, m003())) + } + Return (Add(\dvf2.d000.i000, m002())) + } + + Store(Add(\dvf2.d000.i000, m001()), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z173, 0x001, 0, 0, Local0, 0xabcd0003) + } +} + +/* + * Named object as element of Package + * + * Named element of Package, perhaps, is not implemented by MS, + * i000 in Package(){i000} is, on MS, the same as Package(){"i000"}. + */ +Method(mf26) +{ + Name(ts, "mf26") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + Name(i002, 0xabcd0002) + Name(i003, 0xabcd0003) + + Name(ii00, 0x11112222) + + Name(p000, Package() { + i000, + i001, + i002, + "i000", + \mf26.i003, + 0xabcd0004 + }) + + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(arg0, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x001, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(arg0, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x002, 0, 0, Local0, 0xabcd0002) + } + Store(DerefOf(Index(arg0, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z164, 0x003, 0, 0, Local0, "i000") + } + Store(DerefOf(Index(arg0, 4)), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z164, 0x004, 0, 0, Local0, 0xabcd0003) + } + Store(DerefOf(Index(arg0, 5)), Local0) + if (LNotEqual(Local0, 0xabcd0004)) { + err(ts, z164, 0x004, 0, 0, Local0, 0xabcd0004) + } + + Store(ii00, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x005, 0, 0, Local0, 0x11112222) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x006, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x007, 0, 0, Local0, 0xabcd0001) + } + + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x008, 0, 0, Local0, 0xabcd0002) + } + + Store(DerefOf(Index(p000, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z164, 0x009, 0, 0, Local0, "i000") + } + + Store(DerefOf(Index(p000, 4)), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z164, 0x00a, 0, 0, Local0, 0xabcd0003) + } + + Store(DerefOf(Index(p000, 5)), Local0) + if (LNotEqual(Local0, 0xabcd0004)) { + err(ts, z164, 0x004, 0, 0, Local0, 0xabcd0004) + } +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv00.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv00.asl new file mode 100644 index 000000000..c10c81fad --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv00.asl @@ -0,0 +1,584 @@ +/* + * Access to elements of combined objects (Device) + */ +Name(z167, 167) + +/* + * Named Integer i000 + */ + +/* + * Simple, 3-level + */ + +Method(dv00) +{ + Name(ts, "dv00") + Device(d000) { + Name(i000, 0x00000001) + } + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Return (0xabcd0000) + } + Return (Add(arg0, m003(arg0))) + } + Return (Add(arg0, m002(arg0))) + } + Store(Add(d000.i000, m001(d000.i000)), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z167, 0x001, 0, 0, Local0, 0xabcd0003) + } +} + +Method(dvf0) +{ + Name(ts, "dvf0") + Device(d000) { + Name(i000, 0x00000001) + } + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Return (0xabcd0000) + } + Return (Add(^^d000.i000, m003())) + } + Return (Add(^d000.i000, m002())) + } + + Store(Add(d000.i000, m001()), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z163, 0x001, 0, 0, Local0, 0xabcd0003) + } +} + +Method(dvf1) +{ + Name(ts, "dvf1") + Device(d000) { + Name(i000, 0x00000001) + } + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Return (0xabcd0000) + } + Return (Add(^^^dvf1.d000.i000, m003())) + } + Return (Add(^^dvf1.d000.i000, m002())) + } + + Store(Add(^dvf1.d000.i000, m001()), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z163, 0x001, 0, 0, Local0, 0xabcd0003) + } +} + +/* + * 8-level + * added writing into i000: + * Store(0x00040000, i000) + */ +Method(dv01, 1) +{ + Name(ts, "dv01") + Name(i000, 0x00000001) + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + CopyObject(p000, i000) + } + Return (0) + } + Store(0x80000000, i000) + Return (Add(i000, m008())) + } + Store(0x07000000, i000) + Return (Add(i000, m007())) + } + Store(0x00600000, i000) + Return (Add(i000, m006())) + } + Store(0x00050000, i000) + Return (Add(i000, m005())) + } + Store(0x00004000, i000) + Return (Add(i000, m004())) + } + Store(0x00000300, i000) + Return (Add(i000, m003())) + } + Store(0x00000020, i000) + Return (Add(i000, m002())) + } + Store(Add(i000, m001()), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z167, 0x003, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(i000, 0x80000000)) { + err(ts, z167, 0x004, 0, 0, i000, 0x80000000) + } +} + +/* + * Recurcive execution of m001: + * Add(i000, m001(), Local0) + */ +Method(dv02) +{ + Name(ts, "dv02") + Name(i000, 0x00100000) + Name(i001, 0) + + Method(m001) + { + /* + * Because of the stack overflow issues on MS the number + * of repetitions was changed from 100 to 11 here. + */ + if (LLess(i001, 11)) { + Increment(i000) + Increment(i001) + Add(i000, m001(), Local0) + Return (Local0) + } + Return (0) + } + Store(Add(i000, m001()), Local0) + + if (LNotEqual(Local0, 0x00c00042)) { + err(ts, z167, 0x006, 0, 0, Local0, 0x00c00042) + } + + if (LNotEqual(i000, 0x0010000b)) { + err(ts, z167, 0x007, 0, 0, i000, 0x0010000b) + } +} + +/* + * Local instead of i000 (in in01) + */ +Method(dv03, 1) +{ + Name(ts, "dv03") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Store(arg0, i001) + + Store(0x00000001, Local7) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + CopyObject(p000, Local7) + } + Return (0) + } + Store(0x80000000, Local7) + Return (Add(Local7, m008())) + } + Store(0x07000000, Local7) + Return (Add(Local7, m007())) + } + Store(0x00600000, Local7) + Return (Add(Local7, m006())) + } + Store(0x00050000, Local7) + Return (Add(Local7, m005())) + } + Store(0x00004000, Local7) + Return (Add(Local7, m004())) + } + Store(0x00000300, Local7) + Return (Add(Local7, m003())) + } + Store(0x00000020, Local7) + Return (Add(Local7, m002())) + } + Store(Add(Local7, m001()), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z167, 0x00c, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(Local7, 1)) { + err(ts, z167, 0x00d, 0, 0, Local7, 1) + } +} + +/* + * Arg instead of i000 (in in01) + * + * see ns_0100.asl + */ + +/* + * 8-level + * added writing into i000: + * Store(0x00040000, i000) + * + * dv01 +: + * m00X are passed with i000 + * argX inside m00X is rewritten + */ +Method(dv04) +{ + Name(ts, "dv04") + Name(i000, 0x00000001) + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Method(m001, 2) + { + Method(m002, 2) + { + Method(m003, 2) + { + Method(m004, 2) + { + Method(m005, 2) + { + Method(m006, 2) + { + Method(m007, 2) + { + /* + * ====================== >>>>>>>> + * Sometimes, after I added a big group of + * 'If' operators, this fragment of code causes + * break of execution on MS. But, namely -- + * sometimes! To investigate the reason I + * commented part by part of it to find + * workable code, then un-commented it + * part by part too. + * It entire initial code + * started working on MS again! + */ + /* + Method(m008, 2) + { + if (i001) + { + CopyObject(p000, i000) + } + Store(0x10000008, arg0) + Return (0) + } + Store(0x80000000, i000) + Store(0x10000007, arg0) + Return (Add(i000, m008(i000, arg0))) + */ + /* + * ====================== <<<<<<<< + */ + + Store(0x80000000, i000) + Store(0x10000007, arg0) + Add(i000, 0, Local0) + + Return (Local0) + } + Store(0x07000000, i000) + Store(0x10000006, arg0) + Return (Add(i000, m007(i000, arg0))) + } + Store(0x00600000, i000) + Store(0x10000005, arg0) + Return (Add(i000, m006(i000, arg0))) + } + Store(0x00050000, i000) + Store(0x10000004, arg0) + Return (Add(i000, m005(i000, arg0))) + } + if (LNotEqual(arg0, 0x00000300)) { + err(ts, z167, 0x004, 0, 0, arg0, 0x00000300) + } + if (LNotEqual(arg1, 0x10000001)) { + err(ts, z167, 0x004, 0, 0, arg1, 0x10000001) + } + Store(0x00004000, i000) + Store(0x10000003, arg0) + Return (Add(i000, m004(i000, arg0))) + } + if (LNotEqual(arg0, 0x00000020)) { + err(ts, z167, 0x004, 0, 0, arg0, 0x00000020) + } + if (LNotEqual(i000, 0x00000020)) { + err(ts, z167, 0x004, 0, 0, i000, 0x00000020) + } + Store(0x10000002, arg0) + if (LNotEqual(i000, 0x00000020)) { + err(ts, z167, 0x004, 0, 0, i000, 0x00000020) + } + if (LNotEqual(arg0, 0x10000002)) { + err(ts, z167, 0x004, 0, 0, arg0, 0x10000002) + } + Store(0x00000300, i000) + if (LNotEqual(i000, 0x00000300)) { + err(ts, z167, 0x004, 0, 0, i000, 0x00000300) + } + if (LNotEqual(arg0, 0x10000002)) { + err(ts, z167, 0x004, 0, 0, arg0, 0x10000002) + } + if (LNotEqual(arg1, 0x10000001)) { + err(ts, z167, 0x004, 0, 0, arg1, 0x10000001) + } + Store(0x10000002, arg0) + Store(0x00000300, i000) + Return (Add(i000, m003(i000, arg1))) + } + if (LNotEqual(arg0, 0x00000001)) { + err(ts, z167, 0x004, 0, 0, arg0, 0x00000001) + } + if (LNotEqual(i000, 0x00000001)) { + err(ts, z167, 0x004, 0, 0, i000, 0x00000001) + } + Store(0x10000001, arg0) + if (LNotEqual(i000, 0x00000001)) { + err(ts, z167, 0x004, 0, 0, i000, 0x00000001) + } + if (LNotEqual(arg0, 0x10000001)) { + err(ts, z167, 0x004, 0, 0, arg0, 0x10000001) + } + Store(0x00000020, i000) + if (LNotEqual(i000, 0x00000020)) { + err(ts, z167, 0x004, 0, 0, i000, 0x00000020) + } + if (LNotEqual(arg0, 0x10000001)) { + err(ts, z167, 0x004, 0, 0, arg0, 0x10000001) + } + if (LNotEqual(arg1, 0x10000000)) { + err(ts, z167, 0x004, 0, 0, arg1, 0x10000000) + } + Store(0x10000001, arg0) + Store(0x00000020, i000) + Return (Add(i000, m002(i000, arg0))) + } + Store(Add(i000, m001(i000, 0x10000000)), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z167, 0x003, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(i000, 0x80000000)) { + err(ts, z167, 0x004, 0, 0, i000, 0x80000000) + } +} + +/* + * Note: now the checkings are so that dv05 succeeds on MS. + */ +Method(dv05) +{ + Name(ts, "dv05") + + Name(i000, 0xabcd0000) + Name(s000, "qwrtyu0003") + Name(b000, Buffer() {0xb0,0xb1,0xb2,0xb3,0xb4}) + Name(p000, Package() {0xabcd0001, 0xabcd0002, 0xabcd0003}) + Event(e000) + Mutex(mx00, 0) + Method(mmm0) { + Name(im00, 0xabcd0004) + Name(sm00, "qwertyui") + // Return ( "qwertyui" ) + } + Method(mmm1) { + Name(im00, 0xabcd0004) + Name(sm00, "qwertyui") + // Return ( 0xabcd0004 ) + Return ( "qwertyui" ) + } + Device(d000) { Name(id00, 0xabcd0005) } + ThermalZone(tz00) { Name(itz0, 0xabcd0006) } + Processor(pr00, 0, 0xFFFFFFFF, 0) { Name(ipr0, 0xabcd0007) } + PowerResource(pw00, 1, 0) { Name(ipw0, 0xabcd0008) } + OperationRegion(r000, SystemMemory, 0x100, 0x100) + + Name(b001, Buffer() {0xa0,0xa1,0xa2,0xa3,0xa4}) + CreateField(b001, 0, 8, bf00) + + OperationRegion(r001, SystemMemory, 0x100, 0x100) + Field(r001, ByteAcc, NoLock, Preserve) {f000,32, f001,32, f002,32, f003,32} + BankField(r001, f001, 0, ByteAcc, NoLock, Preserve) {bnk0,32} + IndexField(f002, f003, ByteAcc, NoLock, Preserve) {if00,32, if01,32} + + Method(m001, 2) + { + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, arg1)) { + err(ts, z167, 0x003, 0, 0, Local0, arg1) + } + Return (5) + } + + CH03(ts, z167, 0x000, 0, 0) + + Store(Add(DerefOf(Index(p000, 0)), m001(i000, c009)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(s000, c00a)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(b000, c00b)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(p000, c00c)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(e000, c00f)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(mx00, c011)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(mmm0, c008)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(mmm1, c00a)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(d000, c00e)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(tz00, c015)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(pr00, c014)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(pw00, c013)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(r000, c012)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(bf00, c00b)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(f000, c009)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(bnk0, c009)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(if00, c009)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z167, 0x003, 0, 0, Local0, 0xabcd0006) + } + + CH03(ts, z167, 0x000, 0, 0) +} + +Method(dv06) +{ + Name(ts, "dv06") + Name(i000, 0xabcd0000) + + Store(ObjectType(i000), Local0) + if (LNotEqual(Local0, c009)) { + err(ts, z167, 0x003, 0, 0, Local0, c009) + } +} + +Method(dev0) +{ + SRMT("dv00") + dv00() + + SRMT("dvf0") + dvf0() + SRMT("dvf1") + dvf1() + + SRMT("dv01-0") + dv01(0) + SRMT("dv02") + dv02() + SRMT("dv03-0") + dv03(0) + SRMT("dv04") + dv04() + SRMT("dv05") + if (LAnd(fix1, chk3)) { + /* + * It breaks MS while re-booting, + * for ACPICA it causes exception + * and breaks path. + */ + dv05() + } else { + BLCK() + } + SRMT("dv06") + dv06() +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv10.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv10.asl new file mode 100644 index 000000000..cb78b5aa5 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv10.asl @@ -0,0 +1,985 @@ +/* + * Tests originated from namespace/ns1 + */ + +/* + * Package/Buffer/String/Field/IndexField/BankField/BufferField + * + * Tests below are here + * as specific type arguments passing - + * arguments though passed directly to method, not as references, + * nevertheless allow access to the elements of original objects. + */ + +Name(z164, 164) + +/* + * + * Read/write access to elemens of Package passed to method. + * + */ + +/* + * + * Elements of Package are constant Integer (0xabcd0000) + * + */ + +/* + * Package is passed by ArgX to method: + * - directly + */ +Method(in10) +{ + Name(ts, "in10") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + + Store(0x11112222, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is passed by ArgX to method: + * - by ORef + */ +Method(in11) +{ + Name(ts, "in11") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + Method(m001, 2) + { + Store(DerefOf(arg1), Local7) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x33334444) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is passed by ArgX to method: + * - directly + * - by ORef + */ +Method(in12) +{ + Name(ts, "in12") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + Method(m001, 2) + { + Store(0x11112222, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(arg1), Local7) + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x33334444) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is given directly by name: + * - do ORef and pass to LocalX + * - do DerefOf and pass to LocalX + */ +Method(in13) +{ + Name(ts, "in13") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + Method(m001, 2) + { + Store(RefOf(p000), Local6) + Store(DerefOf(Local6), Local7) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x33334444) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0002) + } +} + +/* + * + * Elements of Package are Named Integer (i000) + * + */ + +/* + * Package is passed by ArgX to method + * + * fail + * + * Note: + * Named element of Package is simply not implemented by MS, + * i000 in Package(){i000} is, on MS, the same as Package(){"i000"}. + */ +Method(in14) +{ + Name(ts, "in14") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + Name(i002, 0xabcd0002) + + Name(ii00, 0x11112222) + + Name(p000, Package() {i000, i001, i002, "i000"}) + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(arg0, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(arg0, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0002) + } + Store(DerefOf(Index(arg0, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z164, 0x000, 0, 0, Local0, "i000") + } + + Store(ii00, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0002) + } + + Store(DerefOf(Index(p000, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z164, 0x000, 0, 0, Local0, "i000") + } +} + +/* + * Package is used directly by Name + * + * Example to show behaviour of MS for Package(){i000} + * + * Note: + * Named element of Package is simply not implemented by MS, + * i000 in Package(){i000} is, on MS, the same as Package(){"i000"}. + */ +Method(in15) +{ + Name(ts, "in15") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + Name(i002, 0xabcd0002) + + Name(ii00, 0x11112222) + + Name(p000, Package() {i000, i001, i002, "i000"}) + + Store(DerefOf(Index(p000, 0)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 1)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 2)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 3)), Local0) + OUTP(Local0) + + Store(ii00, Index(p000, 1)) + + OUTP("After re-write 1-th element:") + + Store(DerefOf(Index(p000, 0)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 1)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 2)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 3)), Local0) + OUTP(Local0) +} + +/* + * Buffer + */ + +Method(in16) +{ + Name(ts, "in16") + Name(b000, Buffer() {0x10, 0x11, 0x12}) + Method(m001, 2) + { + // arg0 - b000 + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x10)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x10) + } + + Store(0x67, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x67)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x67) + } + + // arg1 - RefOf(b000) + + Store(DerefOf(arg1), Local7) + Store(0x55, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x55)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x55) + } + } + + m001(b000, RefOf(b000)) + + Store(DerefOf(Index(b000, 0)), Local0) + if (LNotEqual(Local0, 0x67)) { + err(ts, z164, 0x002, 0, 0, Local0, 0x67) + } + + Store(DerefOf(Index(b000, 1)), Local0) + if (LNotEqual(Local0, 0x11)) { + err(ts, z164, 0x002, 0, 0, Local0, 0x11) + } + + Store(DerefOf(Index(b000, 2)), Local0) + if (LNotEqual(Local0, 0x12)) { + err(ts, z164, 0x002, 0, 0, Local0, 0x12) + } +} + +/* + * Element of Package instead of i000 (in in02) + * + * Recursive call to m001 + */ +Method(in17) +{ + Name(ts, "in17") + Name(i001, 0) + Name(pp00, Package() {0x11111111, 0x00100000, 0x22223333}) + + Method(m001) + { + /* + * Because of the stack overflow issues on MS the number + * of repetitions was changed from 100 to 11 here. + */ + if (LLess(i001, 11)) { + + Store(DerefOf(Index(pp00, 1)), Local0) + Increment(Local0) + Store(Local0, Index(pp00, 1)) + Increment(i001) + Add(DerefOf(Index(pp00, 1)), m001(), Local0) + Return (Local0) + } + Return (0) + } + Store(Add(DerefOf(Index(pp00, 1)), m001()), Local0) + + if (LNotEqual(Local0, 0x00c00042)) { + err(ts, z164, 0x00a, 0, 0, Local0, 0x00c00042) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x0010000b)) { + err(ts, z164, 0x00b, 0, 0, Local0, 0x0010000b) + } + + CH03(ts, z164, 0x00c, 0, 0) +} + +/* + * Buffer Field instead of i000 (in in01) + * + * fail + * + * Note: Buffer Field in expressions is not supported by MS, + * see msfail.asl + */ + +/* + * Field instead of i000 (in in01) + */ +Method(in18, 1) +{ + Name(ts, "in18") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + + CH03(ts, z164, 0x011, 0, 0) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + Store(0x11223344, f001) + } + Return (0) + } + Store(0x80000000, f001) + Return (Add(f001, m008())) + } + Store(0x07000000, f001) + Return (Add(f001, m007())) + } + Store(0x00600000, f001) + Return (Add(f001, m006())) + } + Store(0x00050000, f001) + Return (Add(f001, m005())) + } + Store(0x00004000, f001) + Return (Add(f001, m004())) + } + Store(0x00000300, f001) + Return (Add(f001, m003())) + } + Store(0x00000020, f001) + Return (Add(f001, m002())) + } + + Store(0x00000001, f001) + + Store(Add(f001, m001()), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z164, 0x012, 0, 0, Local0, 0x87654321) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0x80000000, Local1) + } + + if (LNotEqual(f001, Local1)) { + err(ts, z164, 0x013, 0, 0, f001, Local1) + } + + CH03(ts, z164, 0x014, 0, 0) +} + +/* + * Bank Field instead of i000 (in in01) + * + * (is this test correct?) + */ +Method(in19, 1) +{ + Name(ts, "in19") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + BankField(r000, f001, 0, ByteAcc, NoLock, Preserve) { bnk0, 32 } + + CH03(ts, z164, 0x015, 0, 0) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + Store(0x11223344, bnk0) + } + Return (0) + } + Store(0x80000000, bnk0) + Return (Add(bnk0, m008())) + } + Store(0x07000000, bnk0) + Return (Add(bnk0, m007())) + } + Store(0x00600000, bnk0) + Return (Add(bnk0, m006())) + } + Store(0x00050000, bnk0) + Return (Add(bnk0, m005())) + } + Store(0x00004000, bnk0) + Return (Add(bnk0, m004())) + } + Store(0x00000300, bnk0) + Return (Add(bnk0, m003())) + } + Store(0x00000020, bnk0) + Return (Add(bnk0, m002())) + } + + Store(0x00000001, bnk0) + + Store(Add(bnk0, m001()), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z164, 0x016, 0, 0, Local0, 0x87654321) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0x80000000, Local1) + } + + if (LNotEqual(bnk0, Local1)) { + err(ts, z164, 0x017, 0, 0, bnk0, Local1) + } + + CH03(ts, z164, 0x018, 0, 0) +} + +/* + * Index Field instead of i000 (in in01) + * + * (is this test correct?) + */ +Method(in1a, 1) +{ + Name(ts, "in1a") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + IndexField(f000, f001, ByteAcc, NoLock, Preserve) { if00, 32 } + + CH03(ts, z164, 0x019, 0, 0) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + Store(0x11223344, if00) + } + Return (0) + } + Store(0x80000000, if00) + Return (Add(if00, m008())) + } + Store(0x07000000, if00) + Return (Add(if00, m007())) + } + Store(0x00600000, if00) + Return (Add(if00, m006())) + } + Store(0x00050000, if00) + Return (Add(if00, m005())) + } + Store(0x00004000, if00) + Return (Add(if00, m004())) + } + Store(0x00000300, if00) + Return (Add(if00, m003())) + } + Store(0x00000020, if00) + Return (Add(if00, m002())) + } + + Store(0x00000001, if00) + + Store(Add(if00, m001()), Local0) + + /* + * The benchmark values for arg0==0 below + * are how MS actually works. + */ + + if (LNotEqual(Local0, 0x87878787)) { + err(ts, z164, 0x01a, 0, 0, Local0, 0x87878787) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0x80808080, Local1) + } + + if (LNotEqual(if00, Local1)) { + err(ts, z164, 0x01b, 0, 0, if00, Local1) + } + + CH03(ts, z164, 0x01c, 0, 0) +} + +/* + * Element of Buffer instead of i000 (in in01) + */ +Method(in1b, 1) +{ + Name(ts, "in1b") + Name(i001, 0) + Name(b000, Buffer() {0x11, 0x01, 0x22}) + + CH03(ts, z164, 0x01d, 0, 0) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Return (0) + } + Store(0x07, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m007())) + } + Store(0x06, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m006())) + } + Store(0x05, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m005())) + } + Store(0x04, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m004())) + } + Store(0x03, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m003())) + } + Store(0x02, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m002())) + } + Store(Add(DerefOf(Index(b000, 1)), m001()), Local0) + + if (LNotEqual(Local0, 0x1c)) { + err(ts, z164, 0x01e, 0, 0, Local0, 0x1c) + } + + Store(DerefOf(Index(b000, 1)), Local0) + + if (arg0) { + Store(0xff, Local1) + } else { + Store(0x07, Local1) + } + + if (LNotEqual(Local0, Local1)) { + err(ts, z164, 0x01f, 0, 0, Local0, Local1) + } + + CH03(ts, z164, 0x020, 0, 0) +} + +/* + * Element of Buffer instead of i000 (in in01) + * + * in1b+: + * added argument to methods and b000 passed without any use of that + * parameter inside the methods + */ +Method(in1c, 1) +{ + Name(ts, "in1c") + Name(i001, 0) + Name(b000, Buffer() {0x11, 0x01, 0x22}) + + CH03(ts, z164, 0x01d, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Return (0) + } + Store(0x07, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m007(b000))) + } + Store(0x06, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m006(b000))) + } + Store(0x05, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m005(b000))) + } + Store(0x04, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m004(b000))) + } + Store(0x03, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m003(b000))) + } + Store(0x02, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m002(b000))) + } + Store(Add(DerefOf(Index(b000, 1)), m001(b000)), Local0) + Return (Local0) + } + + CH03(ts, z164, 0x000, 0, 0) + + Store(m000(b000), Local0) + + if (LNotEqual(Local0, 0x1c)) { + err(ts, z164, 0x01e, 0, 0, Local0, 0x1c) + } + + Store(DerefOf(Index(b000, 1)), Local0) + + if (arg0) { + Store(0xff, Local1) + } else { + Store(0x07, Local1) + } + + if (LNotEqual(Local0, Local1)) { + err(ts, z164, 0x01f, 0, 0, Local0, Local1) + } + + CH03(ts, z164, 0x020, 0, 0) +} + + +/* + * Element of Package instead of i000 (in in01) + */ +Method(in1d) +{ + Name(ts, "in1d") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + Name(pp00, Package() {0x11111111, 0x00000001, 0x22223333}) + + CH03(ts, z164, 0x006, 0, 0) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Return (0) + } + Store(0x07000000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m007())) + } + Store(0x00600000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m006())) + } + Store(0x00050000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m005())) + } + Store(0x00004000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m004())) + } + Store(0x00000300, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m003())) + } + Store(0x00000020, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m002())) + } + Store(Add(DerefOf(Index(pp00, 1)), m001()), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z164, 0x007, 0, 0, Local0, 0x07654321) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x07000000)) { + err(ts, z164, 0x008, 0, 0, Local0, 0x07000000) + } + + CH03(ts, z164, 0x009, 0, 0) +} + +/* + * Element of Package instead of i000 (in in01) + * + * in1d+: + * added argument to methods and b000 passed without any use of that + * parameter inside the methods + */ +Method(in1e) +{ + Name(ts, "in1e") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + Name(pp00, Package() {0x11111111, 0x00000001, 0x22223333}) + + CH03(ts, z164, 0x006, 0, 0) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Return (0) + } + Store(0x07000000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m007(pp00))) + } + Store(0x00600000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m006(pp00))) + } + Store(0x00050000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m005(pp00))) + } + Store(0x00004000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m004(pp00))) + } + Store(0x00000300, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m003(pp00))) + } + Store(0x00000020, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m002(pp00))) + } + Store(Add(DerefOf(Index(pp00, 1)), m001(pp00)), Local0) + Return (Local0) + } + + CH03(ts, z164, 0x000, 0, 0) + + Store(m000(pp00), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z164, 0x007, 0, 0, Local0, 0x07654321) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x07000000)) { + err(ts, z164, 0x008, 0, 0, Local0, 0x07000000) + } + + CH03(ts, z164, 0x009, 0, 0) +} + +Method(ini1) +{ + SRMT("in10") + in10() + SRMT("in11") + in11() + SRMT("in12") + in12() + SRMT("in13") + in13() + SRMT("in14") + if (chk0) { + in14() + } else { + BLCK() + } + SRMT("in15") + if (chk0) { + in15() + } else { + BLCK() + } + SRMT("in16") + in16() + SRMT("in17") + in17() + SRMT("in18-0") + in18(0) + SRMT("in19-0") + in19(0) + SRMT("in1a-0") + in1a(0) + SRMT("in1b-0") + in1b(0) + SRMT("in1c-0") + in1c(0) + SRMT("in1d") + in1d() + SRMT("in1e") + if (fix0) { + in1e() + } else { + BLCK() + } +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv20.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv20.asl new file mode 100644 index 000000000..1b0c10670 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv20.asl @@ -0,0 +1,248 @@ +/* + * Source file ns_0000.asl + * + * The tests differ those from ns_0000.asl by that the objects are + * passed to methods as argument (Arg) but not directly by name. + */ + +Name(z165, 165) + +/* + * Named Integer i000 + */ + +/* + * Simple, 3-level + */ +Method(in20, 1) +{ + Name(ts, "in20") + Name(i000, 0x00000001) + Name(p000, Package() {1,2,3,4}) + + Name(i001, 0) + + CH03(ts, z165, 0x000, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + if (i001) { + CopyObject(p000, arg0) + } + Return (0xabcd0000) + } + Return (Add(arg0, m003(arg0))) + } + Return (Add(arg0, m002(arg0))) + } + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Store(m000(i000), Local0) + + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z165, 0x001, 0, 0, Local0, 0xabcd0003) + } +} + +/* + * 8-level + * added writing into i000: + * Store(0x00040000, i000) + */ +Method(in21, 1) +{ + Name(ts, "in21") + Name(i000, 0x00000001) + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Store(arg0, i001) + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Method(m008, 1) + { + if (i001) + { + CopyObject(p000, arg0) + } + Return (0) + } + Store(0x80000000, arg0) + Return (Add(arg0, m008(arg0))) + } + Store(0x07000000, arg0) + Return (Add(arg0, m007(arg0))) + } + Store(0x00600000, arg0) + Return (Add(arg0, m006(arg0))) + } + Store(0x00050000, arg0) + Return (Add(arg0, m005(arg0))) + } + Store(0x00004000, arg0) + Return (Add(arg0, m004(arg0))) + } + Store(0x00000300, arg0) + Return (Add(arg0, m003(arg0))) + } + Store(0x00000020, arg0) + Return (Add(arg0, m002(arg0))) + } + + Store(Add(i000, m001(i000)), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z165, 0x003, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(i000, 0x00000001)) { + err(ts, z165, 0x004, 0, 0, i000, 0x00000001) + } +} + +/* + * Recurcive execution of m001: + * Add(i000, m001(), Local0) + */ +Method(in22) +{ + Name(ts, "in22") + Name(i000, 0x00100000) + Name(i001, 0) + + Method(m000, 1) + { + Method(m001, 1) + { + /* + * Because of the stack overflow issues on MS the number + * of repetitions was changed from 100 to 9 here. + */ + if (LLess(i001, 9)) { + Increment(arg0) + Increment(i001) + Add(arg0, m001(arg0), Local0) + Return (Local0) + } + Return (0) + } + Store(Add(arg0, m001(arg0)), Local0) + Return (Local0) + } + + Store(Add(i000, m000(i000)), Local0) + + if (LNotEqual(Local0, 0x00b0002d)) { + err(ts, z165, 0x006, 0, 0, Local0, 0x00b0002d) + } + + if (LNotEqual(i000, 0x00100000)) { + err(ts, z165, 0x007, 0, 0, i000, 0x00100000) + } +} + +/* + * Arg instead of i000 (in in01) + */ +Method(in23, 2) +{ + Name(ts, "in23") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Store(arg0, i001) + + Store(0x00000001, arg1) + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Method(m008, 1) + { + if (i001) + { + CopyObject(p000, arg0) + } + Return (0) + } + Store(0x80000000, arg0) + Return (Add(arg0, m008(8))) + } + Store(0x07000000, arg0) + Return (Add(arg0, m007(7))) + } + Store(0x00600000, arg0) + Return (Add(arg0, m006(6))) + } + Store(0x00050000, arg0) + Return (Add(arg0, m005(5))) + } + Store(0x00004000, arg0) + Return (Add(arg0, m004(4))) + } + Store(0x00000300, arg0) + Return (Add(arg0, m003(3))) + } + Store(0x00000020, arg0) + Return (Add(arg0, m002(2))) + } + Store(Add(arg1, m001(1)), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z165, 0x00f, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(arg1, 1)) { + err(ts, z165, 0x010, 0, 0, arg1, 1) + } + + CH03(ts, z165, 0x011, 0, 0) +} + +Method(ini2) +{ + SRMT("in20-0") + in20(0) + SRMT("in21-0") + in21(0) + SRMT("in22") + in22() + SRMT("in23-0") + in23(0, 0) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv30.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv30.asl new file mode 100644 index 000000000..0b2dd5bb1 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/device/ns_dv30.asl @@ -0,0 +1,882 @@ +/* + * Source file ns_0010.asl + * + * The tests differ those from ns_0010.asl by that the objects are + * passed to methods as argument (Arg) but not directly by name. + */ + +Name(z166, 166) + +/* + * + * Read/write access to elemens of Package passed to method. + * + */ + +/* + * + * Elements of Package are constant Integer (0xabcd0000) + * + */ + +/* + * Package is passed by ArgX to method: + * - directly + */ +Method(in30) +{ + Name(ts, "in30") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0000) + } + + Store(0x11112222, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is passed by ArgX to method: + * - by ORef + */ +Method(in31) +{ + Name(ts, "in31") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(DerefOf(arg1), Local7) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x33334444) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0000) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is passed by ArgX to method: + * - directly + * - by ORef + */ +Method(in32) +{ + Name(ts, "in32") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(0x11112222, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(arg1), Local7) + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x33334444) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is given directly by name: + * - do ORef and pass to LocalX + * - do DerefOf and pass to LocalX + */ +Method(in33) +{ + Name(ts, "in33") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(RefOf(arg0), Local6) + Store(DerefOf(Local6), Local7) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x33334444) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0002) + } +} + +/* + * + * Elements of Package are Named Integer (i000) + * + */ + +/* + * Package is passed by ArgX to method + * + * fail + * + * Note: + * Named element of Package is simply not implemented by MS, + * i000 in Package(){i000} is, on MS, the same as Package(){"i000"}. + */ +Method(in34) +{ + Name(ts, "in34") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + Name(i002, 0xabcd0002) + Name(ii00, 0x11112222) + Name(p000, Package() {i000, i001, i002, "i000"}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z162, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(arg0, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z162, 0x000, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(arg0, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z162, 0x000, 0, 0, Local0, 0xabcd0002) + } + Store(DerefOf(Index(arg0, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z162, 0x000, 0, 0, Local0, "i000") + } + + Store(ii00, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z162, 0x000, 0, 0, Local0, 0x11112222) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z162, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z162, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z162, 0x000, 0, 0, Local0, 0xabcd0002) + } + + Store(DerefOf(Index(p000, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z162, 0x000, 0, 0, Local0, "i000") + } +} + +/* + * Buffer + */ + +Method(in36) +{ + Name(ts, "in36") + Name(b000, Buffer() {0x10, 0x11, 0x12}) + + Method(m000, 2) + { + Method(m001, 2) + { + // arg0 - b000 + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x10)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x10) + } + + Store(0x67, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x67)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x67) + } + + // arg1 - RefOf(b000) + + Store(DerefOf(arg1), Local7) + Store(0x55, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x55)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x55) + } + } + m001(arg0, arg1) + } + + m000(b000, RefOf(b000)) + + Store(DerefOf(Index(b000, 0)), Local0) + if (LNotEqual(Local0, 0x67)) { + err(ts, z166, 0x002, 0, 0, Local0, 0x67) + } + + Store(DerefOf(Index(b000, 1)), Local0) + if (LNotEqual(Local0, 0x11)) { + err(ts, z166, 0x002, 0, 0, Local0, 0x11) + } + + Store(DerefOf(Index(b000, 2)), Local0) + if (LNotEqual(Local0, 0x12)) { + err(ts, z166, 0x002, 0, 0, Local0, 0x12) + } +} + +/* + * Element of Package instead of i000 (in in02) + * + * Recursive call to m001 + */ +Method(in37) +{ + Name(ts, "in37") + Name(i001, 0) + Name(pp00, Package() {0x11111111, 0x00100000, 0x22223333}) + + Method(m000, 1) + { + Method(m001, 1) + { + /* + * Because of the stack overflow issues on MS the number + * of repetitions was changed from 100 to 9 here. + */ + if (LLess(i001, 9)) { + + Store(DerefOf(Index(arg0, 1)), Local0) + Increment(Local0) + Store(Local0, Index(arg0, 1)) + Increment(i001) + Add(DerefOf(Index(arg0, 1)), m001(arg0), Local0) + Return (Local0) + } + Return (0) + } + Store(Add(DerefOf(Index(arg0, 1)), m001(arg0)), Local0) + Return (Local0) + } + + Store(m000(pp00), Local0) + + if (LNotEqual(Local0, 0x00a0002d)) { + err(ts, z166, 0x00a, 0, 0, Local0, 0x00a0002d) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x00100009)) { + err(ts, z166, 0x00b, 0, 0, Local0, 0x00100009) + } + + CH03(ts, z166, 0x00c, 0, 0) +} + +/* + * Buffer Field instead of i000 (in in01) + * + * fail + * + * Note: Buffer Field in expressions is not supported by MS, + * see msfail.asl + */ + +/* + * Field instead of i000 (in in01) + */ +Method(in38, 1) +{ + Name(ts, "in38") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + + CH03(ts, z166, 0x011, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + /* + * To exclude stack overflow + * >>>>>>>>>>>>>>>> + Method(m008, 1) + { + if (i001) + { + Store(0x11223344, arg0) + } + Return (0) + } + Store(0x80000000, arg0) + Return (Add(arg0, m008(arg0))) + * <<<<<<<<<<<<<<<< + */ + Return (0) + } + Store(0x07000000, arg0) + Return (Add(arg0, m007(arg0))) + } + Store(0x00600000, arg0) + Return (Add(arg0, m006(arg0))) + } + Store(0x00050000, arg0) + Return (Add(arg0, m005(arg0))) + } + Store(0x00004000, arg0) + Return (Add(arg0, m004(arg0))) + } + Store(0x00000300, arg0) + Return (Add(arg0, m003(arg0))) + } + Store(0x00000020, arg0) + Return (Add(arg0, m002(arg0))) + } + + Store(0x00000001, arg0) + Store(Add(arg0, m001(arg0)), Local0) + Return (Local0) + } + + Store(0xabcd9876, f001) + + Store(m000(f001), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z166, 0x012, 0, 0, Local0, 0x07654321) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0xabcd9876, Local1) + } + + if (LNotEqual(f001, Local1)) { + err(ts, z166, 0x013, 0, 0, f001, Local1) + } + + CH03(ts, z166, 0x014, 0, 0) +} + +/* + * Bank Field instead of i000 (in in01) + * + * (is this test correct?) + */ +Method(in39, 1) +{ + Name(ts, "in39") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + BankField(r000, f001, 0, ByteAcc, NoLock, Preserve) { bnk0, 32 } + + CH03(ts, z166, 0x015, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + /* + * To exclude stack overflow + * >>>>>>>>>>>>>>>> + Method(m008, 1) + { + if (i001) + { + Store(0x11223344, arg0) + } + Return (0) + } + Store(0x80000000, arg0) + Return (Add(arg0, m008(arg0))) + * <<<<<<<<<<<<<<<< + */ + Return (0) + } + Store(0x07000000, arg0) + Return (Add(arg0, m007(arg0))) + } + Store(0x00600000, arg0) + Return (Add(arg0, m006(arg0))) + } + Store(0x00050000, arg0) + Return (Add(arg0, m005(arg0))) + } + Store(0x00004000, arg0) + Return (Add(arg0, m004(arg0))) + } + Store(0x00000300, arg0) + Return (Add(arg0, m003(arg0))) + } + Store(0x00000020, arg0) + Return (Add(arg0, m002(arg0))) + } + + Store(0x00000001, arg0) + Store(Add(arg0, m001(arg0)), Local0) + Return (Local0) + } + + Store(0xaabbccdd, bnk0) + Store(m000(bnk0), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z166, 0x016, 0, 0, Local0, 0x07654321) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0xaabbccdd, Local1) + } + + if (LNotEqual(bnk0, Local1)) { + err(ts, z166, 0x017, 0, 0, bnk0, Local1) + } + + CH03(ts, z166, 0x018, 0, 0) +} + +/* + * Index Field instead of i000 (in in01) + * + * (is this test correct?) + */ +Method(in3a, 1) +{ + Name(ts, "in3a") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + IndexField(f000, f001, ByteAcc, NoLock, Preserve) { if00, 32 } + + CH03(ts, z166, 0x019, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + /* + * To exclude stack overflow + * >>>>>>>>>>>>>>>> + Method(m008, 1) + { + if (i001) + { + Store(0x11223344, if00) + } + Return (0) + } + Store(0x80000000, if00) + Return (Add(if00, m008(if00))) + * <<<<<<<<<<<<<<<< + */ + Return (0) + } + Store(0x07000000, if00) + Return (Add(if00, m007(if00))) + } + Store(0x00600000, if00) + Return (Add(if00, m006(if00))) + } + Store(0x00050000, if00) + Return (Add(if00, m005(if00))) + } + Store(0x00004000, if00) + Return (Add(if00, m004(if00))) + } + Store(0x00000300, if00) + Return (Add(if00, m003(if00))) + } + Store(0x00000020, if00) + Return (Add(if00, m002(if00))) + } + + Store(0x00000001, if00) + Store(Add(if00, m001(if00)), Local0) + Return (Local0) + } + + Store(0xabababab, if00) + Store(m000(if00), Local0) + + /* + * The benchmark values for arg0==0 below + * are how MS actually works. + */ + + if (LNotEqual(Local0, 0x07070707)) { + err(ts, z166, 0x01a, 0, 0, Local0, 0x07070707) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0x07070707, Local1) + } + + if (LNotEqual(if00, Local1)) { + err(ts, z166, 0x01b, 0, 0, if00, Local1) + } + + CH03(ts, z166, 0x01c, 0, 0) +} + +/* + * Element of Buffer instead of i000 (in in01) + * + * see in3c below + * + * Method(in3b, 1) + * { + * } + */ + +/* + * Element of Buffer instead of i000 (in in01) + * + * m01b+: + * added argument to methods and b000 passed without any use of that + * parameter inside the methods + */ +Method(in3c, 1) +{ + Name(ts, "in3c") + Name(i001, 0) + Name(b000, Buffer() {0x11, 0x01, 0x22}) + + CH03(ts, z162, 0x01d, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Return (0) + } + Store(0x07, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m007(arg0))) + } + Store(0x06, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m006(arg0))) + } + Store(0x05, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m005(arg0))) + } + Store(0x04, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m004(arg0))) + } + Store(0x03, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m003(arg0))) + } + Store(0x02, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m002(arg0))) + } + Store(Add(DerefOf(Index(arg0, 1)), m001(arg0)), Local0) + Return (Local0) + } + + Store(m000(b000), Local0) + + if (LNotEqual(Local0, 0x1c)) { + err(ts, z162, 0x01e, 0, 0, Local0, 0x1c) + } + + Store(DerefOf(Index(b000, 1)), Local0) + + if (arg0) { + Store(0xff, Local1) + } else { + Store(0x07, Local1) + } + + if (LNotEqual(Local0, Local1)) { + err(ts, z162, 0x01f, 0, 0, Local0, Local1) + } + + CH03(ts, z162, 0x020, 0, 0) +} + +/* + * Element of Package instead of i000 (in in01) + * + * see in3e below + * + * Method(in3d) + * { + * } + */ + +/* + * Element of Package instead of i000 (in in01) + * + * m01d+: + * added argument to methods and b000 passed without any use of that + * parameter inside the methods + */ +Method(in3e) +{ + Name(ts, "in3e") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + Name(pp00, Package() {0x11111111, 0x00000001, 0x22223333}) + + CH03(ts, z162, 0x006, 0, 0) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Return (0) + } + Store(0x07000000, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m007(arg0))) + } + Store(0x00600000, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m006(arg0))) + } + Store(0x00050000, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m005(arg0))) + } + Store(0x00004000, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m004(arg0))) + } + Store(0x00000300, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m003(arg0))) + } + Store(0x00000020, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m002(arg0))) + } + Store(Add(DerefOf(Index(arg0, 1)), m001(arg0)), Local0) + Return (Local0) + } + + Store(m000(pp00), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z162, 0x007, 0, 0, Local0, 0x07654321) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x07000000)) { + err(ts, z162, 0x008, 0, 0, Local0, 0x07000000) + } + + CH03(ts, z162, 0x009, 0, 0) +} + +Method(ini3) +{ + SRMT("in30") + in30() + SRMT("in31") + in31() + SRMT("in32") + in32() + SRMT("in33") + in33() + SRMT("in34") + if (chk0) { + in34() + } else { + BLCK() + } + SRMT("in36") + in36() + SRMT("in37") + in37() + SRMT("in38-0") + in38(0) + SRMT("in39-0") + in39(0) + SRMT("in3a-0") + in3a(0) + SRMT("in3c-0") + in3c(0) + SRMT("in3e") + in3e() +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in00.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in00.asl new file mode 100644 index 000000000..a1d67df07 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in00.asl @@ -0,0 +1,597 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests originated from namespace/ns0 + */ + +/* + * Trying to get the chain of calls of methods such that + * sections of operative stack corresponding to different + * methods contain the internal object (itself, not a RefOf + * reference to it) of the same Name Space node. + * + * Then force (by Store/CopyObject): + * 1) changing the value of that internal object + * 2) replacing the internal object itself by some another one + * + * Check that the changing/replacing has no effect on the + * values evaluated on the lowest stages of calculation. + * + * Accessing objects by argX and directly by name too. + */ + +Name(z163, 163) + +/* + * Named Integer i000 + */ + +/* + * Simple, 3-level + */ +Method(in00, 1) +{ + Name(ts, "in00") + Name(i000, 0x00000001) + Name(p000, Package() {1,2,3,4}) + + Name(i001, 0) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + if (i001) { + CopyObject(p000, i000) + } + Return (0xabcd0000) + } + Return (Add(i000, m003())) + } + Return (Add(i000, m002())) + } + Store(Add(i000, m001()), Local0) + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z163, 0x001, 0, 0, Local0, 0xabcd0003) + } +} + +/* + * 8-level + * added writing into i000: + * Store(0x00040000, i000) + */ +Method(in01, 1) +{ + Name(ts, "in01") + Name(i000, 0x00000001) + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + CopyObject(p000, i000) + } + Return (0) + } + Store(0x80000000, i000) + Return (Add(i000, m008())) + } + Store(0x07000000, i000) + Return (Add(i000, m007())) + } + Store(0x00600000, i000) + Return (Add(i000, m006())) + } + Store(0x00050000, i000) + Return (Add(i000, m005())) + } + Store(0x00004000, i000) + Return (Add(i000, m004())) + } + Store(0x00000300, i000) + Return (Add(i000, m003())) + } + Store(0x00000020, i000) + Return (Add(i000, m002())) + } + Store(Add(i000, m001()), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z163, 0x003, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(i000, 0x80000000)) { + err(ts, z163, 0x004, 0, 0, i000, 0x80000000) + } +} + +/* + * Recurcive execution of m001: + * Add(i000, m001(), Local0) + */ +Method(in02) +{ + Name(ts, "in02") + Name(i000, 0x00100000) + Name(i001, 0) + + Method(m001) + { + /* + * Because of the stack overflow issues on MS the number + * of repetitions was changed from 100 to 11 here. + */ + if (LLess(i001, 11)) { + Increment(i000) + Increment(i001) + Add(i000, m001(), Local0) + Return (Local0) + } + Return (0) + } + Store(Add(i000, m001()), Local0) + + if (LNotEqual(Local0, 0x00c00042)) { + err(ts, z163, 0x006, 0, 0, Local0, 0x00c00042) + } + + if (LNotEqual(i000, 0x0010000b)) { + err(ts, z163, 0x007, 0, 0, i000, 0x0010000b) + } +} + +/* + * Local instead of i000 (in in01) + */ +Method(in03, 1) +{ + Name(ts, "in03") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Store(arg0, i001) + + Store(0x00000001, Local7) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + CopyObject(p000, Local7) + } + Return (0) + } + Store(0x80000000, Local7) + Return (Add(Local7, m008())) + } + Store(0x07000000, Local7) + Return (Add(Local7, m007())) + } + Store(0x00600000, Local7) + Return (Add(Local7, m006())) + } + Store(0x00050000, Local7) + Return (Add(Local7, m005())) + } + Store(0x00004000, Local7) + Return (Add(Local7, m004())) + } + Store(0x00000300, Local7) + Return (Add(Local7, m003())) + } + Store(0x00000020, Local7) + Return (Add(Local7, m002())) + } + Store(Add(Local7, m001()), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z163, 0x00c, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(Local7, 1)) { + err(ts, z163, 0x00d, 0, 0, Local7, 1) + } +} + +/* + * Arg instead of i000 (in in01) + * + * see ns_0100.asl + */ + +/* + * 8-level + * added writing into i000: + * Store(0x00040000, i000) + * + * in01 +: + * m00X are passed with i000 + * argX inside m00X is rewritten + */ +Method(in04) +{ + Name(ts, "in04") + Name(i000, 0x00000001) + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Method(m001, 2) + { + Method(m002, 2) + { + Method(m003, 2) + { + Method(m004, 2) + { + Method(m005, 2) + { + Method(m006, 2) + { + Method(m007, 2) + { + /* + * ====================== >>>>>>>> + * Sometimes, after I added a big group of + * 'If' operators, this fragment of code causes + * break of execution on MS. But, namely -- + * sometimes! To investigate the reason I + * commented part by part of it to find + * workable code, then un-commented it + * part by part too. + * It entire initial code + * started working on MS again! + */ + /* + Method(m008, 2) + { + if (i001) + { + CopyObject(p000, i000) + } + Store(0x10000008, arg0) + Return (0) + } + Store(0x80000000, i000) + Store(0x10000007, arg0) + Return (Add(i000, m008(i000, arg0))) + */ + /* + * ====================== <<<<<<<< + */ + + Store(0x80000000, i000) + Store(0x10000007, arg0) + Add(i000, 0, Local0) + + Return (Local0) + } + Store(0x07000000, i000) + Store(0x10000006, arg0) + Return (Add(i000, m007(i000, arg0))) + } + Store(0x00600000, i000) + Store(0x10000005, arg0) + Return (Add(i000, m006(i000, arg0))) + } + Store(0x00050000, i000) + Store(0x10000004, arg0) + Return (Add(i000, m005(i000, arg0))) + } + if (LNotEqual(arg0, 0x00000300)) { + err(ts, z163, 0x004, 0, 0, arg0, 0x00000300) + } + if (LNotEqual(arg1, 0x10000001)) { + err(ts, z163, 0x004, 0, 0, arg1, 0x10000001) + } + Store(0x00004000, i000) + Store(0x10000003, arg0) + Return (Add(i000, m004(i000, arg0))) + } + if (LNotEqual(arg0, 0x00000020)) { + err(ts, z163, 0x004, 0, 0, arg0, 0x00000020) + } + if (LNotEqual(i000, 0x00000020)) { + err(ts, z163, 0x004, 0, 0, i000, 0x00000020) + } + Store(0x10000002, arg0) + if (LNotEqual(i000, 0x00000020)) { + err(ts, z163, 0x004, 0, 0, i000, 0x00000020) + } + if (LNotEqual(arg0, 0x10000002)) { + err(ts, z163, 0x004, 0, 0, arg0, 0x10000002) + } + Store(0x00000300, i000) + if (LNotEqual(i000, 0x00000300)) { + err(ts, z163, 0x004, 0, 0, i000, 0x00000300) + } + if (LNotEqual(arg0, 0x10000002)) { + err(ts, z163, 0x004, 0, 0, arg0, 0x10000002) + } + if (LNotEqual(arg1, 0x10000001)) { + err(ts, z163, 0x004, 0, 0, arg1, 0x10000001) + } + Store(0x10000002, arg0) + Store(0x00000300, i000) + Return (Add(i000, m003(i000, arg1))) + } + if (LNotEqual(arg0, 0x00000001)) { + err(ts, z163, 0x004, 0, 0, arg0, 0x00000001) + } + if (LNotEqual(i000, 0x00000001)) { + err(ts, z163, 0x004, 0, 0, i000, 0x00000001) + } + Store(0x10000001, arg0) + if (LNotEqual(i000, 0x00000001)) { + err(ts, z163, 0x004, 0, 0, i000, 0x00000001) + } + if (LNotEqual(arg0, 0x10000001)) { + err(ts, z163, 0x004, 0, 0, arg0, 0x10000001) + } + Store(0x00000020, i000) + if (LNotEqual(i000, 0x00000020)) { + err(ts, z163, 0x004, 0, 0, i000, 0x00000020) + } + if (LNotEqual(arg0, 0x10000001)) { + err(ts, z163, 0x004, 0, 0, arg0, 0x10000001) + } + if (LNotEqual(arg1, 0x10000000)) { + err(ts, z163, 0x004, 0, 0, arg1, 0x10000000) + } + Store(0x10000001, arg0) + Store(0x00000020, i000) + Return (Add(i000, m002(i000, arg0))) + } + Store(Add(i000, m001(i000, 0x10000000)), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z163, 0x003, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(i000, 0x80000000)) { + err(ts, z163, 0x004, 0, 0, i000, 0x80000000) + } +} + +/* + * Note: now the checkings are so that in05 succeeds on MS. + */ +Method(in05) +{ + Name(ts, "in05") + + Name(i000, 0xabcd0000) + Name(s000, "qwrtyu0003") + Name(b000, Buffer() {0xb0,0xb1,0xb2,0xb3,0xb4}) + Name(p000, Package() {0xabcd0001, 0xabcd0002, 0xabcd0003}) + Event(e000) + Mutex(mx00, 0) + Method(mmm0) { + Name(im00, 0xabcd0004) + Name(sm00, "qwertyui") + // Return ( "qwertyui" ) + } + Method(mmm1) { + Name(im00, 0xabcd0004) + Name(sm00, "qwertyui") + // Return ( 0xabcd0004 ) + Return ( "qwertyui" ) + } + Device(d000) { Name(id00, 0xabcd0005) } + ThermalZone(tz00) { Name(itz0, 0xabcd0006) } + Processor(pr00, 0, 0xFFFFFFFF, 0) { Name(ipr0, 0xabcd0007) } + PowerResource(pw00, 1, 0) { Name(ipw0, 0xabcd0008) } + OperationRegion(r000, SystemMemory, 0x100, 0x100) + + Name(b001, Buffer() {0xa0,0xa1,0xa2,0xa3,0xa4}) + CreateField(b001, 0, 8, bf00) + + OperationRegion(r001, SystemMemory, 0x100, 0x100) + Field(r001, ByteAcc, NoLock, Preserve) {f000,32, f001,32, f002,32, f003,32} + BankField(r001, f001, 0, ByteAcc, NoLock, Preserve) {bnk0,32} + IndexField(f002, f003, ByteAcc, NoLock, Preserve) {if00,32, if01,32} + + Method(m001, 2) + { + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, arg1)) { + err(ts, z163, 0x003, 0, 0, Local0, arg1) + } + Return (5) + } + + CH03(ts, z163, 0x000, 0, 0) + + Store(Add(DerefOf(Index(p000, 0)), m001(i000, c009)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(s000, c00a)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(b000, c00b)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(p000, c00c)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(e000, c00f)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(mx00, c011)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(mmm0, c008)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(mmm1, c00a)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(d000, c00e)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(tz00, c015)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(pr00, c014)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(pw00, c013)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(r000, c012)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(bf00, c00b)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(f000, c009)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(bnk0, c009)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + Store(Add(DerefOf(Index(p000, 0)), m001(if00, c009)), Local0) + if (LNotEqual(Local0, 0xabcd0006)) { + err(ts, z163, 0x003, 0, 0, Local0, 0xabcd0006) + } + + + Store(ObjectType(f000), Local0) + if (LNotEqual(Local0, c00d)) { + err(ts, z163, 0x003, 0, 0, Local0, c00d) + } + Store(ObjectType(if00), Local0) + if (LNotEqual(Local0, c00d)) { + err(ts, z163, 0x003, 0, 0, Local0, c00d) + } + Store(ObjectType(bnk0), Local0) + if (LNotEqual(Local0, c00d)) { + err(ts, z163, 0x003, 0, 0, Local0, c00d) + } + Store(ObjectType(bf00), Local0) + if (LNotEqual(Local0, c016)) { + err(ts, z163, 0x003, 0, 0, Local0, c016) + } + + CH03(ts, z163, 0x000, 0, 0) +} + +Method(in06) +{ + Name(ts, "in06") + Name(i000, 0xabcd0000) + + Store(ObjectType(i000), Local0) + if (LNotEqual(Local0, c009)) { + err(ts, z163, 0x003, 0, 0, Local0, c009) + } +} + +Method(ini0) +{ + SRMT("in00-0") + in00(0) + SRMT("in01-0") + in01(0) + SRMT("in02") + in02() + SRMT("in03-0") + in03(0) + SRMT("in04") + in04() + SRMT("in05") + if (LAnd(fix1, chk2)) { + /* + * It breaks MS while re-booting, + * for ACPICA it causes exception + * and breaks path. + */ + in05() + } else { + BLCK() + } + SRMT("in06") + in06() + + CH03("ini0", z163, 0x000, 0, 0) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in10.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in10.asl new file mode 100644 index 000000000..663e23960 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in10.asl @@ -0,0 +1,1020 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests originated from namespace/ns1 + */ + +/* + * Package/Buffer/String/Field/IndexField/BankField/BufferField + * + * Tests below are here + * as specific type arguments passing - + * arguments though passed directly to method, not as references, + * nevertheless allow access to the elements of original objects. + */ + +Name(z164, 164) + +/* + * + * Read/write access to elemens of Package passed to method. + * + */ + +/* + * + * Elements of Package are constant Integer (0xabcd0000) + * + */ + +/* + * Package is passed by ArgX to method: + * - directly + */ +Method(in10) +{ + Name(ts, "in10") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + + Store(0x11112222, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is passed by ArgX to method: + * - by ORef + */ +Method(in11) +{ + Name(ts, "in11") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + Method(m001, 2) + { + Store(DerefOf(arg1), Local7) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x33334444) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is passed by ArgX to method: + * - directly + * - by ORef + */ +Method(in12) +{ + Name(ts, "in12") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + Method(m001, 2) + { + Store(0x11112222, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(arg1), Local7) + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x33334444) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is given directly by name: + * - do ORef and pass to LocalX + * - do DerefOf and pass to LocalX + */ +Method(in13) +{ + Name(ts, "in13") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + Method(m001, 2) + { + Store(RefOf(p000), Local6) + Store(DerefOf(Local6), Local7) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x33334444) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0002) + } +} + +/* + * + * Elements of Package are Named Integer (i000) + * + */ + +/* + * Package is passed by ArgX to method + * + * fail + * + * Note: + * Named element of Package is simply not implemented by MS, + * i000 in Package(){i000} is, on MS, the same as Package(){"i000"}. + */ +Method(in14) +{ + Name(ts, "in14") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + Name(i002, 0xabcd0002) + + Name(ii00, 0x11112222) + + Name(p000, Package() {i000, i001, i002, "i000"}) + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(arg0, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(arg0, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0002) + } + Store(DerefOf(Index(arg0, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z164, 0x000, 0, 0, Local0, "i000") + } + + Store(ii00, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + } + + m001(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z164, 0x000, 0, 0, Local0, 0xabcd0002) + } + + Store(DerefOf(Index(p000, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z164, 0x000, 0, 0, Local0, "i000") + } +} + +/* + * Package is used directly by Name + * + * Example to show behaviour of MS for Package(){i000} + * + * Note: + * Named element of Package is simply not implemented by MS, + * i000 in Package(){i000} is, on MS, the same as Package(){"i000"}. + */ +Method(in15) +{ + Name(ts, "in15") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + Name(i002, 0xabcd0002) + + Name(ii00, 0x11112222) + + Name(p000, Package() {i000, i001, i002, "i000"}) + + Store(DerefOf(Index(p000, 0)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 1)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 2)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 3)), Local0) + OUTP(Local0) + + Store(ii00, Index(p000, 1)) + + OUTP("After re-write 1-th element:") + + Store(DerefOf(Index(p000, 0)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 1)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 2)), Local0) + OUTP(Local0) + Store(DerefOf(Index(p000, 3)), Local0) + OUTP(Local0) +} + +/* + * Buffer + */ + +Method(in16) +{ + Name(ts, "in16") + Name(b000, Buffer() {0x10, 0x11, 0x12}) + Method(m001, 2) + { + // arg0 - b000 + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x10)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x10) + } + + Store(0x67, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x67)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x67) + } + + // arg1 - RefOf(b000) + + Store(DerefOf(arg1), Local7) + Store(0x55, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x55)) { + err(ts, z164, 0x000, 0, 0, Local0, 0x55) + } + } + + m001(b000, RefOf(b000)) + + Store(DerefOf(Index(b000, 0)), Local0) + if (LNotEqual(Local0, 0x67)) { + err(ts, z164, 0x002, 0, 0, Local0, 0x67) + } + + Store(DerefOf(Index(b000, 1)), Local0) + if (LNotEqual(Local0, 0x11)) { + err(ts, z164, 0x002, 0, 0, Local0, 0x11) + } + + Store(DerefOf(Index(b000, 2)), Local0) + if (LNotEqual(Local0, 0x12)) { + err(ts, z164, 0x002, 0, 0, Local0, 0x12) + } +} + +/* + * Element of Package instead of i000 (in in02) + * + * Recursive call to m001 + */ +Method(in17) +{ + Name(ts, "in17") + Name(i001, 0) + Name(pp00, Package() {0x11111111, 0x00100000, 0x22223333}) + + Method(m001) + { + /* + * Because of the stack overflow issues on MS the number + * of repetitions was changed from 100 to 11 here. + */ + if (LLess(i001, 11)) { + + Store(DerefOf(Index(pp00, 1)), Local0) + Increment(Local0) + Store(Local0, Index(pp00, 1)) + Increment(i001) + Add(DerefOf(Index(pp00, 1)), m001(), Local0) + Return (Local0) + } + Return (0) + } + Store(Add(DerefOf(Index(pp00, 1)), m001()), Local0) + + if (LNotEqual(Local0, 0x00c00042)) { + err(ts, z164, 0x00a, 0, 0, Local0, 0x00c00042) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x0010000b)) { + err(ts, z164, 0x00b, 0, 0, Local0, 0x0010000b) + } + + CH03(ts, z164, 0x00c, 0, 0) +} + +/* + * Buffer Field instead of i000 (in in01) + * + * fail + * + * Note: Buffer Field in expressions is not supported by MS, + * see msfail.asl + */ + +/* + * Field instead of i000 (in in01) + */ +Method(in18, 1) +{ + Name(ts, "in18") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + + CH03(ts, z164, 0x011, 0, 0) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + Store(0x11223344, f001) + } + Return (0) + } + Store(0x80000000, f001) + Return (Add(f001, m008())) + } + Store(0x07000000, f001) + Return (Add(f001, m007())) + } + Store(0x00600000, f001) + Return (Add(f001, m006())) + } + Store(0x00050000, f001) + Return (Add(f001, m005())) + } + Store(0x00004000, f001) + Return (Add(f001, m004())) + } + Store(0x00000300, f001) + Return (Add(f001, m003())) + } + Store(0x00000020, f001) + Return (Add(f001, m002())) + } + + Store(0x00000001, f001) + + Store(Add(f001, m001()), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z164, 0x012, 0, 0, Local0, 0x87654321) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0x80000000, Local1) + } + + if (LNotEqual(f001, Local1)) { + err(ts, z164, 0x013, 0, 0, f001, Local1) + } + + CH03(ts, z164, 0x014, 0, 0) +} + +/* + * Bank Field instead of i000 (in in01) + * + * (is this test correct?) + */ +Method(in19, 1) +{ + Name(ts, "in19") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + BankField(r000, f001, 0, ByteAcc, NoLock, Preserve) { bnk0, 32 } + + CH03(ts, z164, 0x015, 0, 0) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + Store(0x11223344, bnk0) + } + Return (0) + } + Store(0x80000000, bnk0) + Return (Add(bnk0, m008())) + } + Store(0x07000000, bnk0) + Return (Add(bnk0, m007())) + } + Store(0x00600000, bnk0) + Return (Add(bnk0, m006())) + } + Store(0x00050000, bnk0) + Return (Add(bnk0, m005())) + } + Store(0x00004000, bnk0) + Return (Add(bnk0, m004())) + } + Store(0x00000300, bnk0) + Return (Add(bnk0, m003())) + } + Store(0x00000020, bnk0) + Return (Add(bnk0, m002())) + } + + Store(0x00000001, bnk0) + + Store(Add(bnk0, m001()), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z164, 0x016, 0, 0, Local0, 0x87654321) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0x80000000, Local1) + } + + if (LNotEqual(bnk0, Local1)) { + err(ts, z164, 0x017, 0, 0, bnk0, Local1) + } + + CH03(ts, z164, 0x018, 0, 0) +} + +/* + * Index Field instead of i000 (in in01) + * + * (is this test correct?) + */ +Method(in1a, 1) +{ + Name(ts, "in1a") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + IndexField(f000, f001, ByteAcc, NoLock, Preserve) { if00, 32 } + + CH03(ts, z164, 0x019, 0, 0) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Method(m008) + { + if (i001) + { + Store(0x11223344, if00) + } + Return (0) + } + Store(0x80000000, if00) + Return (Add(if00, m008())) + } + Store(0x07000000, if00) + Return (Add(if00, m007())) + } + Store(0x00600000, if00) + Return (Add(if00, m006())) + } + Store(0x00050000, if00) + Return (Add(if00, m005())) + } + Store(0x00004000, if00) + Return (Add(if00, m004())) + } + Store(0x00000300, if00) + Return (Add(if00, m003())) + } + Store(0x00000020, if00) + Return (Add(if00, m002())) + } + + Store(0x00000001, if00) + + Store(Add(if00, m001()), Local0) + + /* + * The benchmark values for arg0==0 below + * are how MS actually works. + */ + + if (LNotEqual(Local0, 0x87878787)) { + err(ts, z164, 0x01a, 0, 0, Local0, 0x87878787) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0x80808080, Local1) + } + + if (LNotEqual(if00, Local1)) { + err(ts, z164, 0x01b, 0, 0, if00, Local1) + } + + CH03(ts, z164, 0x01c, 0, 0) +} + +/* + * Element of Buffer instead of i000 (in in01) + */ +Method(in1b, 1) +{ + Name(ts, "in1b") + Name(i001, 0) + Name(b000, Buffer() {0x11, 0x01, 0x22}) + + CH03(ts, z164, 0x01d, 0, 0) + + Store(arg0, i001) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Return (0) + } + Store(0x07, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m007())) + } + Store(0x06, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m006())) + } + Store(0x05, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m005())) + } + Store(0x04, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m004())) + } + Store(0x03, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m003())) + } + Store(0x02, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m002())) + } + Store(Add(DerefOf(Index(b000, 1)), m001()), Local0) + + if (LNotEqual(Local0, 0x1c)) { + err(ts, z164, 0x01e, 0, 0, Local0, 0x1c) + } + + Store(DerefOf(Index(b000, 1)), Local0) + + if (arg0) { + Store(0xff, Local1) + } else { + Store(0x07, Local1) + } + + if (LNotEqual(Local0, Local1)) { + err(ts, z164, 0x01f, 0, 0, Local0, Local1) + } + + CH03(ts, z164, 0x020, 0, 0) +} + +/* + * Element of Buffer instead of i000 (in in01) + * + * in1b+: + * added argument to methods and b000 passed without any use of that + * parameter inside the methods + */ +Method(in1c, 1) +{ + Name(ts, "in1c") + Name(i001, 0) + Name(b000, Buffer() {0x11, 0x01, 0x22}) + + CH03(ts, z164, 0x01d, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Return (0) + } + Store(0x07, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m007(b000))) + } + Store(0x06, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m006(b000))) + } + Store(0x05, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m005(b000))) + } + Store(0x04, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m004(b000))) + } + Store(0x03, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m003(b000))) + } + Store(0x02, Index(b000, 1)) + Return (Add(DerefOf(Index(b000, 1)), m002(b000))) + } + Store(Add(DerefOf(Index(b000, 1)), m001(b000)), Local0) + Return (Local0) + } + + CH03(ts, z164, 0x000, 0, 0) + + Store(m000(b000), Local0) + + if (LNotEqual(Local0, 0x1c)) { + err(ts, z164, 0x01e, 0, 0, Local0, 0x1c) + } + + Store(DerefOf(Index(b000, 1)), Local0) + + if (arg0) { + Store(0xff, Local1) + } else { + Store(0x07, Local1) + } + + if (LNotEqual(Local0, Local1)) { + err(ts, z164, 0x01f, 0, 0, Local0, Local1) + } + + CH03(ts, z164, 0x020, 0, 0) +} + + +/* + * Element of Package instead of i000 (in in01) + */ +Method(in1d) +{ + Name(ts, "in1d") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + Name(pp00, Package() {0x11111111, 0x00000001, 0x22223333}) + + CH03(ts, z164, 0x006, 0, 0) + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + Return (0) + } + Store(0x07000000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m007())) + } + Store(0x00600000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m006())) + } + Store(0x00050000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m005())) + } + Store(0x00004000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m004())) + } + Store(0x00000300, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m003())) + } + Store(0x00000020, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m002())) + } + Store(Add(DerefOf(Index(pp00, 1)), m001()), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z164, 0x007, 0, 0, Local0, 0x07654321) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x07000000)) { + err(ts, z164, 0x008, 0, 0, Local0, 0x07000000) + } + + CH03(ts, z164, 0x009, 0, 0) +} + +/* + * Element of Package instead of i000 (in in01) + * + * in1d+: + * added argument to methods and b000 passed without any use of that + * parameter inside the methods + */ +Method(in1e) +{ + Name(ts, "in1e") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + Name(pp00, Package() {0x11111111, 0x00000001, 0x22223333}) + + CH03(ts, z164, 0x006, 0, 0) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Return (0) + } + Store(0x07000000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m007(pp00))) + } + Store(0x00600000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m006(pp00))) + } + Store(0x00050000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m005(pp00))) + } + Store(0x00004000, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m004(pp00))) + } + Store(0x00000300, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m003(pp00))) + } + Store(0x00000020, Index(pp00, 1)) + Return (Add(DerefOf(Index(pp00, 1)), m002(pp00))) + } + Store(Add(DerefOf(Index(pp00, 1)), m001(pp00)), Local0) + Return (Local0) + } + + CH03(ts, z164, 0x000, 0, 0) + + Store(m000(pp00), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z164, 0x007, 0, 0, Local0, 0x07654321) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x07000000)) { + err(ts, z164, 0x008, 0, 0, Local0, 0x07000000) + } + + CH03(ts, z164, 0x009, 0, 0) +} + +Method(ini1) +{ + SRMT("in10") + in10() + SRMT("in11") + in11() + SRMT("in12") + in12() + SRMT("in13") + in13() + SRMT("in14") + if (chk0) { + in14() + } else { + BLCK() + } + SRMT("in15") + if (chk0) { + in15() + } else { + BLCK() + } + SRMT("in16") + in16() + SRMT("in17") + in17() + SRMT("in18-0") + in18(0) + SRMT("in19-0") + in19(0) + SRMT("in1a-0") + in1a(0) + SRMT("in1b-0") + in1b(0) + SRMT("in1c-0") + if (y275) { + in1c(0) + } else { + BLCK() + } + SRMT("in1d") + in1d() + SRMT("in1e") + if (LAnd(fix0, y275)) { + in1e() + } else { + BLCK() + } + + CH03("ini1", z164, 0x000, 0, 0) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in20.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in20.asl new file mode 100644 index 000000000..1b8cf9cfc --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in20.asl @@ -0,0 +1,279 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Source file ns_0000.asl + * + * The tests differ those from ns_0000.asl by that the objects are + * passed to methods as argument (Arg) but not directly by name. + */ + +Name(z165, 165) + +/* + * Named Integer i000 + */ + +/* + * Simple, 3-level + */ +Method(in20, 1) +{ + Name(ts, "in20") + Name(i000, 0x00000001) + Name(p000, Package() {1,2,3,4}) + + Name(i001, 0) + + CH03(ts, z165, 0x000, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + if (i001) { + CopyObject(p000, arg0) + } + Return (0xabcd0000) + } + Return (Add(arg0, m003(arg0))) + } + Return (Add(arg0, m002(arg0))) + } + Store(Add(arg0, m001(arg0)), Local0) + + Return (Local0) + } + + Store(m000(i000), Local0) + + if (LNotEqual(Local0, 0xabcd0003)) { + err(ts, z165, 0x001, 0, 0, Local0, 0xabcd0003) + } +} + +/* + * 8-level + * added writing into i000: + * Store(0x00040000, i000) + */ +Method(in21, 1) +{ + Name(ts, "in21") + Name(i000, 0x00000001) + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Store(arg0, i001) + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Method(m008, 1) + { + if (i001) + { + CopyObject(p000, arg0) + } + Return (0) + } + Store(0x80000000, arg0) + Return (Add(arg0, m008(arg0))) + } + Store(0x07000000, arg0) + Return (Add(arg0, m007(arg0))) + } + Store(0x00600000, arg0) + Return (Add(arg0, m006(arg0))) + } + Store(0x00050000, arg0) + Return (Add(arg0, m005(arg0))) + } + Store(0x00004000, arg0) + Return (Add(arg0, m004(arg0))) + } + Store(0x00000300, arg0) + Return (Add(arg0, m003(arg0))) + } + Store(0x00000020, arg0) + Return (Add(arg0, m002(arg0))) + } + + Store(Add(i000, m001(i000)), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z165, 0x003, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(i000, 0x00000001)) { + err(ts, z165, 0x004, 0, 0, i000, 0x00000001) + } +} + +/* + * Recurcive execution of m001: + * Add(i000, m001(), Local0) + */ +Method(in22) +{ + Name(ts, "in22") + Name(i000, 0x00100000) + Name(i001, 0) + + Method(m000, 1) + { + Method(m001, 1) + { + /* + * Because of the stack overflow issues on MS the number + * of repetitions was changed from 100 to 9 here. + */ + if (LLess(i001, 9)) { + Increment(arg0) + Increment(i001) + Add(arg0, m001(arg0), Local0) + Return (Local0) + } + Return (0) + } + Store(Add(arg0, m001(arg0)), Local0) + Return (Local0) + } + + Store(Add(i000, m000(i000)), Local0) + + if (LNotEqual(Local0, 0x00b0002d)) { + err(ts, z165, 0x006, 0, 0, Local0, 0x00b0002d) + } + + if (LNotEqual(i000, 0x00100000)) { + err(ts, z165, 0x007, 0, 0, i000, 0x00100000) + } +} + +/* + * Arg instead of i000 (in in01) + */ +Method(in23, 2) +{ + Name(ts, "in23") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + Store(arg0, i001) + + Store(0x00000001, arg1) + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Method(m008, 1) + { + if (i001) + { + CopyObject(p000, arg0) + } + Return (0) + } + Store(0x80000000, arg0) + Return (Add(arg0, m008(8))) + } + Store(0x07000000, arg0) + Return (Add(arg0, m007(7))) + } + Store(0x00600000, arg0) + Return (Add(arg0, m006(6))) + } + Store(0x00050000, arg0) + Return (Add(arg0, m005(5))) + } + Store(0x00004000, arg0) + Return (Add(arg0, m004(4))) + } + Store(0x00000300, arg0) + Return (Add(arg0, m003(3))) + } + Store(0x00000020, arg0) + Return (Add(arg0, m002(2))) + } + Store(Add(arg1, m001(1)), Local0) + + if (LNotEqual(Local0, 0x87654321)) { + err(ts, z165, 0x00f, 0, 0, Local0, 0x87654321) + } + + if (LNotEqual(arg1, 1)) { + err(ts, z165, 0x010, 0, 0, arg1, 1) + } + + CH03(ts, z165, 0x011, 0, 0) +} + +Method(ini2) +{ + SRMT("in20-0") + in20(0) + SRMT("in21-0") + in21(0) + SRMT("in22") + in22() + SRMT("in23-0") + in23(0, 0) + + CH03("ini2", z165, 0x000, 0, 0) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in30.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in30.asl new file mode 100644 index 000000000..2f2c04aca --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in30.asl @@ -0,0 +1,913 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Source file ns_0010.asl + * + * The tests differ those from ns_0010.asl by that the objects are + * passed to methods as argument (Arg) but not directly by name. + */ + +Name(z166, 166) + +/* + * + * Read/write access to elemens of Package passed to method. + * + */ + +/* + * + * Elements of Package are constant Integer (0xabcd0000) + * + */ + +/* + * Package is passed by ArgX to method: + * - directly + */ +Method(in30) +{ + Name(ts, "in30") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0000) + } + + Store(0x11112222, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is passed by ArgX to method: + * - by ORef + */ +Method(in31) +{ + Name(ts, "in31") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(DerefOf(arg1), Local7) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x33334444) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0000) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is passed by ArgX to method: + * - directly + * - by ORef + */ +Method(in32) +{ + Name(ts, "in32") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(0x11112222, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(arg1), Local7) + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x33334444) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } +} + +/* + * Package is given directly by name: + * - do ORef and pass to LocalX + * - do DerefOf and pass to LocalX + */ +Method(in33) +{ + Name(ts, "in33") + Name(p000, Package() {0xabcd0000, 0xabcd0001, 0xabcd0002}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(RefOf(arg0), Local6) + Store(DerefOf(Local6), Local7) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(0x33334444, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x33334444)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x33334444) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0002) + } +} + +/* + * + * Elements of Package are Named Integer (i000) + * + */ + +/* + * Package is passed by ArgX to method + * + * fail + * + * Note: + * Named element of Package is simply not implemented by MS, + * i000 in Package(){i000} is, on MS, the same as Package(){"i000"}. + */ +Method(in34) +{ + Name(ts, "in34") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + Name(i002, 0xabcd0002) + Name(ii00, 0x11112222) + Name(p000, Package() {i000, i001, i002, "i000"}) + + Method(m000, 2) + { + Method(m001, 2) + { + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0xabcd0000)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0000) + } + Store(DerefOf(Index(arg0, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } + Store(DerefOf(Index(arg0, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0002) + } + Store(DerefOf(Index(arg0, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z166, 0x000, 0, 0, Local0, "i000") + } + + Store(ii00, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + } + m001(arg0, arg1) + } + + m000(p000, RefOf(p000)) + + Store(DerefOf(Index(p000, 0)), Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x11112222) + } + + Store(DerefOf(Index(p000, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0001) + } + + Store(DerefOf(Index(p000, 2)), Local0) + if (LNotEqual(Local0, 0xabcd0002)) { + err(ts, z166, 0x000, 0, 0, Local0, 0xabcd0002) + } + + Store(DerefOf(Index(p000, 3)), Local0) + if (LNotEqual(Local0, "i000")) { + err(ts, z166, 0x000, 0, 0, Local0, "i000") + } +} + +/* + * Buffer + */ + +Method(in36) +{ + Name(ts, "in36") + Name(b000, Buffer() {0x10, 0x11, 0x12}) + + Method(m000, 2) + { + Method(m001, 2) + { + // arg0 - b000 + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x10)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x10) + } + + Store(0x67, Index(arg0, 0)) + + Store(DerefOf(Index(arg0, 0)), Local0) + if (LNotEqual(Local0, 0x67)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x67) + } + + // arg1 - RefOf(b000) + + Store(DerefOf(arg1), Local7) + Store(0x55, Index(Local7, 1)) + + Store(DerefOf(Index(Local7, 1)), Local0) + if (LNotEqual(Local0, 0x55)) { + err(ts, z166, 0x000, 0, 0, Local0, 0x55) + } + } + m001(arg0, arg1) + } + + m000(b000, RefOf(b000)) + + Store(DerefOf(Index(b000, 0)), Local0) + if (LNotEqual(Local0, 0x67)) { + err(ts, z166, 0x002, 0, 0, Local0, 0x67) + } + + Store(DerefOf(Index(b000, 1)), Local0) + if (LNotEqual(Local0, 0x11)) { + err(ts, z166, 0x002, 0, 0, Local0, 0x11) + } + + Store(DerefOf(Index(b000, 2)), Local0) + if (LNotEqual(Local0, 0x12)) { + err(ts, z166, 0x002, 0, 0, Local0, 0x12) + } +} + +/* + * Element of Package instead of i000 (in in02) + * + * Recursive call to m001 + */ +Method(in37) +{ + Name(ts, "in37") + Name(i001, 0) + Name(pp00, Package() {0x11111111, 0x00100000, 0x22223333}) + + Method(m000, 1) + { + Method(m001, 1) + { + /* + * Because of the stack overflow issues on MS the number + * of repetitions was changed from 100 to 9 here. + */ + if (LLess(i001, 9)) { + + Store(DerefOf(Index(arg0, 1)), Local0) + Increment(Local0) + Store(Local0, Index(arg0, 1)) + Increment(i001) + Add(DerefOf(Index(arg0, 1)), m001(arg0), Local0) + Return (Local0) + } + Return (0) + } + Store(Add(DerefOf(Index(arg0, 1)), m001(arg0)), Local0) + Return (Local0) + } + + Store(m000(pp00), Local0) + + if (LNotEqual(Local0, 0x00a0002d)) { + err(ts, z166, 0x00a, 0, 0, Local0, 0x00a0002d) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x00100009)) { + err(ts, z166, 0x00b, 0, 0, Local0, 0x00100009) + } + + CH03(ts, z166, 0x00c, 0, 0) +} + +/* + * Buffer Field instead of i000 (in in01) + * + * fail + * + * Note: Buffer Field in expressions is not supported by MS, + * see msfail.asl + */ + +/* + * Field instead of i000 (in in01) + */ +Method(in38, 1) +{ + Name(ts, "in38") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + + CH03(ts, z166, 0x011, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + /* + * To exclude stack overflow + * >>>>>>>>>>>>>>>> + Method(m008, 1) + { + if (i001) + { + Store(0x11223344, arg0) + } + Return (0) + } + Store(0x80000000, arg0) + Return (Add(arg0, m008(arg0))) + * <<<<<<<<<<<<<<<< + */ + Return (0) + } + Store(0x07000000, arg0) + Return (Add(arg0, m007(arg0))) + } + Store(0x00600000, arg0) + Return (Add(arg0, m006(arg0))) + } + Store(0x00050000, arg0) + Return (Add(arg0, m005(arg0))) + } + Store(0x00004000, arg0) + Return (Add(arg0, m004(arg0))) + } + Store(0x00000300, arg0) + Return (Add(arg0, m003(arg0))) + } + Store(0x00000020, arg0) + Return (Add(arg0, m002(arg0))) + } + + Store(0x00000001, arg0) + Store(Add(arg0, m001(arg0)), Local0) + Return (Local0) + } + + Store(0xabcd9876, f001) + + Store(m000(f001), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z166, 0x012, 0, 0, Local0, 0x07654321) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0xabcd9876, Local1) + } + + if (LNotEqual(f001, Local1)) { + err(ts, z166, 0x013, 0, 0, f001, Local1) + } + + CH03(ts, z166, 0x014, 0, 0) +} + +/* + * Bank Field instead of i000 (in in01) + * + * (is this test correct?) + */ +Method(in39, 1) +{ + Name(ts, "in39") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + BankField(r000, f001, 0, ByteAcc, NoLock, Preserve) { bnk0, 32 } + + CH03(ts, z166, 0x015, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + /* + * To exclude stack overflow + * >>>>>>>>>>>>>>>> + Method(m008, 1) + { + if (i001) + { + Store(0x11223344, arg0) + } + Return (0) + } + Store(0x80000000, arg0) + Return (Add(arg0, m008(arg0))) + * <<<<<<<<<<<<<<<< + */ + Return (0) + } + Store(0x07000000, arg0) + Return (Add(arg0, m007(arg0))) + } + Store(0x00600000, arg0) + Return (Add(arg0, m006(arg0))) + } + Store(0x00050000, arg0) + Return (Add(arg0, m005(arg0))) + } + Store(0x00004000, arg0) + Return (Add(arg0, m004(arg0))) + } + Store(0x00000300, arg0) + Return (Add(arg0, m003(arg0))) + } + Store(0x00000020, arg0) + Return (Add(arg0, m002(arg0))) + } + + Store(0x00000001, arg0) + Store(Add(arg0, m001(arg0)), Local0) + Return (Local0) + } + + Store(0xaabbccdd, bnk0) + Store(m000(bnk0), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z166, 0x016, 0, 0, Local0, 0x07654321) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0xaabbccdd, Local1) + } + + if (LNotEqual(bnk0, Local1)) { + err(ts, z166, 0x017, 0, 0, bnk0, Local1) + } + + CH03(ts, z166, 0x018, 0, 0) +} + +/* + * Index Field instead of i000 (in in01) + * + * (is this test correct?) + */ +Method(in3a, 1) +{ + Name(ts, "in3a") + Name(i001, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000,32, f001,32 } + IndexField(f000, f001, ByteAcc, NoLock, Preserve) { if00, 32 } + + CH03(ts, z166, 0x019, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + /* + * To exclude stack overflow + * >>>>>>>>>>>>>>>> + Method(m008, 1) + { + if (i001) + { + Store(0x11223344, if00) + } + Return (0) + } + Store(0x80000000, if00) + Return (Add(if00, m008(if00))) + * <<<<<<<<<<<<<<<< + */ + Return (0) + } + Store(0x07000000, if00) + Return (Add(if00, m007(if00))) + } + Store(0x00600000, if00) + Return (Add(if00, m006(if00))) + } + Store(0x00050000, if00) + Return (Add(if00, m005(if00))) + } + Store(0x00004000, if00) + Return (Add(if00, m004(if00))) + } + Store(0x00000300, if00) + Return (Add(if00, m003(if00))) + } + Store(0x00000020, if00) + Return (Add(if00, m002(if00))) + } + + Store(0x00000001, if00) + Store(Add(if00, m001(if00)), Local0) + Return (Local0) + } + + Store(0xabababab, if00) + Store(m000(if00), Local0) + + /* + * The benchmark values for arg0==0 below + * are how MS actually works. + */ + + if (LNotEqual(Local0, 0x07070707)) { + err(ts, z166, 0x01a, 0, 0, Local0, 0x07070707) + } + + if (arg0) { + Store(0x11223344, Local1) + } else { + Store(0x07070707, Local1) + } + + if (LNotEqual(if00, Local1)) { + err(ts, z166, 0x01b, 0, 0, if00, Local1) + } + + CH03(ts, z166, 0x01c, 0, 0) +} + +/* + * Element of Buffer instead of i000 (in in01) + * + * see in3c below + * + * Method(in3b, 1) + * { + * } + */ + +/* + * Element of Buffer instead of i000 (in in01) + * + * m01b+: + * added argument to methods and b000 passed without any use of that + * parameter inside the methods + */ +Method(in3c, 1) +{ + Name(ts, "in3c") + Name(i001, 0) + Name(b000, Buffer() {0x11, 0x01, 0x22}) + + CH03(ts, z166, 0x01d, 0, 0) + + Store(arg0, i001) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Return (0) + } + Store(0x07, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m007(arg0))) + } + Store(0x06, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m006(arg0))) + } + Store(0x05, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m005(arg0))) + } + Store(0x04, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m004(arg0))) + } + Store(0x03, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m003(arg0))) + } + Store(0x02, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m002(arg0))) + } + Store(Add(DerefOf(Index(arg0, 1)), m001(arg0)), Local0) + Return (Local0) + } + + Store(m000(b000), Local0) + + if (LNotEqual(Local0, 0x1c)) { + err(ts, z166, 0x01e, 0, 0, Local0, 0x1c) + } + + Store(DerefOf(Index(b000, 1)), Local0) + + if (arg0) { + Store(0xff, Local1) + } else { + Store(0x07, Local1) + } + + if (LNotEqual(Local0, Local1)) { + err(ts, z166, 0x01f, 0, 0, Local0, Local1) + } + + CH03(ts, z166, 0x020, 0, 0) +} + +/* + * Element of Package instead of i000 (in in01) + * + * see in3e below + * + * Method(in3d) + * { + * } + */ + +/* + * Element of Package instead of i000 (in in01) + * + * m01d+: + * added argument to methods and b000 passed without any use of that + * parameter inside the methods + */ +Method(in3e) +{ + Name(ts, "in3e") + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + Name(pp00, Package() {0x11111111, 0x00000001, 0x22223333}) + + CH03(ts, z166, 0x006, 0, 0) + + Method(m000, 1) + { + + Method(m001, 1) + { + Method(m002, 1) + { + Method(m003, 1) + { + Method(m004, 1) + { + Method(m005, 1) + { + Method(m006, 1) + { + Method(m007, 1) + { + Return (0) + } + Store(0x07000000, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m007(arg0))) + } + Store(0x00600000, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m006(arg0))) + } + Store(0x00050000, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m005(arg0))) + } + Store(0x00004000, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m004(arg0))) + } + Store(0x00000300, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m003(arg0))) + } + Store(0x00000020, Index(arg0, 1)) + Return (Add(DerefOf(Index(arg0, 1)), m002(arg0))) + } + Store(Add(DerefOf(Index(arg0, 1)), m001(arg0)), Local0) + Return (Local0) + } + + Store(m000(pp00), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z166, 0x007, 0, 0, Local0, 0x07654321) + } + + Store(DerefOf(Index(pp00, 1)), Local0) + + if (LNotEqual(Local0, 0x07000000)) { + err(ts, z166, 0x008, 0, 0, Local0, 0x07000000) + } + + CH03(ts, z166, 0x009, 0, 0) +} + +Method(ini3) +{ + SRMT("in30") + in30() + SRMT("in31") + in31() + SRMT("in32") + in32() + SRMT("in33") + in33() + SRMT("in34") + if (chk0) { + in34() + } else { + BLCK() + } + SRMT("in36") + in36() + SRMT("in37") + in37() + SRMT("in38-0") + in38(0) + SRMT("in39-0") + in39(0) + SRMT("in3a-0") + in3a(0) + SRMT("in3c-0") + in3c(0) + SRMT("in3e") + in3e() + + CH03("ini3", z166, 0x000, 0, 0) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in40.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in40.asl new file mode 100644 index 000000000..71d187eb5 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in40.asl @@ -0,0 +1,4654 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Method invocations, Arguments, Locals... + * + * The same object is passed simultaneously by several Args, + * thus, the same object is represented in stack several times. + */ + +Name(z167, 167) + +/* + * See comment below why the functionally unnecessary + * or commented branches 'if (chk0)' are not removed. + * + * They remind the problems of adjusting AML code for MS. + */ + +Name(cmd0, 0) +Name(stp0, 0) + +// Opcodes of actions +Name(OT00, 0) // ObjectType +Name(AD00, 1) // Add +Name(LN00, 2) // LNotEqual +Name(LN01, 3) // LNotEqual +Name(LN02, 4) // LNotEqual +Name(LN03, 5) // LNotEqual +Name(LN04, 6) // LNotEqual +Name(LN05, 7) // LNotEqual +Name(LN06, 8) // LNotEqual +Name(LN07, 9) // LNotEqual +Name(LN08, 10) // LNotEqual + +/* + * Verify the type of object + */ +Method(obt0, 2) +{ + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, arg1)) { + err("obt0", z167, 0x000, 0, 0, Local0, arg1) + } + Return (5) +} + +/* + * Do simple verification actions + * + * arg0 - command to be performed + * arg1 - object + * arg2 - depends on arg0 + */ +Method(act0, 4) +{ + Name(ts, "act0") + + Switch (arg0) { + Case (0) { // ObjectType + Store(ObjectType(arg1), Local0) + if (LNotEqual(Local0, arg2)) { + err(ts, z167, 0x000, 0, 0, Local0, arg2) + } + } + Case (1) { // Add + Add(arg1, arg2, Local0) + if (LNotEqual(Local0, arg3)) { + err(ts, z167, 0x001, 0, 0, Local0, arg3) + } + } + Case (2) { // LNotEqual + if (LNotEqual(arg1, 0xabcd0000)) { + err(ts, z167, 0x002, 0, 0, arg1, 0xabcd0000) + } + } + Case (3) { // LNotEqual + // if (chk0) { + if (LNotEqual(arg1, "qwrtyu0003")) { + err(ts, z167, 0x003, 0, 0, arg1, "qwrtyu0003") + } + // } + } + Case (4) { // LNotEqual + // if (chk0) { + if (LNotEqual(arg1, "abcd0800")) { + err(ts, z167, 0x004, 0, 0, arg1, "abcd0800") + } + // } + } + Case (5) { // LNotEqual + // if (chk0) { + if (LNotEqual(arg1, Buffer() {0xb0,0xb1,0xb2,0xb3,0xb4})) { + err(ts, z167, 0x005, 0, 0, arg1, Buffer() {0xb0,0xb1,0xb2,0xb3,0xb4}) + } + // } + } + Case (6) { // LNotEqual + Store(DerefOf(Index(arg1, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0902)) { + err(ts, z167, 0x006, 0, 0, Local0, 0xabcd0902) + } + } + Case (7) { // LNotEqual + if (LNotEqual(arg1, 0xabcd0a00)) { + err(ts, z167, 0x007, 0, 0, arg1, 0xabcd0a00) + } + } + Case (8) { // LNotEqual + if (LNotEqual(arg1, 0xabababab)) { + err(ts, z167, 0x008, 0, 0, arg1, 0xabababab) + } + } + Case (9) { // LNotEqual + if (LNotEqual(arg1, 0)) { + err(ts, z167, 0x009, 0, 0, arg1, 0) + } + } + Case (10) { // LNotEqual + if (LNotEqual(arg1, 0xabcd0d08)) { + err(ts, z167, 0x00a, 0, 0, arg1, 0xabcd0d08) + } + } + } // Switch (arg0) +} + +/* Methods with different # of args but doing the same */ + +Method(mI01, 1) +{ + if (LNot(chk0)) { + + /* + * This code helps for some branches to work on MS. + * This code being placed in Switch below doesn't work. + * I moved this code from the Switch below and replaced + * calls to Methods by the contents of those methods. + * + * Nevertheless, I have not removed the 'if (chk0)' in + * Switch below and beneath it to show additionally the + * problems I encountered, where MS doesn't work, while + * attempting to work with Switch. + */ + + if (LEqual(cmd0, 1)) { // Integer + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c009)) { + err("mI01", z167, 0x000, 0, 0, Local0, c009) + } + Add(arg0, 1, Local0) + if (LNotEqual(Local0, 0xabcd0001)) { + err("mI01", z167, 0x001, 0, 0, Local0, 0xabcd0001) + } + if (LNotEqual(arg0, 0xabcd0000)) { + err("mI01", z167, 0x007, 0, 0, arg0, 0xabcd0000) + } + + Return (arg0) + } + + if (LEqual(cmd0, 2)) { // String + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c00a)) { + err("mI01", z167, 0x000, 0, 0, Local0, c00a) + } + + if (LNot(run4)) { // Run on ACPICA only + if (LNotEqual(arg0, "qwrtyu0003")) { + err("mI01", z167, 0x007, 0, 0, arg0, "qwrtyu0003") + } + } + Return (arg0) + } + + if (LEqual(cmd0, 3)) { // String applicable to the Implicit Conversion Rules ("abcd0800") + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c00a)) { + err("mI01", z167, 0x000, 0, 0, Local0, c00a) + } + + if (LNot(run4)) { // Run on ACPICA only + Add(arg0, 5, Local0) + if (LNotEqual(Local0, 0xabcd0805)) { + err("mI01", z167, 0x001, 0, 0, Local0, 0xabcd0805) + } + if (LNotEqual(arg0, "abcd0800")) { + err("mI01", z167, 0x007, 0, 0, arg0, "abcd0800") + } + } + + Return (arg0) + } + + if (LEqual(cmd0, 4)) { // Buffer + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c00b)) { + err("mI01", z167, 0x000, 0, 0, Local0, c00b) + } + + if (LNot(run4)) { // Run on ACPICA only + Add(arg0, 7, Local0) + if (LNotEqual(Local0, 0xb4b3b2b1b7)) { + err("mI01", z167, 0x001, 0, 0, Local0, 0xb4b3b2b1b7) + } + if (LNotEqual(arg0, Buffer() {0xb0,0xb1,0xb2,0xb3,0xb4})) { + err("mI01", z167, 0x007, 0, 0, arg0, Buffer() {0xb0,0xb1,0xb2,0xb3,0xb4}) + } + } + + Return (arg0) + } + + if (LEqual(cmd0, 5)) { // Package + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c00c)) { + err("mI01", z167, 0x000, 0, 0, Local0, c00c) + } + Store(DerefOf(Index(arg0, 1)), Local0) + if (LNotEqual(Local0, 0xabcd0902)) { + err("mI01", z167, 0x006, 0, 0, Local0, 0xabcd0902) + } + Return (arg0) + } + + if (LEqual(cmd0, 6)) { // Field + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c009)) { + err("mI01", z167, 0x000, 0, 0, Local0, c009) + } + Add(arg0, 9, Local0) + if (LNotEqual(Local0, 0xabcd0a09)) { + err("mI01", z167, 0x001, 0, 0, Local0, 0xabcd0a09) + } + if (LNotEqual(arg0, 0xabcd0a00)) { + err("mI01", z167, 0x007, 0, 0, arg0, 0xabcd0a00) + } + + Return (arg0) + } + + if (LEqual(cmd0, 7)) { // Device + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c00e)) { + err("mI01", z167, 0x000, 0, 0, Local0, c00e) + } + Return (arg0) + } + + if (LEqual(cmd0, 8)) { // Event + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c00f)) { + err("mI01", z167, 0x000, 0, 0, Local0, c00f) + } + Return (arg0) + } + + if (LEqual(cmd0, 9)) { // Mutex + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c011)) { + err("mI01", z167, 0x000, 0, 0, Local0, c011) + } + Return (arg0) + } + + if (LEqual(cmd0, 10)) { // Operation Region + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c012)) { + err("mI01", z167, 0x000, 0, 0, Local0, c012) + } + Return (arg0) + } + + if (LEqual(cmd0, 11)) { // Power Resource + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c013)) { + err("mI01", z167, 0x000, 0, 0, Local0, c013) + } + Return (arg0) + } + + if (LEqual(cmd0, 12)) { // Processor + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c014)) { + err("mI01", z167, 0x000, 0, 0, Local0, c014) + } + Return (arg0) + } + + if (LEqual(cmd0, 13)) { // Thermal Zone + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c015)) { + err("mI01", z167, 0x000, 0, 0, Local0, c015) + } + Return (arg0) + } + + if (LEqual(cmd0, 14)) { // Index Field + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c009)) { + err("mI01", z167, 0x000, 0, 0, Local0, c009) + } + Add(arg0, 9, Local0) + if (LNotEqual(Local0, 0xabababb4)) { + err("mI01", z167, 0x001, 0, 0, Local0, 0xabababb4) + } + if (LNotEqual(arg0, 0xabababab)) { + err("mI01", z167, 0x008, 0, 0, arg0, 0xabababab) + } + Return (arg0) + } + + if (LEqual(cmd0, 15)) { // Bank Field + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, c009)) { + err("mI01", z167, 0x000, 0, 0, Local0, c009) + } + Add(arg0, 9, Local0) + if (LNotEqual(Local0, 9)) { + err("mI01", z167, 0x001, 0, 0, Local0, 9) + } + if (LNotEqual(arg0, 0)) { + err("mI01", z167, 0x009, 0, 0, arg0, 0) + } + + Return (arg0) + } + + if (LEqual(cmd0, 16)) { // Buffer Field + + // On MS ObjectType(BufferField) == c00b + + Store(ObjectType(arg0), Local0) + if (LAnd(LNotEqual(Local0, c009), LNotEqual(Local0, c00b))) { + err("mI01", z167, 0x000, 0, 0, Local0, c00b) + } + + if (chk0) { + Add(arg0, 2, Local0) + if (LNotEqual(Local0, 0xabcd0d0a)) { + err("mI01", z167, 0x001, 0, 0, Local0, 0xabcd0d0a) + } + if (LNotEqual(arg0, 0xabcd0d08)) { + err("mI01", z167, 0x00a, 0, 0, arg0, 0xabcd0d08) + } + } + Return (arg0) + } + } + + Switch (cmd0) { + Case (1) { // Integer + act0(OT00, arg0, c009, 0) + act0(LN00, arg0, 0, 0) + act0(AD00, arg0, 1, 0xabcd0001) + } + Case (2) { // String ("qwrtyu0003") + act0(OT00, arg0, c00a, 0) + act0(LN01, arg0, 0, 0) + } + Case (3) { // String applicable to the Implicit Conversion Rules ("abcd0800") + act0(OT00, arg0, c00a, 0) + act0(LN02, arg0, 0, 0) + // if (chk0) { + act0(AD00, arg0, 5, 0xabcd0805) + // } + } + Case (4) { // Buffer + act0(OT00, arg0, c00b, 0) + act0(LN03, arg0, 0, 0) + // if (chk0) { + act0(AD00, arg0, 7, 0xb4b3b2b1b7) + // } + } + Case (5) { // Package + act0(OT00, arg0, c00c, 0) + act0(LN04, arg0, 0, 0) + } + Case (6) { // Field + act0(OT00, arg0, c009, 0) + // if (chk0) { + // This breaks Field (see qqq below): + act0(LN05, arg0, 0, 0) + // } + act0(AD00, arg0, 9, 0xabcd0a09) + } + Case (7) { // Device + act0(OT00, arg0, c00e, 0) + } + Case (8) { // Event + act0(OT00, arg0, c00f, 0) + } + Case (9) { // Mutex + act0(OT00, arg0, c011, 0) + } + Case (10) { // Operation Region + act0(OT00, arg0, c012, 0) + } + Case (11) { // Power Resource + // if (chk0) { + act0(OT00, arg0, c013, 0) + // } + } + Case (12) { // Processor + act0(OT00, arg0, c014, 0) + } + Case (13) { // Thermal Zone + act0(OT00, arg0, c015, 0) + } + Case (14) { // Index Field + act0(OT00, arg0, c009, 0) + // if (chk0) { + act0(LN06, arg0, 0, 0) + // } + act0(AD00, arg0, 9, 0xabababb4) + } + Case (15) { // Bank Field + // if (chk0) { + act0(OT00, arg0, c009, 0) + // } + // if (chk0) { + act0(LN07, arg0, 0, 0) + // } + // if (chk0) { + act0(AD00, arg0, 9, 9) + // } + } + Case (16) { // Buffer Field + // if (chk0) { + act0(OT00, arg0, c009, 0) + // } + // if (chk0) { + act0(LN08, arg0, 0, 0) + // } + // if (chk0) { + act0(AD00, arg0, 2, 0xabcd0d0a) + // } + } + Default { // Uninitialized + act0(OT00, arg0, c008, 0) + } + + } // Switch (arg0) + + Return (arg0) +} + +Method(mI02, 2) { + mI01(arg0) + mI01(arg1) + Return (arg0) +} +Method(mI03, 3) { + mI01(arg0) + mI01(arg1) + mI01(arg2) + Return (arg0) +} +Method(mI04, 4) { + mI01(arg0) + mI01(arg1) + mI01(arg2) + mI01(arg3) + Return (arg0) +} +Method(mI05, 5) { + mI01(arg0) + mI01(arg1) + mI01(arg2) + mI01(arg3) + mI01(arg4) + Return (arg0) +} +Method(mI06, 6) { + mI01(arg0) + mI01(arg1) + mI01(arg2) + mI01(arg3) + mI01(arg4) + mI01(arg5) + Return (arg0) +} +Method(mI07, 7) { + mI01(arg0) + mI01(arg1) + mI01(arg2) + mI01(arg3) + mI01(arg4) + mI01(arg5) + mI01(arg6) + Return (arg0) +} + +Method(in40, 7) +{ + Name(ts, "in40") + + Name(i000, 0xabcd0000) + Name(s000, "qwrtyu0003") + Name(s001, "abcd0800") + Name(b000, Buffer() {0xb0,0xb1,0xb2,0xb3,0xb4}) + Name(p000, Package() {0xabcd0901, 0xabcd0902, 0xabcd0903}) + Method(mmm0) { + Name(im00, 0xabcd0004) + Name(sm00, "qwertyui") + // Return ( "qwertyui" ) + } + Method(mmm1) { + Name(im00, 0xabcd0004) + Name(sm00, "qwertyui") + // Return ( 0xabcd0004 ) + Return ( "qwertyui" ) + } + + + + + /* + * Integer + */ + Name(ii00, 0) + Name(ii01, 0) + Name(ii03, 0) + Name(ii05, 0) + + Store(1, cmd0) + Store(i000, ii00) + + + + + /* + * Modification 0: + */ + + mI01(ii00) + mI02(ii00, ii00) + mI03(ii00, ii00, ii00) + mI04(ii00, ii00, ii00, ii00) + mI05(ii00, ii00, ii00, ii00, ii00) + mI06(ii00, ii00, ii00, ii00, ii00, ii00) + mI07(ii00, ii00, ii00, ii00, ii00, ii00, ii00) + + mI01( + mI01(ii00)) + + mI02( + mI01(ii00), + mI02(ii00, ii00)) + + mI03( + mI01(ii00), + mI02(ii00, ii00), + mI03(ii00, ii00, ii00)) + + mI04( + mI01(ii00), + mI02(ii00, ii00), + mI03(ii00, ii00, ii00), + mI04(ii00, ii00, ii00, ii00)) + + if (y262) { + + mI05( + mI01(ii00), + mI02(ii00, ii00), + mI03(ii00, ii00, ii00), + mI04(ii00, ii00, ii00, ii00), + mI05(ii00, ii00, ii00, ii00, ii00)) + + mI06( + mI01(ii00), + mI02(ii00, ii00), + mI03(ii00, ii00, ii00), + mI04(ii00, ii00, ii00, ii00), + mI05(ii00, ii00, ii00, ii00, ii00), + mI06(ii00, ii00, ii00, ii00, ii00, ii00)) + mI07( + mI01(ii00), + mI02(ii00, ii00), + mI03(ii00, ii00, ii00), + mI04(ii00, ii00, ii00, ii00), + mI05(ii00, ii00, ii00, ii00, ii00), + mI06(ii00, ii00, ii00, ii00, ii00, ii00), + mI07(ii00, ii00, ii00, ii00, ii00, ii00, ii00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(ii00, Local1) + Store(ii00, Local3) + Store(ii00, Local5) + + mI01(ii00) + mI02(ii00, Local1) + mI03(ii00, Local1, ii00) + mI04(ii00, Local1, ii00, Local3) + mI05(ii00, Local1, ii00, Local3, ii00) + mI06(ii00, Local1, ii00, Local3, ii00, Local5) + mI07(ii00, Local1, ii00, Local3, ii00, Local5, ii00) + + mI01( + mI01(ii00)) + + mI02( + mI01(ii00), + mI02(ii00, Local1)) + + mI03( + mI01(ii00), + mI02(ii00, Local1), + mI03(ii00, Local1, ii00)) + + mI04( + mI01(ii00), + mI02(ii00, Local1), + mI03(ii00, Local1, ii00), + mI04(ii00, Local1, ii00, Local3)) + + if (y262) { + + mI05( + mI01(ii00), + mI02(ii00, Local1), + mI03(ii00, Local1, ii00), + mI04(ii00, Local1, ii00, Local3), + mI05(ii00, Local1, ii00, Local3, ii00)) + + mI06( + mI01(ii00), + mI02(ii00, Local1), + mI03(ii00, Local1, ii00), + mI04(ii00, Local1, ii00, Local3), + mI05(ii00, Local1, ii00, Local3, ii00), + mI06(ii00, Local1, ii00, Local3, ii00, Local5)) + mI07( + mI01(ii00), + mI02(ii00, Local1), + mI03(ii00, Local1, ii00), + mI04(ii00, Local1, ii00, Local3), + mI05(ii00, Local1, ii00, Local3, ii00), + mI06(ii00, Local1, ii00, Local3, ii00, Local5), + mI07(ii00, Local1, ii00, Local3, ii00, Local5, ii00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (effectively local) + */ + + Store(ii00, Arg1) + Store(ii00, Arg3) + Store(ii00, Arg5) + + mI01(ii00) + mI02(ii00, Arg1) + mI03(ii00, Arg1, ii00) + mI04(ii00, Arg1, ii00, Arg3) + mI05(ii00, Arg1, ii00, Arg3, ii00) + mI06(ii00, Arg1, ii00, Arg3, ii00, Arg5) + mI07(ii00, Arg1, ii00, Arg3, ii00, Arg5, ii00) + + mI01( + mI01(ii00)) + + mI02( + mI01(ii00), + mI02(ii00, Arg1)) + + mI03( + mI01(ii00), + mI02(ii00, Arg1), + mI03(ii00, Arg1, ii00)) + + mI04( + mI01(ii00), + mI02(ii00, Arg1), + mI03(ii00, Arg1, ii00), + mI04(ii00, Arg1, ii00, Arg3)) + + if (y262) { + + mI05( + mI01(ii00), + mI02(ii00, Arg1), + mI03(ii00, Arg1, ii00), + mI04(ii00, Arg1, ii00, Arg3), + mI05(ii00, Arg1, ii00, Arg3, ii00)) + + mI06( + mI01(ii00), + mI02(ii00, Arg1), + mI03(ii00, Arg1, ii00), + mI04(ii00, Arg1, ii00, Arg3), + mI05(ii00, Arg1, ii00, Arg3, ii00), + mI06(ii00, Arg1, ii00, Arg3, ii00, Arg5)) + mI07( + mI01(ii00), + mI02(ii00, Arg1), + mI03(ii00, Arg1, ii00), + mI04(ii00, Arg1, ii00, Arg3), + mI05(ii00, Arg1, ii00, Arg3, ii00), + mI06(ii00, Arg1, ii00, Arg3, ii00, Arg5), + mI07(ii00, Arg1, ii00, Arg3, ii00, Arg5, ii00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 3: + * + * Some params are intermediately stored to Named + */ + + Store(ii00, ii01) + Store(ii00, ii03) + Store(ii00, ii05) + + mI01(ii00) + mI02(ii00, ii01) + mI03(ii00, ii01, ii00) + mI04(ii00, ii01, ii00, ii03) + mI05(ii00, ii01, ii00, ii03, ii00) + mI06(ii00, ii01, ii00, ii03, ii00, ii05) + mI07(ii00, ii01, ii00, ii03, ii00, ii05, ii00) + + mI01( + mI01(ii00)) + + mI02( + mI01(ii00), + mI02(ii00, ii01)) + + mI03( + mI01(ii00), + mI02(ii00, ii01), + mI03(ii00, ii01, ii00)) + + mI04( + mI01(ii00), + mI02(ii00, ii01), + mI03(ii00, ii01, ii00), + mI04(ii00, ii01, ii00, ii03)) + + if (y262) { + + mI05( + mI01(ii00), + mI02(ii00, ii01), + mI03(ii00, ii01, ii00), + mI04(ii00, ii01, ii00, ii03), + mI05(ii00, ii01, ii00, ii03, ii00)) + + mI06( + mI01(ii00), + mI02(ii00, ii01), + mI03(ii00, ii01, ii00), + mI04(ii00, ii01, ii00, ii03), + mI05(ii00, ii01, ii00, ii03, ii00), + mI06(ii00, ii01, ii00, ii03, ii00, ii05)) + mI07( + mI01(ii00), + mI02(ii00, ii01), + mI03(ii00, ii01, ii00), + mI04(ii00, ii01, ii00, ii03), + mI05(ii00, ii01, ii00, ii03, ii00), + mI06(ii00, ii01, ii00, ii03, ii00, ii05), + mI07(ii00, ii01, ii00, ii03, ii00, ii05, ii00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * String + */ + Name(ss00, "v") + Name(ss01, "v") + Name(ss03, "v") + Name(ss05, "v") + + Store(2, cmd0) + Store(s000, ss00) + + + + + /* + * Modification 0: + */ + + mI01(ss00) + mI02(ss00, ss00) + mI03(ss00, ss00, ss00) + mI04(ss00, ss00, ss00, ss00) + mI05(ss00, ss00, ss00, ss00, ss00) + mI06(ss00, ss00, ss00, ss00, ss00, ss00) + mI07(ss00, ss00, ss00, ss00, ss00, ss00, ss00) + + mI01( + mI01(ss00)) + + mI02( + mI01(ss00), + mI02(ss00, ss00)) + + mI03( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00)) + + mI04( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00), + mI04(ss00, ss00, ss00, ss00)) + + if (y262) { + + mI05( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00), + mI04(ss00, ss00, ss00, ss00), + mI05(ss00, ss00, ss00, ss00, ss00)) + + mI06( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00), + mI04(ss00, ss00, ss00, ss00), + mI05(ss00, ss00, ss00, ss00, ss00), + mI06(ss00, ss00, ss00, ss00, ss00, ss00)) + mI07( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00), + mI04(ss00, ss00, ss00, ss00), + mI05(ss00, ss00, ss00, ss00, ss00), + mI06(ss00, ss00, ss00, ss00, ss00, ss00), + mI07(ss00, ss00, ss00, ss00, ss00, ss00, ss00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(ss00, Local1) + Store(ss00, Local3) + Store(ss00, Local5) + + mI01(ss00) + mI02(ss00, Local1) + mI03(ss00, Local1, ss00) + mI04(ss00, Local1, ss00, Local3) + mI05(ss00, Local1, ss00, Local3, ss00) + mI06(ss00, Local1, ss00, Local3, ss00, Local5) + mI07(ss00, Local1, ss00, Local3, ss00, Local5, ss00) + + mI01( + mI01(ss00)) + + mI02( + mI01(ss00), + mI02(ss00, Local1)) + + mI03( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00)) + + mI04( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00), + mI04(ss00, Local1, ss00, Local3)) + + if (y262) { + + mI05( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00), + mI04(ss00, Local1, ss00, Local3), + mI05(ss00, Local1, ss00, Local3, ss00)) + + mI06( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00), + mI04(ss00, Local1, ss00, Local3), + mI05(ss00, Local1, ss00, Local3, ss00), + mI06(ss00, Local1, ss00, Local3, ss00, Local5)) + mI07( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00), + mI04(ss00, Local1, ss00, Local3), + mI05(ss00, Local1, ss00, Local3, ss00), + mI06(ss00, Local1, ss00, Local3, ss00, Local5), + mI07(ss00, Local1, ss00, Local3, ss00, Local5, ss00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (effectively local) + */ + + Store(ss00, Arg1) + Store(ss00, Arg3) + Store(ss00, Arg5) + + mI01(ss00) + mI02(ss00, Arg1) + mI03(ss00, Arg1, ss00) + mI04(ss00, Arg1, ss00, Arg3) + mI05(ss00, Arg1, ss00, Arg3, ss00) + mI06(ss00, Arg1, ss00, Arg3, ss00, Arg5) + mI07(ss00, Arg1, ss00, Arg3, ss00, Arg5, ss00) + + mI01( + mI01(ss00)) + + mI02( + mI01(ss00), + mI02(ss00, Arg1)) + + mI03( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00)) + + mI04( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00), + mI04(ss00, Arg1, ss00, Arg3)) + + if (y262) { + + mI05( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00), + mI04(ss00, Arg1, ss00, Arg3), + mI05(ss00, Arg1, ss00, Arg3, ss00)) + + mI06( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00), + mI04(ss00, Arg1, ss00, Arg3), + mI05(ss00, Arg1, ss00, Arg3, ss00), + mI06(ss00, Arg1, ss00, Arg3, ss00, Arg5)) + mI07( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00), + mI04(ss00, Arg1, ss00, Arg3), + mI05(ss00, Arg1, ss00, Arg3, ss00), + mI06(ss00, Arg1, ss00, Arg3, ss00, Arg5), + mI07(ss00, Arg1, ss00, Arg3, ss00, Arg5, ss00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 3: + * + * Some params are intermediately stored to Named + */ + + Store(ss00, ss01) + Store(ss00, ss03) + Store(ss00, ss05) + + mI01(ss00) + mI02(ss00, ss01) + mI03(ss00, ss01, ss00) + mI04(ss00, ss01, ss00, ss03) + mI05(ss00, ss01, ss00, ss03, ss00) + mI06(ss00, ss01, ss00, ss03, ss00, ss05) + mI07(ss00, ss01, ss00, ss03, ss00, ss05, ss00) + + mI01( + mI01(ss00)) + + mI02( + mI01(ss00), + mI02(ss00, ss01)) + + mI03( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00)) + + mI04( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00), + mI04(ss00, ss01, ss00, ss03)) + + if (y262) { + + mI05( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00), + mI04(ss00, ss01, ss00, ss03), + mI05(ss00, ss01, ss00, ss03, ss00)) + + mI06( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00), + mI04(ss00, ss01, ss00, ss03), + mI05(ss00, ss01, ss00, ss03, ss00), + mI06(ss00, ss01, ss00, ss03, ss00, ss05)) + mI07( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00), + mI04(ss00, ss01, ss00, ss03), + mI05(ss00, ss01, ss00, ss03, ss00), + mI06(ss00, ss01, ss00, ss03, ss00, ss05), + mI07(ss00, ss01, ss00, ss03, ss00, ss05, ss00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * String (applicable to Implicit Conversion Rules) + */ + Store(3, cmd0) + Store(s001, ss00) + + + + + /* + * Modification 0: + */ + + mI01(ss00) + mI02(ss00, ss00) + mI03(ss00, ss00, ss00) + mI04(ss00, ss00, ss00, ss00) + mI05(ss00, ss00, ss00, ss00, ss00) + mI06(ss00, ss00, ss00, ss00, ss00, ss00) + mI07(ss00, ss00, ss00, ss00, ss00, ss00, ss00) + + mI01( + mI01(ss00)) + + mI02( + mI01(ss00), + mI02(ss00, ss00)) + + mI03( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00)) + + mI04( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00), + mI04(ss00, ss00, ss00, ss00)) + + if (y262) { + + mI05( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00), + mI04(ss00, ss00, ss00, ss00), + mI05(ss00, ss00, ss00, ss00, ss00)) + + mI06( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00), + mI04(ss00, ss00, ss00, ss00), + mI05(ss00, ss00, ss00, ss00, ss00), + mI06(ss00, ss00, ss00, ss00, ss00, ss00)) + mI07( + mI01(ss00), + mI02(ss00, ss00), + mI03(ss00, ss00, ss00), + mI04(ss00, ss00, ss00, ss00), + mI05(ss00, ss00, ss00, ss00, ss00), + mI06(ss00, ss00, ss00, ss00, ss00, ss00), + mI07(ss00, ss00, ss00, ss00, ss00, ss00, ss00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(ss00, Local1) + Store(ss00, Local3) + Store(ss00, Local5) + + mI01(ss00) + mI02(ss00, Local1) + mI03(ss00, Local1, ss00) + mI04(ss00, Local1, ss00, Local3) + mI05(ss00, Local1, ss00, Local3, ss00) + mI06(ss00, Local1, ss00, Local3, ss00, Local5) + mI07(ss00, Local1, ss00, Local3, ss00, Local5, ss00) + + mI01( + mI01(ss00)) + + mI02( + mI01(ss00), + mI02(ss00, Local1)) + + mI03( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00)) + + mI04( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00), + mI04(ss00, Local1, ss00, Local3)) + + if (y262) { + + mI05( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00), + mI04(ss00, Local1, ss00, Local3), + mI05(ss00, Local1, ss00, Local3, ss00)) + + mI06( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00), + mI04(ss00, Local1, ss00, Local3), + mI05(ss00, Local1, ss00, Local3, ss00), + mI06(ss00, Local1, ss00, Local3, ss00, Local5)) + mI07( + mI01(ss00), + mI02(ss00, Local1), + mI03(ss00, Local1, ss00), + mI04(ss00, Local1, ss00, Local3), + mI05(ss00, Local1, ss00, Local3, ss00), + mI06(ss00, Local1, ss00, Local3, ss00, Local5), + mI07(ss00, Local1, ss00, Local3, ss00, Local5, ss00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (effectively local) + */ + + Store(ss00, Arg1) + Store(ss00, Arg3) + Store(ss00, Arg5) + + mI01(ss00) + mI02(ss00, Arg1) + mI03(ss00, Arg1, ss00) + mI04(ss00, Arg1, ss00, Arg3) + mI05(ss00, Arg1, ss00, Arg3, ss00) + mI06(ss00, Arg1, ss00, Arg3, ss00, Arg5) + mI07(ss00, Arg1, ss00, Arg3, ss00, Arg5, ss00) + + mI01( + mI01(ss00)) + + mI02( + mI01(ss00), + mI02(ss00, Arg1)) + + mI03( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00)) + + mI04( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00), + mI04(ss00, Arg1, ss00, Arg3)) + + if (y262) { + + mI05( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00), + mI04(ss00, Arg1, ss00, Arg3), + mI05(ss00, Arg1, ss00, Arg3, ss00)) + + mI06( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00), + mI04(ss00, Arg1, ss00, Arg3), + mI05(ss00, Arg1, ss00, Arg3, ss00), + mI06(ss00, Arg1, ss00, Arg3, ss00, Arg5)) + mI07( + mI01(ss00), + mI02(ss00, Arg1), + mI03(ss00, Arg1, ss00), + mI04(ss00, Arg1, ss00, Arg3), + mI05(ss00, Arg1, ss00, Arg3, ss00), + mI06(ss00, Arg1, ss00, Arg3, ss00, Arg5), + mI07(ss00, Arg1, ss00, Arg3, ss00, Arg5, ss00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 3: + * + * Some params are intermediately stored to Named + */ + + Store(ss00, ss01) + Store(ss00, ss03) + Store(ss00, ss05) + + mI01(ss00) + mI02(ss00, ss01) + mI03(ss00, ss01, ss00) + mI04(ss00, ss01, ss00, ss03) + mI05(ss00, ss01, ss00, ss03, ss00) + mI06(ss00, ss01, ss00, ss03, ss00, ss05) + mI07(ss00, ss01, ss00, ss03, ss00, ss05, ss00) + + mI01( + mI01(ss00)) + + mI02( + mI01(ss00), + mI02(ss00, ss01)) + + mI03( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00)) + + mI04( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00), + mI04(ss00, ss01, ss00, ss03)) + + if (y262) { + + mI05( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00), + mI04(ss00, ss01, ss00, ss03), + mI05(ss00, ss01, ss00, ss03, ss00)) + + mI06( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00), + mI04(ss00, ss01, ss00, ss03), + mI05(ss00, ss01, ss00, ss03, ss00), + mI06(ss00, ss01, ss00, ss03, ss00, ss05)) + mI07( + mI01(ss00), + mI02(ss00, ss01), + mI03(ss00, ss01, ss00), + mI04(ss00, ss01, ss00, ss03), + mI05(ss00, ss01, ss00, ss03, ss00), + mI06(ss00, ss01, ss00, ss03, ss00, ss05), + mI07(ss00, ss01, ss00, ss03, ss00, ss05, ss00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Buffer + */ + Name(bb00, Buffer(5) {}) + Name(bb01, Buffer(5) {}) + Name(bb03, Buffer(5) {}) + Name(bb05, Buffer(5) {}) + + Store(4, cmd0) + Store(b000, bb00) + + + + + /* + * Modification 0: + */ + + mI01(bb00) + mI02(bb00, bb00) + mI03(bb00, bb00, bb00) + mI04(bb00, bb00, bb00, bb00) + mI05(bb00, bb00, bb00, bb00, bb00) + mI06(bb00, bb00, bb00, bb00, bb00, bb00) + mI07(bb00, bb00, bb00, bb00, bb00, bb00, bb00) + + mI01( + mI01(bb00)) + + mI02( + mI01(bb00), + mI02(bb00, bb00)) + + mI03( + mI01(bb00), + mI02(bb00, bb00), + mI03(bb00, bb00, bb00)) + + mI04( + mI01(bb00), + mI02(bb00, bb00), + mI03(bb00, bb00, bb00), + mI04(bb00, bb00, bb00, bb00)) + + if (y262) { + + mI05( + mI01(bb00), + mI02(bb00, bb00), + mI03(bb00, bb00, bb00), + mI04(bb00, bb00, bb00, bb00), + mI05(bb00, bb00, bb00, bb00, bb00)) + + mI06( + mI01(bb00), + mI02(bb00, bb00), + mI03(bb00, bb00, bb00), + mI04(bb00, bb00, bb00, bb00), + mI05(bb00, bb00, bb00, bb00, bb00), + mI06(bb00, bb00, bb00, bb00, bb00, bb00)) + mI07( + mI01(bb00), + mI02(bb00, bb00), + mI03(bb00, bb00, bb00), + mI04(bb00, bb00, bb00, bb00), + mI05(bb00, bb00, bb00, bb00, bb00), + mI06(bb00, bb00, bb00, bb00, bb00, bb00), + mI07(bb00, bb00, bb00, bb00, bb00, bb00, bb00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(bb00, Local1) + Store(bb00, Local3) + Store(bb00, Local5) + + mI01(bb00) + mI02(bb00, Local1) + mI03(bb00, Local1, bb00) + mI04(bb00, Local1, bb00, Local3) + mI05(bb00, Local1, bb00, Local3, bb00) + mI06(bb00, Local1, bb00, Local3, bb00, Local5) + mI07(bb00, Local1, bb00, Local3, bb00, Local5, bb00) + + mI01( + mI01(bb00)) + + mI02( + mI01(bb00), + mI02(bb00, Local1)) + + mI03( + mI01(bb00), + mI02(bb00, Local1), + mI03(bb00, Local1, bb00)) + + mI04( + mI01(bb00), + mI02(bb00, Local1), + mI03(bb00, Local1, bb00), + mI04(bb00, Local1, bb00, Local3)) + + if (y262) { + + mI05( + mI01(bb00), + mI02(bb00, Local1), + mI03(bb00, Local1, bb00), + mI04(bb00, Local1, bb00, Local3), + mI05(bb00, Local1, bb00, Local3, bb00)) + + mI06( + mI01(bb00), + mI02(bb00, Local1), + mI03(bb00, Local1, bb00), + mI04(bb00, Local1, bb00, Local3), + mI05(bb00, Local1, bb00, Local3, bb00), + mI06(bb00, Local1, bb00, Local3, bb00, Local5)) + mI07( + mI01(bb00), + mI02(bb00, Local1), + mI03(bb00, Local1, bb00), + mI04(bb00, Local1, bb00, Local3), + mI05(bb00, Local1, bb00, Local3, bb00), + mI06(bb00, Local1, bb00, Local3, bb00, Local5), + mI07(bb00, Local1, bb00, Local3, bb00, Local5, bb00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (effectively local) + */ + + Store(bb00, Arg1) + Store(bb00, Arg3) + Store(bb00, Arg5) + + mI01(bb00) + mI02(bb00, Arg1) + mI03(bb00, Arg1, bb00) + mI04(bb00, Arg1, bb00, Arg3) + mI05(bb00, Arg1, bb00, Arg3, bb00) + mI06(bb00, Arg1, bb00, Arg3, bb00, Arg5) + mI07(bb00, Arg1, bb00, Arg3, bb00, Arg5, bb00) + + mI01( + mI01(bb00)) + + mI02( + mI01(bb00), + mI02(bb00, Arg1)) + + mI03( + mI01(bb00), + mI02(bb00, Arg1), + mI03(bb00, Arg1, bb00)) + + mI04( + mI01(bb00), + mI02(bb00, Arg1), + mI03(bb00, Arg1, bb00), + mI04(bb00, Arg1, bb00, Arg3)) + + if (y262) { + + mI05( + mI01(bb00), + mI02(bb00, Arg1), + mI03(bb00, Arg1, bb00), + mI04(bb00, Arg1, bb00, Arg3), + mI05(bb00, Arg1, bb00, Arg3, bb00)) + + mI06( + mI01(bb00), + mI02(bb00, Arg1), + mI03(bb00, Arg1, bb00), + mI04(bb00, Arg1, bb00, Arg3), + mI05(bb00, Arg1, bb00, Arg3, bb00), + mI06(bb00, Arg1, bb00, Arg3, bb00, Arg5)) + mI07( + mI01(bb00), + mI02(bb00, Arg1), + mI03(bb00, Arg1, bb00), + mI04(bb00, Arg1, bb00, Arg3), + mI05(bb00, Arg1, bb00, Arg3, bb00), + mI06(bb00, Arg1, bb00, Arg3, bb00, Arg5), + mI07(bb00, Arg1, bb00, Arg3, bb00, Arg5, bb00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 3: + * + * Some params are intermediately stored to Named + */ + + Store(bb00, bb01) + Store(bb00, bb03) + Store(bb00, bb05) + + mI01(bb00) + mI02(bb00, bb01) + mI03(bb00, bb01, bb00) + mI04(bb00, bb01, bb00, bb03) + mI05(bb00, bb01, bb00, bb03, bb00) + mI06(bb00, bb01, bb00, bb03, bb00, bb05) + mI07(bb00, bb01, bb00, bb03, bb00, bb05, bb00) + + mI01( + mI01(bb00)) + + mI02( + mI01(bb00), + mI02(bb00, bb01)) + + mI03( + mI01(bb00), + mI02(bb00, bb01), + mI03(bb00, bb01, bb00)) + + mI04( + mI01(bb00), + mI02(bb00, bb01), + mI03(bb00, bb01, bb00), + mI04(bb00, bb01, bb00, bb03)) + + if (y262) { + + mI05( + mI01(bb00), + mI02(bb00, bb01), + mI03(bb00, bb01, bb00), + mI04(bb00, bb01, bb00, bb03), + mI05(bb00, bb01, bb00, bb03, bb00)) + + mI06( + mI01(bb00), + mI02(bb00, bb01), + mI03(bb00, bb01, bb00), + mI04(bb00, bb01, bb00, bb03), + mI05(bb00, bb01, bb00, bb03, bb00), + mI06(bb00, bb01, bb00, bb03, bb00, bb05)) + mI07( + mI01(bb00), + mI02(bb00, bb01), + mI03(bb00, bb01, bb00), + mI04(bb00, bb01, bb00, bb03), + mI05(bb00, bb01, bb00, bb03, bb00), + mI06(bb00, bb01, bb00, bb03, bb00, bb05), + mI07(bb00, bb01, bb00, bb03, bb00, bb05, bb00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Package + */ + Name(pp00, Package() {0xabcd0901, 0xabcd0902, 0xabcd0903}) + Name(pp01, Package(3) {}) + Name(pp03, Package(3) {}) + Name(pp05, Package(3) {}) + + Store(5, cmd0) + if (chk0) { + Store(p000, pp00) + } + + + + + /* + * Modification 0: + */ + + mI01(pp00) + mI02(pp00, pp00) + mI03(pp00, pp00, pp00) + mI04(pp00, pp00, pp00, pp00) + mI05(pp00, pp00, pp00, pp00, pp00) + mI06(pp00, pp00, pp00, pp00, pp00, pp00) + mI07(pp00, pp00, pp00, pp00, pp00, pp00, pp00) + + mI01( + mI01(pp00)) + + mI02( + mI01(pp00), + mI02(pp00, pp00)) + + mI03( + mI01(pp00), + mI02(pp00, pp00), + mI03(pp00, pp00, pp00)) + + mI04( + mI01(pp00), + mI02(pp00, pp00), + mI03(pp00, pp00, pp00), + mI04(pp00, pp00, pp00, pp00)) + + if (y262) { + + mI05( + mI01(pp00), + mI02(pp00, pp00), + mI03(pp00, pp00, pp00), + mI04(pp00, pp00, pp00, pp00), + mI05(pp00, pp00, pp00, pp00, pp00)) + + mI06( + mI01(pp00), + mI02(pp00, pp00), + mI03(pp00, pp00, pp00), + mI04(pp00, pp00, pp00, pp00), + mI05(pp00, pp00, pp00, pp00, pp00), + mI06(pp00, pp00, pp00, pp00, pp00, pp00)) + mI07( + mI01(pp00), + mI02(pp00, pp00), + mI03(pp00, pp00, pp00), + mI04(pp00, pp00, pp00, pp00), + mI05(pp00, pp00, pp00, pp00, pp00), + mI06(pp00, pp00, pp00, pp00, pp00, pp00), + mI07(pp00, pp00, pp00, pp00, pp00, pp00, pp00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(pp00, Local1) + Store(pp00, Local3) + Store(pp00, Local5) + + mI01(pp00) + mI02(pp00, Local1) + mI03(pp00, Local1, pp00) + mI04(pp00, Local1, pp00, Local3) + mI05(pp00, Local1, pp00, Local3, pp00) + mI06(pp00, Local1, pp00, Local3, pp00, Local5) + mI07(pp00, Local1, pp00, Local3, pp00, Local5, pp00) + + mI01( + mI01(pp00)) + + mI02( + mI01(pp00), + mI02(pp00, Local1)) + + mI03( + mI01(pp00), + mI02(pp00, Local1), + mI03(pp00, Local1, pp00)) + + mI04( + mI01(pp00), + mI02(pp00, Local1), + mI03(pp00, Local1, pp00), + mI04(pp00, Local1, pp00, Local3)) + + if (y262) { + + mI05( + mI01(pp00), + mI02(pp00, Local1), + mI03(pp00, Local1, pp00), + mI04(pp00, Local1, pp00, Local3), + mI05(pp00, Local1, pp00, Local3, pp00)) + + mI06( + mI01(pp00), + mI02(pp00, Local1), + mI03(pp00, Local1, pp00), + mI04(pp00, Local1, pp00, Local3), + mI05(pp00, Local1, pp00, Local3, pp00), + mI06(pp00, Local1, pp00, Local3, pp00, Local5)) + mI07( + mI01(pp00), + mI02(pp00, Local1), + mI03(pp00, Local1, pp00), + mI04(pp00, Local1, pp00, Local3), + mI05(pp00, Local1, pp00, Local3, pp00), + mI06(pp00, Local1, pp00, Local3, pp00, Local5), + mI07(pp00, Local1, pp00, Local3, pp00, Local5, pp00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (effectively local) + */ + + Store(pp00, Arg1) + Store(pp00, Arg3) + Store(pp00, Arg5) + + mI01(pp00) + mI02(pp00, Arg1) + mI03(pp00, Arg1, pp00) + mI04(pp00, Arg1, pp00, Arg3) + mI05(pp00, Arg1, pp00, Arg3, pp00) + mI06(pp00, Arg1, pp00, Arg3, pp00, Arg5) + mI07(pp00, Arg1, pp00, Arg3, pp00, Arg5, pp00) + + mI01( + mI01(pp00)) + + mI02( + mI01(pp00), + mI02(pp00, Arg1)) + + mI03( + mI01(pp00), + mI02(pp00, Arg1), + mI03(pp00, Arg1, pp00)) + + mI04( + mI01(pp00), + mI02(pp00, Arg1), + mI03(pp00, Arg1, pp00), + mI04(pp00, Arg1, pp00, Arg3)) + + if (y262) { + + mI05( + mI01(pp00), + mI02(pp00, Arg1), + mI03(pp00, Arg1, pp00), + mI04(pp00, Arg1, pp00, Arg3), + mI05(pp00, Arg1, pp00, Arg3, pp00)) + + mI06( + mI01(pp00), + mI02(pp00, Arg1), + mI03(pp00, Arg1, pp00), + mI04(pp00, Arg1, pp00, Arg3), + mI05(pp00, Arg1, pp00, Arg3, pp00), + mI06(pp00, Arg1, pp00, Arg3, pp00, Arg5)) + mI07( + mI01(pp00), + mI02(pp00, Arg1), + mI03(pp00, Arg1, pp00), + mI04(pp00, Arg1, pp00, Arg3), + mI05(pp00, Arg1, pp00, Arg3, pp00), + mI06(pp00, Arg1, pp00, Arg3, pp00, Arg5), + mI07(pp00, Arg1, pp00, Arg3, pp00, Arg5, pp00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + if (chk0) { + + /* + * Modification 3: + * + * Some params are intermediately stored to Named + */ + + Store(pp00, pp01) + Store(pp00, pp03) + Store(pp00, pp05) + + mI01(pp00) + mI02(pp00, pp01) + + mI03(pp00, pp01, pp00) + mI04(pp00, pp01, pp00, pp03) + mI05(pp00, pp01, pp00, pp03, pp00) + mI06(pp00, pp01, pp00, pp03, pp00, pp05) + mI07(pp00, pp01, pp00, pp03, pp00, pp05, pp00) + + mI01( + mI01(pp00)) + + mI02( + mI01(pp00), + mI02(pp00, pp01)) + + mI03( + mI01(pp00), + mI02(pp00, pp01), + mI03(pp00, pp01, pp00)) + + mI04( + mI01(pp00), + mI02(pp00, pp01), + mI03(pp00, pp01, pp00), + mI04(pp00, pp01, pp00, pp03)) + + if (y262) { + + mI05( + mI01(pp00), + mI02(pp00, pp01), + mI03(pp00, pp01, pp00), + mI04(pp00, pp01, pp00, pp03), + mI05(pp00, pp01, pp00, pp03, pp00)) + + mI06( + mI01(pp00), + mI02(pp00, pp01), + mI03(pp00, pp01, pp00), + mI04(pp00, pp01, pp00, pp03), + mI05(pp00, pp01, pp00, pp03, pp00), + mI06(pp00, pp01, pp00, pp03, pp00, pp05)) + mI07( + mI01(pp00), + mI02(pp00, pp01), + mI03(pp00, pp01, pp00), + mI04(pp00, pp01, pp00, pp03), + mI05(pp00, pp01, pp00, pp03, pp00), + mI06(pp00, pp01, pp00, pp03, pp00, pp05), + mI07(pp00, pp01, pp00, pp03, pp00, pp05, pp00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + } // if (chk0) +} + +Method(in41, 7) +{ + Name(ts, "in41") + + Event(e000) + Mutex(mx00, 0) + Method(mmm0) { + Name(im00, 0xabcd0004) + Name(sm00, "qwertyui") + // Return ( "qwertyui" ) + } + Method(mmm1) { + Name(im00, 0xabcd0004) + Name(sm00, "qwertyui") + // Return ( 0xabcd0004 ) + Return ( "qwertyui" ) + } + Device(d000) { Name(id00, 0xabcd0005) } + ThermalZone(tz00) { Name(itz0, 0xabcd0006) } + Processor(pr00, 0, 0xFFFFFFFF, 0) { Name(ipr0, 0xabcd0007) } + PowerResource(pw00, 1, 0) { Name(ipw0, 0xabcd0008) } + OperationRegion(r000, SystemMemory, 0x000, 0x080) + + Name(b001, Buffer() {0xa0,0xa1,0xa2,0xa3,0xa4}) + CreateField(b001, 0, 32, bf00) + + OperationRegion(r001, SystemMemory, 0x080, 0x080) + Field(r001, ByteAcc, NoLock, Preserve) {f000,32, f001,32, f002,32, f003,32} + BankField(r001, f001, 0, ByteAcc, NoLock, Preserve) {bnk0,32} + IndexField(f002, f003, ByteAcc, NoLock, Preserve) {if00,32, if01,32} + + + + + /* + * Field + */ + OperationRegion(r002, SystemMemory, 0x100, 0x080) + Field(r002, ByteAcc, NoLock, Preserve) {ff00,32, ff01,32, ff03,32, ff05,32} + + Store(6, cmd0) + Store(0xabcd0a00, f000) + Store(f000, ff00) + + + + + /* + * Modification 0: + */ + + mI01(ff00) + mI02(ff00, ff00) + mI03(ff00, ff00, ff00) + mI04(ff00, ff00, ff00, ff00) + mI05(ff00, ff00, ff00, ff00, ff00) + mI06(ff00, ff00, ff00, ff00, ff00, ff00) + mI07(ff00, ff00, ff00, ff00, ff00, ff00, ff00) + + mI01( + mI01(ff00)) + + mI02( + mI01(ff00), + mI02(ff00, ff00)) + + mI03( + mI01(ff00), + mI02(ff00, ff00), + mI03(ff00, ff00, ff00)) + + mI04( + mI01(ff00), + mI02(ff00, ff00), + mI03(ff00, ff00, ff00), + mI04(ff00, ff00, ff00, ff00)) + + if (y262) { + + mI05( + mI01(ff00), + mI02(ff00, ff00), + mI03(ff00, ff00, ff00), + mI04(ff00, ff00, ff00, ff00), + mI05(ff00, ff00, ff00, ff00, ff00)) + + mI06( + mI01(ff00), + mI02(ff00, ff00), + mI03(ff00, ff00, ff00), + mI04(ff00, ff00, ff00, ff00), + mI05(ff00, ff00, ff00, ff00, ff00), + mI06(ff00, ff00, ff00, ff00, ff00, ff00)) + + // if (chk0) { + // qqq: This breaks Field: + + mI07( + mI01(ff00), + mI02(ff00, ff00), + mI03(ff00, ff00, ff00), + mI04(ff00, ff00, ff00, ff00), + mI05(ff00, ff00, ff00, ff00, ff00), + mI06(ff00, ff00, ff00, ff00, ff00, ff00), + mI07(ff00, ff00, ff00, ff00, ff00, ff00, ff00)) + // } + + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(ff00, Local1) + Store(ff00, Local3) + Store(ff00, Local5) + + mI01(ff00) + mI02(ff00, Local1) + mI03(ff00, Local1, ff00) + mI04(ff00, Local1, ff00, Local3) + mI05(ff00, Local1, ff00, Local3, ff00) + mI06(ff00, Local1, ff00, Local3, ff00, Local5) + mI07(ff00, Local1, ff00, Local3, ff00, Local5, ff00) + + mI01( + mI01(ff00)) + + mI02( + mI01(ff00), + mI02(ff00, Local1)) + + mI03( + mI01(ff00), + mI02(ff00, Local1), + mI03(ff00, Local1, ff00)) + + mI04( + mI01(ff00), + mI02(ff00, Local1), + mI03(ff00, Local1, ff00), + mI04(ff00, Local1, ff00, Local3)) + + if (y262) { + + mI05( + mI01(ff00), + mI02(ff00, Local1), + mI03(ff00, Local1, ff00), + mI04(ff00, Local1, ff00, Local3), + mI05(ff00, Local1, ff00, Local3, ff00)) + + mI06( + mI01(ff00), + mI02(ff00, Local1), + mI03(ff00, Local1, ff00), + mI04(ff00, Local1, ff00, Local3), + mI05(ff00, Local1, ff00, Local3, ff00), + mI06(ff00, Local1, ff00, Local3, ff00, Local5)) + + // if (chk0) { // qqq: This breaks Field: + mI07( + mI01(ff00), + mI02(ff00, Local1), + mI03(ff00, Local1, ff00), + mI04(ff00, Local1, ff00, Local3), + mI05(ff00, Local1, ff00, Local3, ff00), + mI06(ff00, Local1, ff00, Local3, ff00, Local5), + mI07(ff00, Local1, ff00, Local3, ff00, Local5, ff00)) + // } + + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (effectively local) + */ + + Store(ff00, Arg1) + Store(ff00, Arg3) + Store(ff00, Arg5) + + mI01(ff00) + mI02(ff00, Arg1) + mI03(ff00, Arg1, ff00) + mI04(ff00, Arg1, ff00, Arg3) + mI05(ff00, Arg1, ff00, Arg3, ff00) + mI06(ff00, Arg1, ff00, Arg3, ff00, Arg5) + mI07(ff00, Arg1, ff00, Arg3, ff00, Arg5, ff00) + + mI01( + mI01(ff00)) + + mI02( + mI01(ff00), + mI02(ff00, Arg1)) + + mI03( + mI01(ff00), + mI02(ff00, Arg1), + mI03(ff00, Arg1, ff00)) + + mI04( + mI01(ff00), + mI02(ff00, Arg1), + mI03(ff00, Arg1, ff00), + mI04(ff00, Arg1, ff00, Arg3)) + + if (y262) { + + mI05( + mI01(ff00), + mI02(ff00, Arg1), + mI03(ff00, Arg1, ff00), + mI04(ff00, Arg1, ff00, Arg3), + mI05(ff00, Arg1, ff00, Arg3, ff00)) + + mI06( + mI01(ff00), + mI02(ff00, Arg1), + mI03(ff00, Arg1, ff00), + mI04(ff00, Arg1, ff00, Arg3), + mI05(ff00, Arg1, ff00, Arg3, ff00), + mI06(ff00, Arg1, ff00, Arg3, ff00, Arg5)) + + // if (chk0) { // qqq: This breaks Field: + mI07( + mI01(ff00), + mI02(ff00, Arg1), + mI03(ff00, Arg1, ff00), + mI04(ff00, Arg1, ff00, Arg3), + mI05(ff00, Arg1, ff00, Arg3, ff00), + mI06(ff00, Arg1, ff00, Arg3, ff00, Arg5), + mI07(ff00, Arg1, ff00, Arg3, ff00, Arg5, ff00)) + // } + + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 3: + * + * Some params are intermediately stored to Named + */ + + Store(ff00, ff01) + Store(ff00, ff03) + Store(ff00, ff05) + + mI01(ff00) + mI02(ff00, ff01) + mI03(ff00, ff01, ff00) + mI04(ff00, ff01, ff00, ff03) + mI05(ff00, ff01, ff00, ff03, ff00) + mI06(ff00, ff01, ff00, ff03, ff00, ff05) + mI07(ff00, ff01, ff00, ff03, ff00, ff05, ff00) + + mI01( + mI01(ff00)) + + mI02( + mI01(ff00), + mI02(ff00, ff01)) + + mI03( + mI01(ff00), + mI02(ff00, ff01), + mI03(ff00, ff01, ff00)) + + mI04( + mI01(ff00), + mI02(ff00, ff01), + mI03(ff00, ff01, ff00), + mI04(ff00, ff01, ff00, ff03)) + + if (y262) { + + mI05( + mI01(ff00), + mI02(ff00, ff01), + mI03(ff00, ff01, ff00), + mI04(ff00, ff01, ff00, ff03), + mI05(ff00, ff01, ff00, ff03, ff00)) + + mI06( + mI01(ff00), + mI02(ff00, ff01), + mI03(ff00, ff01, ff00), + mI04(ff00, ff01, ff00, ff03), + mI05(ff00, ff01, ff00, ff03, ff00), + mI06(ff00, ff01, ff00, ff03, ff00, ff05)) + + // if (chk0) { // qqq: This breaks Field: + mI07( + mI01(ff00), + mI02(ff00, ff01), + mI03(ff00, ff01, ff00), + mI04(ff00, ff01, ff00, ff03), + mI05(ff00, ff01, ff00, ff03, ff00), + mI06(ff00, ff01, ff00, ff03, ff00, ff05), + mI07(ff00, ff01, ff00, ff03, ff00, ff05, ff00)) + // } + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Index Field + */ + OperationRegion(r003, SystemMemory, 0x180, 0x080) + Field(r003, ByteAcc, NoLock, Preserve) {f004,32, f005,32} + IndexField(f004, f005, ByteAcc, NoLock, Preserve) {if02,32} + + Store(14, cmd0) + Store(0xabcd0b04, if00) + Store(if00, if02) + + + + + /* + * Modification 0: + */ + + mI01(if02) + mI02(if02, if02) + mI03(if02, if02, if02) + mI04(if02, if02, if02, if02) + mI05(if02, if02, if02, if02, if02) + mI06(if02, if02, if02, if02, if02, if02) + mI07(if02, if02, if02, if02, if02, if02, if02) + + // if (chk0) { + + mI01( + mI01(if02)) + + mI02( + mI01(if02), + mI02(if02, if02)) + + mI03( + mI01(if02), + mI02(if02, if02), + mI03(if02, if02, if02)) + + mI04( + mI01(if02), + mI02(if02, if02), + mI03(if02, if02, if02), + mI04(if02, if02, if02, if02)) + + if (y262) { + + mI05( + mI01(if02), + mI02(if02, if02), + mI03(if02, if02, if02), + mI04(if02, if02, if02, if02), + mI05(if02, if02, if02, if02, if02)) + + mI06( + mI01(if02), + mI02(if02, if02), + mI03(if02, if02, if02), + mI04(if02, if02, if02, if02), + mI05(if02, if02, if02, if02, if02), + mI06(if02, if02, if02, if02, if02, if02)) + mI07( + mI01(if02), + mI02(if02, if02), + mI03(if02, if02, if02), + mI04(if02, if02, if02, if02), + mI05(if02, if02, if02, if02, if02), + mI06(if02, if02, if02, if02, if02, if02), + mI07(if02, if02, if02, if02, if02, if02, if02)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(if02, Local1) + Store(if02, Local3) + Store(if02, Local5) + + mI01(if02) + mI02(if02, Local1) + mI03(if02, Local1, if02) + mI04(if02, Local1, if02, Local3) + mI05(if02, Local1, if02, Local3, if02) + mI06(if02, Local1, if02, Local3, if02, Local5) + mI07(if02, Local1, if02, Local3, if02, Local5, if02) + + mI01( + mI01(if02)) + + mI02( + mI01(if02), + mI02(if02, Local1)) + + mI03( + mI01(if02), + mI02(if02, Local1), + mI03(if02, Local1, if02)) + + mI04( + mI01(if02), + mI02(if02, Local1), + mI03(if02, Local1, if02), + mI04(if02, Local1, if02, Local3)) + + if (y262) { + + mI05( + mI01(if02), + mI02(if02, Local1), + mI03(if02, Local1, if02), + mI04(if02, Local1, if02, Local3), + mI05(if02, Local1, if02, Local3, if02)) + + mI06( + mI01(if02), + mI02(if02, Local1), + mI03(if02, Local1, if02), + mI04(if02, Local1, if02, Local3), + mI05(if02, Local1, if02, Local3, if02), + mI06(if02, Local1, if02, Local3, if02, Local5)) + mI07( + mI01(if02), + mI02(if02, Local1), + mI03(if02, Local1, if02), + mI04(if02, Local1, if02, Local3), + mI05(if02, Local1, if02, Local3, if02), + mI06(if02, Local1, if02, Local3, if02, Local5), + mI07(if02, Local1, if02, Local3, if02, Local5, if02)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (effectively local) + */ + + Store(if02, Arg1) + Store(if02, Arg3) + Store(if02, Arg5) + + mI01(if02) + mI02(if02, Arg1) + mI03(if02, Arg1, if02) + mI04(if02, Arg1, if02, Arg3) + mI05(if02, Arg1, if02, Arg3, if02) + mI06(if02, Arg1, if02, Arg3, if02, Arg5) + mI07(if02, Arg1, if02, Arg3, if02, Arg5, if02) + + mI01( + mI01(if02)) + + mI02( + mI01(if02), + mI02(if02, Arg1)) + + mI03( + mI01(if02), + mI02(if02, Arg1), + mI03(if02, Arg1, if02)) + + mI04( + mI01(if02), + mI02(if02, Arg1), + mI03(if02, Arg1, if02), + mI04(if02, Arg1, if02, Arg3)) + + if (y262) { + + mI05( + mI01(if02), + mI02(if02, Arg1), + mI03(if02, Arg1, if02), + mI04(if02, Arg1, if02, Arg3), + mI05(if02, Arg1, if02, Arg3, if02)) + + mI06( + mI01(if02), + mI02(if02, Arg1), + mI03(if02, Arg1, if02), + mI04(if02, Arg1, if02, Arg3), + mI05(if02, Arg1, if02, Arg3, if02), + mI06(if02, Arg1, if02, Arg3, if02, Arg5)) + mI07( + mI01(if02), + mI02(if02, Arg1), + mI03(if02, Arg1, if02), + mI04(if02, Arg1, if02, Arg3), + mI05(if02, Arg1, if02, Arg3, if02), + mI06(if02, Arg1, if02, Arg3, if02, Arg5), + mI07(if02, Arg1, if02, Arg3, if02, Arg5, if02)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 3: + * + * Some params are intermediately stored to Named + */ + + Store(if02, ff01) + Store(if02, ff03) + Store(if02, ff05) + + mI01(if02) + mI02(if02, ff01) + mI03(if02, ff01, if02) + mI04(if02, ff01, if02, ff03) + mI05(if02, ff01, if02, ff03, if02) + mI06(if02, ff01, if02, ff03, if02, ff05) + mI07(if02, ff01, if02, ff03, if02, ff05, if02) + + mI01( + mI01(if02)) + + mI02( + mI01(if02), + mI02(if02, ff01)) + + mI03( + mI01(if02), + mI02(if02, ff01), + mI03(if02, ff01, if02)) + + mI04( + mI01(if02), + mI02(if02, ff01), + mI03(if02, ff01, if02), + mI04(if02, ff01, if02, ff03)) + + if (y262) { + + mI05( + mI01(if02), + mI02(if02, ff01), + mI03(if02, ff01, if02), + mI04(if02, ff01, if02, ff03), + mI05(if02, ff01, if02, ff03, if02)) + + mI06( + mI01(if02), + mI02(if02, ff01), + mI03(if02, ff01, if02), + mI04(if02, ff01, if02, ff03), + mI05(if02, ff01, if02, ff03, if02), + mI06(if02, ff01, if02, ff03, if02, ff05)) + mI07( + mI01(if02), + mI02(if02, ff01), + mI03(if02, ff01, if02), + mI04(if02, ff01, if02, ff03), + mI05(if02, ff01, if02, ff03, if02), + mI06(if02, ff01, if02, ff03, if02, ff05), + mI07(if02, ff01, if02, ff03, if02, ff05, if02)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) + + + + + /* + * Bank Field + */ + OperationRegion(r004, SystemMemory, 0x200, 0x080) + Field(r004, ByteAcc, NoLock, Preserve) {f006,32} + BankField(r004, f006, 0, ByteAcc, NoLock, Preserve) {bnk1,32} + + Store(15, cmd0) + Store(0xabcd0c07, bnk0) + Store(bnk0, bnk1) + + + + + /* + * Modification 0: + */ + + mI01(bnk1) + mI02(bnk1, bnk1) + mI03(bnk1, bnk1, bnk1) + mI04(bnk1, bnk1, bnk1, bnk1) + + // if (chk0) { + + mI05(bnk1, bnk1, bnk1, bnk1, bnk1) + mI06(bnk1, bnk1, bnk1, bnk1, bnk1, bnk1) + mI07(bnk1, bnk1, bnk1, bnk1, bnk1, bnk1, bnk1) + + mI01( + mI01(bnk1)) + + mI02( + mI01(bnk1), + mI02(bnk1, bnk1)) + + mI03( + mI01(bnk1), + mI02(bnk1, bnk1), + mI03(bnk1, bnk1, bnk1)) + + mI04( + mI01(bnk1), + mI02(bnk1, bnk1), + mI03(bnk1, bnk1, bnk1), + mI04(bnk1, bnk1, bnk1, bnk1)) + + if (y262) { + + mI05( + mI01(bnk1), + mI02(bnk1, bnk1), + mI03(bnk1, bnk1, bnk1), + mI04(bnk1, bnk1, bnk1, bnk1), + mI05(bnk1, bnk1, bnk1, bnk1, bnk1)) + + mI06( + mI01(bnk1), + mI02(bnk1, bnk1), + mI03(bnk1, bnk1, bnk1), + mI04(bnk1, bnk1, bnk1, bnk1), + mI05(bnk1, bnk1, bnk1, bnk1, bnk1), + mI06(bnk1, bnk1, bnk1, bnk1, bnk1, bnk1)) + mI07( + mI01(bnk1), + mI02(bnk1, bnk1), + mI03(bnk1, bnk1, bnk1), + mI04(bnk1, bnk1, bnk1, bnk1), + mI05(bnk1, bnk1, bnk1, bnk1, bnk1), + mI06(bnk1, bnk1, bnk1, bnk1, bnk1, bnk1), + mI07(bnk1, bnk1, bnk1, bnk1, bnk1, bnk1, bnk1)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) + + + + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(bnk1, Local1) + Store(bnk1, Local3) + Store(bnk1, Local5) + + mI01(bnk1) + mI02(bnk1, Local1) + mI03(bnk1, Local1, bnk1) + + // if (chk0) { + + mI04(bnk1, Local1, bnk1, Local3) + mI05(bnk1, Local1, bnk1, Local3, bnk1) + mI06(bnk1, Local1, bnk1, Local3, bnk1, Local5) + mI07(bnk1, Local1, bnk1, Local3, bnk1, Local5, bnk1) + + mI01( + mI01(bnk1)) + + mI02( + mI01(bnk1), + mI02(bnk1, Local1)) + + mI03( + mI01(bnk1), + mI02(bnk1, Local1), + mI03(bnk1, Local1, bnk1)) + + mI04( + mI01(bnk1), + mI02(bnk1, Local1), + mI03(bnk1, Local1, bnk1), + mI04(bnk1, Local1, bnk1, Local3)) + + if (y262) { + + mI05( + mI01(bnk1), + mI02(bnk1, Local1), + mI03(bnk1, Local1, bnk1), + mI04(bnk1, Local1, bnk1, Local3), + mI05(bnk1, Local1, bnk1, Local3, bnk1)) + + mI06( + mI01(bnk1), + mI02(bnk1, Local1), + mI03(bnk1, Local1, bnk1), + mI04(bnk1, Local1, bnk1, Local3), + mI05(bnk1, Local1, bnk1, Local3, bnk1), + mI06(bnk1, Local1, bnk1, Local3, bnk1, Local5)) + mI07( + mI01(bnk1), + mI02(bnk1, Local1), + mI03(bnk1, Local1, bnk1), + mI04(bnk1, Local1, bnk1, Local3), + mI05(bnk1, Local1, bnk1, Local3, bnk1), + mI06(bnk1, Local1, bnk1, Local3, bnk1, Local5), + mI07(bnk1, Local1, bnk1, Local3, bnk1, Local5, bnk1)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) { + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (effectively local) + */ + + Store(bnk1, Arg1) + Store(bnk1, Arg3) + Store(bnk1, Arg5) + + mI01(bnk1) + mI02(bnk1, Arg1) + mI03(bnk1, Arg1, bnk1) + mI04(bnk1, Arg1, bnk1, Arg3) + + // if (chk0) { + + mI05(bnk1, Arg1, bnk1, Arg3, bnk1) + mI06(bnk1, Arg1, bnk1, Arg3, bnk1, Arg5) + mI07(bnk1, Arg1, bnk1, Arg3, bnk1, Arg5, bnk1) + + mI01( + mI01(bnk1)) + + mI02( + mI01(bnk1), + mI02(bnk1, Arg1)) + + mI03( + mI01(bnk1), + mI02(bnk1, Arg1), + mI03(bnk1, Arg1, bnk1)) + + mI04( + mI01(bnk1), + mI02(bnk1, Arg1), + mI03(bnk1, Arg1, bnk1), + mI04(bnk1, Arg1, bnk1, Arg3)) + + if (y262) { + + mI05( + mI01(bnk1), + mI02(bnk1, Arg1), + mI03(bnk1, Arg1, bnk1), + mI04(bnk1, Arg1, bnk1, Arg3), + mI05(bnk1, Arg1, bnk1, Arg3, bnk1)) + + mI06( + mI01(bnk1), + mI02(bnk1, Arg1), + mI03(bnk1, Arg1, bnk1), + mI04(bnk1, Arg1, bnk1, Arg3), + mI05(bnk1, Arg1, bnk1, Arg3, bnk1), + mI06(bnk1, Arg1, bnk1, Arg3, bnk1, Arg5)) + mI07( + mI01(bnk1), + mI02(bnk1, Arg1), + mI03(bnk1, Arg1, bnk1), + mI04(bnk1, Arg1, bnk1, Arg3), + mI05(bnk1, Arg1, bnk1, Arg3, bnk1), + mI06(bnk1, Arg1, bnk1, Arg3, bnk1, Arg5), + mI07(bnk1, Arg1, bnk1, Arg3, bnk1, Arg5, bnk1)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) { + + + + + /* + * Modification 3: + * + * Some params are intermediately stored to Named + */ + + Store(bnk1, ff01) + Store(bnk1, ff03) + Store(bnk1, ff05) + + mI01(bnk1) + mI02(bnk1, ff01) + mI03(bnk1, ff01, bnk1) + mI04(bnk1, ff01, bnk1, ff03) + + // if (chk0) { + + mI05(bnk1, ff01, bnk1, ff03, bnk1) + mI06(bnk1, ff01, bnk1, ff03, bnk1, ff05) + mI07(bnk1, ff01, bnk1, ff03, bnk1, ff05, bnk1) + + mI01( + mI01(bnk1)) + + mI02( + mI01(bnk1), + mI02(bnk1, ff01)) + + mI03( + mI01(bnk1), + mI02(bnk1, ff01), + mI03(bnk1, ff01, bnk1)) + + mI04( + mI01(bnk1), + mI02(bnk1, ff01), + mI03(bnk1, ff01, bnk1), + mI04(bnk1, ff01, bnk1, ff03)) + + if (y262) { + + mI05( + mI01(bnk1), + mI02(bnk1, ff01), + mI03(bnk1, ff01, bnk1), + mI04(bnk1, ff01, bnk1, ff03), + mI05(bnk1, ff01, bnk1, ff03, bnk1)) + + mI06( + mI01(bnk1), + mI02(bnk1, ff01), + mI03(bnk1, ff01, bnk1), + mI04(bnk1, ff01, bnk1, ff03), + mI05(bnk1, ff01, bnk1, ff03, bnk1), + mI06(bnk1, ff01, bnk1, ff03, bnk1, ff05)) + mI07( + mI01(bnk1), + mI02(bnk1, ff01), + mI03(bnk1, ff01, bnk1), + mI04(bnk1, ff01, bnk1, ff03), + mI05(bnk1, ff01, bnk1, ff03, bnk1), + mI06(bnk1, ff01, bnk1, ff03, bnk1, ff05), + mI07(bnk1, ff01, bnk1, ff03, bnk1, ff05, bnk1)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) { + + + + + /* + * Buffer Field + */ + Name(b002, Buffer() {0xa0,0xa1,0xa2,0xa3,0xa4}) + CreateField(b002, 0, 32, bf01) + + Store(16, cmd0) + Store(0xabcd0d08, bf00) + Store(bf00, bf01) + + + + + /* + * Modification 0: + */ + + mI01(bf01) + mI02(bf01, bf01) + mI03(bf01, bf01, bf01) + mI04(bf01, bf01, bf01, bf01) + mI05(bf01, bf01, bf01, bf01, bf01) + mI06(bf01, bf01, bf01, bf01, bf01, bf01) + mI07(bf01, bf01, bf01, bf01, bf01, bf01, bf01) + + mI01( + mI01(bf01)) + + mI02( + mI01(bf01), + mI02(bf01, bf01)) + + mI03( + mI01(bf01), + mI02(bf01, bf01), + mI03(bf01, bf01, bf01)) + + mI04( + mI01(bf01), + mI02(bf01, bf01), + mI03(bf01, bf01, bf01), + mI04(bf01, bf01, bf01, bf01)) + + if (y262) { + + mI05( + mI01(bf01), + mI02(bf01, bf01), + mI03(bf01, bf01, bf01), + mI04(bf01, bf01, bf01, bf01), + mI05(bf01, bf01, bf01, bf01, bf01)) + + mI06( + mI01(bf01), + mI02(bf01, bf01), + mI03(bf01, bf01, bf01), + mI04(bf01, bf01, bf01, bf01), + mI05(bf01, bf01, bf01, bf01, bf01), + mI06(bf01, bf01, bf01, bf01, bf01, bf01)) + mI07( + mI01(bf01), + mI02(bf01, bf01), + mI03(bf01, bf01, bf01), + mI04(bf01, bf01, bf01, bf01), + mI05(bf01, bf01, bf01, bf01, bf01), + mI06(bf01, bf01, bf01, bf01, bf01, bf01), + mI07(bf01, bf01, bf01, bf01, bf01, bf01, bf01)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(bf01, Local1) + Store(bf01, Local3) + Store(bf01, Local5) + + mI01(bf01) + + // if (chk0) { + + mI02(bf01, Local1) + mI03(bf01, Local1, bf01) + mI04(bf01, Local1, bf01, Local3) + mI05(bf01, Local1, bf01, Local3, bf01) + mI06(bf01, Local1, bf01, Local3, bf01, Local5) + mI07(bf01, Local1, bf01, Local3, bf01, Local5, bf01) + + mI01( + mI01(bf01)) + + mI02( + mI01(bf01), + mI02(bf01, Local1)) + + mI03( + mI01(bf01), + mI02(bf01, Local1), + mI03(bf01, Local1, bf01)) + + mI04( + mI01(bf01), + mI02(bf01, Local1), + mI03(bf01, Local1, bf01), + mI04(bf01, Local1, bf01, Local3)) + + if (y262) { + + mI05( + mI01(bf01), + mI02(bf01, Local1), + mI03(bf01, Local1, bf01), + mI04(bf01, Local1, bf01, Local3), + mI05(bf01, Local1, bf01, Local3, bf01)) + + mI06( + mI01(bf01), + mI02(bf01, Local1), + mI03(bf01, Local1, bf01), + mI04(bf01, Local1, bf01, Local3), + mI05(bf01, Local1, bf01, Local3, bf01), + mI06(bf01, Local1, bf01, Local3, bf01, Local5)) + mI07( + mI01(bf01), + mI02(bf01, Local1), + mI03(bf01, Local1, bf01), + mI04(bf01, Local1, bf01, Local3), + mI05(bf01, Local1, bf01, Local3, bf01), + mI06(bf01, Local1, bf01, Local3, bf01, Local5), + mI07(bf01, Local1, bf01, Local3, bf01, Local5, bf01)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) { + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (effectively local) + */ + + Store(bf01, Arg1) + Store(bf01, Arg3) + Store(bf01, Arg5) + + mI01(bf01) + + // if (chk0) { + + mI02(bf01, Arg1) + mI03(bf01, Arg1, bf01) + mI04(bf01, Arg1, bf01, Arg3) + mI05(bf01, Arg1, bf01, Arg3, bf01) + mI06(bf01, Arg1, bf01, Arg3, bf01, Arg5) + mI07(bf01, Arg1, bf01, Arg3, bf01, Arg5, bf01) + + mI01( + mI01(bf01)) + + mI02( + mI01(bf01), + mI02(bf01, Arg1)) + + mI03( + mI01(bf01), + mI02(bf01, Arg1), + mI03(bf01, Arg1, bf01)) + + mI04( + mI01(bf01), + mI02(bf01, Arg1), + mI03(bf01, Arg1, bf01), + mI04(bf01, Arg1, bf01, Arg3)) + + if (y262) { + + mI05( + mI01(bf01), + mI02(bf01, Arg1), + mI03(bf01, Arg1, bf01), + mI04(bf01, Arg1, bf01, Arg3), + mI05(bf01, Arg1, bf01, Arg3, bf01)) + + mI06( + mI01(bf01), + mI02(bf01, Arg1), + mI03(bf01, Arg1, bf01), + mI04(bf01, Arg1, bf01, Arg3), + mI05(bf01, Arg1, bf01, Arg3, bf01), + mI06(bf01, Arg1, bf01, Arg3, bf01, Arg5)) + mI07( + mI01(bf01), + mI02(bf01, Arg1), + mI03(bf01, Arg1, bf01), + mI04(bf01, Arg1, bf01, Arg3), + mI05(bf01, Arg1, bf01, Arg3, bf01), + mI06(bf01, Arg1, bf01, Arg3, bf01, Arg5), + mI07(bf01, Arg1, bf01, Arg3, bf01, Arg5, bf01)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) { + + + + + /* + * Modification 3: + * + * Some params are intermediately stored to Named + */ + + Name(ii06, 0) + Name(ii07, 0) + Name(ii08, 0) + + Store(bf01, ii06) + Store(bf01, ii07) + Store(bf01, ii08) + + mI01(bf01) + mI02(bf01, ii06) + mI03(bf01, ii06, bf01) + mI04(bf01, ii06, bf01, ii07) + mI05(bf01, ii06, bf01, ii07, bf01) + mI06(bf01, ii06, bf01, ii07, bf01, ii08) + mI07(bf01, ii06, bf01, ii07, bf01, ii08, bf01) + + mI01( + mI01(bf01)) + + mI02( + mI01(bf01), + mI02(bf01, ii06)) + + mI03( + mI01(bf01), + mI02(bf01, ii06), + mI03(bf01, ii06, bf01)) + + mI04( + mI01(bf01), + mI02(bf01, ii06), + mI03(bf01, ii06, bf01), + mI04(bf01, ii06, bf01, ii07)) + + + if (y262) { + + mI05( + mI01(bf01), + mI02(bf01, ii06), + mI03(bf01, ii06, bf01), + mI04(bf01, ii06, bf01, ii07), + mI05(bf01, ii06, bf01, ii07, bf01)) + + mI06( + mI01(bf01), + mI02(bf01, ii06), + mI03(bf01, ii06, bf01), + mI04(bf01, ii06, bf01, ii07), + mI05(bf01, ii06, bf01, ii07, bf01), + mI06(bf01, ii06, bf01, ii07, bf01, ii08)) + mI07( + mI01(bf01), + mI02(bf01, ii06), + mI03(bf01, ii06, bf01), + mI04(bf01, ii06, bf01, ii07), + mI05(bf01, ii06, bf01, ii07, bf01), + mI06(bf01, ii06, bf01, ii07, bf01, ii08), + mI07(bf01, ii06, bf01, ii07, bf01, ii08, bf01)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Device + */ + Store(7, cmd0) + + + + + /* + * Modification 0: + */ + + mI01(d000) + mI02(d000, d000) + mI03(d000, d000, d000) + mI04(d000, d000, d000, d000) + + // if (chk0) { + + mI05(d000, d000, d000, d000, d000) + mI06(d000, d000, d000, d000, d000, d000) + mI07(d000, d000, d000, d000, d000, d000, d000) + + mI01( + mI01(d000)) + + mI02( + mI01(d000), + mI02(d000, d000)) + + mI03( + mI01(d000), + mI02(d000, d000), + mI03(d000, d000, d000)) + + mI04( + mI01(d000), + mI02(d000, d000), + mI03(d000, d000, d000), + mI04(d000, d000, d000, d000)) + + if (y262) { + + mI05( + mI01(d000), + mI02(d000, d000), + mI03(d000, d000, d000), + mI04(d000, d000, d000, d000), + mI05(d000, d000, d000, d000, d000)) + + mI06( + mI01(d000), + mI02(d000, d000), + mI03(d000, d000, d000), + mI04(d000, d000, d000, d000), + mI05(d000, d000, d000, d000, d000), + mI06(d000, d000, d000, d000, d000, d000)) + mI07( + mI01(d000), + mI02(d000, d000), + mI03(d000, d000, d000), + mI04(d000, d000, d000, d000), + mI05(d000, d000, d000, d000, d000), + mI06(d000, d000, d000, d000, d000, d000), + mI07(d000, d000, d000, d000, d000, d000, d000)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) + + + + + if (SLC0) { + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + */ + + Store(d000, Local1) + Store(d000, Local3) + Store(d000, Local5) + + mI01(d000) + mI02(d000, Local1) + mI03(d000, Local1, d000) + mI04(d000, Local1, d000, Local3) + mI05(d000, Local1, d000, Local3, d000) + mI06(d000, Local1, d000, Local3, d000, Local5) + mI07(d000, Local1, d000, Local3, d000, Local5, d000) + + mI01( + mI01(d000)) + + mI02( + mI01(d000), + mI02(d000, Local1)) + + mI03( + mI01(d000), + mI02(d000, Local1), + mI03(d000, Local1, d000)) + + mI04( + mI01(d000), + mI02(d000, Local1), + mI03(d000, Local1, d000), + mI04(d000, Local1, d000, Local3)) + + if (y262) { + + mI05( + mI01(d000), + mI02(d000, Local1), + mI03(d000, Local1, d000), + mI04(d000, Local1, d000, Local3), + mI05(d000, Local1, d000, Local3, d000)) + + mI06( + mI01(d000), + mI02(d000, Local1), + mI03(d000, Local1, d000), + mI04(d000, Local1, d000, Local3), + mI05(d000, Local1, d000, Local3, d000), + mI06(d000, Local1, d000, Local3, d000, Local5)) + mI07( + mI01(d000), + mI02(d000, Local1), + mI03(d000, Local1, d000), + mI04(d000, Local1, d000, Local3), + mI05(d000, Local1, d000, Local3, d000), + mI06(d000, Local1, d000, Local3, d000, Local5), + mI07(d000, Local1, d000, Local3, d000, Local5, d000)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (efectively local) + */ + + Store(d000, Arg1) + Store(d000, Arg3) + Store(d000, Arg5) + + mI01(d000) + mI02(d000, Arg1) + mI03(d000, Arg1, d000) + mI04(d000, Arg1, d000, Arg3) + + // if (chk0) { + + mI05(d000, Arg1, d000, Arg3, d000) + mI06(d000, Arg1, d000, Arg3, d000, Arg5) + mI07(d000, Arg1, d000, Arg3, d000, Arg5, d000) + + mI01( + mI01(d000)) + + mI02( + mI01(d000), + mI02(d000, Arg1)) + + mI03( + mI01(d000), + mI02(d000, Arg1), + mI03(d000, Arg1, d000)) + + mI04( + mI01(d000), + mI02(d000, Arg1), + mI03(d000, Arg1, d000), + mI04(d000, Arg1, d000, Arg3)) + + if (y262) { + + mI05( + mI01(d000), + mI02(d000, Arg1), + mI03(d000, Arg1, d000), + mI04(d000, Arg1, d000, Arg3), + mI05(d000, Arg1, d000, Arg3, d000)) + + mI06( + mI01(d000), + mI02(d000, Arg1), + mI03(d000, Arg1, d000), + mI04(d000, Arg1, d000, Arg3), + mI05(d000, Arg1, d000, Arg3, d000), + mI06(d000, Arg1, d000, Arg3, d000, Arg5)) + mI07( + mI01(d000), + mI02(d000, Arg1), + mI03(d000, Arg1, d000), + mI04(d000, Arg1, d000, Arg3), + mI05(d000, Arg1, d000, Arg3, d000), + mI06(d000, Arg1, d000, Arg3, d000, Arg5), + mI07(d000, Arg1, d000, Arg3, d000, Arg5, d000)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) { + + } // if (SLC0) + + + + + /* + * Event + */ + Store(8, cmd0) + + + + + /* + * Modification 0: + */ + + mI01(e000) + + // if (chk0) { + + mI02(e000, e000) + mI03(e000, e000, e000) + mI04(e000, e000, e000, e000) + mI05(e000, e000, e000, e000, e000) + mI06(e000, e000, e000, e000, e000, e000) + mI07(e000, e000, e000, e000, e000, e000, e000) + + mI01( + mI01(e000)) + + mI02( + mI01(e000), + mI02(e000, e000)) + + mI03( + mI01(e000), + mI02(e000, e000), + mI03(e000, e000, e000)) + + mI04( + mI01(e000), + mI02(e000, e000), + mI03(e000, e000, e000), + mI04(e000, e000, e000, e000)) + + if (y262) { + + mI05( + mI01(e000), + mI02(e000, e000), + mI03(e000, e000, e000), + mI04(e000, e000, e000, e000), + mI05(e000, e000, e000, e000, e000)) + + mI06( + mI01(e000), + mI02(e000, e000), + mI03(e000, e000, e000), + mI04(e000, e000, e000, e000), + mI05(e000, e000, e000, e000, e000), + mI06(e000, e000, e000, e000, e000, e000)) + mI07( + mI01(e000), + mI02(e000, e000), + mI03(e000, e000, e000), + mI04(e000, e000, e000, e000), + mI05(e000, e000, e000, e000, e000), + mI06(e000, e000, e000, e000, e000, e000), + mI07(e000, e000, e000, e000, e000, e000, e000)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) { + + + + + if (SLC0) { + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + * + * Note: + * in the checking above the locals (Local1, Local3, Local5) + * were assigned with the object of type Device. MS rejects + * those locals to be rewritten after that assigning. + * So, here I use Local0,Local2,Local4. + */ + + Store(e000, Local0) + Store(e000, Local2) + Store(e000, Local4) + + mI01(e000) + mI02(e000, Local0) + mI03(e000, Local0, e000) + mI04(e000, Local0, e000, Local2) + mI05(e000, Local0, e000, Local2, e000) + mI06(e000, Local0, e000, Local2, e000, Local4) + mI07(e000, Local0, e000, Local2, e000, Local4, e000) + + mI01( + mI01(e000)) + + mI02( + mI01(e000), + mI02(e000, Local0)) + + mI03( + mI01(e000), + mI02(e000, Local0), + mI03(e000, Local0, e000)) + + mI04( + mI01(e000), + mI02(e000, Local0), + mI03(e000, Local0, e000), + mI04(e000, Local0, e000, Local2)) + + if (y262) { + + mI05( + mI01(e000), + mI02(e000, Local0), + mI03(e000, Local0, e000), + mI04(e000, Local0, e000, Local2), + mI05(e000, Local0, e000, Local2, e000)) + + mI06( + mI01(e000), + mI02(e000, Local0), + mI03(e000, Local0, e000), + mI04(e000, Local0, e000, Local2), + mI05(e000, Local0, e000, Local2, e000), + mI06(e000, Local0, e000, Local2, e000, Local4)) + mI07( + mI01(e000), + mI02(e000, Local0), + mI03(e000, Local0, e000), + mI04(e000, Local0, e000, Local2), + mI05(e000, Local0, e000, Local2, e000), + mI06(e000, Local0, e000, Local2, e000, Local4), + mI07(e000, Local0, e000, Local2, e000, Local4, e000)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (efectively local) + * + * Note: + * in the checking above the locals (Local1, Local3, Local5) + * were assigned with the object of type Device. MS rejects + * those locals to be rewritten after that assigning. + * So, here I use Arg0,Arg2,Arg4. + */ + + Store(e000, Arg0) + Store(e000, Arg2) + Store(e000, Arg4) + + mI01(e000) + mI02(e000, Arg0) + mI03(e000, Arg0, e000) + mI04(e000, Arg0, e000, Arg2) + mI05(e000, Arg0, e000, Arg2, e000) + mI06(e000, Arg0, e000, Arg2, e000, Arg4) + mI07(e000, Arg0, e000, Arg2, e000, Arg4, e000) + + mI01( + mI01(e000)) + + mI02( + mI01(e000), + mI02(e000, Arg0)) + + mI03( + mI01(e000), + mI02(e000, Arg0), + mI03(e000, Arg0, e000)) + + mI04( + mI01(e000), + mI02(e000, Arg0), + mI03(e000, Arg0, e000), + mI04(e000, Arg0, e000, Arg2)) + + if (y262) { + + mI05( + mI01(e000), + mI02(e000, Arg0), + mI03(e000, Arg0, e000), + mI04(e000, Arg0, e000, Arg2), + mI05(e000, Arg0, e000, Arg2, e000)) + + mI06( + mI01(e000), + mI02(e000, Arg0), + mI03(e000, Arg0, e000), + mI04(e000, Arg0, e000, Arg2), + mI05(e000, Arg0, e000, Arg2, e000), + mI06(e000, Arg0, e000, Arg2, e000, Arg4)) + mI07( + mI01(e000), + mI02(e000, Arg0), + mI03(e000, Arg0, e000), + mI04(e000, Arg0, e000, Arg2), + mI05(e000, Arg0, e000, Arg2, e000), + mI06(e000, Arg0, e000, Arg2, e000, Arg4), + mI07(e000, Arg0, e000, Arg2, e000, Arg4, e000)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + } // if (SLC0) + + + + + /* + * Method + */ + + + + + /* + * Mutex + */ + Store(9, cmd0) + + + + + /* + * Modification 0: + */ + + mI01(mx00) + + // if (chk0) { + + mI02(mx00, mx00) + mI03(mx00, mx00, mx00) + mI04(mx00, mx00, mx00, mx00) + mI05(mx00, mx00, mx00, mx00, mx00) + mI06(mx00, mx00, mx00, mx00, mx00, mx00) + mI07(mx00, mx00, mx00, mx00, mx00, mx00, mx00) + + mI01( + mI01(mx00)) + + mI02( + mI01(mx00), + mI02(mx00, mx00)) + + mI03( + mI01(mx00), + mI02(mx00, mx00), + mI03(mx00, mx00, mx00)) + + mI04( + mI01(mx00), + mI02(mx00, mx00), + mI03(mx00, mx00, mx00), + mI04(mx00, mx00, mx00, mx00)) + + if (y262) { + + mI05( + mI01(mx00), + mI02(mx00, mx00), + mI03(mx00, mx00, mx00), + mI04(mx00, mx00, mx00, mx00), + mI05(mx00, mx00, mx00, mx00, mx00)) + + mI06( + mI01(mx00), + mI02(mx00, mx00), + mI03(mx00, mx00, mx00), + mI04(mx00, mx00, mx00, mx00), + mI05(mx00, mx00, mx00, mx00, mx00), + mI06(mx00, mx00, mx00, mx00, mx00, mx00)) + mI07( + mI01(mx00), + mI02(mx00, mx00), + mI03(mx00, mx00, mx00), + mI04(mx00, mx00, mx00, mx00), + mI05(mx00, mx00, mx00, mx00, mx00), + mI06(mx00, mx00, mx00, mx00, mx00, mx00), + mI07(mx00, mx00, mx00, mx00, mx00, mx00, mx00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) { + + + + + if (SLCK) { + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + * + * Note: + * in the checkings above the locals (Local0-Local5) + * were assigned with the object of type Device/Event. + * MS rejects those locals to be rewritten after that assigning. + * So, I have no more Locals for checking (SLCK here - because of that). + */ + + Store(mx00, Local1) + Store(mx00, Local3) + Store(mx00, Local5) + + mI01(mx00) + mI02(mx00, Local1) + mI03(mx00, Local1, mx00) + mI04(mx00, Local1, mx00, Local3) + mI05(mx00, Local1, mx00, Local3, mx00) + mI06(mx00, Local1, mx00, Local3, mx00, Local5) + mI07(mx00, Local1, mx00, Local3, mx00, Local5, mx00) + + mI01( + mI01(mx00)) + + mI02( + mI01(mx00), + mI02(mx00, Local1)) + + mI03( + mI01(mx00), + mI02(mx00, Local1), + mI03(mx00, Local1, mx00)) + + mI04( + mI01(mx00), + mI02(mx00, Local1), + mI03(mx00, Local1, mx00), + mI04(mx00, Local1, mx00, Local3)) + + if (y262) { + + mI05( + mI01(mx00), + mI02(mx00, Local1), + mI03(mx00, Local1, mx00), + mI04(mx00, Local1, mx00, Local3), + mI05(mx00, Local1, mx00, Local3, mx00)) + + mI06( + mI01(mx00), + mI02(mx00, Local1), + mI03(mx00, Local1, mx00), + mI04(mx00, Local1, mx00, Local3), + mI05(mx00, Local1, mx00, Local3, mx00), + mI06(mx00, Local1, mx00, Local3, mx00, Local5)) + mI07( + mI01(mx00), + mI02(mx00, Local1), + mI03(mx00, Local1, mx00), + mI04(mx00, Local1, mx00, Local3), + mI05(mx00, Local1, mx00, Local3, mx00), + mI06(mx00, Local1, mx00, Local3, mx00, Local5), + mI07(mx00, Local1, mx00, Local3, mx00, Local5, mx00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (efectively local) + * + * Note: + * in the checkings above the locals (Arg0-Arg5) + * were assigned with the object of type Device/Event. + * MS rejects those locals to be rewritten after that assigning. + * So, I have no more Args for checking (SLCK here - because of that). + */ + + Store(mx00, Arg1) + Store(mx00, Arg3) + Store(mx00, Arg5) + + mI01(mx00) + mI02(mx00, Arg1) + mI03(mx00, Arg1, mx00) + mI04(mx00, Arg1, mx00, Arg3) + mI05(mx00, Arg1, mx00, Arg3, mx00) + mI06(mx00, Arg1, mx00, Arg3, mx00, Arg5) + mI07(mx00, Arg1, mx00, Arg3, mx00, Arg5, mx00) + + mI01( + mI01(mx00)) + + mI02( + mI01(mx00), + mI02(mx00, Arg1)) + + mI03( + mI01(mx00), + mI02(mx00, Arg1), + mI03(mx00, Arg1, mx00)) + + mI04( + mI01(mx00), + mI02(mx00, Arg1), + mI03(mx00, Arg1, mx00), + mI04(mx00, Arg1, mx00, Arg3)) + + if (y262) { + + mI05( + mI01(mx00), + mI02(mx00, Arg1), + mI03(mx00, Arg1, mx00), + mI04(mx00, Arg1, mx00, Arg3), + mI05(mx00, Arg1, mx00, Arg3, mx00)) + + mI06( + mI01(mx00), + mI02(mx00, Arg1), + mI03(mx00, Arg1, mx00), + mI04(mx00, Arg1, mx00, Arg3), + mI05(mx00, Arg1, mx00, Arg3, mx00), + mI06(mx00, Arg1, mx00, Arg3, mx00, Arg5)) + mI07( + mI01(mx00), + mI02(mx00, Arg1), + mI03(mx00, Arg1, mx00), + mI04(mx00, Arg1, mx00, Arg3), + mI05(mx00, Arg1, mx00, Arg3, mx00), + mI06(mx00, Arg1, mx00, Arg3, mx00, Arg5), + mI07(mx00, Arg1, mx00, Arg3, mx00, Arg5, mx00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + } // if (SLCK) + + + + + /* + * Operation Region + */ + Store(10, cmd0) + + + + + /* + * Modification 0: + */ + + mI01(r000) + + // if (chk0) { + + mI02(r000, r000) + mI03(r000, r000, r000) + mI04(r000, r000, r000, r000) + mI05(r000, r000, r000, r000, r000) + mI06(r000, r000, r000, r000, r000, r000) + mI07(r000, r000, r000, r000, r000, r000, r000) + + mI01( + mI01(r000)) + + mI02( + mI01(r000), + mI02(r000, r000)) + + mI03( + mI01(r000), + mI02(r000, r000), + mI03(r000, r000, r000)) + + mI04( + mI01(r000), + mI02(r000, r000), + mI03(r000, r000, r000), + mI04(r000, r000, r000, r000)) + + if (y262) { + + mI05( + mI01(r000), + mI02(r000, r000), + mI03(r000, r000, r000), + mI04(r000, r000, r000, r000), + mI05(r000, r000, r000, r000, r000)) + + mI06( + mI01(r000), + mI02(r000, r000), + mI03(r000, r000, r000), + mI04(r000, r000, r000, r000), + mI05(r000, r000, r000, r000, r000), + mI06(r000, r000, r000, r000, r000, r000)) + mI07( + mI01(r000), + mI02(r000, r000), + mI03(r000, r000, r000), + mI04(r000, r000, r000, r000), + mI05(r000, r000, r000, r000, r000), + mI06(r000, r000, r000, r000, r000, r000), + mI07(r000, r000, r000, r000, r000, r000, r000)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) { + + + + + if (SLCK) { + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + * + * Note: + * in the checkings above the locals (Local0-Local5) + * were assigned with the object of type Device/Event. + * MS rejects those locals to be rewritten after that assigning. + * So, I have no more Locals for checking (SLCK here - because of that). + */ + + Store(r000, Local1) + Store(r000, Local3) + Store(r000, Local5) + + mI01(r000) + mI02(r000, Local1) + mI03(r000, Local1, r000) + mI04(r000, Local1, r000, Local3) + mI05(r000, Local1, r000, Local3, r000) + mI06(r000, Local1, r000, Local3, r000, Local5) + mI07(r000, Local1, r000, Local3, r000, Local5, r000) + + mI01( + mI01(r000)) + + mI02( + mI01(r000), + mI02(r000, Local1)) + + mI03( + mI01(r000), + mI02(r000, Local1), + mI03(r000, Local1, r000)) + + mI04( + mI01(r000), + mI02(r000, Local1), + mI03(r000, Local1, r000), + mI04(r000, Local1, r000, Local3)) + + if (y262) { + + mI05( + mI01(r000), + mI02(r000, Local1), + mI03(r000, Local1, r000), + mI04(r000, Local1, r000, Local3), + mI05(r000, Local1, r000, Local3, r000)) + + mI06( + mI01(r000), + mI02(r000, Local1), + mI03(r000, Local1, r000), + mI04(r000, Local1, r000, Local3), + mI05(r000, Local1, r000, Local3, r000), + mI06(r000, Local1, r000, Local3, r000, Local5)) + mI07( + mI01(r000), + mI02(r000, Local1), + mI03(r000, Local1, r000), + mI04(r000, Local1, r000, Local3), + mI05(r000, Local1, r000, Local3, r000), + mI06(r000, Local1, r000, Local3, r000, Local5), + mI07(r000, Local1, r000, Local3, r000, Local5, r000)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (efectively local) + * + * Note: + * in the checkings above the locals (Arg0-Arg5) + * were assigned with the object of type Device/Event. + * MS rejects those locals to be rewritten after that assigning. + * So, I have no more Args for checking (SLCK here - because of that). + */ + + Store(r000, Arg1) + Store(r000, Arg3) + Store(r000, Arg5) + + mI01(r000) + mI02(r000, Arg1) + mI03(r000, Arg1, r000) + mI04(r000, Arg1, r000, Arg3) + mI05(r000, Arg1, r000, Arg3, r000) + mI06(r000, Arg1, r000, Arg3, r000, Arg5) + mI07(r000, Arg1, r000, Arg3, r000, Arg5, r000) + + mI01( + mI01(r000)) + + mI02( + mI01(r000), + mI02(r000, Arg1)) + + mI03( + mI01(r000), + mI02(r000, Arg1), + mI03(r000, Arg1, r000)) + + mI04( + mI01(r000), + mI02(r000, Arg1), + mI03(r000, Arg1, r000), + mI04(r000, Arg1, r000, Arg3)) + + if (y262) { + + mI05( + mI01(r000), + mI02(r000, Arg1), + mI03(r000, Arg1, r000), + mI04(r000, Arg1, r000, Arg3), + mI05(r000, Arg1, r000, Arg3, r000)) + + mI06( + mI01(r000), + mI02(r000, Arg1), + mI03(r000, Arg1, r000), + mI04(r000, Arg1, r000, Arg3), + mI05(r000, Arg1, r000, Arg3, r000), + mI06(r000, Arg1, r000, Arg3, r000, Arg5)) + mI07( + mI01(r000), + mI02(r000, Arg1), + mI03(r000, Arg1, r000), + mI04(r000, Arg1, r000, Arg3), + mI05(r000, Arg1, r000, Arg3, r000), + mI06(r000, Arg1, r000, Arg3, r000, Arg5), + mI07(r000, Arg1, r000, Arg3, r000, Arg5, r000)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + } // if (SLCK) + + + + + /* + * Power Resource + */ + Store(11, cmd0) + + + + + /* + * Modification 0: + */ + + mI01(pw00) + mI02(pw00, pw00) + mI03(pw00, pw00, pw00) + mI04(pw00, pw00, pw00, pw00) + mI05(pw00, pw00, pw00, pw00, pw00) + mI06(pw00, pw00, pw00, pw00, pw00, pw00) + mI07(pw00, pw00, pw00, pw00, pw00, pw00, pw00) + + mI01( + mI01(pw00)) + mI02( + mI01(pw00), + mI02(pw00, pw00)) + mI03( + mI01(pw00), + mI02(pw00, pw00), + mI03(pw00, pw00, pw00)) + + // if (chk0) { + + mI04( + mI01(pw00), + mI02(pw00, pw00), + mI03(pw00, pw00, pw00), + mI04(pw00, pw00, pw00, pw00)) + + if (y262) { + + mI05( + mI01(pw00), + mI02(pw00, pw00), + mI03(pw00, pw00, pw00), + mI04(pw00, pw00, pw00, pw00), + mI05(pw00, pw00, pw00, pw00, pw00)) + + mI06( + mI01(pw00), + mI02(pw00, pw00), + mI03(pw00, pw00, pw00), + mI04(pw00, pw00, pw00, pw00), + mI05(pw00, pw00, pw00, pw00, pw00), + mI06(pw00, pw00, pw00, pw00, pw00, pw00)) + mI07( + mI01(pw00), + mI02(pw00, pw00), + mI03(pw00, pw00, pw00), + mI04(pw00, pw00, pw00, pw00), + mI05(pw00, pw00, pw00, pw00, pw00), + mI06(pw00, pw00, pw00, pw00, pw00, pw00), + mI07(pw00, pw00, pw00, pw00, pw00, pw00, pw00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + // } // if (chk0) + + + + + if (SLCK) { + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + * + * Note: no Locals for this checking (see comment above). + */ + + Store(pw00, Local1) + Store(pw00, Local3) + Store(pw00, Local5) + + mI01(pw00) + mI02(pw00, Local1) + mI03(pw00, Local1, pw00) + mI04(pw00, Local1, pw00, Local3) + mI05(pw00, Local1, pw00, Local3, pw00) + mI06(pw00, Local1, pw00, Local3, pw00, Local5) + mI07(pw00, Local1, pw00, Local3, pw00, Local5, pw00) + + mI01( + mI01(pw00)) + + mI02( + mI01(pw00), + mI02(pw00, Local1)) + + mI03( + mI01(pw00), + mI02(pw00, Local1), + mI03(pw00, Local1, pw00)) + + mI04( + mI01(pw00), + mI02(pw00, Local1), + mI03(pw00, Local1, pw00), + mI04(pw00, Local1, pw00, Local3)) + + if (y262) { + + mI05( + mI01(pw00), + mI02(pw00, Local1), + mI03(pw00, Local1, pw00), + mI04(pw00, Local1, pw00, Local3), + mI05(pw00, Local1, pw00, Local3, pw00)) + + mI06( + mI01(pw00), + mI02(pw00, Local1), + mI03(pw00, Local1, pw00), + mI04(pw00, Local1, pw00, Local3), + mI05(pw00, Local1, pw00, Local3, pw00), + mI06(pw00, Local1, pw00, Local3, pw00, Local5)) + mI07( + mI01(pw00), + mI02(pw00, Local1), + mI03(pw00, Local1, pw00), + mI04(pw00, Local1, pw00, Local3), + mI05(pw00, Local1, pw00, Local3, pw00), + mI06(pw00, Local1, pw00, Local3, pw00, Local5), + mI07(pw00, Local1, pw00, Local3, pw00, Local5, pw00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (efectively local) + * + * Note: no Args for this checking (see comment above). + */ + + Store(pw00, Arg1) + Store(pw00, Arg3) + Store(pw00, Arg5) + + mI01(pw00) + mI02(pw00, Arg1) + mI03(pw00, Arg1, pw00) + mI04(pw00, Arg1, pw00, Arg3) + mI05(pw00, Arg1, pw00, Arg3, pw00) + mI06(pw00, Arg1, pw00, Arg3, pw00, Arg5) + mI07(pw00, Arg1, pw00, Arg3, pw00, Arg5, pw00) + + mI01( + mI01(pw00)) + + mI02( + mI01(pw00), + mI02(pw00, Arg1)) + + mI03( + mI01(pw00), + mI02(pw00, Arg1), + mI03(pw00, Arg1, pw00)) + + mI04( + mI01(pw00), + mI02(pw00, Arg1), + mI03(pw00, Arg1, pw00), + mI04(pw00, Arg1, pw00, Arg3)) + + if (y262) { + + mI05( + mI01(pw00), + mI02(pw00, Arg1), + mI03(pw00, Arg1, pw00), + mI04(pw00, Arg1, pw00, Arg3), + mI05(pw00, Arg1, pw00, Arg3, pw00)) + + mI06( + mI01(pw00), + mI02(pw00, Arg1), + mI03(pw00, Arg1, pw00), + mI04(pw00, Arg1, pw00, Arg3), + mI05(pw00, Arg1, pw00, Arg3, pw00), + mI06(pw00, Arg1, pw00, Arg3, pw00, Arg5)) + mI07( + mI01(pw00), + mI02(pw00, Arg1), + mI03(pw00, Arg1, pw00), + mI04(pw00, Arg1, pw00, Arg3), + mI05(pw00, Arg1, pw00, Arg3, pw00), + mI06(pw00, Arg1, pw00, Arg3, pw00, Arg5), + mI07(pw00, Arg1, pw00, Arg3, pw00, Arg5, pw00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + } // if (SLCK) + + + + + /* + * Processor + */ + Store(12, cmd0) + + + + + /* + * Modification 0: + */ + + mI01(pr00) + mI02(pr00, pr00) + mI03(pr00, pr00, pr00) + mI04(pr00, pr00, pr00, pr00) + mI05(pr00, pr00, pr00, pr00, pr00) + mI06(pr00, pr00, pr00, pr00, pr00, pr00) + mI07(pr00, pr00, pr00, pr00, pr00, pr00, pr00) + + mI01( + mI01(pr00)) + + mI02( + mI01(pr00), + mI02(pr00, pr00)) + + mI03( + mI01(pr00), + mI02(pr00, pr00), + mI03(pr00, pr00, pr00)) + + mI04( + mI01(pr00), + mI02(pr00, pr00), + mI03(pr00, pr00, pr00), + mI04(pr00, pr00, pr00, pr00)) + + if (y262) { + + mI05( + mI01(pr00), + mI02(pr00, pr00), + mI03(pr00, pr00, pr00), + mI04(pr00, pr00, pr00, pr00), + mI05(pr00, pr00, pr00, pr00, pr00)) + + mI06( + mI01(pr00), + mI02(pr00, pr00), + mI03(pr00, pr00, pr00), + mI04(pr00, pr00, pr00, pr00), + mI05(pr00, pr00, pr00, pr00, pr00), + mI06(pr00, pr00, pr00, pr00, pr00, pr00)) + mI07( + mI01(pr00), + mI02(pr00, pr00), + mI03(pr00, pr00, pr00), + mI04(pr00, pr00, pr00, pr00), + mI05(pr00, pr00, pr00, pr00, pr00), + mI06(pr00, pr00, pr00, pr00, pr00, pr00), + mI07(pr00, pr00, pr00, pr00, pr00, pr00, pr00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + if (SLCK) { + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + * + * Note: no Locals for this checking (see comment above). + */ + + Store(pr00, Local1) + Store(pr00, Local3) + Store(pr00, Local5) + + mI01(pr00) + mI02(pr00, Local1) + mI03(pr00, Local1, pr00) + mI04(pr00, Local1, pr00, Local3) + mI05(pr00, Local1, pr00, Local3, pr00) + mI06(pr00, Local1, pr00, Local3, pr00, Local5) + mI07(pr00, Local1, pr00, Local3, pr00, Local5, pr00) + + mI01( + mI01(pr00)) + + mI02( + mI01(pr00), + mI02(pr00, Local1)) + + mI03( + mI01(pr00), + mI02(pr00, Local1), + mI03(pr00, Local1, pr00)) + + mI04( + mI01(pr00), + mI02(pr00, Local1), + mI03(pr00, Local1, pr00), + mI04(pr00, Local1, pr00, Local3)) + + if (y262) { + + mI05( + mI01(pr00), + mI02(pr00, Local1), + mI03(pr00, Local1, pr00), + mI04(pr00, Local1, pr00, Local3), + mI05(pr00, Local1, pr00, Local3, pr00)) + + mI06( + mI01(pr00), + mI02(pr00, Local1), + mI03(pr00, Local1, pr00), + mI04(pr00, Local1, pr00, Local3), + mI05(pr00, Local1, pr00, Local3, pr00), + mI06(pr00, Local1, pr00, Local3, pr00, Local5)) + mI07( + mI01(pr00), + mI02(pr00, Local1), + mI03(pr00, Local1, pr00), + mI04(pr00, Local1, pr00, Local3), + mI05(pr00, Local1, pr00, Local3, pr00), + mI06(pr00, Local1, pr00, Local3, pr00, Local5), + mI07(pr00, Local1, pr00, Local3, pr00, Local5, pr00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (efectively local) + * + * Note: no Args for this checking (see comment above). + */ + + Store(pr00, Arg1) + Store(pr00, Arg3) + Store(pr00, Arg5) + + mI01(pr00) + mI02(pr00, Arg1) + mI03(pr00, Arg1, pr00) + mI04(pr00, Arg1, pr00, Arg3) + mI05(pr00, Arg1, pr00, Arg3, pr00) + mI06(pr00, Arg1, pr00, Arg3, pr00, Arg5) + mI07(pr00, Arg1, pr00, Arg3, pr00, Arg5, pr00) + + mI01( + mI01(pr00)) + + mI02( + mI01(pr00), + mI02(pr00, Arg1)) + + mI03( + mI01(pr00), + mI02(pr00, Arg1), + mI03(pr00, Arg1, pr00)) + + mI04( + mI01(pr00), + mI02(pr00, Arg1), + mI03(pr00, Arg1, pr00), + mI04(pr00, Arg1, pr00, Arg3)) + + if (y262) { + + mI05( + mI01(pr00), + mI02(pr00, Arg1), + mI03(pr00, Arg1, pr00), + mI04(pr00, Arg1, pr00, Arg3), + mI05(pr00, Arg1, pr00, Arg3, pr00)) + + mI06( + mI01(pr00), + mI02(pr00, Arg1), + mI03(pr00, Arg1, pr00), + mI04(pr00, Arg1, pr00, Arg3), + mI05(pr00, Arg1, pr00, Arg3, pr00), + mI06(pr00, Arg1, pr00, Arg3, pr00, Arg5)) + mI07( + mI01(pr00), + mI02(pr00, Arg1), + mI03(pr00, Arg1, pr00), + mI04(pr00, Arg1, pr00, Arg3), + mI05(pr00, Arg1, pr00, Arg3, pr00), + mI06(pr00, Arg1, pr00, Arg3, pr00, Arg5), + mI07(pr00, Arg1, pr00, Arg3, pr00, Arg5, pr00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + } // if (SLCK) + + + + + /* + * Thermal Zone + */ + Store(13, cmd0) + + + + + /* + * Modification 0: + */ + + mI01(tz00) + mI02(tz00, tz00) + mI03(tz00, tz00, tz00) + mI04(tz00, tz00, tz00, tz00) + mI05(tz00, tz00, tz00, tz00, tz00) + mI06(tz00, tz00, tz00, tz00, tz00, tz00) + mI07(tz00, tz00, tz00, tz00, tz00, tz00, tz00) + + mI01( + mI01(tz00)) + + mI02( + mI01(tz00), + mI02(tz00, tz00)) + + mI03( + mI01(tz00), + mI02(tz00, tz00), + mI03(tz00, tz00, tz00)) + + mI04( + mI01(tz00), + mI02(tz00, tz00), + mI03(tz00, tz00, tz00), + mI04(tz00, tz00, tz00, tz00)) + + if (y262) { + + mI05( + mI01(tz00), + mI02(tz00, tz00), + mI03(tz00, tz00, tz00), + mI04(tz00, tz00, tz00, tz00), + mI05(tz00, tz00, tz00, tz00, tz00)) + + mI06( + mI01(tz00), + mI02(tz00, tz00), + mI03(tz00, tz00, tz00), + mI04(tz00, tz00, tz00, tz00), + mI05(tz00, tz00, tz00, tz00, tz00), + mI06(tz00, tz00, tz00, tz00, tz00, tz00)) + mI07( + mI01(tz00), + mI02(tz00, tz00), + mI03(tz00, tz00, tz00), + mI04(tz00, tz00, tz00, tz00), + mI05(tz00, tz00, tz00, tz00, tz00), + mI06(tz00, tz00, tz00, tz00, tz00, tz00), + mI07(tz00, tz00, tz00, tz00, tz00, tz00, tz00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + if (SLCK) { + + /* + * Modification 1: + * + * Some params are intermediately stored to Locals + * + * Note: no Locals for this checking (see comment above). + */ + + Store(tz00, Local1) + Store(tz00, Local3) + Store(tz00, Local5) + + mI01(tz00) + mI02(tz00, Local1) + mI03(tz00, Local1, tz00) + mI04(tz00, Local1, tz00, Local3) + mI05(tz00, Local1, tz00, Local3, tz00) + mI06(tz00, Local1, tz00, Local3, tz00, Local5) + mI07(tz00, Local1, tz00, Local3, tz00, Local5, tz00) + + mI01( + mI01(tz00)) + + mI02( + mI01(tz00), + mI02(tz00, Local1)) + + mI03( + mI01(tz00), + mI02(tz00, Local1), + mI03(tz00, Local1, tz00)) + + mI04( + mI01(tz00), + mI02(tz00, Local1), + mI03(tz00, Local1, tz00), + mI04(tz00, Local1, tz00, Local3)) + + if (y262) { + + mI05( + mI01(tz00), + mI02(tz00, Local1), + mI03(tz00, Local1, tz00), + mI04(tz00, Local1, tz00, Local3), + mI05(tz00, Local1, tz00, Local3, tz00)) + + mI06( + mI01(tz00), + mI02(tz00, Local1), + mI03(tz00, Local1, tz00), + mI04(tz00, Local1, tz00, Local3), + mI05(tz00, Local1, tz00, Local3, tz00), + mI06(tz00, Local1, tz00, Local3, tz00, Local5)) + mI07( + mI01(tz00), + mI02(tz00, Local1), + mI03(tz00, Local1, tz00), + mI04(tz00, Local1, tz00, Local3), + mI05(tz00, Local1, tz00, Local3, tz00), + mI06(tz00, Local1, tz00, Local3, tz00, Local5), + mI07(tz00, Local1, tz00, Local3, tz00, Local5, tz00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + + + + /* + * Modification 2: + * + * Some params are intermediately stored to Args (efectively local) + * + * Note: no Args for this checking (see comment above). + */ + + Store(tz00, Arg1) + Store(tz00, Arg3) + Store(tz00, Arg5) + + mI01(tz00) + mI02(tz00, Arg1) + mI03(tz00, Arg1, tz00) + mI04(tz00, Arg1, tz00, Arg3) + mI05(tz00, Arg1, tz00, Arg3, tz00) + mI06(tz00, Arg1, tz00, Arg3, tz00, Arg5) + mI07(tz00, Arg1, tz00, Arg3, tz00, Arg5, tz00) + + mI01( + mI01(tz00)) + + mI02( + mI01(tz00), + mI02(tz00, Arg1)) + + mI03( + mI01(tz00), + mI02(tz00, Arg1), + mI03(tz00, Arg1, tz00)) + + mI04( + mI01(tz00), + mI02(tz00, Arg1), + mI03(tz00, Arg1, tz00), + mI04(tz00, Arg1, tz00, Arg3)) + + if (y262) { + + mI05( + mI01(tz00), + mI02(tz00, Arg1), + mI03(tz00, Arg1, tz00), + mI04(tz00, Arg1, tz00, Arg3), + mI05(tz00, Arg1, tz00, Arg3, tz00)) + + mI06( + mI01(tz00), + mI02(tz00, Arg1), + mI03(tz00, Arg1, tz00), + mI04(tz00, Arg1, tz00, Arg3), + mI05(tz00, Arg1, tz00, Arg3, tz00), + mI06(tz00, Arg1, tz00, Arg3, tz00, Arg5)) + mI07( + mI01(tz00), + mI02(tz00, Arg1), + mI03(tz00, Arg1, tz00), + mI04(tz00, Arg1, tz00, Arg3), + mI05(tz00, Arg1, tz00, Arg3, tz00), + mI06(tz00, Arg1, tz00, Arg3, tz00, Arg5), + mI07(tz00, Arg1, tz00, Arg3, tz00, Arg5, tz00)) + } else { + OUTP("WARNING: some tests of ns_in40.asl are blocked!") + } + + } // if (SLCK) +} + +Method(ini4) +{ + SRMT("in40") + in40(0,0,0,0,0,0,0) + + SRMT("in41") + in41(0,0,0,0,0,0,0) + + CH03("ini4", z167, 0x000, 0, 0) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in50.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in50.asl new file mode 100644 index 000000000..af2d53ad1 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/initial/ns_in50.asl @@ -0,0 +1,652 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Expressions + */ + +Name(z168, 168) + +/* + * Table 1: operations applied in this file tests + * + * 1 - Add (arg0, arg1, RES) => Local7 + * 7 - Decrement (arg0 --> RES) => Local7 + * 14 - Increment (arg0 --> RES) => Local7 + * 9 - Divide (arg0, arg1, RES, RES) => Local7 + * 38 - ShiftLeft (arg0, arg1, RES) => Local7 + * 28 - Multiply (arg0, arg1, RES) => Local7 + * 44 - Store (arg0, RES) => Local7 + * 33 - Or (arg0, arg1, RES) => Local7 + * 39 - ShiftRight (arg0, arg1, RES) => Local7 + * 45 - Subtract (arg0, arg1, RES) => Local7 + * 2 - And (arg0, arg1, RES) => Local7 + * 27 - Mod (arg0, arg1, RES) => Local7 + * 11 - FindSetLeftBit (arg0, RES) => Local7 + * 12 - FindSetRightBit (arg0, RES) => Local7 + * 53 - XOr (arg0, arg1, RES) => Local7 + * 29 - NAnd (arg0, arg1, RES) => Local7 + * 30 - NOr (arg0, arg1, RES) => Local7 + * 31 - Not (arg0, RES) => Local7 + * 22 - LNot (arg0) => Local7 + * 24 - LOr (arg0, arg1) => Local7 + * 16 - LAnd (arg0, arg1) => Local7 + * 17 - LEqual (arg0, arg1) => Local7 + * 18 - LGreater (arg0, arg1) => Local7 + * 19 - LGreaterEqual (arg0, arg1) => Local7 + * 20 - LLess (arg0, arg1) => Local7 + * 21 - LLessEqual (arg0, arg1) => Local7 + * 23 - LNotEqual (arg0, arg1) => Local7 + */ + +/* + * This method doesn't contain verification and is + * only used to determine opcodes not implemented on MS. + * For verification is intended the method in51. + * + * The ASL Mod operation is not implemented on MS + */ +Method(in50) +{ + Name(ts, "in50") + + Store(0xabcd0000, Local0) + Store(2, Local1) + + Add (Local0, Local1, Local2) + Decrement (Local0) + Increment (Local0) + Divide (Local0, Local1, Local2, Local3) + ShiftLeft (Local0, Local1, Local2) + Multiply (Local0, Local1, Local2) + Store (Local0, Local2) + Or (Local0, Local1, Local2) + ShiftRight (Local0, Local1, Local2) + Subtract (Local0, Local1, Local2) + And (Local0, Local1, Local2) + if (chk0) { + Mod (Local0, Local1, Local2) + } + FindSetLeftBit (Local0, Local2) + FindSetRightBit (Local0, Local2) + XOr (Local0, Local1, Local2) + NAnd (Local0, Local1, Local2) + NOr (Local0, Local1, Local2) + Not (Local0, Local2) + LNot (Local0) + LOr (Local0, Local1) + LAnd (Local0, Local1) + LEqual (Local0, Local1) + LGreater (Local0, Local1) + LGreaterEqual (Local0, Local1) + LLess (Local0, Local1) + LLessEqual (Local0, Local1) + LNotEqual (Local0, Local1) +} + +/* + * Internal objects of methods on MS consume some internal + * resources of ACPI MS interpreter. We are forced to pull + * some of internal objects of in51 out to prevent breakage + * of MS interpreter. + */ +Name(ii31, 0xabcd0031) +Name(ii32, 0xabcd0032) +Name(ii33, 0xabcd0033) +Name(ii34, 0xabcd0034) +Name(ii35, 0xabcd0035) +Name(ii36, 0xabcd0036) +Name(ii37, 0xabcd0037) +Name(ii38, 0xabcd0038) +Name(ii39, 0xabcd0039) +Name(ii3a, 0xabcd003a) +Name(ii3b, 0xabcd003b) +Name(ii3c, 0xabcd003c) +Name(ii3d, 0xabcd003d) +Name(ii3e, 0xabcd003e) +Name(ii3f, 0xabcd003f) +Name(ii40, 0xabcd0040) +Name(ii41, 0xabcd0041) +Name(ii42, 0xabcd0042) +Name(ii43, 0xabcd0043) +Name(ii44, 0xabcd0044) +Name(ii45, 0xabcd0045) +Name(ii46, 0xabcd0046) +Name(ii47, 0xabcd0047) + +/* + * All opcodes of Table 1 above are applied in a single expression + * and their results are then verified. + * + * The ASL Mod operation is not implemented on MS thus + * it is not applied here. All other opcodes enumerated + * in the table above are applied and verified in this test. + */ +Method(in51, 7) +{ + Name(ts, "in51") + + Name(i000, 0x00010000) + Name(i001, 0x0a510010) + Name(i002, 0x15210800) + Name(i003, 0xfeabc8d9) + Name(i004, 0x1234bcde) + Name(i005, 0xfe04bcde) + Name(i006, 0x12345678) + Name(i007, 0x01000000) + Name(i008, 0x60f5c7a2) + + Name(ii00, 0xabcd0000) + Name(ii01, 0xabcd0001) + Name(ii02, 0xabcd0002) + Name(ii03, 0xabcd0003) + Name(ii04, 0xabcd0004) + Name(ii05, 0xabcd0005) + Name(ii06, 0xabcd0006) + Name(ii07, 0xabcd0007) + Name(ii08, 0xabcd0008) + Name(ii09, 0xabcd0009) + Name(ii0a, 0xabcd000a) + Name(ii0b, 0xabcd000b) + Name(ii0c, 0xabcd000c) + Name(ii0d, 0xabcd000d) + Name(ii0e, 0xabcd000e) + Name(ii0f, 0xabcd000f) + Name(ii10, 0xabcd0010) + Name(ii11, 0xabcd0011) + Name(ii12, 0xabcd0012) + Name(ii13, 0xabcd0013) + Name(ii14, 0xabcd0014) + Name(ii15, 0xabcd0015) + Name(ii16, 0xabcd0016) + Name(ii17, 0xabcd0017) + Name(ii18, 0xabcd0018) + Name(ii19, 0xabcd0019) + Name(ii1a, 0xabcd001a) + Name(ii1b, 0xabcd001b) + Name(ii1c, 0xabcd001c) + Name(ii1d, 0xabcd001d) + Name(ii1e, 0xabcd001e) + Name(ii1f, 0xabcd001f) + Name(ii20, 0xabcd0020) + Name(ii21, 0xabcd0021) + Name(ii22, 0xabcd0022) + Name(ii23, 0xabcd0023) + Name(ii24, 0xabcd0024) + Name(ii25, 0xabcd0025) + Name(ii26, 0xabcd0026) + Name(ii27, 0xabcd0027) + Name(ii28, 0xabcd0028) + Name(ii29, 0xabcd0029) + Name(ii2a, 0xabcd002a) + Name(ii2b, 0xabcd002b) + Name(ii2c, 0xabcd002c) + Name(ii2d, 0xabcd002d) + Name(ii2e, 0xabcd002e) + Name(ii2f, 0xabcd002f) + Name(ii30, 0xabcd0030) +/* + Name(ii31, 0xabcd0031) + Name(ii32, 0xabcd0032) + Name(ii33, 0xabcd0033) + Name(ii34, 0xabcd0034) + Name(ii35, 0xabcd0035) + Name(ii36, 0xabcd0036) + Name(ii37, 0xabcd0037) + Name(ii38, 0xabcd0038) + Name(ii39, 0xabcd0039) + Name(ii3a, 0xabcd003a) + Name(ii3b, 0xabcd003b) + Name(ii3c, 0xabcd003c) + Name(ii3d, 0xabcd003d) + Name(ii3e, 0xabcd003e) + Name(ii3f, 0xabcd003f) + Name(ii40, 0xabcd0040) + Name(ii41, 0xabcd0041) + Name(ii42, 0xabcd0042) + Name(ii43, 0xabcd0043) + Name(ii44, 0xabcd0044) + Name(ii45, 0xabcd0045) + Name(ii46, 0xabcd0046) + Name(ii47, 0xabcd0047) +*/ + + + Add( + Add( + Add( + Add( + Add( + Add( + Add( + Add( + Add( + Subtract( + Or( + And( + Store( + Multiply( + ShiftLeft( + Divide( + Add( + Add( + Add(Add(Increment(i000), Increment(i000), i000), + Add(Increment(i000), Increment(i000), i000), Local0), + Add(Add(Decrement(i000), Decrement(i000), i000), + Add(Decrement(i000), Decrement(i000), i000), Local1), + arg0), + Add(Add(Increment(i000), Decrement(i000), i000), + Add(Increment(i000), Decrement(i000), i000), Local2), arg1), + 17, // Divide + ii00, Local3 // Divide + ), // ShiftLeft + 3, // ShiftLeft + ii01), // ShiftLeft + 2, // Multiply + i000), // Multiply + arg2), // Store + 0xffffffff, // And + ii0c), // And + 0x20000000, // Or + ii0d), // Or + + // Subtract + + Multiply( + And( + Add( + Add( + Add( + XOr( + Add( + Add( + Add( + Store( + And( + ShiftRight( + Or(i001, 0x15210800, Local5), + 3, // ShiftRight + ii02), // ShiftRight + 0x035E2102, // And + i000), // And + Local6), // Store + // Add + Add(0, 7, ii03), + ii04), // Add + FindSetLeftBit(0x7bcd0000, ii05), + arg3), // Add + FindSetRightBit(0x7bcd0000, ii06), + arg4), // Add + 0x11b4937f, // XOr + arg5), // XOr + NAnd(i003, 0xffffffff, ii07), + arg6), // Add + NOr(i004, 0xf8f0f0f0, ii08), + Local7), // Add + Not(i005, ii09), + ii0a), // Add + 0xffffffff, // And + ii0b), // And + And(Store(LNot(Store(LNot(ii0b), ii0e)), ii0f), 0x01) + ), // Multiply + + Local4), // Subtract + + // Add + Store(LNot(Store(LNot(i006), ii11)), ii12), + ii10), // Add + // Add + Store(LOr(LNot(And(Store(LOr(i007, 0), ii14), 0x01)), 0), ii15), + ii13), // Add + // Add + Store(LAnd(LNot(And(Store(LAnd(i007, 1), ii16), 0x01)), 0), ii17), + ii18), // Add + // Add + Add( + Store(LEqual(i008, 0x60f5c7a2), ii19), + Store(LEqual(i008, 0x60f5c7a0), ii1a), ii1b), + ii1c), // Add + // Add + Add( + Add( + Store(LGreater(i008, 0x60f5c7a2), ii1d), + Store(LGreater(i008, 0x60f5c7a3), ii1e), ii1f), + Add( + Store(LGreater(i008, 0x60f5c7a1), ii20), + Store(LGreater(i008, 0x60f5c7a0), ii21), ii22), + ii23), + ii24), // Add + // Add + Add( + Add( + Store(LGreaterEqual(i008, 0x60f5c7a2), ii25), + Store(LGreaterEqual(i008, 0x60f5c7a3), ii26), ii27), + Add( + Store(LGreaterEqual(i008, 0x60f5c7a1), ii28), + Store(LGreaterEqual(i008, 0x60f5c7a0), ii29), ii2a), + ii2b), + ii2c), // Add + // Add + Add( + Add( + Store(LLess(i008, 0x60f5c7a2), ii2d), + Store(LLess(i008, 0x60f5c7a3), ii2e), ii2f), + Add( + Store(LLess(i008, 0x60f5c7a1), ii30), + Store(LLess(i008, 0x60f5c7a0), ii31), ii32), + ii33), + ii34), // Add + // Add + Add( + Add( + Store(LLessEqual(i008, 0x60f5c7a2), ii35), + Store(LLessEqual(i008, 0x60f5c7a3), ii36), ii37), + Add( + Store(LLessEqual(i008, 0x60f5c7a1), ii38), + Store(LLessEqual(i008, 0x60f5c7a0), ii39), ii3a), + ii3b), + ii3c), // Add + // Add + Add( + Add( + Store(LNotEqual(i008, 0x60f5c7a2), ii3d), + Store(LNotEqual(i008, 0x60f5c7a3), ii3e), ii3f), + Add( + Store(LNotEqual(i008, 0x60f5c7a1), ii40), + Store(LNotEqual(i008, 0x60f5c7a0), ii41), ii42), + ii43), + ii44) // Add + + + + if (LNotEqual(Local0, 0x0006000C)) { + err(ts, z168, 0x000, 0, 0, Local0, 0x0006000C) + } + if (LNotEqual(Local1, 0x0018002A)) { + err(ts, z168, 0x001, 0, 0, Local1, 0x0018002A) + } + if (LNotEqual(Local2, 0x006000A6)) { + err(ts, z168, 0x002, 0, 0, Local2, 0x006000A6) + } + if (LNotEqual(arg0, 0x001E0036)) { + err(ts, z168, 0x003, 0, 0, arg0, 0x001E0036) + } + if (LNotEqual(arg1, 0x007E00DC)) { + err(ts, z168, 0x004, 0, 0, arg1, 0x007E00DC) + } + if (LNotEqual(ii00, 0x00000006)) { + err(ts, z168, 0x005, 0, 0, ii00, 0x00000006) + } + if (LNotEqual(Local3, 0x00076976)) { + err(ts, z168, 0x006, 0, 0, Local3, 0x00076976) + } + if (LNotEqual(ii01, 0x003B4BB0)) { + err(ts, z168, 0x007, 0, 0, ii01, 0x003B4BB0) + } + if (LNotEqual(arg2, 0x00769760)) { + err(ts, z168, 0x008, 0, 0, arg2, 0x00769760) + } + if (LNotEqual(Local5, 0x1F710810)) { + err(ts, z168, 0x009, 0, 0, Local5, 0x1F710810) + } + if (LNotEqual(ii02, 0x03EE2102)) { + err(ts, z168, 0x00a, 0, 0, ii02, 0x03EE2102) + } + if (LNotEqual(Local6, 0x034E2102)) { + err(ts, z168, 0x00b, 0, 0, Local6, 0x034E2102) + } + if (LNotEqual(ii03, 0x00000007)) { + err(ts, z168, 0x00c, 0, 0, ii03, 0x00000007) + } + if (LNotEqual(ii04, 0x034E2109)) { + err(ts, z168, 0x00d, 0, 0, ii04, 0x034E2109) + } + if (LNotEqual(ii05, 0x0000001F)) { + err(ts, z168, 0x00e, 0, 0, ii05, 0x0000001F) + } + if (LNotEqual(arg3, 0x034E2128)) { + err(ts, z168, 0x00f, 0, 0, arg3, 0x034E2128) + } + if (LNotEqual(ii06, 0x00000011)) { + err(ts, z168, 0x010, 0, 0, ii06, 0x00000011) + } + if (LNotEqual(arg4, 0x034E2139)) { + err(ts, z168, 0x011, 0, 0, arg4, 0x034E2139) + } + if (LNotEqual(arg5, 0x12FAB246)) { + err(ts, z168, 0x012, 0, 0, arg5, 0x12FAB246) + } + if (LNotEqual(ii07, 0xFFFFFFFF01543726)) { + err(ts, z168, 0x013, 0, 0, ii07, 0xFFFFFFFF01543726) + } + if (LNotEqual(arg6, 0xFFFFFFFF144EE96C)) { + err(ts, z168, 0x014, 0, 0, arg6, 0xFFFFFFFF144EE96C) + } + if (LNotEqual(ii08, 0xFFFFFFFF050B0301)) { + err(ts, z168, 0x015, 0, 0, ii08, 0xFFFFFFFF050B0301) + } + if (LNotEqual(Local7, 0xFFFFFFFE1959EC6D)) { + err(ts, z168, 0x016, 0, 0, Local7, 0xFFFFFFFE1959EC6D) + } + if (LNotEqual(ii09, 0xFFFFFFFF01FB4321)) { + err(ts, z168, 0x017, 0, 0, ii09, 0xFFFFFFFF01FB4321) + } + if (LNotEqual(ii0a, 0xFFFFFFFD1B552F8E)) { + err(ts, z168, 0x018, 0, 0, ii0a, 0xFFFFFFFD1B552F8E) + } + if (LNotEqual(ii0b, 0x1B552F8E)) { + err(ts, z168, 0x019, 0, 0, ii0b, 0x1B552F8E) + } + if (LNotEqual(ii0c, 0x00769760)) { + err(ts, z168, 0x01a, 0, 0, ii0c, 0x00769760) + } + if (LNotEqual(ii0d, 0x20769760)) { + err(ts, z168, 0x01b, 0, 0, ii0d, 0x20769760) + } + if (LNotEqual(ii0e, 0)) { + err(ts, z168, 0x01c, 0, 0, ii0e, 0) + } + if (LNotEqual(ii0f, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x01d, 0, 0, ii0f, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(Local4, 0x052167D2)) { + err(ts, z168, 0x01e, 0, 0, Local4, 0x052167D2) + } + if (LNotEqual(ii10, 0x052167D1)) { + err(ts, z168, 0x01f, 0, 0, ii10, 0x052167D1) + } + if (LNotEqual(ii11, 0)) { + err(ts, z168, 0x020, 0, 0, ii11, 0) + } + if (LNotEqual(ii12, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x021, 0, 0, ii12, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii13, 0x00000000052167D1)) { + err(ts, z168, 0x022, 0, 0, ii13, 0x00000000052167D1) + } + if (LNotEqual(ii14, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x023, 0, 0, ii14, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii15, 0)) { + err(ts, z168, 0x024, 0, 0, ii15, 0) + } + if (LNotEqual(ii16, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x025, 0, 0, ii16, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii17, 0)) { + err(ts, z168, 0x026, 0, 0, ii17, 0) + } + if (LNotEqual(ii18, 0x052167D1)) { + err(ts, z168, 0x027, 0, 0, ii18, 0x052167D1) + } + if (LNotEqual(ii19, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x028, 0, 0, ii19, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii1a, 0)) { + err(ts, z168, 0x029, 0, 0, ii1a, 0) + } + if (LNotEqual(ii1b, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x02a, 0, 0, ii1c, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii1c, 0x052167D0)) { + err(ts, z168, 0x02b, 0, 0, ii1d, 0x052167D0) + } + if (LNotEqual(ii1d, 0)) { + err(ts, z168, 0x02c, 0, 0, ii1d, 0) + } + if (LNotEqual(ii1e, 0)) { + err(ts, z168, 0x02d, 0, 0, ii1e, 0) + } + if (LNotEqual(ii1f, 0)) { + err(ts, z168, 0x02e, 0, 0, ii1f, 0) + } + if (LNotEqual(ii20, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x02f, 0, 0, ii20, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii21, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x30, 0, 0, ii21, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii22, 0xFFFFFFFFFFFFFFFE)) { + err(ts, z168, 0x031, 0, 0, ii22, 0xFFFFFFFFFFFFFFFE) + } + if (LNotEqual(ii23, 0xFFFFFFFFFFFFFFFE)) { + err(ts, z168, 0x032, 0, 0, ii23, 0xFFFFFFFFFFFFFFFE) + } + if (LNotEqual(ii24, 0x052167CE)) { + err(ts, z168, 0x033, 0, 0, ii24, 0x052167CE) + } + if (LNotEqual(ii25, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x034, 0, 0, ii25, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii26, 0)) { + err(ts, z168, 0x035, 0, 0, ii26, 0) + } + if (LNotEqual(ii27, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x036, 0, 0, ii27, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii28, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x037, 0, 0, ii28, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii29, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x038, 0, 0, ii29, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii2a, 0xFFFFFFFFFFFFFFFE)) { + err(ts, z168, 0x039, 0, 0, ii2a, 0xFFFFFFFFFFFFFFFE) + } + if (LNotEqual(ii2b, 0xFFFFFFFFFFFFFFFD)) { + err(ts, z168, 0x03a, 0, 0, ii2b, 0xFFFFFFFFFFFFFFFD) + } + if (LNotEqual(ii2c, 0x052167CB)) { + err(ts, z168, 0x03b, 0, 0, ii2c, 0x052167CB) + } + if (LNotEqual(ii2d, 0)) { + err(ts, z168, 0x03c, 0, 0, ii2d, 0) + } + if (LNotEqual(ii2e, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x03d, 0, 0, ii2e, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii2f, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x03e, 0, 0, ii2f, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii30, 0)) { + err(ts, z168, 0x03f, 0, 0, ii30, 0) + } + if (LNotEqual(ii31, 0)) { + err(ts, z168, 0x040, 0, 0, ii31, 0) + } + if (LNotEqual(ii32, 0)) { + err(ts, z168, 0x041, 0, 0, ii32, 0) + } + if (LNotEqual(ii33, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x042, 0, 0, ii33, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii34, 0x052167CA)) { + err(ts, z168, 0x043, 0, 0, ii34, 0x052167CA) + } + if (LNotEqual(ii35, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x044, 0, 0, ii35, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii36, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x045, 0, 0, ii36, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii37, 0xFFFFFFFFFFFFFFFE)) { + err(ts, z168, 0x046, 0, 0, ii37, 0xFFFFFFFFFFFFFFFE) + } + if (LNotEqual(ii38, 0)) { + err(ts, z168, 0x047, 0, 0, ii38, 0) + } + if (LNotEqual(ii39, 0)) { + err(ts, z168, 0x048, 0, 0, ii39, 0) + } + if (LNotEqual(ii3a, 0)) { + err(ts, z168, 0x049, 0, 0, ii3a, 0) + } + if (LNotEqual(ii3b, 0xFFFFFFFFFFFFFFFE)) { + err(ts, z168, 0x04a, 0, 0, ii3b, 0xFFFFFFFFFFFFFFFE) + } + if (LNotEqual(ii3c, 0x052167C8)) { + err(ts, z168, 0x04b, 0, 0, ii3c, 0x052167C8) + } + if (LNotEqual(ii3d, 0)) { + err(ts, z168, 0x04c, 0, 0, ii3d, 0) + } + if (LNotEqual(ii3e, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x04d, 0, 0, ii3e, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii3f, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x04e, 0, 0, ii3f, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii40, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x04f, 0, 0, ii40, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii41, 0xFFFFFFFFFFFFFFFF)) { + err(ts, z168, 0x050, 0, 0, ii41, 0xFFFFFFFFFFFFFFFF) + } + if (LNotEqual(ii42, 0xFFFFFFFFFFFFFFFE)) { + err(ts, z168, 0x051, 0, 0, ii42, 0xFFFFFFFFFFFFFFFE) + } + if (LNotEqual(ii43, 0xFFFFFFFFFFFFFFFD)) { + err(ts, z168, 0x052, 0, 0, ii43, 0xFFFFFFFFFFFFFFFD) + } + if (LNotEqual(ii44, 0x052167C5)) { + err(ts, z168, 0x053, 0, 0, ii44, 0x052167C5) + } +} + +Method(ini5) +{ + SRMT("in50") + in50() + + SRMT("in51") + in51(0,0,0,0,0,0,0) + + CH03("ini5", z168, 0x000, 0, 0) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/method/mt0_abbu.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/method/mt0_abbu.asl new file mode 100644 index 000000000..00b39637c --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/method/mt0_abbu.asl @@ -0,0 +1,3234 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests to check path names with method type syllables + */ + +Name(z169, 169) + + +Processor(pr7d, 0, 0x000, 0x008) +{ + Name(iy07, 0xabcd0120) +} + +/* + * Test shows maximal supported depth of enclosed method calls on MS + */ +Method(mt00) +{ + Name(ts, "mt00") + + Name(i000, 0) + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + // OUTC("Number of calls to methods depends on the length of this message!") + OUTC("Max") + Store(0xabcd0000, i000) + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z169, 0x100, 0, 0) + + mm00() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z169, 0x000, 0, 0, i000, 0xabcd0000) + } + + CH03(ts, z169, 0x101, 0, 0) +} + +/* + * The same as mt00, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt01) +{ + Name(ts, "mt01") + + Name(i000, 0) + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + OUTC("Max") + Store(0xabcd0000, i000) + } + mm1f() + } + mm1e() + } + mm1d() + } + mm1c() + } + mm1b() + } + mm1a() + } + mm19() + } + mm18() + } + mm17() + } + mm16() + } + mm15() + } + mm14() + } + mm13() + } + mm12() + } + mm11() + } + mm10() + } + mm0f() + } + mm0e() + } + mm0d() + } + mm0c() + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z169, 0x102, 0, 0) + + mm00() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z169, 0x001, 0, 0, i000, 0xabcd0000) + } + + CH03(ts, z169, 0x103, 0, 0) +} + +/* + * Test shows maximal supported depth of enclosed method calls on MS + */ +Method(mt02) +{ + Name(ts, "mt02") + + Name(i000, 0) + + Method(mm00) + { + mm01() + } + Method(mm01) + { + mm02() + } + Method(mm02) + { + mm03() + } + Method(mm03) + { + mm04() + } + Method(mm04) + { + mm05() + } + Method(mm05) + { + mm06() + } + Method(mm06) + { + mm07() + } + Method(mm07) + { + mm08() + } + Method(mm08) + { + mm09() + } + Method(mm09) + { + mm0a() + } + Method(mm0a) + { + mm0b() + } + Method(mm0b) + { + mm0c() + } + Method(mm0c) + { + mm0d() + } + Method(mm0d) + { + mm0e() + } + Method(mm0e) + { + mm0f() + } + Method(mm0f) + { + OUTC("Max") + Store(0xabcd0000, i000) + } + + CH03(ts, z169, 0x104, 0, 0) + + mm00() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z169, 0x002, 0, 0, i000, 0xabcd0000) + } + + CH03(ts, z169, 0x105, 0, 0) +} + +/* + * The same as mt02, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt03) +{ + Name(ts, "mt03") + + Name(i000, 0) + + Method(mm00) + { + mm01() + } + Method(mm01) + { + mm02() + } + Method(mm02) + { + mm03() + } + Method(mm03) + { + mm04() + } + Method(mm04) + { + mm05() + } + Method(mm05) + { + mm06() + } + Method(mm06) + { + mm07() + } + Method(mm07) + { + mm08() + } + Method(mm08) + { + mm09() + } + Method(mm09) + { + mm0a() + } + Method(mm0a) + { + mm0b() + } + Method(mm0b) + { + mm0c() + } + Method(mm0c) + { + mm0d() + } + Method(mm0d) + { + mm0e() + } + Method(mm0e) + { + mm0f() + } + Method(mm0f) + { + mm10() + } + Method(mm10) + { + mm11() + } + Method(mm11) + { + mm12() + } + Method(mm12) + { + mm13() + } + Method(mm13) + { + mm14() + } + Method(mm14) + { + mm15() + } + Method(mm15) + { + mm16() + } + Method(mm16) + { + mm17() + } + Method(mm17) + { + mm18() + } + Method(mm18) + { + mm19() + } + Method(mm19) + { + mm1a() + } + Method(mm1a) + { + mm1b() + } + Method(mm1b) + { + mm1c() + } + Method(mm1c) + { + mm1d() + } + Method(mm1d) + { + mm1e() + } + Method(mm1e) + { + mm1f() + } + Method(mm1f) + { + OUTC("Max") + Store(0xabcd0000, i000) + } + + CH03(ts, z169, 0x106, 0, 0) + + mm00() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z169, 0x003, 0, 0, i000, 0xabcd0000) + } + + CH03(ts, z169, 0x107, 0, 0) +} + +/* + * Increment object with the name of method in the name path + */ +Method(mt04) +{ + Name(ts, "mt04") + + Device(dz05) + { + Name(iy07, 0xabcd0900) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Increment(\_SB_.ABBU.mt04.dz05.iy07) + Store (\_SB_.ABBU.mt04.dz05.iy07, Local0) + OUTC("mt04, \_SB_.ABBU.mt04.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0909)) { + err(ts, z169, 0x004, 0, 0, Local0, 0xabcd0909) + } + if (LNotEqual(\_SB_.ABBU.mt04.dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x005, 0, 0, \_SB_.ABBU.mt04.dz05.iy07, 0xabcd0909) + } + } + Increment(\_SB_.ABBU.mt04.dz05.iy07) + mm07() + } + Increment(\_SB_.ABBU.mt04.dz05.iy07) + mm06() + } + Increment(\_SB_.ABBU.mt04.dz05.iy07) + mm05() + } + Increment(\_SB_.ABBU.mt04.dz05.iy07) + mm04() + } + Increment(\_SB_.ABBU.mt04.dz05.iy07) + mm03() + } + Increment(\_SB_.ABBU.mt04.dz05.iy07) + mm02() + } + Increment(\_SB_.ABBU.mt04.dz05.iy07) + mm01() + } + + CH03(ts, z169, 0x006, 0, 0) + + Increment(\_SB_.ABBU.mt04.dz05.iy07) + mm00() + + if (LNotEqual(\_SB_.ABBU.mt04.dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x007, 0, 0, \_SB_.ABBU.mt04.dz05.iy07, 0xabcd0909) + } + + CH03(ts, z169, 0x008, 0, 0) +} + +/* + * The same as mt04, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt05) +{ + Name(ts, "mt05") + + Device(dz05) + { + Name(iy07, 0xabcd0900) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + Increment(\_SB_.ABBU.mt05.dz05.iy07) + Store (\_SB_.ABBU.mt05.dz05.iy07, Local0) + OUTC("mt05, \_SB_.ABBU.mt05.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0921)) { + err(ts, z169, 0x009, 0, 0, Local0, 0xabcd0921) + } + if (LNotEqual(\_SB_.ABBU.mt05.dz05.iy07, 0xabcd0921)) { + err(ts, z169, 0x00a, 0, 0, \_SB_.ABBU.mt05.dz05.iy07, 0xabcd0921) + } + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm1f() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm1e() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm1d() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm1c() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm1b() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm1a() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm19() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm18() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm17() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm16() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm15() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm14() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm13() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm12() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm11() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm10() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm0f() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm0e() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm0d() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm0c() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm0b() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm0a() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm09() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm08() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm07() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm06() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm05() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm04() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm03() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm02() + } + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm01() + } + + CH03(ts, z169, 0x108, 0, 0) + + Increment(\_SB_.ABBU.mt05.dz05.iy07) + mm00() + + if (LNotEqual(\_SB_.ABBU.mt05.dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x00b, 0, 0, \_SB_.ABBU.mt05.dz05.iy07, 0xabcd0909) + } + + CH03(ts, z169, 0x109, 0, 0) +} + +/* + * Check access to the internal object of method being executed + * from the point inside the tree of that method being executed + * but by the method statically declared outside that method. + */ +Method(mt06) +{ + Name(ts, "mt06") + + Device(dz05) + { + Name(iy07, 0xabcd0900) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Store (0x11112222, \_SB_.ABBU.mt06.dz05.iy07) + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + Store (\_SB_.ABBU.mt06.dz05.iy07, Local0) + OUTC("mt06, \_SB_.ABBU.mt06.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z169, 0x00c, 0, 0, Local0, 0x11112222) + } + if (LNotEqual(\_SB_.ABBU.mt06.dz05.iy07, 0x11112222)) { + err(ts, z169, 0x00d, 0, 0, \_SB_.ABBU.mt06.dz05.iy07, 0x11112222) + } + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z169, 0x10a, 0, 0) + + mm00() + + mt07() // succeeds here + + if (LNotEqual(\_SB_.ABBU.mt06.dz05.iy07, 0x11112222)) { + err(ts, z169, 0x00e, 0, 0, \_SB_.ABBU.mt06.dz05.iy07, 0x11112222) + } + + CH03(ts, z169, 0x10b, 0, 0) +} + +/* + * Access to the internal object of method mt06 + * + * Result differs depending on either mt06 is invoked or not. + * Unfortunately, we can run mt06 and mt07 simultaneously only + * on the same thread (invocation). + */ +Method(mt07) +{ + Name(ts, "mt07") + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Store (\_SB_.ABBU.mt06.dz05.iy07, Local0) + OUTC("0 mt07, \_SB_.ABBU.mt06.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z169, 0x00f, 0, 0, Local0, 0x11112222) + } + if (LNotEqual(\_SB_.ABBU.mt06.dz05.iy07, 0x11112222)) { + err(ts, z169, 0x010, 0, 0, \_SB_.ABBU.mt06.dz05.iy07, 0x11112222) + } + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z169, 0x10c, 0, 0) + + mm00() + + Store (\_SB_.ABBU.mt06.dz05.iy07, Local0) + OUTC("1 mt07, \_SB_.ABBU.mt06.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z169, 0x011, 0, 0, Local0, 0x11112222) + } + if (LNotEqual(\_SB_.ABBU.mt06.dz05.iy07, 0x11112222)) { + err(ts, z169, 0x012, 0, 0, \_SB_.ABBU.mt06.dz05.iy07, 0x11112222) + } + + CH03(ts, z169, 0x10d, 0, 0) +} + +/* + * The same as mt06, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt08) +{ + Name(ts, "mt08") + + Device(dz05) + { + Name(iy07, 0xabcd0900) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Store (0x22223333, \_SB_.ABBU.mt08.dz05.iy07) + } + mm0f() + } + mm0e() + } + mm0d() + } + mm0c() + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + Store (\_SB_.ABBU.mt08.dz05.iy07, Local0) + OUTC("mt08, \_SB_.ABBU.mt08.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x22223333)) { + err(ts, z169, 0x013, 0, 0, Local0, 0x22223333) + } + if (LNotEqual(\_SB_.ABBU.mt08.dz05.iy07, 0x22223333)) { + err(ts, z169, 0x014, 0, 0, \_SB_.ABBU.mt08.dz05.iy07, 0x22223333) + } + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z169, 0x10e, 0, 0) + + mm00() + + mt09() // succeeds here + + if (LNotEqual(\_SB_.ABBU.mt08.dz05.iy07, 0x22223333)) { + err(ts, z169, 0x015, 0, 0, \_SB_.ABBU.mt08.dz05.iy07, 0x22223333) + } + + CH03(ts, z169, 0x10f, 0, 0) +} + +/* + * Access to the internal object of method mt08 + * + * see comment to mt07 + */ +Method(mt09) +{ + Name(ts, "mt09") + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Store (\_SB_.ABBU.mt08.dz05.iy07, Local0) + OUTC("0 mt09, \_SB_.ABBU.mt08.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x22223333)) { + err(ts, z169, 0x016, 0, 0, Local0, 0x22223333) + } + if (LNotEqual(\_SB_.ABBU.mt08.dz05.iy07, 0x22223333)) { + err(ts, z169, 0x017, 0, 0, \_SB_.ABBU.mt08.dz05.iy07, 0x22223333) + } + } + mm0f() + } + mm0e() + } + mm0d() + } + mm0c() + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z169, 0x110, 0, 0) + + mm00() + + Store (\_SB_.ABBU.mt08.dz05.iy07, Local0) + OUTC("1 mt09, \_SB_.ABBU.mt08.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x22223333)) { + err(ts, z169, 0x018, 0, 0, Local0, 0x22223333) + } + if (LNotEqual(\_SB_.ABBU.mt08.dz05.iy07, 0x22223333)) { + err(ts, z169, 0x019, 0, 0, \_SB_.ABBU.mt08.dz05.iy07, 0x22223333) + } + + CH03(ts, z169, 0x111, 0, 0) +} + +/* + * Check simple access to the object by the name path + * without method name syllables + */ +Method(mt0a) +{ + Name(ts, "mt0a") + + CH03(ts, z169, 0x112, 0, 0) + + Store (\_SB_.ABBU.pr7d.iy07, Local0) + OUTC("mt0a, \_SB_.ABBU.pr7d.iy07:") + OUTC(Local0) + if (LNotEqual(\_SB_.ABBU.pr7d.iy07, 0xabcd0120)) { + err(ts, z169, 0x01a, 0, 0, \_SB_.ABBU.pr7d.iy07, 0xabcd0120) + } + + CH03(ts, z169, 0x113, 0, 0) +} + +/* + * Simple increment (see comment to mt0a) + */ +Method(mt0b) +{ + Name(ts, "mt0b") + + CH03(ts, z169, 0x114, 0, 0) + + Increment(\_SB_.ABBU.pr7d.iy07) + Store (\_SB_.ABBU.pr7d.iy07, Local0) + OUTC("mt0b, \_SB_.ABBU.pr7d.iy07:") + OUTC(Local0) + + if (LNotEqual(\_SB_.ABBU.pr7d.iy07, 0xabcd0121)) { + err(ts, z169, 0x01b, 0, 0, \_SB_.ABBU.pr7d.iy07, 0xabcd0121) + } + + CH03(ts, z169, 0x115, 0, 0) +} + +/* + * Check simple access to the object by the name path + * which contains the method name syllables + */ +Method(mt0c) +{ + Name(ts, "mt0c") + + Processor(pr7d, 0, 0x000, 0x008) + { + Name(iy07, 0xabcd0660) + } + + CH03(ts, z169, 0x01c, 0, 0) + + Increment(\_SB_.ABBU.mt0c.pr7d.iy07) + Store (\_SB_.ABBU.mt0c.pr7d.iy07, Local0) + OUTC("mt0c, \_SB_.ABBU.mt0c.pr7d.iy07:") + OUTC(Local0) + + if (LNotEqual(\_SB_.ABBU.mt0c.pr7d.iy07, 0xabcd0661)) { + err(ts, z169, 0x01d, 0, 0, \_SB_.ABBU.mt0c.pr7d.iy07, 0xabcd0661) + } + + CH03(ts, z169, 0x01e, 0, 0) +} + +/* + * Simply long cycle in While + */ +Method(mt0d) +{ + Name(ts, "mt0d") + + Name(i000, 0xabcd1234) + + CH03(ts, z169, 0x116, 0, 0) + + Store(0, Local0) + While (1) { + Increment(Local0) +// if (LEqual(Local0, 0x40000)) { + if (LEqual(Local0, 100)) { + // Break -- doesn't work on MS + OUTC("mt0d, Local0:") + OUTC(Local0) + + mt0e() + + CH03(ts, z169, 0x117, 0, 0) + + Return + } + } + + CH03(ts, z169, 0x118, 0, 0) +} + +/* + * Access to the internal object of method mt0d + */ +Method(mt0e) +{ + Name(ts, "mt0e") + + CH03(ts, z169, 0x119, 0, 0) + + Store (\_SB_.ABBU.mt0d.i000, Local0) + OUTC("mt0e, \_SB_.ABBU.mt0d.i000:") + OUTC(Local0) + + if (LNotEqual(\_SB_.ABBU.mt0d.i000, 0xabcd1234)) { + err(ts, z169, 0x01f, 0, 0, \_SB_.ABBU.mt0d.i000, 0xabcd1234) + } + + CH03(ts, z169, 0x11a, 0, 0) +} + +/* + * Use Add for incrementing object with the + * name of method in the name path. + */ +Method(mt0f) +{ + Name(ts, "mt0f") + + Device(dz05) + { + Name(iy07, 0xabcd0900) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Add(\_SB_.ABBU.mt0f.dz05.iy07, 1, \_SB_.ABBU.mt0f.dz05.iy07) + Store (\_SB_.ABBU.mt0f.dz05.iy07, Local0) + OUTC("mt0f, \_SB_.ABBU.mt0f.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0909)) { + err(ts, z169, 0x020, 0, 0, Local0, 0xabcd0909) + } + if (LNotEqual(\_SB_.ABBU.mt0f.dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x021, 0, 0, \_SB_.ABBU.mt0f.dz05.iy07, 0xabcd0909) + } + } + Add(\_SB_.ABBU.mt0f.dz05.iy07, 1, \_SB_.ABBU.mt0f.dz05.iy07) + mm07() + } + Add(\_SB_.ABBU.mt0f.dz05.iy07, 1, \_SB_.ABBU.mt0f.dz05.iy07) + mm06() + } + Add(\_SB_.ABBU.mt0f.dz05.iy07, 1, \_SB_.ABBU.mt0f.dz05.iy07) + mm05() + } + Add(\_SB_.ABBU.mt0f.dz05.iy07, 1, \_SB_.ABBU.mt0f.dz05.iy07) + mm04() + } + Add(\_SB_.ABBU.mt0f.dz05.iy07, 1, \_SB_.ABBU.mt0f.dz05.iy07) + mm03() + } + Add(\_SB_.ABBU.mt0f.dz05.iy07, 1, \_SB_.ABBU.mt0f.dz05.iy07) + mm02() + } + Add(\_SB_.ABBU.mt0f.dz05.iy07, 1, \_SB_.ABBU.mt0f.dz05.iy07) + mm01() + } + + CH03(ts, z169, 0x022, 0, 0) + + Add(\_SB_.ABBU.mt0f.dz05.iy07, 1, \_SB_.ABBU.mt0f.dz05.iy07) + mm00() + + if (LNotEqual(\_SB_.ABBU.mt0f.dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x023, 0, 0, \_SB_.ABBU.mt0f.dz05.iy07, 0xabcd0909) + } + + CH03(ts, z169, 0x024, 0, 0) +} + +/* + * The same as mt0f, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt10) +{ + Name(ts, "mt10") + + Device(dz05) + { + Name(iy07, 0xabcd0900) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + Store (\_SB_.ABBU.mt10.dz05.iy07, Local0) + OUTC("mt10, \_SB_.ABBU.mt10.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0909)) { + err(ts, z169, 0x025, 0, 0, Local0, 0xabcd0909) + } + if (LNotEqual(\_SB_.ABBU.mt10.dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x026, 0, 0, \_SB_.ABBU.mt10.dz05.iy07, 0xabcd0909) + } + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm0f() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm0e() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm0d() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm0c() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm0b() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm0a() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm09() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm08() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm07() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm06() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm05() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm04() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm03() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm02() + } + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm01() + } + + CH03(ts, z169, 0x027, 0, 0) + + Add(\_SB_.ABBU.mt10.dz05.iy07, 1, \_SB_.ABBU.mt10.dz05.iy07) + mm00() + + if (LNotEqual(\_SB_.ABBU.mt10.dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x028, 0, 0, \_SB_.ABBU.mt10.dz05.iy07, 0xabcd0909) + } + + CH03(ts, z169, 0x029, 0, 0) +} + +/* + * Increment with the parent name paths + */ +Method(mt11) +{ + Name(ts, "mt11") + + Device(dz05) + { + Name(iy07, 0xabcd0900) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Increment(^^^^^^^^dz05.iy07) + Store (^^^^^^^^dz05.iy07, Local0) + OUTC("mt11, ^^^^^^^^dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0909)) { + err(ts, z169, 0x02a, 0, 0, Local0, 0xabcd0909) + } + if (LNotEqual(^^^^^^^^dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x02b, 0, 0, ^^^^^^^^dz05.iy07, 0xabcd0909) + } + } + Increment(^^^^^^^dz05.iy07) + mm07() + } + Increment(^^^^^^dz05.iy07) + mm06() + } + Increment(^^^^^dz05.iy07) + mm05() + } + Increment(^^^^dz05.iy07) + mm04() + } + Increment(^^^dz05.iy07) + mm03() + } + Increment(^^dz05.iy07) + mm02() + } + Increment(^dz05.iy07) + mm01() + } + + CH03(ts, z169, 0x02c, 0, 0) + + Increment(dz05.iy07) + mm00() + + if (LNotEqual(dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x02d, 0, 0, dz05.iy07, 0xabcd0909) + } + + CH03(ts, z169, 0x02e, 0, 0) +} + +/* + * The same as mt11, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt12) +{ + Name(ts, "mt12") + + Device(dz05) + { + Name(iy07, 0xabcd0900) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + OUTC("mt12, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0921)) { + err(ts, z169, 0x02f, 0, 0, Local0, 0xabcd0921) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd0921)) { + err(ts, z169, 0x030, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd0921) + } + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1f() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1e() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1d() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1c() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1b() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1a() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm19() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm18() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm17() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm16() + } + Increment(^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm15() + } + Increment(^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm14() + } + Increment(^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm13() + } + Increment(^^^^^^^^^^^^^^^^^^dz05.iy07) + mm12() + } + Increment(^^^^^^^^^^^^^^^^^dz05.iy07) + mm11() + } + Increment(^^^^^^^^^^^^^^^^dz05.iy07) + mm10() + } + Increment(^^^^^^^^^^^^^^^dz05.iy07) + mm0f() + } + Increment(^^^^^^^^^^^^^^dz05.iy07) + mm0e() + } + Increment(^^^^^^^^^^^^^dz05.iy07) + mm0d() + } + Increment(^^^^^^^^^^^^dz05.iy07) + mm0c() + } + Increment(^^^^^^^^^^^dz05.iy07) + mm0b() + } + Increment(^^^^^^^^^^dz05.iy07) + mm0a() + } + Increment(^^^^^^^^^dz05.iy07) + mm09() + } + Increment(^^^^^^^^dz05.iy07) + mm08() + } + Increment(^^^^^^^dz05.iy07) + mm07() + } + Increment(^^^^^^dz05.iy07) + mm06() + } + Increment(^^^^^dz05.iy07) + mm05() + } + Increment(^^^^dz05.iy07) + mm04() + } + Increment(^^^dz05.iy07) + mm03() + } + Increment(^^dz05.iy07) + mm02() + } + Increment(^dz05.iy07) + mm01() + } + + CH03(ts, z169, 0x11b, 0, 0) + + Increment(dz05.iy07) + mm00() + + if (LNotEqual(dz05.iy07, 0xabcd0909)) { + err(ts, z169, 0x031, 0, 0, dz05.iy07, 0xabcd0909) + } + + CH03(ts, z169, 0x11c, 0, 0) +} + +/* + * Simple Store of object with the name of method in the name path + */ +Method(mt13) +{ + Name(ts, "mt13") + + Device(dz05) + { + Name(iy07, 0xabcd0500) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Store (\_SB_.ABBU.mt13.dz05.iy07, Local0) + OUTC("mt13, \_SB_.ABBU.mt13.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0500)) { + err(ts, z169, 0x032, 0, 0, Local0, 0xabcd0500) + } + if (LNotEqual(\_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z169, 0x033, 0, 0, \_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\_SB_.ABBU.mt13.dz05.iy07, Local0) + mm06() + if (LNotEqual(\_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z169, 0x034, 0, 0, \_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\_SB_.ABBU.mt13.dz05.iy07, Local0) + mm05() + if (LNotEqual(\_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z169, 0x035, 0, 0, \_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\_SB_.ABBU.mt13.dz05.iy07, Local0) + mm04() + if (LNotEqual(\_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z169, 0x036, 0, 0, \_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\_SB_.ABBU.mt13.dz05.iy07, Local0) + mm03() + if (LNotEqual(\_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z169, 0x037, 0, 0, \_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\_SB_.ABBU.mt13.dz05.iy07, Local0) + mm02() + if (LNotEqual(\_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z169, 0x038, 0, 0, \_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\_SB_.ABBU.mt13.dz05.iy07, Local0) + mm01() + if (LNotEqual(\_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z169, 0x039, 0, 0, \_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500) + } + } + + CH03(ts, z169, 0x03a, 0, 0) + + Store (\_SB_.ABBU.mt13.dz05.iy07, Local0) + mm00() + + if (LNotEqual(\_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z169, 0x03b, 0, 0, \_SB_.ABBU.mt13.dz05.iy07, 0xabcd0500) + } + + CH03(ts, z169, 0x03c, 0, 0) +} + +/* + * The same as mt13, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt14) +{ + Name(ts, "mt14") + + Device(dz05) + { + Name(iy07, 0xabcd2900) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + OUTC("mt14, \_SB_.ABBU.mt14.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x03d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x03e, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm1f() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x03f, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x040, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm1e() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x041, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x042, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm1d() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x043, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x044, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm1c() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x045, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x046, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm1b() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x047, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x048, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm1a() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x049, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x04a, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm19() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x04b, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x04c, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm18() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x04d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x04e, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm17() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x04f, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x050, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm16() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x051, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x052, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm15() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x053, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x054, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm14() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x055, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x056, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm13() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x057, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x058, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm12() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x059, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x05a, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm11() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x05b, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x05c, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm10() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x05d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x05e, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm0f() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x05f, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x060, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm0e() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x061, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x062, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm0d() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x063, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x064, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm0c() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x065, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x066, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm0b() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x067, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x068, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm0a() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x069, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x06a, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm09() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x06b, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x06c, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm08() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x06d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x06e, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm07() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x06f, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x070, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm06() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x071, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x072, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm05() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x073, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x074, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm04() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x075, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x076, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm03() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x077, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x078, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm02() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x079, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x07a, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm01() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x07b, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x07c, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + } + + CH03(ts, z169, 0x11d, 0, 0) + + Store (\_SB_.ABBU.mt14.dz05.iy07, Local0) + mm00() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z169, 0x07d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z169, 0x07e, 0, 0, \_SB_.ABBU.mt14.dz05.iy07, 0xabcd2900) + } + + CH03(ts, z169, 0x11e, 0, 0) +} + +/* + * The same as mt14, but contains parent name paths. + * To be run on ACPICA only. + */ +Method(mt15) +{ + Name(ts, "mt15") + + Device(dz05) + { + Name(iy07, 0xabcd3900) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + OUTC("mt15, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x07f, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x080, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1f() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x081, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x082, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1e() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x083, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x084, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1d() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x085, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x086, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1c() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x087, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x088, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1b() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x089, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x08a, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1a() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x08b, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x08c, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm19() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x08d, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x08e, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm18() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x08f, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x090, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm17() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x091, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x092, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm16() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x093, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x094, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm15() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x095, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x096, 0, 0, ^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm14() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x097, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x098, 0, 0, ^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm13() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x099, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x09a, 0, 0, ^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm12() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x09b, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x09c, 0, 0, ^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm11() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x09d, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x09e, 0, 0, ^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm10() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x09f, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0a0, 0, 0, ^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm0f() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0a1, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0a2, 0, 0, ^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^dz05.iy07, Local0) + mm0e() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0a3, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0a4, 0, 0, ^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^dz05.iy07, Local0) + mm0d() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0a5, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0a6, 0, 0, ^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^dz05.iy07, Local0) + mm0c() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0a7, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0a8, 0, 0, ^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^dz05.iy07, Local0) + mm0b() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0a9, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0aa, 0, 0, ^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^dz05.iy07, Local0) + mm0a() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0ab, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0ac, 0, 0, ^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^dz05.iy07, Local0) + mm09() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0ad, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0ae, 0, 0, ^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^dz05.iy07, Local0) + mm08() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0af, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0b0, 0, 0, ^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^dz05.iy07, Local0) + mm07() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0b1, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0b2, 0, 0, ^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^dz05.iy07, Local0) + mm06() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0b3, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0b4, 0, 0, ^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^dz05.iy07, Local0) + mm05() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0b5, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0b6, 0, 0, ^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^dz05.iy07, Local0) + mm04() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0b7, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0b8, 0, 0, ^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^dz05.iy07, Local0) + mm03() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0b9, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0ba, 0, 0, ^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^dz05.iy07, Local0) + mm02() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0bb, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0bc, 0, 0, ^^dz05.iy07, 0xabcd3900) + } + } + Store (^dz05.iy07, Local0) + mm01() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0bd, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0be, 0, 0, ^dz05.iy07, 0xabcd3900) + } + } + + CH03(ts, z169, 0x11f, 0, 0) + + Store (dz05.iy07, Local0) + mm00() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z169, 0x0bf, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(dz05.iy07, 0xabcd3900)) { + err(ts, z169, 0x0c0, 0, 0, dz05.iy07, 0xabcd3900) + } + + CH03(ts, z169, 0x120, 0, 0) +} + +/* + * Access to the internal object of invoked method + */ +Method(mt16, 1) +{ + Name(ts, "mt16") + + Name(i000, 0) + Name(i001, 0) + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Device(dz05) + { + Name(iy07, 0xabcd4900) + } + if (LEqual(i001, 1)) { + Store(0xabcd4904, dz05.iy07) + m001(1) + } elseif (LEqual(i001, 2)) { + Store(0xabcd4905, dz05.iy07) + m001(2) + } elseif (LEqual(i001, 3)) { + m001(3) + } + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + Method(m000) + { + Store (^mm00.mm01.mm02.mm03.mm04.dz05.iy07, i000) + } + + Method(m001, 1) + { + Method(mmF1, 1) + { + Method(mmF2, 1) + { + Device(dz05) + { + Name(iy07, 0xabcd6900) + } + if (LEqual(arg0, 1)) { + Store (\_SB_.ABBU.mt16.mm00.mm01.mm02.mm03.mm04.dz05.iy07, i000) + } elseif (LEqual(arg0, 2)) { + Store (^^^mm00.mm01.mm02.mm03.mm04.dz05.iy07, i000) + } elseif (LEqual(arg0, 3)) { + Store (^^mmF1.mmF2.dz05.iy07, i000) + } + } + mmF2(arg0) + } + mmF1(arg0) + } + + CH03(ts, z169, 0x0c1, 0, 0) + + if (LEqual(arg0, 0)) { + // Access to the internal data of method (mm00...) not being invoked + m000() + CH04(ts, 0, 5, z169, 0x0c2, 0, 0) // AE_NOT_FOUND + } elseif (LEqual(arg0, 1)) { + + // Access to the internal data of method (mm00...) being invoked + // by \_SB_.ABBU.mt16.mm00.... + + Store(1, i001) + mm00() + if (LNotEqual(i000, 0xabcd4904)) { + err(ts, z169, 0x0c3, 0, 0, i000, 0xabcd4904) + } + } elseif (LEqual(arg0, 2)) { + + // Access to the internal data of method (mm00...) being invoked + // by ^^^^^^^^^^^^mm00... + + Store(2, i001) + mm00() + if (LNotEqual(i000, 0xabcd4905)) { + err(ts, z169, 0x0c4, 0, 0, i000, 0xabcd4905) + } + + } elseif (LEqual(arg0, 3)) { + + // Access to the internal data of method (m001.mmF1.mmF2.mmF3.dz05.iy07...) + // being invoked by ^^^^^^^^^^^^mm01... + + Store(3, i001) + mm00() + if (LNotEqual(i000, 0xabcd6900)) { + err(ts, z169, 0x0c4, 0, 0, i000, 0xabcd6900) + } + } + + CH03(ts, z169, 0x0c5, 0, 0) +} + +/* + * The same as mt16, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt17, 1) +{ + Name(ts, "mt17") + + Name(i000, 0) + Name(i001, 0) + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + Method(mm20) + { + Method(mm21) + { + Device(dz05) + { + Name(iy07, 0xabcd5900) + } + Method(mm22) + { + Method(mm23) + { + Method(mm24) + { + Method(mm25) + { + if (LEqual(i001, 1)) { + Store(0xabcd4906, ^^^^dz05.iy07) + m001(1) + } elseif (LEqual(i001, 2)) { + Store(0xabcd4907, ^^^^dz05.iy07) + m001(2) + } elseif (LEqual(i001, 3)) { + m001(3) + } + } + mm25() + } + mm24() + } + mm23() + } + mm22() + } + mm21() + } + mm20() + } + mm1f() + } + mm1e() + } + mm1d() + } + mm1c() + } + mm1b() + } + mm1a() + } + mm19() + } + mm18() + } + mm17() + } + mm16() + } + mm15() + } + mm14() + } + mm13() + } + mm12() + } + mm11() + } + mm10() + } + mm0f() + } + mm0e() + } + mm0d() + } + mm0c() + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + Method(m000) + { + Store (^mm00.mm01.mm02.mm03.mm04.mm05.mm06.mm07.mm08.mm09.mm0a.mm0b.mm0c.mm0d.mm0e.mm0f.mm10.mm11.mm12.mm13.mm14.mm15.mm16.mm17.mm18.mm19.mm1a.mm1b.mm1c.mm1d.mm1e.mm1f.mm20.mm21.dz05.iy07, i000) + } + + Method(m001, 1) + { + Method(mmF1, 1) + { + Method(mmF2, 1) + { + Method(mmF3, 1) + { + Method(mmF4, 1) + { + Method(mmF5, 1) + { + Method(mmF6, 1) + { + Method(mmF7, 1) + { + Method(mmF8, 1) + { + Method(mmF9, 1) + { + Method(mmFa, 1) + { + Method(mmFb, 1) + { + Method(mmFc, 1) + { + Method(mmFd, 1) + { + Method(mmFe, 1) + { + Method(mmFf, 1) + { + Method(mm10, 1) + { + Method(mm11, 1) + { + Device(dz05) + { + Name(iy07, 0xabcd4908) + } + Method(mm12, 1) + { + Method(mm13, 1) + { + Method(mm14, 1) + { + Method(mm15, 1) + { + Method(mm16, 1) + { + Method(mm17, 1) + { + Method(mm18, 1) + { + Method(mm19, 1) + { + Method(mm1a, 1) + { + Method(mm1b, 1) + { + Method(mm1c, 1) + { + Method(mm1d, 1) + { + Method(mm1e, 1) + { + Method(mm1f, 1) + { +if (LEqual(arg0, 1)) { + Store (\_SB_.ABBU.mt17.mm00.mm01.mm02.mm03.mm04.mm05.mm06.mm07.mm08.mm09.mm0a.mm0b.mm0c.mm0d.mm0e.mm0f.mm10.mm11.mm12.mm13.mm14.mm15.mm16.mm17.mm18.mm19.mm1a.mm1b.mm1c.mm1d.mm1e.mm1f.mm20.mm21.dz05.iy07, i000) +} elseif (LEqual(arg0, 2)) { + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^mm00.mm01.mm02.mm03.mm04.mm05.mm06.mm07.mm08.mm09.mm0a.mm0b.mm0c.mm0d.mm0e.mm0f.mm10.mm11.mm12.mm13.mm14.mm15.mm16.mm17.mm18.mm19.mm1a.mm1b.mm1c.mm1d.mm1e.mm1f.mm20.mm21.dz05.iy07, i000) +} elseif (LEqual(arg0, 3)) { + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^mmF6.mmF7.mmF8.mmF9.mmFa.mmFb.mmFc.mmFd.mmFe.mmFf.mm10.mm11.dz05.iy07, i000) +} + } + mm1f(arg0) + } + mm1e(arg0) + } + mm1d(arg0) + } + mm1c(arg0) + } + mm1b(arg0) + } + mm1a(arg0) + } + mm19(arg0) + } + mm18(arg0) + } + mm17(arg0) + } + mm16(arg0) + } + mm15(arg0) + } + mm14(arg0) + } + mm13(arg0) + } + mm12(arg0) + } + mm11(arg0) + } + mm10(arg0) + } + mmFf(arg0) + } + mmFe(arg0) + } + mmFd(arg0) + } + mmFc(arg0) + } + mmFb(arg0) + } + mmFa(arg0) + } + mmF9(arg0) + } + mmF8(arg0) + } + mmF7(arg0) + } + mmF6(arg0) + } + mmF5(arg0) + } + mmF4(arg0) + } + mmF3(arg0) + } + mmF2(arg0) + } + mmF1(arg0) + } + + CH03(ts, z169, 0x0c6, 0, 0) + + if (LEqual(arg0, 0)) { + // Access to the internal data of method (mm00...) not being invoked + m000() + CH04(ts, 0, 5, z169, 0x0c7, 0, 0) // AE_NOT_FOUND + } elseif (LEqual(arg0, 1)) { + + // Access to the internal data of method (mm00...) being invoked + // by \_SB_.ABBU.mt16.mm00.... + + Store(1, i001) + mm00() + if (LNotEqual(i000, 0xabcd4906)) { + err(ts, z169, 0x0c8, 0, 0, i000, 0xabcd4906) + } + } elseif (LEqual(arg0, 2)) { + + // Access to the internal data of method (mm00...) being invoked + // by ^^^^^^^^^^^^mm00... + + Store(2, i001) + mm00() + if (LNotEqual(i000, 0xabcd4907)) { + err(ts, z169, 0x0c9, 0, 0, i000, 0xabcd4907) + } + + } elseif (LEqual(arg0, 3)) { + + // Access to the internal data of method (m001.mmF1.mmF2.mmF3.dz05.iy07...) + // being invoked by ^^^^^^^^^^^^mm01... + + Store(3, i001) + mm00() + if (LNotEqual(i000, 0xabcd4908)) { + err(ts, z169, 0x0ca, 0, 0, i000, 0xabcd4908) + } + } + + CH03(ts, z169, 0x0cb, 0, 0) +} + +Method(mt18, 1) +{ + Name(ts, "mt18") + + Device(dz05) + { + Name(iy07, 0xabcd4900) + } + + CH03(ts, z169, 0x0cc, 0, 0) + + if (arg0) { + Store(0xabcd9000, \_SB_.ABBU.mt18.dz05.iy07) + if (LNotEqual(\_SB_.ABBU.mt18.dz05.iy07, 0xabcd9000)) { + err(ts, z169, 0x0ca, 0, 0, \_SB_.ABBU.mt18.dz05.iy07, 0xabcd9000) + } + } else { + Store(0xabcd9001, dz05.iy07) + if (LNotEqual(dz05.iy07, 0xabcd9001)) { + err(ts, z169, 0x0ca, 0, 0, dz05.iy07, 0xabcd9001) + } + } + + CH03(ts, z169, 0x0cd, 0, 0) +} + +Method(mt19, 1) +{ + Name(ts, "mt19") + + Processor(pr7d, 0, 0x000, 0x008) + { + Name(iy07, 0xabcd0660) + } + + CH03(ts, z169, 0x0ce, 0, 0) + + if (arg0) { + Store(0xabcd9002, \_SB_.ABBU.mt19.pr7d.iy07) + if (LNotEqual(\_SB_.ABBU.mt19.pr7d.iy07, 0xabcd9002)) { + err(ts, z169, 0x0ca, 0, 0, \_SB_.ABBU.mt19.pr7d.iy07, 0xabcd9002) + } + } else { + Store(0xabcd9003, pr7d.iy07) + if (LNotEqual(pr7d.iy07, 0xabcd9003)) { + err(ts, z169, 0x0ca, 0, 0, pr7d.iy07, 0xabcd9003) + } + } + + CH03(ts, z169, 0x0cf, 0, 0) +} + +Method(mt1a, 1) +{ + Name(ts, "mt1a") + + CH03(ts, z169, 0x0d0, 0, 0) + if (arg0) { + Store(0xabcd9004, \_SB_.ABBU.pr7d.iy07) + if (LNotEqual(\_SB_.ABBU.pr7d.iy07, 0xabcd9004)) { + err(ts, z169, 0x0ca, 0, 0, \_SB_.ABBU.pr7d.iy07, 0xabcd9004) + } + } else { + Store(0xabcd9005, ^pr7d.iy07) + if (LNotEqual(^pr7d.iy07, 0xabcd9005)) { + err(ts, z169, 0x0ca, 0, 0, ^pr7d.iy07, 0xabcd9005) + } + } + CH03(ts, z169, 0x0d1, 0, 0) +} + + + +Method(mtff) +{ + Name(run0, 1) + + + + // Works on both + SRMT("mt00") + mt00() + + if (chk0) { + // Exceeded the depth supported on MS + SRMT("mt01") + mt01() + } + + // Works on both + SRMT("mt02") + mt02() + + if (chk0) { + // Exceeded the depth supported on MS + SRMT("mt03") + mt03() + } + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt04") + mt04() + } + + if (LAnd(chk0, run0)) { + // Exceeded the depth supported on MS + SRMT("mt05") + mt05() + } + + // Works on both + SRMT("mt06") + mt06() + + if (0) { + // Fails for both here - for MS and ACPICA + SRMT("mt07") + mt07() + } + + if (chk0) { + // Exceeded the depth supported on MS + SRMT("mt08") + mt08() + } + + // Works on both + SRMT("mt0a") + mt0a() + SRMT("mt0b") + mt0b() + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt0c") + mt0c() + } + + // Simply long cycle in While + SRMT("mt0d") + mt0d() + + if (0) { + SRMT("mt0e") + mt0e() // Result: ACPICA - AE_NOT_FOUND, MS - Failure + } + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt0f") + mt0f() + } + + if (LAnd(chk0, run0)) { + // Exceeded the depth supported on MS + SRMT("mt10") + mt10() + } + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt11") + mt11() + } + + if (LAnd(chk0, run0)) { + // Exceeded the depth supported on MS + SRMT("mt12") + mt12() + } + + // Works on both + SRMT("mt13") + mt13() + + if (chk0) { + // Exceeded the depth supported on MS + SRMT("mt14") + mt14() + SRMT("mt15") + mt15() + } + + if (chk0) { + // ACPICA - AE_NOT_FOUND (it is correct), MS - Failure + SRMT("mt16-0") + mt16(0) + } + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt16-1") + mt16(1) + SRMT("mt16-2") + mt16(2) + SRMT("mt16-3") + mt16(3) + } + + if (chk0) { + // ACPICA - AE_NOT_FOUND (it is correct), MS - Failure + SRMT("mt17-0") + mt17(0) + } + + if (LAnd(chk0, run0)) { + // Exceeded the depth supported on MS + SRMT("mt17-1") + mt17(1) + SRMT("mt17-2") + mt17(2) + } + + SRMT("mt18-0") + mt18(0) + SRMT("mt18-1") + mt18(1) + SRMT("mt19-0") + mt19(0) + SRMT("mt19-1") + mt19(1) + SRMT("mt1a-0") + mt1a(0) + SRMT("mt1a-1") + mt1a(1) +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/method/mt0_aslts.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/method/mt0_aslts.asl new file mode 100644 index 000000000..927ad3a9e --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/method/mt0_aslts.asl @@ -0,0 +1,3156 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests to check path names with method type syllables + */ + +Name(z170, 170) + + +Processor(pr7d, 0, 0x000, 0x008) +{ + Name(iy07, 0xabcd0120) +} + +/* + * Test shows maximal supported depth of enclosed method calls on MS + */ +Method(mt00) +{ + Name(ts, "mt00") + + Name(i000, 0) + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + // OUTC("Number of calls to methods depends on the length of this message!") + OUTC("Max") + Store(0xabcd0000, i000) + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z170, 0x100, 0, 0) + + mm00() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z170, 0x000, 0, 0, i000, 0xabcd0000) + } + + CH03(ts, z170, 0x101, 0, 0) +} + +/* + * The same as mt00, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt01) +{ + Name(ts, "mt01") + + Name(i000, 0) + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + OUTC("Max") + Store(0xabcd0000, i000) + } + mm1f() + } + mm1e() + } + mm1d() + } + mm1c() + } + mm1b() + } + mm1a() + } + mm19() + } + mm18() + } + mm17() + } + mm16() + } + mm15() + } + mm14() + } + mm13() + } + mm12() + } + mm11() + } + mm10() + } + mm0f() + } + mm0e() + } + mm0d() + } + mm0c() + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z170, 0x102, 0, 0) + + mm00() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z170, 0x001, 0, 0, i000, 0xabcd0000) + } + + CH03(ts, z170, 0x103, 0, 0) +} + +/* + * Test shows maximal supported depth of enclosed method calls on MS + */ +Method(mt02) +{ + Name(ts, "mt02") + + Name(i000, 0) + + Method(mm00) + { + mm01() + } + Method(mm01) + { + mm02() + } + Method(mm02) + { + mm03() + } + Method(mm03) + { + mm04() + } + Method(mm04) + { + mm05() + } + Method(mm05) + { + mm06() + } + Method(mm06) + { + mm07() + } + Method(mm07) + { + mm08() + } + Method(mm08) + { + mm09() + } + Method(mm09) + { + mm0a() + } + Method(mm0a) + { + mm0b() + } + Method(mm0b) + { + mm0c() + } + Method(mm0c) + { + mm0d() + } + Method(mm0d) + { + mm0e() + } + Method(mm0e) + { + mm0f() + } + Method(mm0f) + { + OUTC("Max") + Store(0xabcd0000, i000) + } + + CH03(ts, z170, 0x104, 0, 0) + + mm00() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z170, 0x002, 0, 0, i000, 0xabcd0000) + } + + CH03(ts, z170, 0x105, 0, 0) +} + +/* + * The same as mt02, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt03) +{ + Name(ts, "mt03") + + Name(i000, 0) + + Method(mm00) + { + mm01() + } + Method(mm01) + { + mm02() + } + Method(mm02) + { + mm03() + } + Method(mm03) + { + mm04() + } + Method(mm04) + { + mm05() + } + Method(mm05) + { + mm06() + } + Method(mm06) + { + mm07() + } + Method(mm07) + { + mm08() + } + Method(mm08) + { + mm09() + } + Method(mm09) + { + mm0a() + } + Method(mm0a) + { + mm0b() + } + Method(mm0b) + { + mm0c() + } + Method(mm0c) + { + mm0d() + } + Method(mm0d) + { + mm0e() + } + Method(mm0e) + { + mm0f() + } + Method(mm0f) + { + mm10() + } + Method(mm10) + { + mm11() + } + Method(mm11) + { + mm12() + } + Method(mm12) + { + mm13() + } + Method(mm13) + { + mm14() + } + Method(mm14) + { + mm15() + } + Method(mm15) + { + mm16() + } + Method(mm16) + { + mm17() + } + Method(mm17) + { + mm18() + } + Method(mm18) + { + mm19() + } + Method(mm19) + { + mm1a() + } + Method(mm1a) + { + mm1b() + } + Method(mm1b) + { + mm1c() + } + Method(mm1c) + { + mm1d() + } + Method(mm1d) + { + mm1e() + } + Method(mm1e) + { + mm1f() + } + Method(mm1f) + { + OUTC("Max") + Store(0xabcd0000, i000) + } + + CH03(ts, z170, 0x106, 0, 0) + + mm00() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z170, 0x003, 0, 0, i000, 0xabcd0000) + } + + CH03(ts, z170, 0x107, 0, 0) +} + +/* + * Increment object with the name of method in the name path + */ +Method(mt04) +{ + Name(ts, "mt04") + + Device(dz05) + { + Name(iy07, 0xabcd0100) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Increment(\mt04.dz05.iy07) + Store (\mt04.dz05.iy07, Local0) + OUTC("mt04, \mt04.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0109)) { + err(ts, z170, 0x004, 0, 0, Local0, 0xabcd0109) + } + if (LNotEqual(\mt04.dz05.iy07, 0xabcd0109)) { + err(ts, z170, 0x005, 0, 0, \mt04.dz05.iy07, 0xabcd0109) + } + } + Increment(\mt04.dz05.iy07) + mm07() + } + Increment(\mt04.dz05.iy07) + mm06() + } + Increment(\mt04.dz05.iy07) + mm05() + } + Increment(\mt04.dz05.iy07) + mm04() + } + Increment(\mt04.dz05.iy07) + mm03() + } + Increment(\mt04.dz05.iy07) + mm02() + } + Increment(\mt04.dz05.iy07) + mm01() + } + + CH03(ts, z170, 0x006, 0, 0) + + Increment(\mt04.dz05.iy07) + + mm00() + + if (LNotEqual(\mt04.dz05.iy07, 0xabcd0109)) { + err(ts, z170, 0x007, 0, 0, \mt04.dz05.iy07, 0xabcd0109) + } + + CH03(ts, z170, 0x008, 0, 0) +} + +/* + * The same as mt04, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt05) +{ + Name(ts, "mt05") + + Device(dz05) + { + Name(iy07, 0xabcd0200) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Increment(\mt05.dz05.iy07) + Store (\mt05.dz05.iy07, Local0) + OUTC("mt05, \mt05.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0211)) { + err(ts, z170, 0x009, 0, 0, Local0, 0xabcd0211) + } + if (LNotEqual(\mt05.dz05.iy07, 0xabcd0211)) { + err(ts, z170, 0x00a, 0, 0, \mt05.dz05.iy07, 0xabcd0211) + } + } + Increment(\mt05.dz05.iy07) + mm0f() + } + Increment(\mt05.dz05.iy07) + mm0e() + } + Increment(\mt05.dz05.iy07) + mm0d() + } + Increment(\mt05.dz05.iy07) + mm0c() + } + Increment(\mt05.dz05.iy07) + mm0b() + } + Increment(\mt05.dz05.iy07) + mm0a() + } + Increment(\mt05.dz05.iy07) + mm09() + } + Increment(\mt05.dz05.iy07) + mm08() + } + Increment(\mt05.dz05.iy07) + mm07() + } + Increment(\mt05.dz05.iy07) + mm06() + } + Increment(\mt05.dz05.iy07) + mm05() + } + Increment(\mt05.dz05.iy07) + mm04() + } + Increment(\mt05.dz05.iy07) + mm03() + } + Increment(\mt05.dz05.iy07) + mm02() + } + Increment(\mt05.dz05.iy07) + mm01() + } + + CH03(ts, z170, 0x108, 0, 0) + + Increment(\mt05.dz05.iy07) + mm00() + + if (LNotEqual(\mt05.dz05.iy07, 0xabcd0211)) { + err(ts, z170, 0x00b, 0, 0, \mt05.dz05.iy07, 0xabcd0211) + } + + CH03(ts, z170, 0x109, 0, 0) +} + +/* + * Check access to the internal object of method being executed + * from the point inside the tree of that method being executed + * but by the method statically declared outside that method. + */ +Method(mt06) +{ + Name(ts, "mt06") + + Device(dz05) + { + Name(iy07, 0xabcd0300) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Store (0x11112222, \mt06.dz05.iy07) + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + Store (\mt06.dz05.iy07, Local0) + OUTC("mt06, \mt06.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z170, 0x00c, 0, 0, Local0, 0x11112222) + } + if (LNotEqual(\mt06.dz05.iy07, 0x11112222)) { + err(ts, z170, 0x00d, 0, 0, \mt06.dz05.iy07, 0x11112222) + } + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z170, 0x10a, 0, 0) + + mm00() + + mt07() + + if (LNotEqual(\mt06.dz05.iy07, 0x11112222)) { + err(ts, z170, 0x00e, 0, 0, \mt06.dz05.iy07, 0x11112222) + } + + CH03(ts, z170, 0x10b, 0, 0) +} + +/* + * Access to the internal object of method mt06 + * + * Result differs depending on either mt06 is invoked or not. + * Unfortunately, we can run mt06 and mt07 simultaneously only + * on the same thread (invocation). + */ +Method(mt07) +{ + Name(ts, "mt07") + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Store (\mt06.dz05.iy07, Local0) + OUTC("0 mt07, \mt06.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z170, 0x00f, 0, 0, Local0, 0x11112222) + } + if (LNotEqual(\mt06.dz05.iy07, 0x11112222)) { + err(ts, z170, 0x010, 0, 0, \mt06.dz05.iy07, 0x11112222) + } + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z170, 0x10c, 0, 0) + + mm00() + + Store (\mt06.dz05.iy07, Local0) + OUTC("1 mt07, \mt06.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x11112222)) { + err(ts, z170, 0x011, 0, 0, Local0, 0x11112222) + } + if (LNotEqual(\mt06.dz05.iy07, 0x11112222)) { + err(ts, z170, 0x012, 0, 0, \mt06.dz05.iy07, 0x11112222) + } + + CH03(ts, z170, 0x10d, 0, 0) +} + +/* + * The same as mt06, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt08) +{ + Name(ts, "mt08") + + Device(dz05) + { + Name(iy07, 0xabcd0400) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Store (0x22223333, \mt08.dz05.iy07) + } + mm0f() + } + mm0e() + } + mm0d() + } + mm0c() + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + Store (\mt08.dz05.iy07, Local0) + OUTC("mt08, \mt08.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x22223333)) { + err(ts, z170, 0x013, 0, 0, Local0, 0x22223333) + } + if (LNotEqual(\mt08.dz05.iy07, 0x22223333)) { + err(ts, z170, 0x014, 0, 0, \mt08.dz05.iy07, 0x22223333) + } + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z170, 0x10e, 0, 0) + + mm00() + + mt09() + + if (LNotEqual(\mt08.dz05.iy07, 0x22223333)) { + err(ts, z170, 0x015, 0, 0, \mt08.dz05.iy07, 0x22223333) + } + + CH03(ts, z170, 0x10f, 0, 0) +} + +/* + * Access to the internal object of method mt08 + * + * see comment to mt07 + */ +Method(mt09) +{ + Name(ts, "mt09") + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Store (\mt08.dz05.iy07, Local0) + OUTC("0 mt09, \mt08.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x22223333)) { + err(ts, z170, 0x016, 0, 0, Local0, 0x22223333) + } + if (LNotEqual(\mt08.dz05.iy07, 0x22223333)) { + err(ts, z170, 0x017, 0, 0, \mt08.dz05.iy07, 0x22223333) + } + } + mm0f() + } + mm0e() + } + mm0d() + } + mm0c() + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + CH03(ts, z170, 0x110, 0, 0) + + mm00() + + Store (\mt08.dz05.iy07, Local0) + OUTC("1 mt09, \mt08.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0x22223333)) { + err(ts, z170, 0x018, 0, 0, Local0, 0x22223333) + } + if (LNotEqual(\mt08.dz05.iy07, 0x22223333)) { + err(ts, z170, 0x019, 0, 0, \mt08.dz05.iy07, 0x22223333) + } + + CH03(ts, z170, 0x111, 0, 0) +} + +/* + * Check simple access to the object by the name path + * without method name syllables + */ +Method(mt0a) +{ + Name(ts, "mt0a") + + CH03(ts, z170, 0x112, 0, 0) + + Store (\pr7d.iy07, Local0) + OUTC("mt0a, \pr7d.iy07:") + OUTC(Local0) + if (LNotEqual(\pr7d.iy07, 0xabcd0120)) { + err(ts, z170, 0x01a, 0, 0, \pr7d.iy07, 0xabcd0120) + } + + CH03(ts, z170, 0x113, 0, 0) +} + +/* + * Simple increment (see comment to mt0a) + */ +Method(mt0b) +{ + Name(ts, "mt0b") + + CH03(ts, z170, 0x114, 0, 0) + + Increment(\pr7d.iy07) + Store (\pr7d.iy07, Local0) + OUTC("mt0b, \pr7d.iy07:") + OUTC(Local0) + + if (LNotEqual(\pr7d.iy07, 0xabcd0121)) { + err(ts, z170, 0x01b, 0, 0, \pr7d.iy07, 0xabcd0121) + } + + CH03(ts, z170, 0x115, 0, 0) +} + +/* + * Check simple access to the object by the name path + * which contains the method name syllables + */ +Method(mt0c) +{ + Name(ts, "mt0c") + + Processor(pr7d, 0, 0x000, 0x008) + { + Name(iy07, 0xabcd0660) + } + + CH03(ts, z170, 0x116, 0, 0) + + Increment(\mt0c.pr7d.iy07) + Store (\mt0c.pr7d.iy07, Local0) + OUTC("mt0c, \mt0c.pr7d.iy07:") + OUTC(Local0) + + if (LNotEqual(\mt0c.pr7d.iy07, 0xabcd0661)) { + err(ts, z170, 0x01d, 0, 0, \mt0c.pr7d.iy07, 0xabcd0661) + } + + CH03(ts, z170, 0x117, 0, 0) +} + +/* + * Simply long cycle in While + */ +Method(mt0d) +{ + Name(ts, "mt0d") + + Name(i000, 0xabcd1234) + + CH03(ts, z170, 0x118, 0, 0) + + Store(0, Local0) + While (1) { + Increment(Local0) +// if (LEqual(Local0, 0x40000)) { + if (LEqual(Local0, 100)) { + // Break -- doesn't work on MS + OUTC("mt0d, Local0:") + OUTC(Local0) + + mt0e() + + CH03(ts, z170, 0x119, 0, 0) + + Return + } + } + + CH03(ts, z170, 0x11a, 0, 0) +} + +/* + * Access to the internal object of method mt0d + */ +Method(mt0e) +{ + Name(ts, "mt0e") + + CH03(ts, z170, 0x11b, 0, 0) + + Store (\mt0d.i000, Local0) + OUTC("mt0e, \mt0d.i000:") + OUTC(Local0) + + if (LNotEqual(\mt0d.i000, 0xabcd1234)) { + err(ts, z170, 0x01f, 0, 0, \mt0d.i000, 0xabcd1234) + } + + CH03(ts, z170, 0x11c, 0, 0) +} + +/* + * Use Add for incrementing object with the + * name of method in the name path. + */ +Method(mt0f) +{ + Name(ts, "mt0f") + + Device(dz05) + { + Name(iy07, 0xabcd0500) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Add(\mt0f.dz05.iy07, 1, \mt0f.dz05.iy07) + Store (\mt0f.dz05.iy07, Local0) + OUTC("mt0f, \mt0f.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0509)) { + err(ts, z170, 0x020, 0, 0, Local0, 0xabcd0509) + } + if (LNotEqual(\mt0f.dz05.iy07, 0xabcd0509)) { + err(ts, z170, 0x021, 0, 0, \mt0f.dz05.iy07, 0xabcd0509) + } + } + Add(\mt0f.dz05.iy07, 1, \mt0f.dz05.iy07) + mm07() + } + Add(\mt0f.dz05.iy07, 1, \mt0f.dz05.iy07) + mm06() + } + Add(\mt0f.dz05.iy07, 1, \mt0f.dz05.iy07) + mm05() + } + Add(\mt0f.dz05.iy07, 1, \mt0f.dz05.iy07) + mm04() + } + Add(\mt0f.dz05.iy07, 1, \mt0f.dz05.iy07) + mm03() + } + Add(\mt0f.dz05.iy07, 1, \mt0f.dz05.iy07) + mm02() + } + Add(\mt0f.dz05.iy07, 1, \mt0f.dz05.iy07) + mm01() + } + + CH03(ts, z170, 0x022, 0, 0) + + Add(\mt0f.dz05.iy07, 1, \mt0f.dz05.iy07) + mm00() + + if (LNotEqual(\mt0f.dz05.iy07, 0xabcd0509)) { + err(ts, z170, 0x023, 0, 0, \mt0f.dz05.iy07, 0xabcd0509) + } + + CH03(ts, z170, 0x024, 0, 0) +} + +/* + * The same as mt0f, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt10) +{ + Name(ts, "mt10") + + Device(dz05) + { + Name(iy07, 0xabcd0600) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + Store (\mt10.dz05.iy07, Local0) + OUTC("mt10, \mt10.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0611)) { + err(ts, z170, 0x025, 0, 0, Local0, 0xabcd0611) + } + if (LNotEqual(\mt10.dz05.iy07, 0xabcd0611)) { + err(ts, z170, 0x026, 0, 0, \mt10.dz05.iy07, 0xabcd0611) + } + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm0f() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm0e() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm0d() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm0c() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm0b() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm0a() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm09() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm08() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm07() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm06() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm05() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm04() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm03() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm02() + } + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm01() + } + + CH03(ts, z170, 0x027, 0, 0) + + Add(\mt10.dz05.iy07, 1, \mt10.dz05.iy07) + mm00() + + if (LNotEqual(\mt10.dz05.iy07, 0xabcd0611)) { + err(ts, z170, 0x028, 0, 0, \mt10.dz05.iy07, 0xabcd0611) + } + + CH03(ts, z170, 0x029, 0, 0) +} + +/* + * Increment with the parent name paths + */ +Method(mt11) +{ + Name(ts, "mt11") + + Device(dz05) + { + Name(iy07, 0xabcd0700) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Increment(^^^^^^^^dz05.iy07) + Store (^^^^^^^^dz05.iy07, Local0) + OUTC("mt11, ^^^^^^^^dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0709)) { + err(ts, z170, 0x02a, 0, 0, Local0, 0xabcd0709) + } + if (LNotEqual(^^^^^^^^dz05.iy07, 0xabcd0709)) { + err(ts, z170, 0x02b, 0, 0, ^^^^^^^^dz05.iy07, 0xabcd0709) + } + } + Increment(^^^^^^^dz05.iy07) + mm07() + } + Increment(^^^^^^dz05.iy07) + mm06() + } + Increment(^^^^^dz05.iy07) + mm05() + } + Increment(^^^^dz05.iy07) + mm04() + } + Increment(^^^dz05.iy07) + mm03() + } + Increment(^^dz05.iy07) + mm02() + } + Increment(^dz05.iy07) + mm01() + } + + CH03(ts, z170, 0x02c, 0, 0) + + Increment(dz05.iy07) + mm00() + + if (LNotEqual(dz05.iy07, 0xabcd0709)) { + err(ts, z170, 0x02d, 0, 0, dz05.iy07, 0xabcd0709) + } + + CH03(ts, z170, 0x02e, 0, 0) +} + +/* + * The same as mt11, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt12) +{ + Name(ts, "mt12") + + Device(dz05) + { + Name(iy07, 0xabcd0800) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + OUTC("mt12, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0821)) { + err(ts, z170, 0x02f, 0, 0, Local0, 0xabcd0821) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd0821)) { + err(ts, z170, 0x030, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd0821) + } + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1f() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1e() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1d() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1c() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1b() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm1a() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm19() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm18() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm17() + } + Increment(^^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm16() + } + Increment(^^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm15() + } + Increment(^^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm14() + } + Increment(^^^^^^^^^^^^^^^^^^^dz05.iy07) + mm13() + } + Increment(^^^^^^^^^^^^^^^^^^dz05.iy07) + mm12() + } + Increment(^^^^^^^^^^^^^^^^^dz05.iy07) + mm11() + } + Increment(^^^^^^^^^^^^^^^^dz05.iy07) + mm10() + } + Increment(^^^^^^^^^^^^^^^dz05.iy07) + mm0f() + } + Increment(^^^^^^^^^^^^^^dz05.iy07) + mm0e() + } + Increment(^^^^^^^^^^^^^dz05.iy07) + mm0d() + } + Increment(^^^^^^^^^^^^dz05.iy07) + mm0c() + } + Increment(^^^^^^^^^^^dz05.iy07) + mm0b() + } + Increment(^^^^^^^^^^dz05.iy07) + mm0a() + } + Increment(^^^^^^^^^dz05.iy07) + mm09() + } + Increment(^^^^^^^^dz05.iy07) + mm08() + } + Increment(^^^^^^^dz05.iy07) + mm07() + } + Increment(^^^^^^dz05.iy07) + mm06() + } + Increment(^^^^^dz05.iy07) + mm05() + } + Increment(^^^^dz05.iy07) + mm04() + } + Increment(^^^dz05.iy07) + mm03() + } + Increment(^^dz05.iy07) + mm02() + } + Increment(^dz05.iy07) + mm01() + } + + CH03(ts, z170, 0x11d, 0, 0) + + Increment(dz05.iy07) + mm00() + + if (LNotEqual(dz05.iy07, 0xabcd0821)) { + err(ts, z170, 0x031, 0, 0, dz05.iy07, 0xabcd0821) + } + + CH03(ts, z170, 0x11e, 0, 0) +} + +/* + * Simple Store of object with the name of method in the name path + */ +Method(mt13) +{ + Name(ts, "mt13") + + Device(dz05) + { + Name(iy07, 0xabcd0500) + } + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Store (\mt13.dz05.iy07, Local0) + OUTC("mt13, \mt13.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd0500)) { + err(ts, z170, 0x032, 0, 0, Local0, 0xabcd0500) + } + if (LNotEqual(\mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z170, 0x033, 0, 0, \mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\mt13.dz05.iy07, Local0) + mm06() + if (LNotEqual(\mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z170, 0x034, 0, 0, \mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\mt13.dz05.iy07, Local0) + mm05() + if (LNotEqual(\mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z170, 0x035, 0, 0, \mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\mt13.dz05.iy07, Local0) + mm04() + if (LNotEqual(\mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z170, 0x036, 0, 0, \mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\mt13.dz05.iy07, Local0) + mm03() + if (LNotEqual(\mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z170, 0x037, 0, 0, \mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\mt13.dz05.iy07, Local0) + mm02() + if (LNotEqual(\mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z170, 0x038, 0, 0, \mt13.dz05.iy07, 0xabcd0500) + } + } + Store (\mt13.dz05.iy07, Local0) + mm01() + if (LNotEqual(\mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z170, 0x039, 0, 0, \mt13.dz05.iy07, 0xabcd0500) + } + } + + CH03(ts, z170, 0x03a, 0, 0) + + Store (\mt13.dz05.iy07, Local0) + mm00() + + if (LNotEqual(\mt13.dz05.iy07, 0xabcd0500)) { + err(ts, z170, 0x03b, 0, 0, \mt13.dz05.iy07, 0xabcd0500) + } + + CH03(ts, z170, 0x03c, 0, 0) +} + +/* + * The same as mt13, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt14) +{ + Name(ts, "mt14") + + Device(dz05) + { + Name(iy07, 0xabcd2900) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + Store (\mt14.dz05.iy07, Local0) + OUTC("mt14, \mt14.dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x03d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x03e, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm1f() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x03f, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x040, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm1e() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x041, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x042, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm1d() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x043, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x044, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm1c() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x045, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x046, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm1b() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x047, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x048, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm1a() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x049, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x04a, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm19() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x04b, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x04c, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm18() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x04d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x04e, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm17() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x04f, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x050, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm16() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x051, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x052, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm15() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x053, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x054, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm14() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x055, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x056, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm13() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x057, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x058, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm12() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x059, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x05a, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm11() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x05b, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x05c, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm10() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x05d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x05e, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm0f() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x05f, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x060, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm0e() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x061, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x062, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm0d() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x063, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x064, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm0c() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x065, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x066, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm0b() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x067, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x068, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm0a() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x069, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x06a, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm09() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x06b, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x06c, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm08() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x06d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x06e, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm07() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x06f, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x070, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm06() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x071, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x072, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm05() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x073, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x074, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm04() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x075, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x076, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm03() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x077, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x078, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm02() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x079, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x07a, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + Store (\mt14.dz05.iy07, Local0) + mm01() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x07b, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x07c, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + } + + CH03(ts, z170, 0x11f, 0, 0) + + Store (\mt14.dz05.iy07, Local0) + mm00() + if (LNotEqual(Local0, 0xabcd2900)) { + err(ts, z170, 0x07d, 0, 0, Local0, 0xabcd2900) + } + if (LNotEqual(\mt14.dz05.iy07, 0xabcd2900)) { + err(ts, z170, 0x07e, 0, 0, \mt14.dz05.iy07, 0xabcd2900) + } + + CH03(ts, z170, 0x120, 0, 0) +} + +/* + * The same as mt14, but contains parent name paths. + * To be run on ACPICA only. + */ +Method(mt15) +{ + Name(ts, "mt15") + + Device(dz05) + { + Name(iy07, 0xabcd3900) + } + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + OUTC("mt15, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07:") + OUTC(Local0) + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x07f, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x080, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1f() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x081, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x082, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1e() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x083, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x084, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1d() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x085, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x086, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1c() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x087, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x088, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1b() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x089, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x08a, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm1a() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x08b, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x08c, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm19() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x08d, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x08e, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm18() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x08f, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x090, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm17() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x091, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x092, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm16() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x093, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x094, 0, 0, ^^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm15() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x095, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x096, 0, 0, ^^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm14() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x097, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x098, 0, 0, ^^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm13() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x099, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x09a, 0, 0, ^^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm12() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x09b, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x09c, 0, 0, ^^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm11() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x09d, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x09e, 0, 0, ^^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm10() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x09f, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0a0, 0, 0, ^^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^^dz05.iy07, Local0) + mm0f() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0a1, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0a2, 0, 0, ^^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^^dz05.iy07, Local0) + mm0e() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0a3, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0a4, 0, 0, ^^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^^dz05.iy07, Local0) + mm0d() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0a5, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0a6, 0, 0, ^^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^^dz05.iy07, Local0) + mm0c() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0a7, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0a8, 0, 0, ^^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^^dz05.iy07, Local0) + mm0b() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0a9, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0aa, 0, 0, ^^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^^dz05.iy07, Local0) + mm0a() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0ab, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0ac, 0, 0, ^^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^^dz05.iy07, Local0) + mm09() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0ad, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0ae, 0, 0, ^^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^^dz05.iy07, Local0) + mm08() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0af, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0b0, 0, 0, ^^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^^dz05.iy07, Local0) + mm07() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0b1, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0b2, 0, 0, ^^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^^dz05.iy07, Local0) + mm06() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0b3, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0b4, 0, 0, ^^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^^dz05.iy07, Local0) + mm05() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0b5, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0b6, 0, 0, ^^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^^dz05.iy07, Local0) + mm04() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0b7, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0b8, 0, 0, ^^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^^dz05.iy07, Local0) + mm03() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0b9, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0ba, 0, 0, ^^^dz05.iy07, 0xabcd3900) + } + } + Store (^^dz05.iy07, Local0) + mm02() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0bb, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0bc, 0, 0, ^^dz05.iy07, 0xabcd3900) + } + } + Store (^dz05.iy07, Local0) + mm01() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0bd, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(^dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0be, 0, 0, ^dz05.iy07, 0xabcd3900) + } + } + + CH03(ts, z170, 0x121, 0, 0) + + Store (dz05.iy07, Local0) + mm00() + if (LNotEqual(Local0, 0xabcd3900)) { + err(ts, z170, 0x0bf, 0, 0, Local0, 0xabcd3900) + } + if (LNotEqual(dz05.iy07, 0xabcd3900)) { + err(ts, z170, 0x0c0, 0, 0, dz05.iy07, 0xabcd3900) + } + + CH03(ts, z170, 0x122, 0, 0) +} + +/* + * Access to the internal object of invoked method + */ +Method(mt16, 1) +{ + Name(ts, "mt16") + + Name(i000, 0) + Name(i001, 0) + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Device(dz05) + { + Name(iy07, 0xabcd4900) + } + if (LEqual(i001, 1)) { + Store(0xabcd4904, dz05.iy07) + m001(1) + } elseif (LEqual(i001, 2)) { + Store(0xabcd4905, dz05.iy07) + m001(2) + } elseif (LEqual(i001, 3)) { + m001(3) + } + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + Method(m000) + { + Store (^mm00.mm01.mm02.mm03.mm04.dz05.iy07, i000) + } + + Method(m001, 1) + { + Method(mmF1, 1) + { + Method(mmF2, 1) + { + Device(dz05) + { + Name(iy07, 0xabcd6900) + } + if (LEqual(arg0, 1)) { + Store (\mt16.mm00.mm01.mm02.mm03.mm04.dz05.iy07, i000) + } elseif (LEqual(arg0, 2)) { + Store (^^^mm00.mm01.mm02.mm03.mm04.dz05.iy07, i000) + } elseif (LEqual(arg0, 3)) { + Store (^^mmF1.mmF2.dz05.iy07, i000) + } + } + mmF2(arg0) + } + mmF1(arg0) + } + + CH03(ts, z170, 0x0c1, 0, 0) + + if (LEqual(arg0, 0)) { + // Access to the internal data of method (mm00...) not being invoked + m000() + CH04(ts, 1, 5, z170, 0x0c2, 0, 0) // AE_NOT_FOUND + } elseif (LEqual(arg0, 1)) { + + // Access to the internal data of method (mm00...) being invoked + // by \mt16.mm00.... + + Store(0, i000) + Store(1, i001) + mm00() + if (LNotEqual(i000, 0xabcd4904)) { + err(ts, z170, 0x0c3, 0, 0, i000, 0xabcd4904) + } + } elseif (LEqual(arg0, 2)) { + + // Access to the internal data of method (mm00...) being invoked + // by ^^^^^^^^^^^^mm00... + + Store(2, i001) + mm00() + if (LNotEqual(i000, 0xabcd4905)) { + err(ts, z170, 0x0c4, 0, 0, i000, 0xabcd4905) + } + + } elseif (LEqual(arg0, 3)) { + + // Access to the internal data of method (m001.mmF1.mmF2.mmF3.dz05.iy07...) + // being invoked by ^^^^^^^^^^^^mm01... + + Store(3, i001) + mm00() + if (LNotEqual(i000, 0xabcd6900)) { + err(ts, z170, 0x1c4, 0, 0, i000, 0xabcd6900) + } + } + + CH03(ts, z170, 0x0c5, 0, 0) +} + +/* + * The same as mt16, but contains more depth of enclosed method calls. + * To be run on ACPICA only. + */ +Method(mt17, 1) +{ + Name(ts, "mt17") + + Name(i000, 0) + Name(i001, 0) + + Method(mm00) + { + Method(mm01) + { + Method(mm02) + { + Method(mm03) + { + Method(mm04) + { + Method(mm05) + { + Method(mm06) + { + Method(mm07) + { + Method(mm08) + { + Method(mm09) + { + Method(mm0a) + { + Method(mm0b) + { + Method(mm0c) + { + Method(mm0d) + { + Method(mm0e) + { + Method(mm0f) + { + Method(mm10) + { + Method(mm11) + { + Method(mm12) + { + Method(mm13) + { + Method(mm14) + { + Method(mm15) + { + Method(mm16) + { + Method(mm17) + { + Method(mm18) + { + Method(mm19) + { + Method(mm1a) + { + Method(mm1b) + { + Method(mm1c) + { + Method(mm1d) + { + Method(mm1e) + { + Method(mm1f) + { + Method(mm20) + { + Method(mm21) + { + Device(dz05) + { + Name(iy07, 0xabcd5900) + } + Method(mm22) + { + Method(mm23) + { + Method(mm24) + { + Method(mm25) + { + if (LEqual(i001, 1)) { + Store(0xabcd4906, ^^^^dz05.iy07) + m001(1) + } elseif (LEqual(i001, 2)) { + Store(0xabcd4907, ^^^^dz05.iy07) + m001(2) + } elseif (LEqual(i001, 3)) { + m001(3) + } + } + mm25() + } + mm24() + } + mm23() + } + mm22() + } + mm21() + } + mm20() + } + mm1f() + } + mm1e() + } + mm1d() + } + mm1c() + } + mm1b() + } + mm1a() + } + mm19() + } + mm18() + } + mm17() + } + mm16() + } + mm15() + } + mm14() + } + mm13() + } + mm12() + } + mm11() + } + mm10() + } + mm0f() + } + mm0e() + } + mm0d() + } + mm0c() + } + mm0b() + } + mm0a() + } + mm09() + } + mm08() + } + mm07() + } + mm06() + } + mm05() + } + mm04() + } + mm03() + } + mm02() + } + mm01() + } + + Method(m000) + { + Store (^mm00.mm01.mm02.mm03.mm04.mm05.mm06.mm07.mm08.mm09.mm0a.mm0b.mm0c.mm0d.mm0e.mm0f.mm10.mm11.mm12.mm13.mm14.mm15.mm16.mm17.mm18.mm19.mm1a.mm1b.mm1c.mm1d.mm1e.mm1f.mm20.mm21.dz05.iy07, i000) + } + + Method(m001, 1) + { + Method(mmF1, 1) + { + Method(mmF2, 1) + { + Method(mmF3, 1) + { + Method(mmF4, 1) + { + Method(mmF5, 1) + { + Method(mmF6, 1) + { + Method(mmF7, 1) + { + Method(mmF8, 1) + { + Method(mmF9, 1) + { + Method(mmFa, 1) + { + Method(mmFb, 1) + { + Method(mmFc, 1) + { + Method(mmFd, 1) + { + Method(mmFe, 1) + { + Method(mmFf, 1) + { + Method(mm10, 1) + { + Method(mm11, 1) + { + Device(dz05) + { + Name(iy07, 0xabcd4908) + } + Method(mm12, 1) + { + Method(mm13, 1) + { + Method(mm14, 1) + { + Method(mm15, 1) + { + Method(mm16, 1) + { + Method(mm17, 1) + { + Method(mm18, 1) + { + Method(mm19, 1) + { + Method(mm1a, 1) + { + Method(mm1b, 1) + { + Method(mm1c, 1) + { + Method(mm1d, 1) + { + Method(mm1e, 1) + { + Method(mm1f, 1) + { +if (LEqual(arg0, 1)) { + Store (\mt17.mm00.mm01.mm02.mm03.mm04.mm05.mm06.mm07.mm08.mm09.mm0a.mm0b.mm0c.mm0d.mm0e.mm0f.mm10.mm11.mm12.mm13.mm14.mm15.mm16.mm17.mm18.mm19.mm1a.mm1b.mm1c.mm1d.mm1e.mm1f.mm20.mm21.dz05.iy07, i000) +} elseif (LEqual(arg0, 2)) { + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^mm00.mm01.mm02.mm03.mm04.mm05.mm06.mm07.mm08.mm09.mm0a.mm0b.mm0c.mm0d.mm0e.mm0f.mm10.mm11.mm12.mm13.mm14.mm15.mm16.mm17.mm18.mm19.mm1a.mm1b.mm1c.mm1d.mm1e.mm1f.mm20.mm21.dz05.iy07, i000) +} elseif (LEqual(arg0, 3)) { + Store (^^^^^^^^^^^^^^^^^^^^^^^^^^mmF6.mmF7.mmF8.mmF9.mmFa.mmFb.mmFc.mmFd.mmFe.mmFf.mm10.mm11.dz05.iy07, i000) +} + } + mm1f(arg0) + } + mm1e(arg0) + } + mm1d(arg0) + } + mm1c(arg0) + } + mm1b(arg0) + } + mm1a(arg0) + } + mm19(arg0) + } + mm18(arg0) + } + mm17(arg0) + } + mm16(arg0) + } + mm15(arg0) + } + mm14(arg0) + } + mm13(arg0) + } + mm12(arg0) + } + mm11(arg0) + } + mm10(arg0) + } + mmFf(arg0) + } + mmFe(arg0) + } + mmFd(arg0) + } + mmFc(arg0) + } + mmFb(arg0) + } + mmFa(arg0) + } + mmF9(arg0) + } + mmF8(arg0) + } + mmF7(arg0) + } + mmF6(arg0) + } + mmF5(arg0) + } + mmF4(arg0) + } + mmF3(arg0) + } + mmF2(arg0) + } + mmF1(arg0) + } + + CH03(ts, z170, 0x0c6, 0, 0) + + if (LEqual(arg0, 0)) { + // Access to the internal data of method (mm00...) not being invoked + m000() + CH04(ts, 1, 5, z170, 0x0c7, 0, 0) // AE_NOT_FOUND + } elseif (LEqual(arg0, 1)) { + + // Access to the internal data of method (mm00...) being invoked + // by \mt16.mm00.... + + Store(1, i001) + mm00() + if (LNotEqual(i000, 0xabcd4906)) { + err(ts, z170, 0x0c8, 0, 0, i000, 0xabcd4906) + } + } elseif (LEqual(arg0, 2)) { + + // Access to the internal data of method (mm00...) being invoked + // by ^^^^^^^^^^^^mm00... + + Store(2, i001) + mm00() + if (LNotEqual(i000, 0xabcd4907)) { + err(ts, z170, 0x0c9, 0, 0, i000, 0xabcd4907) + } + + } elseif (LEqual(arg0, 3)) { + + // Access to the internal data of method (m001.mmF1.mmF2.mmF3.dz05.iy07...) + // being invoked by ^^^^^^^^^^^^mm01... + + Store(3, i001) + mm00() + if (LNotEqual(i000, 0xabcd4908)) { + err(ts, z170, 0x0ca, 0, 0, i000, 0xabcd4908) + } + } + + CH03(ts, z170, 0x0cb, 0, 0) +} + +Method(mt18, 1) +{ + Name(ts, "mt18") + + Device(dz05) + { + Name(iy07, 0xabcd4900) + } + + CH03(ts, z170, 0x0cc, 0, 0) + + if (arg0) { + Store(0xabcd9000, \mt18.dz05.iy07) + if (LNotEqual(\mt18.dz05.iy07, 0xabcd9000)) { + err(ts, z170, 0x0ca, 0, 0, \mt18.dz05.iy07, 0xabcd9000) + } + } else { + Store(0xabcd9001, dz05.iy07) + if (LNotEqual(dz05.iy07, 0xabcd9001)) { + err(ts, z170, 0x0ca, 0, 0, dz05.iy07, 0xabcd9001) + } + } + + CH03(ts, z170, 0x0cd, 0, 0) +} + +Method(mt19, 1) +{ + Name(ts, "mt19") + + Processor(pr7d, 0, 0x000, 0x008) + { + Name(iy07, 0xabcd0660) + } + + CH03(ts, z170, 0x0ce, 0, 0) + + if (arg0) { + Store(0xabcd9002, \mt19.pr7d.iy07) + if (LNotEqual(\mt19.pr7d.iy07, 0xabcd9002)) { + err(ts, z170, 0x0ca, 0, 0, \mt19.pr7d.iy07, 0xabcd9002) + } + } else { + Store(0xabcd9003, pr7d.iy07) + if (LNotEqual(pr7d.iy07, 0xabcd9003)) { + err(ts, z170, 0x0ca, 0, 0, pr7d.iy07, 0xabcd9003) + } + } + + CH03(ts, z170, 0x0cf, 0, 0) +} + +Method(mt1a, 1) +{ + Name(ts, "mt1a") + + CH03(ts, z170, 0x0d0, 0, 0) + if (arg0) { + Store(0xabcd9004, \pr7d.iy07) + if (LNotEqual(\pr7d.iy07, 0xabcd9004)) { + err(ts, z170, 0x0ca, 0, 0, \pr7d.iy07, 0xabcd9004) + } + } else { + Store(0xabcd9005, ^pr7d.iy07) + if (LNotEqual(^pr7d.iy07, 0xabcd9005)) { + err(ts, z170, 0x0ca, 0, 0, ^pr7d.iy07, 0xabcd9005) + } + } + CH03(ts, z170, 0x0d1, 0, 0) +} + + +Method(mtff) +{ + Name(run0, 1) + + // Works on both + SRMT("mt00") + mt00() + + if (chk0) { + // Exceeded the depth supported on MS + SRMT("mt01") + mt01() + } + + // Works on both + SRMT("mt02") + mt02() + + if (chk0) { + // Exceeded the depth supported on MS + SRMT("mt03") + mt03() + } + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt04") + mt04() + } + + if (LAnd(chk0, run0)) { + // Exceeded the depth supported on MS + SRMT("mt05") + mt05() + } + + if (run0) { + // Works on MS, AE_NOT_FOUND on ACPICA + SRMT("mt06") + mt06() + } + + if (0) { + // Fails for both here - for MS and ACPICA + SRMT("mt07") + mt07() + } + + if (chk0) { + // Exceeded the depth supported on MS + SRMT("mt08") + mt08() + } + + // Works on both + SRMT("mt0a") + mt0a() + SRMT("mt0b") + mt0b() + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt0c") + mt0c() + } + + // Simply long cycle in While + SRMT("mt0d") + mt0d() + + if (0) { + SRMT("mt0e") + mt0e() // Result: ACPICA - AE_NOT_FOUND, MS - Failure + } + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt0f") + mt0f() + } + + if (LAnd(chk0, run0)) { + // Exceeded the depth supported on MS + SRMT("mt10") + mt10() + } + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt11") + mt11() + } + + if (LAnd(chk0, run0)) { + // Exceeded the depth supported on MS + SRMT("mt12") + mt12() + } + + // Works on both + SRMT("mt13") + mt13() + + if (chk0) { + // Exceeded the depth supported on MS + SRMT("mt14") + mt14() + SRMT("mt15") + mt15() + } + + if (chk0) { + // ACPICA - AE_NOT_FOUND (it is correct), MS - Failure + SRMT("mt16-0") + mt16(0) + } + + if (run0) { + // Works on MS, AE_AML_OPERAND_TYPE on ACPICA + SRMT("mt16-1") + mt16(1) + SRMT("mt16-2") + mt16(2) + SRMT("mt16-3") + mt16(3) + } + + if (chk0) { + // ACPICA - AE_NOT_FOUND (it is correct), MS - Failure + SRMT("mt17-0") + mt17(0) + } + + if (LAnd(chk0, run0)) { + // Exceeded the depth supported on MS + SRMT("mt17-1") + mt17(1) + SRMT("mt17-2") + mt17(2) + } + + SRMT("mt18-0") + mt18(0) + SRMT("mt18-1") + mt18(1) + SRMT("mt19-0") + mt19(0) + SRMT("mt19-1") + mt19(1) + SRMT("mt1a-0") + mt1a(0) + SRMT("mt1a-1") + mt1a(1) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/misc/ms0.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/misc/ms0.asl new file mode 100644 index 000000000..34a29992c --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/misc/ms0.asl @@ -0,0 +1,240 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests originated from bdemo/0262 + */ + +Name(z162, 162) + +/* + * Bug 262 (Fiodor Suietov): + * + * SUMMARY: Unexpected AE_STACK_OVERFLOW for a method call expression with nested calls + */ +Method(ms00) +{ + Name(ts, "ms00") + + Name(iad1, 0x1) + Name(iad2, 0x10) + Name(iad3, 0x100) + Name(iad4, 0x1000) + Name(iad5, 0x10000) + Name(iad6, 0x100000) + Name(iad7, 0x1000000) + + Method(mad1, 1) {Return(Arg0)} + Method(mad7, 7) {Return(Add(Add(Add(Add(Add(Add(Arg0, Arg1), Arg2), Arg3), Arg4), Arg5), Arg6))} + + Method(m000) + { + Store(mad7(mad1(iad1), mad1(iad2), mad1(iad3), mad1(iad4), mad1(iad5), mad1(iad6), + mad7(mad1(iad1), mad1(iad2), mad1(iad3), mad1(iad4), mad1(iad5), mad1(iad6), + mad7(mad1(iad1), mad1(iad2), mad1(iad3), mad1(iad4), mad1(iad5), mad1(iad6), + mad7(mad1(iad1), mad1(iad2), mad1(iad3), mad1(iad4), mad1(iad5), mad1(iad6), + mad7(mad1(iad1), mad1(iad2), mad1(iad3), mad1(iad4), mad1(iad5), mad1(iad6), + mad7(mad1(iad1), mad1(iad2), mad1(iad3), mad1(iad4), mad1(iad5), mad1(iad6), + mad7(mad1(iad1), mad1(iad2), mad1(iad3), mad1(iad4), mad1(iad5), mad1(iad6), + mad1(iad7)))))))), Local0) + + Store (Local0, Debug) + + if (LNotEqual(Local0, 0x1777777)) { + err(ts, z162, 0x000, 0, 0, Local0, 0x1777777) + } + } + + CH03(ts, z162, 0x001, 0, 0) + m000() + CH03(ts, z162, 0x002, 0, 0) +} + +/* + * This is how MS actually works + */ +Method(ms01, 1) +{ + Name(ts, "ms01") + Name(i000, 0) + Name(b000, Buffer(9) {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}) + CreateField(b000, 0, 8, bf00) + + Name(tp00, 0) + + Method(m000, 1) + { + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, tp00)) { + err(ts, z162, 0x003, 0, 0, Local0, tp00) + } + } + + // This is how it should be: + Store(c009, tp00) + + // This is how MS actually works: + Store(c00b, tp00) + + + Store(ObjectType(bf00), Local0) + if (LNotEqual(Local0, c016)) { + err(ts, z162, 0x004, 0, 0, Local0, c016) + } + + m000(bf00) + + Store(bf00, i000) + Store(ObjectType(i000), Local0) + if (LNotEqual(Local0, c009)) { + err(ts, z162, 0x005, 0, 0, Local0, c009) + } + + Store(bf00, Local1) + Store(ObjectType(Local1), Local0) + if (LNotEqual(Local0, tp00)) { + err(ts, z162, 0x006, 0, 0, Local0, tp00) + } + + Store(bf00, arg0) + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, tp00)) { + err(ts, z162, 0x007, 0, 0, Local0, tp00) + } +} + +/* + * This is how MS actually works + */ +Method(ms02, 1) +{ + Name(ts, "ms02") + Name(i000, 0) + OperationRegion(r000, SystemMemory, 0x100, 0x100) + Field(r000, ByteAcc, NoLock, Preserve) { f000, 8 } + + Name(tp00, 0) + + Method(m000, 1) + { + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, tp00)) { + err(ts, z162, 0x008, 0, 0, Local0, tp00) + } + } + + Store(c009, tp00) + + Store(ObjectType(f000), Local0) + if (LNotEqual(Local0, c00d)) { + err(ts, z162, 0x009, 0, 0, Local0, c00d) + } + + m000(f000) + + Store(f000, i000) + Store(ObjectType(i000), Local0) + if (LNotEqual(Local0, c009)) { + err(ts, z162, 0x00a, 0, 0, Local0, c009) + } + + Store(f000, Local1) + Store(ObjectType(Local1), Local0) + if (LNotEqual(Local0, tp00)) { + err(ts, z162, 0x00b, 0, 0, Local0, tp00) + } + + Store(f000, arg0) + Store(ObjectType(arg0), Local0) + if (LNotEqual(Local0, tp00)) { + err(ts, z162, 0x00c, 0, 0, Local0, tp00) + } +} + +/* + * Bug 275: + * + * SUMMARY: Pop result from bottom principle doesn't work + */ +Method(ms03) +{ + Name(i000, 0x11000000) + Name(i001, 0x00220000) + Name(p000, Package () {0xabcd0000, 0xabcd0001, 0xabcd0002}) + + Method(m000) + { + Return (p000) + } + + Method(m001, 1) + { + Return (0xabcd0003) + } + + Method(m002, 2) + { + Index(arg0, 1, Local0) + Store(DerefOf(Local0), Local1) + + if (LNotEqual(Local1, 0xabcd0001)) { + err("ms03", z162, 0x00d, 0, 0, Local0, c00d) + } + } + + // Works correctly: + m002(p000, 0xabcd0004) + m002(m000(), 0xabcd0004) + m002(p000, m001(Add(i000, i001))) + + // Works incorrectly (bug 275): + m002(m000(), m001(Add(i000, i001))) +} + +Method(msff) +{ + SRMT("ms00") + if (y262) { + ms00() + } else { + BLCK() + } + + SRMT("ms01") + ms01(0) + SRMT("ms02") + ms02(0) + SRMT("ms03") + if (y275) { + ms03() + } else { + BLCK() + } +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/misc/ms1.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/misc/ms1.asl new file mode 100644 index 000000000..93044074c --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/misc/ms1.asl @@ -0,0 +1,6958 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Fiodor Suietov <fiodor.f.suietov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests exercized during ACPICA to MS implementation comparison + */ + +Name(z179, 179) + +/* + * + * Stuff not working under MS: + * + * 1) String to Integer Implicit operand conversion, ms10: a063, b063, c063 - + * a failure when a String in a position of an Integer; errors in e063, + * f063, g063, h063 are inverted by q004 flag (Implicit Operand conversion + * on MS contradicts ACPI Spec). + * 2) No exception on DerefOf of an arbitrary Source, ms11: b083, d083 - + * an expected failure on DerefOf of an Integer. + * 3) Access to FieldObject element of Package causes exception, ms16: f118 - + * a failure when an Integer is stored to a Named Package. + * 4) The Read access automatic dereference ... doesn't work, ms17: b126, + * c126 - a failure when a reference in ArgX is used in a position of Data. + * 5) CopyObject of immediately passed Index ... is not a reference, ms18: + * a127 - a failure due to the CopyObject operator in AML code. + * 6) Copying the RefOf reference to Named object ..., ms19: d128, e128 - + * a failure when a reference is stored to a Package element. + * 7) Store to the Index reference ... returned by Method ..., ms1a: a131, + * b131, c131 - a failure when a Method call is the Target of Store. + * 8) Read access automatic dereference for Index reference ..., ms1b: a132, + * b132 - a failure when the Index argument is used without Derefof. + * 9) Write access automatic dereference for Index reference ..., ms1c: b133 - + * a failure when a String element is to be changed. + * 10) Forward reference within a control method, ms20: cmfr - an expected + * failure when a Named Object is accessed before its declaration. + * 11) Recursive Serialized method execution, ms21: erec - an expected + * failure for the enough deep recursion. + * 12) Implicit return, ms23: emir?, fmir?, gmir - Break in the specifically + * declared while doesn't work. + * 13) Store(..., DeRefof(...)) behavior, ms25: a failure when a Refof or + * Derefof is the Target of Store. + * 14) IndexField implementation, my27: jife - a failure when the Access type + * of a Field is specified to be QWordAcc. + * 15) Acquire/Release, ms29: a hang when used with the Dynamic Mutex. + * 16) ToBuffer optional store, ms2a: it looks like ToBuffer does not work. + * 17) Package size calculation, ms2b: pac2 actually should be used with + * Package(3){1, 2, 3, 4, 5}) declaration, but iASL reports "Initializer + * list too long" error. Use it with -f iASL option. + * 18) Bug 246 issue, ms2f: c246 actually should be used without + * While(1){... Break) declaration, but iASL reports "No enclosing While + * statement" error. Use it with -f iASL option. + * 19) Storing of an improper specified Device object ..., ms33: + * a blue screen appears on the MS OS booting if that Device is global. + * + * 99) + */ + +// Useful for indirect storing + +Method(RSTO, 2) {Store(arg0, arg1)} + +Method(DSTO, 2) {Store(Derefof(arg0), arg1)} + +/* + * Bug 63 issue: + * + * SUMMARY: String to Integer conversion contradicts new April 2005 Conversion Rules + */ +Method(ms10, 1) +{ + Name(ts, "ms10") + + Method(m063, 2) + { + OUTP("Bug 63: Add(\"0x1111\", 0, Local0) should return 0?") + + OUTP("Addend1:") + OUTP(arg0) + + Add(arg0, 0, Local0) + + OUTP("Result (Local0):") + OUTP(Local0) + + if (LNotEqual(arg1, Local0)) { + err(ts, z179, 0x000, 0, 0, Local0, arg1) + } + } + + Method(n063, 3) + { + Name (INT0, 0xffff) + + OUTP("Bug 63upd: Implicit conversion \"0x1111\" to Integer should return 0?") + + OUTP("String:") + OUTP(arg0) + + Store(arg0, INT0) + + OUTP("Result (INT0):") + OUTP(INT0) + + if (LAnd(ABUU, LNot(q004))) { + // Implicit Operand conversion on MS contradicts ACPI Spec + if (LNotEqual(arg2, INT0)) { + err(ts, z179, 0x001, 0, 0, INT0, arg2) + } + } else { + if (LNotEqual(arg1, INT0)) { + err(ts, z179, 0x001, 0, 0, INT0, arg1) + } + } + } + + Method(m000) + { + if (ABUU) { + } else { + m063("0", 0) + m063("0x", 0) + m063("0x1111", 0) + } + m063(1, 1) + + n063("0", 0, 0x30) + n063("0x", 0, 0x7830) + n063("0x1111", 0, 0x31317830) + n063("0x111111111", 0, 0x31317830) + } + + CH03(ts, z179, 0x002, 0, 0) + + switch (arg0) { + case (0) { m000() } + case (1) { m063("0", 0) } + case (2) { m063("0x", 0) } + case (3) { m063("0x1111", 0) } + case (4) { m063(1, 1) } + + case (5) { n063("0", 0, 0x30) } + case (6) { n063("0x", 0, 0x7830) } + case (7) { n063("0x1111", 0, 0x31317830) } + case (8) { n063("0x111111111", 0, 0x31317830) } + } + + CH03(ts, z179, 0x003, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a063) { IIN0() ms10(1) Return(POUT) } +Method(b063) { IIN0() ms10(2) Return(POUT) } +Method(c063) { IIN0() ms10(3) Return(POUT) } +Method(d063) { IIN0() ms10(4) Return(POUT) } +Method(e063) { IIN0() ms10(5) Return(POUT) } +Method(f063) { IIN0() ms10(6) Return(POUT) } +Method(g063) { IIN0() ms10(7) Return(POUT) } +Method(h063) { IIN0() ms10(8) Return(POUT) } + +/* + * Bug 83 issue: + * + * SUMMARY: No exception on DerefOf of an arbitrary Source + */ +Method(ms11, 1) +{ + Name(ts, "ms11") + + Method(m083, 1) + { + Name(i000, 0x89abcdef) + + OUTP("Bug 83: Derefof of non-Ref. (f.e. Integer) should produce exception") + + OUTP("Name(i000, 0x89abcdef)") + + if (arg0) { + Derefof(i000) + CH04(ts, 0, 0xff, z179, 0x004, 0, 0) + } else { + Derefof(Refof(i000)) + CH03(ts, z179, 0x005, 0, 0) + } + } + + Method(n083, 1) + { + Name(i000, 0x89abcdef) + + OUTP("Bug 83upd: Derefof of non-Ref. (f.e. Integer) should produce exception") + + if (arg0) { + Store(0x89abcdef, Local0) + OUTP("Store(0x89abcdef, Local0)") + } else { + Store(Refof(i000), Local0) + OUTP("Store(Refof(i000), Local0)") + } + Derefof(Local0) + if (arg0) { + CH04(ts, 0, 0xff, z179, 0x006, 0, 0) + } else { + CH03(ts, z179, 0x007, 0, 0) + } + } + + Method(m000) + { + m083(0) + if (ABUU) { + } else { + m083(1) + } + n083(0) + if (ABUU) { + } else { + n083(1) + } + } + + CH03(ts, z179, 0x008, 0, 0) + + switch (arg0) { + case (0) { m000() } + case (1) { m083(0) } + case (2) { m083(1) } + case (3) { n083(0) } + case (4) { n083(1) } + } + + CH03(ts, z179, 0x009, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a083) { IIN0() ms11(1) Return(POUT) } +Method(b083) { IIN0() ms11(2) Return(POUT) } +Method(x083) { IIN0() ms11(3) Return(POUT) } +Method(d083) { IIN0() ms11(4) Return(POUT) } + +/* + * Bug 100 issue: + * + * SUMMARY: The specific combination of operators aborts execution + */ +Method(ms12) +{ + Name(ts, "ms12") + + Method(m100) + { + Method(m000) + { + return (0) + } + + Method(m001) + { + m000() + + Device(d000) {} + + Name(i000, 0xabcdef) + + OUTP("Finish of test") + } + + OUTP("Bug 100 (fixed for 20050526): some combination of operators aborts execution") + + m001() + } + CH03(ts, z179, 0x00a, 0, 0) + m100() + CH03(ts, z179, 0x00b, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a100) { IIN0() ms12() Return(POUT) } + +/* + * Bug 113 issue: + * + * SUMMARY: Unexpected dereference of Index reference immediately passed to Method + */ + +Method(ms13, 1) +{ + Name(ts, "ms13") + + Name(p001, Package(){0x10, 0x11, 0x12, 0x13, 0x14}) + Name(p002, Package(){0x20, 0x21, 0x22, 0x23, 0x24}) + Name(p003, Package(){0x30, 0x31, 0x32, 0x33, 0x34}) + Name(p004, Package(){0x40, 0x41, 0x42, 0x43, 0x44}) + Name(p005, Package(){0x50, 0x51, 0x52, 0x53, 0x54}) + + Method(a113) + { + Method(m000, 2) + { + Store(Derefof(arg0), Local0) + if (CH03(ts, z179, 0x00c, 0, 0)) { + } elseif (LNotEqual(Local0, arg1)) { + err(ts, z179, 0x00d, 0, 0, Local0, arg1) + } + } + + OUTP("Bug 113: immediate Indexed Ref. as parameters of Methods are unexpectedly dereferenced 1") + + m000(Index(p001, 0), 0x10) + } + + Method(b113) + { + Method(m000, 2) + { + Store(Derefof(arg0), Local0) + if (CH03(ts, z179, 0x00e, 0, 0)) { + } elseif (LNotEqual(Local0, arg1)) { + err(ts, z179, 0x00f, 0, 0, Local0, arg1) + } + } + + OUTP("Bug 113: immediate Indexed Ref. as parameters of Methods are unexpectedly dereferenced 2") + + Store(Index(p001, 0), Local0) + + m000(Local0, 0x10) + } + + Method(s113) + { + Method(m000, 6) + { + OUTP(Derefof(arg0)) + CH03(ts, z179, 0x012, 0, 0) + OUTP(Derefof(arg1)) + CH03(ts, z179, 0x013, 0, 0) + OUTP(Derefof(arg2)) + CH03(ts, z179, 0x014, 0, 0) + OUTP(Derefof(arg3)) + CH03(ts, z179, 0x015, 0, 0) + OUTP(Derefof(arg4)) + CH03(ts, z179, 0x016, 0, 0) + OUTP(Derefof(arg5)) + CH03(ts, z179, 0x017, 0, 0) + } + + OUTP("Bug 113 MS: immediate Indexed Ref. as parameters of Methods can be dereferenced 3") + + Store(Index(p002, 1), Local0) + + Index(p004, 3, Local1) + + Store(Index(p005, 4, Local2), Local3) + + m000(Index(p001, 0), Local0, Index(p003, 2, Local4), Local1, Local2, Local3) + + OUTP(Derefof(Local4)) + } + + CH03(ts, z179, 0x018, 0, 0) + switch (arg0) { + case (0) { a113() b113() s113()} + case (1) { a113() } + case (2) { b113() } + case (3) { s113() } + } + CH03(ts, z179, 0x019, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a113) { IIN0() ms13(1) Return(POUT) } +Method(b113) { IIN0() ms13(2) Return(POUT) } +Method(c113) { IIN0() ms13(3) Return(POUT) } + +/* + * Bug 114 issue: + * + * SUMMARY: Method object as a Source of Index operation is treated by iASL mistakenly as a call to that Method + */ +Method(ms14, 1) +{ + Name(ts, "ms14") + + Method(m114, 1) + { + Method(m000, 1) + { + Name(i001, 0) + Name(b001, Buffer(){10,2,3,4,5}) + + Method(m001) + { + Increment(i001) + return (Buffer(){10,2,3,4,5}) + } + + Method(m002) + { + Increment(i001) + return (Package(){10,2,3,4,5}) + } + + if (LEqual(arg0, 0)) { + OUTP("Start of test: Method returns (Buffer(){10,2,3,4,5})") + OUTP("Index(m001, 0, Local0)") + Index(m001, 0, Local0) + if (LAnd(ABUU, LNot(q005))) { + } elseif (i001) { + err(ts, z179, 0x01a, 0, 0, i001, 0) + } else { + CH04(ts, 0, 0xff, z179, 0x01b, 0, 0) + } + } elseif (LEqual(arg0, 1)) { + OUTP("Start of test: Method returns (Package(){10,2,3,4,5})") + OUTP("Index(m001, 0, Local0)") + Index(m001, 0, Local0) + if (LAnd(ABUU, LNot(q005))) { + } elseif (i001) { + err(ts, z179, 0x01c, 0, 0, i001, 0) + } else { + CH04(ts, 0, 0xff, z179, 0x01d, 0, 0) + } + } elseif (LEqual(arg0, 2)) { + OUTP("Start of test: Name(b001, Buffer(){10,2,3,4,5})") + OUTP("Index(b001, 0, Local0)") + Index(b001, 0, Local0) + OUTP(i001) + Store(DerefOf(Local0), Local1) + OUTP(Local1) + } + + OUTP("Finish of test") + } + + OUTP("Bug 114: Method object as a Source of Index operation") + m000(arg0) + } + + Method(m000) + { + m114(0) + m114(1) + m114(2) + } + + CH03(ts, z179, 0x01e, 0, 0) + switch (arg0) { + case (0) { m000()} + case (1) { m114(0) } + case (2) { m114(1) } + case (3) { m114(2) } + } + CH03(ts, z179, 0x01f, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a114) { IIN0() ms14(1) Return(POUT) } +Method(b114) { IIN0() ms14(2) Return(POUT) } +Method(c114) { IIN0() ms14(3) Return(POUT) } + +/* + * Bug 115 issue: + * + * SUMMARY: Unexpected dereference of Index reference returned by Method and immediately passed to another Method + */ +Method(ms15, 1) +{ + Name(ts, "ms15") + + Name(p001, Package(){0x10}) + Name(p002, Package(){0x20}) + Name(p003, Package(){0x30}) + Name(p004, Package(){0x40}) + Name(p005, Package(){0x50}) + Name(p006, Package(){0x60}) + + Method(m001) {Return(Index(p001, 0))} + Method(m002) {Store(Index(p002, 0), Local0) + Return(Local0)} + Method(m003) {Return(Index(p003, 0, Local0))} + Method(m004) {Index(p004, 0, Local0) + Return(Local0)} + + Method(m005) {Store(Index(p005, 0, Local0), Local1) + Return(Local1)} + Method(m006) {Store(Index(p006, 0, Local0), Local1) + Return(Local0)} + + Method(a115) + { + + Method(m000, 2) + { + Store(Derefof(arg0), Local0) + if (CH03(ts, z179, 0x020, 0, 0)) { + } elseif (LNotEqual(Local0, arg1)) { + err(ts, z179, 0x021, 0, 0, Local0, arg1) + } + } + + OUTP("Bug 115: immediately returned Indexed Ref. as parameters of Methods are unexpectedly dereferenced 1") + + m000(m001(), 0x10) + } + + Method(b115) + { + + Method(m000, 2) + { + Store(Derefof(arg0), Local0) + if (CH03(ts, z179, 0x022, 0, 0)) { + } elseif (LNotEqual(Local0, arg1)) { + err(ts, z179, 0x023, 0, 0, Local0, arg1) + } + } + + OUTP("Bug 115: immediately returned Indexed Ref. as parameters of Methods are unexpectedly dereferenced 2") + + m000(m002(), 0x20) + } + + Method(c115) + { + + Method(m000, 2) + { + Store(Derefof(arg0), Local0) + if (CH03(ts, z179, 0x024, 0, 0)) { + } elseif (LNotEqual(Local0, arg1)) { + err(ts, z179, 0x025, 0, 0, Local0, arg1) + } + } + + OUTP("Bug 115: immediately returned Indexed Ref. as parameters of Methods are unexpectedly dereferenced 3") + + m000(m003(), 0x30) + } + + Method(d115) + { + + Method(m000, 2) + { + Store(Derefof(arg0), Local0) + if (CH03(ts, z179, 0x026, 0, 0)) { + } elseif (LNotEqual(Local0, arg1)) { + err(ts, z179, 0x027, 0, 0, Local0, arg1) + } + } + + OUTP("Bug 115: immediately returned Indexed Ref. as parameters of Methods are unexpectedly dereferenced 4") + + m000(m004(), 0x40) + } + + Method(e115) + { + + Method(m000, 2) + { + Store(Derefof(arg0), Local0) + if (CH03(ts, z179, 0x028, 0, 0)) { + } elseif (LNotEqual(Local0, arg1)) { + err(ts, z179, 0x029, 0, 0, Local0, arg1) + } + } + + OUTP("Bug 115: immediately returned Indexed Ref. as parameters of Methods are unexpectedly dereferenced 5") + + m000(m005(), 0x50) + } + + Method(f115) + { + + Method(m000, 2) + { + Store(Derefof(arg0), Local0) + if (CH03(ts, z179, 0x02a, 0, 0)) { + } elseif (LNotEqual(Local0, arg1)) { + err(ts, z179, 0x02b, 0, 0, Local0, arg1) + } + } + + OUTP("Bug 115: immediately returned Indexed Ref. as parameters of Methods are unexpectedly dereferenced 6") + + m000(m006(), 0x60) + } + + CH03(ts, z179, 0x02c, 0, 0) + switch (arg0) { + case (0) { a115() b115() c115() d115() e115() f115()} + case (1) { a115() } + case (2) { b115() } + case (3) { c115() } + case (4) { d115() } + case (5) { e115() } + case (6) { f115() } + } + CH03(ts, z179, 0x02d, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a115) { IIN0() ms15(1) Return(POUT) } +Method(b115) { IIN0() ms15(2) Return(POUT) } +Method(c115) { IIN0() ms15(3) Return(POUT) } +Method(d115) { IIN0() ms15(4) Return(POUT) } +Method(e115) { IIN0() ms15(5) Return(POUT) } +Method(f115) { IIN0() ms15(6) Return(POUT) } + +/* + * Bug 118 issue: + * + * SUMMARY: Access to FieldObject element of Package causes exception + */ +Method(ms16, 1) +{ + Name(ts, "ms16") + + Method(a118) + { + Name(p90d, Package() {0xd650a284}) + + // Access to the Integer data as an element of Package + Method(m000) + { + OUTP("Test m000 started") + + Store(Index(p90d, 0), Local0) + Store(DerefOf(Local0), Local1) + Store(ObjectType(Local1), Local2) + + if (LNotEqual(Local2, 1)) { + err(ts, z179, 0x02e, 0, 0, Local2, 1) + if (LEqual(Local2, 2)) { + OUTP(Local1) + } else { + OUTP(Local2) + } + } else { + OUTP(Local1) + if (LNotEqual(Local1, 0xd650a284)) { + err(ts, z179, 0x02f, 0, 0, Local1, 0xd650a284) + } else { + OUTP("Ok") + } + } + + OUTP("Test m000 finished") + } + + OUTP("Bug 118: Integer data as an element of Package") + + m000() + } + + Method(b118) + { + Name(i900, 0xd650a284) + + Name(p90d, Package() {i900}) + + // Access to the named Integer object as an element of Package + Method(m000) + { + OUTP("Test m000 started") + + Store(Index(p90d, 0), Local0) + Store(DerefOf(Local0), Local1) + Store(ObjectType(Local1), Local2) + + if (LAnd(ABUU, LNot(q006))) { + if (LNotEqual(Local2, 2)) { + err(ts, z179, 0x030, 0, 0, Local2, 2) + } + } elseif (LNotEqual(Local2, 1)) { + err(ts, z179, 0x030, 0, 0, Local2, 1) + } else { + OUTP(Local1) + if (LNotEqual(Local1, 0xd650a284)) { + err(ts, z179, 0x031, 0, 0, Local1, 0xd650a284) + } else { + OUTP("Ok") + } + } + + OUTP("Test m000 finished") + } + + OUTP("Bug 118: Named Integer Object reference in Package") + + m000() + } + + Method(c118) + { + Name(b900, Buffer() {10,2,3,4,5,6,7,8,9}) + + CreateField(b900, 0, 8, bf90) + + Name(p915, Package() {bf90}) + + // Access to the Buffer Field object as an element of Package + Method(m001) + { + OUTP("Test m001 started") + + Store(Index(p915, 0), Local0) + Store(DerefOf(Local0), Local1) + Store(ObjectType(Local1), Local2) + + if (LAnd(ABUU, LNot(q006))) { + if (LNotEqual(Local2, 2)) { + err(ts, z179, 0x032, 0, 0, Local2, 2) + } + } elseif (LNotEqual(Local2, 0xE)) { + err(ts, z179, 0x032, 0, 0, Local2, 0xE) + } elseif (y118) { + OUTP(Local1) + if (LNotEqual(Local1, 10)) { + err(ts, z179, 0x033, 0, 0, Local1, 10) + } else { + OUTP("Ok") + } + } + + OUTP("Test m001 finished") + } + + OUTP("Bug 118: Named Buffer Field Object reference in Package") + + m001() + } + + Method(d118) + { + Name(b900, Buffer() {10,2,3,4,5,6,7,8,9}) + + CreateField(b900, 0, 8, bf90) + + // Access to the Buffer Field object by Reference + Method(m001) + { + OUTP("Test m001 started: Store bf90 to Local1") + + Store(bf90, Local1) + Store(ObjectType(Local1), Local2) + + if (LAnd(ABUU, LNot(q007))) { + if (LNotEqual(Local2, 3)) { + err(ts, z179, 0x034, 0, 0, Local2, 3) + } + } elseif (LNotEqual(Local2, 1)) { + err(ts, z179, 0x034, 0, 0, Local2, 1) + } else { + OUTP(Local1) + if (LNotEqual(Local1, 10)) { + err(ts, z179, 0x035, 0, 0, Local1, 10) + } else { + OUTP("Ok") + } + } + + OUTP("Test m001 finished") + } + + OUTP("Bug 118 issue: Fields are immediately resolved to integers/buffers.") + + m001() + } + + Method(e118) + { + Name(b900, Buffer() {10,2,3,4,5,6,7,8,9}) + + CreateField(b900, 0, 8, bf90) + + // Access to the Buffer Field object by Reference + Method(m001) + { + OUTP("Test m001 started: Store DerefOf(Refof(bf90)) to Local1") + + Store(Refof(bf90), Local0) + Store(DerefOf(Local0), Local1) + Store(ObjectType(Local1), Local2) + + if (LAnd(ABUU, LNot(q007))) { + if (LNotEqual(Local2, 3)) { + err(ts, z179, 0x036, 0, 0, Local2, 3) + } + } elseif (LNotEqual(Local2, 1)) { + err(ts, z179, 0x036, 0, 0, Local2, 1) + } else { + OUTP(Local1) + if (LNotEqual(Local1, 10)) { + err(ts, z179, 0x037, 0, 0, Local1, 10) + } else { + OUTP("Ok") + } + } + + OUTP("Test m001 finished") + } + + OUTP("Bug 118 issue: Fields are immediately resolved to integers/buffers.") + + m001() + } + + Method(f118) + { + Name(b900, Buffer() {10,2,3,4,5,6,7,8,9}) + + CreateField(b900, 0, 8, bf90) + + Name(p915, Package(1) {}) + + // Access to the Buffer Field object by Reference + Method(m001) + { + Method(m000, 1) {return(arg0)} + + OUTP("Test m001 started: Store DerefOf(Refof(bf90)) to Named Package") + + Store(Refof(bf90), Local0) + Store(DerefOf(Local0), p915) + Store(ObjectType(p915), Local2) + + if (LNotEqual(Local2, 1)) { + err(ts, z179, 0x038, 0, 0, Local2, 1) + } else { + OUTP(p915) + if (LNotEqual(m000(p915), 10)) { + err(ts, z179, 0x039, 0, 0, p915, 10) + } else { + OUTP("Ok") + } + } + + OUTP("Test m001 finished") + } + + OUTP("Bug 118 issue: Fields are immediately resolved to integers/buffers.") + + m001() + } + + Method(g118) + { + Name(i900, 0xd650a284) + + Name(p90d, Package() {i900}) + + // Access to the named Integer object as an element of Package + Method(m000) + { + OUTP("Test m000 started") + + Store(Index(p90d, 0), Local0) + Store(DerefOf(Local0), Local1) + Store(ObjectType(Local1), Local2) + + if (LAnd(ABUU, LNot(q006))) { + if (LNotEqual(Local2, 2)) { + err(ts, z179, 0x03a, 0, 0, Local2, 2) + } + } elseif (LNotEqual(Local2, 1)) { + err(ts, z179, 0x03a, 0, 0, Local2, 1) + } else { + OUTP(Local1) + if (LNotEqual(Local1, 0xd650a284)) { + err(ts, z179, 0x03b, 0, 0, Local1, 0xd650a284) + } else { + OUTP("Ok") + } + } + + OUTP("Test m000 finished") + } + + OUTP("Bug 118: DerefOf Named Integer Object reference in Package") + + m000() + } + + Method(m000) + { + a118() + b118() + c118() + d118() + e118() + if (ABUU) { + } else { + f118() + } + g118() + } + + CH03(ts, z179, 0x03c, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { a118() } + case (2) { b118() } + case (3) { c118() } + case (4) { d118() } + case (5) { e118() } + case (6) { f118() } + case (7) { g118() } + } + CH03(ts, z179, 0x03d, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a118) { IIN0() ms16(1) Return(POUT) } +Method(b118) { IIN0() ms16(2) Return(POUT) } +Method(c118) { IIN0() ms16(3) Return(POUT) } +Method(d118) { IIN0() ms16(4) Return(POUT) } +Method(e118) { IIN0() ms16(5) Return(POUT) } +Method(f118) { IIN0() ms16(6) Return(POUT) } +Method(g118) { IIN0() ms16(7) Return(POUT) } + +/* + * Bug 126 issue: + * + * SUMMARY: The Read access automatic dereference for RefOf reference doesn't work + */ +Method(ms17, 1) +{ + Name(ts, "ms17") + + Method(m126, 1) + { + Method(m000, 1) + { + Name(i001, 0) + + OUTP("m000 started, apply DerefOf()") + + Store(DerefOf(arg0), Local0) + Add(Local0, 1, Local6) + CH03(ts, z179, 0x03e, 0, 0) + OUTP(Local6) + + Store(DerefOf(arg0), i001) + OUTP(i001) + Add(i001, 1, Local7) + CH03(ts, z179, 0x03f, 0, 0) + OUTP(Local7) + + if (LNotEqual(Local6, Local7)) { + err(ts, z179, 0x040, 0, 0, Local6, Local7) + } + + OUTP("m000 finished") + } + + Method(m001, 1) + { + + Name(i001, 0) + + OUTP("m001 started, DONT apply DerefOf()") + + Store(arg0, Local0) + OUTP("Before Add") + Add(Local0, 1, Local6) + CH03(ts, z179, 0x041, 0, 0) + OUTP("After Add") + OUTP(Local6) + + OUTP("sit 1") + + Store(arg0, i001) + CH03(ts, z179, 0x042, 0, 0) + OUTP(i001) + Add(i001, 1, Local7) + CH03(ts, z179, 0x043, 0, 0) + if (LNotEqual(Local6, Local7)) { + err(ts, z179, 0x044, 0, 0, Local6, Local7) + } + + OUTP("m001 finished") + } + + Method(m002, 1) + { + OUTP("m002 started, immediate Arg") + + OUTP("Before Add") + Add(arg0, 1, Local7) + CH03(ts, z179, 0x045, 0, 0) + OUTP("After Add") + if (LNotEqual(8, Local7)) { + err(ts, z179, 0x046, 0, 0, Local7, 8) + } + + OUTP("m002 finished") + } + + Method(m003, 1) + { + OUTP("m003 started, apply DerefOf(Arg)") + + OUTP("Before Add") + Add(DerefOf(arg0), 1, Local7) + CH03(ts, z179, 0x047, 0, 0) + OUTP("After Add") + if (LNotEqual(8, Local7)) { + err(ts, z179, 0x048, 0, 0, Local7, 8) + } + + OUTP("m003 finished") + } + + Name(i000, 7) + Name(i001, 7) + Name(i002, 7) + Name(i003, 7) + + + OUTP("Bug 126: automatic dereference on reading issue") + if (LEqual(arg0, 0)) { + m000(RefOf(i000)) + } elseif (LEqual(arg0, 1)) { + m001(RefOf(i001)) + } elseif (LEqual(arg0, 2)) { + m002(RefOf(i002)) + } elseif (LEqual(arg0, 3)) { + m003(RefOf(i003)) + } + } + + Method(m000) + { + m126(0) + if (ABUU) { + } else { + m126(1) + m126(2) + } + m126(3) + } + + CH03(ts, z179, 0x049, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { m126(0) } + case (2) { m126(1) } + case (3) { m126(2) } + case (4) { m126(3) } + } + CH03(ts, z179, 0x04a, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a126) { IIN0() ms17(1) Return(POUT) } +Method(b126) { IIN0() ms17(2) Return(POUT) } +Method(c126) { IIN0() ms17(3) Return(POUT) } +Method(d126) { IIN0() ms17(4) Return(POUT) } + + +/* + * Bug 127 issue: + * + * SUMMARY: Unexpectedly CopyObject of immediately passed Index reference is not reference + */ +Method(ms18) +{ + Name(ts, "ms18") + + Method(m127) + { + Name (p000, Package(2) {1, 2}) + + OUTP("Bug 127: CopyObject unexpectedly performs dereference") + + OUTP("Store(Index(p000, 0, Local0), Local1):") + + Store(Index(p000, 0, Local0), Local1) + + Derefof(Local0) + CH03(ts, z179, 0x04b, 0, 0) + + Derefof(Local1) + CH03(ts, z179, 0x04c, 0, 0) + + OUTP("CopyObject(Index(p000, 0, Local2), Local3):") + + CopyObject(Index(p000, 0, Local2), Local3) + + Derefof(Local2) + CH03(ts, z179, 0x04d, 0, 0) + + Derefof(Local3) + CH03(ts, z179, 0x04e, 0, 0) + } + + CH03(ts, z179, 0x04f, 0, 0) + m127() + CH03(ts, z179, 0x050, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a127) { IIN0() ms18() Return(POUT) } + +/* + * Bug 128 issue: + * + * SUMMARY: Copying the RefOf reference to Named object spoils that reference + */ +Method(ms19, 1) +{ + Name(ts, "ms19") + + // Store Object_Reference to LocalX (No exception, Ok) + Method(a128) + { + Name(i000, 0x1234) + + OUTP("Bug 128:") + + OUTP("a128 started: Store Object_Reference to LocalX (No exception, Ok)") + + Store(RefOf(i000), Local0) + + Store(DerefOf(Local0), Local1) + + if (LNotEqual(Local1, 0x1234)) { + err(ts, z179, 0x051, 0, 0, Local1, 0x1234) + } + + OUTP("a128 finished") + } + + // Store Object_Reference to NamedX (Exception, Ok) + Method(b128) + { + Name(i000, 0x1234) + Name(ref0, 0) + + OUTP("Bug 128:") + + OUTP("b128 started: Store Object_Reference to NamedX (Exception, Ok)") + + Store(RefOf(i000), ref0) + CH04(ts, 0, 0xff, z179, 0x052, 0, 0) + + OUTP("b128 finished") + } + + // CopyObject Object_Reference to NamedX (Exception, Bug) + Method(c128) + { + Name(i000, 0x1234) + Name(ref0, 0) + + OUTP("Bug 128:") + + OUTP("c128 started: CopyObject Object_Reference to NamedX (Exception, Bug)") + + CopyObject(RefOf(i000), ref0) + if (CH04(ts, 0, 0xff, z179, 0x053, 0, 0)) { + return + } + + // When an invocation of a Method tries to return a Package, + // where some reference was saved, the AE_TYPE exeption occurs. + //OUTP(ref0) + + Store(DerefOf(ref0), Local1) + + if (LNotEqual(Local1, 0x1234)) { + err(ts, z179, 0x054, 0, 0, Local1, 0x1234) + } + + OUTP("c128 finished") + } + + // Store Object_Reference to uninit Package element (No exception, Ok) + Method(d128) + { + Name(i000, 0x1234) + Name(p000, Package(1){}) + + OUTP("Bug 128:") + + OUTP("d128 started: Store Object_Reference to uninit Package element (No exception, Ok)") + + Store(RefOf(i000), Index(p000, 0)) + + Store(DerefOf(DerefOf(Index(p000, 0))), Local1) + + if (LNotEqual(Local1, 0x1234)) { + err(ts, z179, 0x055, 0, 0, Local1, 0x1234) + } + + OUTP("d128 finished") + } + + // Store Object_Reference to init Package element (No exception, Ok) + Method(e128) + { + Name(i000, 0x1234) + Name(p000, Package(1){0x5678}) + + OUTP("Bug 128:") + + OUTP("d128 started: Store Object_Reference to init Package element (No exception, Ok)") + + Store(RefOf(i000), Index(p000, 0)) + + Store(DerefOf(DerefOf(Index(p000, 0))), Local1) + + if (LNotEqual(Local1, 0x1234)) { + err(ts, z179, 0x056, 0, 0, Local1, 0x1234) + } + + OUTP("d128 finished") + } + + Method(m000) + { + a128() + + // Causes exception + if (ABUU) { + } else { + b128() + } + + // Causes exception + if (ABUU) { + } else { + c128() + } + + if (ABUU) { + } else { + d128() + } + + if (ABUU) { + } else { + e128() + } + } + + CH03(ts, z179, 0x057, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { a128() } + case (2) { b128() } + case (3) { c128() } + case (4) { d128() } + case (5) { e128() } + } + CH03(ts, z179, 0x058, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a128) { IIN0() ms19(1) Return(POUT) } +Method(b128) { IIN0() ms19(2) Return(POUT) } +Method(c128) { IIN0() ms19(3) Return(POUT) } +Method(d128) { IIN0() ms19(4) Return(POUT) } +Method(e128) { IIN0() ms19(5) Return(POUT) } + +/* + * Bug 131 issue: + * + * SUMMARY: Store to the Index reference immediately returned by Method doesn't work + */ +Method(ms1a, 1) +{ + Name(ts, "ms1a") + + Method(a131) + { + Name(i000, 0x77) + Name(i001, 0) + + Method(m000) + { + Increment(i001) + return (RefOf(i000)) + } + + Method(m001) + { + Increment(i001) + Store(RefOf(i000), Local0) + return (Local0) + } + + OUTP("Case return (RefOf(i000))") + + Store(5, m000()) + + if (LEqual(i001, 0)) { + err(ts, z179, 0x059, 0, 0, i001, 0) + } elseif (LNotEqual(i000, 5)) { + err(ts, z179, 0x05a, 0, 0, i000, 5) + } else { + OUTP("Ok a131") + } + } + + Method(b131) + { + Name(i000, 0x77) + Name(i001, 0) + + Method(m000) + { + Increment(i001) + return (RefOf(i000)) + } + + Method(m001) + { + Increment(i001) + Store(RefOf(i000), Local0) + return (Local0) + } + + OUTP("Case return (Local0) (= RefOf(i000))") + + Store(0x15, m001()) + + if (LEqual(i001, 0)) { + err(ts, z179, 0x05b, 0, 0, i001, 0) + } elseif (LNotEqual(i000, 0x15)) { + err(ts, z179, 0x05c, 0, 0, i000, 0x15) + } else { + OUTP("Ok b131") + } + } + + Method(c131) + { + Name(i000, 0x77) + Name(i001, 0) + + Method(m000) + { + Increment(i001) + return (RefOf(i000)) + } + + Method(m001) + { + Increment(i001) + Store(RefOf(i000), Local0) + return (Local0) + } + + Store(Refof(Local0), Local1) + + OUTP("Case Store(return (RefOf(i000)), Local0)") + + Store(m000(), Local0) + + Store(0x25, Derefof(Local1)) + + if (LEqual(i001, 0)) { + err(ts, z179, 0x05d, 0, 0, i001, 0) + } elseif (LNotEqual(i000, 0x25)) { + err(ts, z179, 0x05e, 0, 0, i000, 0x25) + } else { + OUTP("Ok c131") + } + } + + Method(d131) + { + Name(i000, 0x77) + Name(i001, 0) + + Method(m000) + { + Increment(i001) + return (RefOf(i000)) + } + + Method(m001) + { + Increment(i001) + Store(RefOf(i000), Local0) + return (Local0) + } + + OUTP("Case - test tools proper work indication") + + RSTO(0x35, m000()) + + if (LEqual(i001, 0)) { + err(ts, z179, 0x05f, 0, 0, i001, 0) + } elseif (LNotEqual(i000, 0x35)) { + err(ts, z179, 0x050, 0, 0, i000, 0x35) + } else { + OUTP("Ok d131") + } + } + + Method(e131) + { + Name(i000, 0x77) + Name(i001, 0) + + Method(m000) + { + Increment(i001) + return (RefOf(i000)) + } + + OUTP("Case Store(return (RefOf(i000)), Local0), step 1") + + Store(m000(), Local0) + + if (LEqual(i001, 0)) { + err(ts, z179, 0x061, 0, 0, i001, 0) + } else { + OUTP("Ok e131") + } + } + + Method(m000) + { + if (ABUU) { + } else { + a131() + } + + if (ABUU) { + } else { + b131() + } + + if (ABUU) { + } else { + c131() + } + + d131() + e131() + } + + OUTP("Bug 131: Writing to the reference immediately returned by Method") + + CH03(ts, z179, 0x062, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { a131() } + case (2) { b131() } + case (3) { c131() } + case (4) { d131() } + case (5) { e131() } + } + CH03(ts, z179, 0x063, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a131) { IIN0() ms1a(1) Return(POUT) } +Method(b131) { IIN0() ms1a(2) Return(POUT) } +Method(c131) { IIN0() ms1a(3) Return(POUT) } +Method(d131) { IIN0() ms1a(4) Return(POUT) } +Method(e131) { IIN0() ms1a(4) Return(POUT) } + +/* + * Bug 132 issue: + * + * SUMMARY: The Read access automatic dereference for Index reference doesn't work + */ +Method(ms1b, 1) +{ + Name(ts, "ms1b") + + Method(m132, 2) + { + Name(p000, Package(1) {0x77}) + + Method(m000, 2) + { + + OUTP("m000 started") + + if (arg1) { + Add(DerefOf(arg0), 1, Local7) + } else { + Add(arg0, 1, Local7) + } + CH03(ts, z179, 0x064, 0, 0) + + OUTP("After Add") + + if (LNotEqual(Local7, 0x78)) { + err(ts, z179, 0x065, 0, 0, Local7, 0x78) + } else { + OUTP("Ok 0") + } + OUTP(Local7) + + if (arg1) { + OUTP("Accessed with DerefOf properly!") + } else { + OUTP("Accessed without DerefOf properly!") + } + } + + OUTP("Bug 132: read access \"Automatic dereference\" for Index Reference") + + if (arg0) { + OUTP("Transfer Index reference by LocalX:") + Index(p000, 0, Local0) + m000(Local0, arg1) + } else { + OUTP("Specify Index reference immediately:") + m000(Index(p000, 0), arg1) + } + } + + Method(m000) + { + if (ABUU) { + } else { + m132(0, 0) + } + + if (ABUU) { + } else { + m132(1, 0) + } + + m132(0, 1) + m132(1, 1) + } + + CH03(ts, z179, 0x066, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { m132(0, 0) } + case (2) { m132(1, 0) } + case (3) { m132(0, 1) } + case (4) { m132(1, 1) } + } + CH03(ts, z179, 0x067, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a132) { IIN0() ms1b(1) Return(POUT) } +Method(b132) { IIN0() ms1b(2) Return(POUT) } +Method(c132) { IIN0() ms1b(3) Return(POUT) } +Method(d132) { IIN0() ms1b(4) Return(POUT) } + +/* + * Bug 133 issue: + * + * SUMMARY: The Write access automatic dereference for Index reference doesn't work + */ +Method(ms1c, 1) +{ + Name(ts, "ms1c") + + Method(m133, 1) + { + Name(i000, 0) + Name(s000, "q_er0000") + Name(b000, Buffer(4) {1,0,3,4}) + Name(p000, Package(3) {5,0,7}) + + Method(m000, 1) + { + Store(0x77, arg0) + } + + OUTP("Bug 133: WRITE access to the initial object by reference in ArgX") + + if (LEqual(arg0, 0)) { + OUTP("Writing by RefOf reference to Integer") + + Store(RefOf(i000), Local0) + m000(Local0) + if (LNotEqual(i000, 0x77)) { + err(ts, z179, 0x068, 0, 0, i000, 0x77) + } else { + OUTP("Ok 0") + } + OUTP(i000) + + } elseif (LEqual(arg0, 1)) { + OUTP("Writing by Index to String") + + Index(s000, 1, Local0) + m000(Local0) + Store(Derefof(Local0), Local1) + if (LNotEqual(Local1, 0x77)) { + err(ts, z179, 0x069, 0, 0, Local1, 0x77) + } else { + OUTP("Ok 1") + } + OUTP(s000) + + } elseif (LEqual(arg0, 2)) { + OUTP("Writing by Index to Buffer") + + Index(b000, 1, Local0) + m000(Local0) + + Store(Derefof(Local0), Local1) + if (LNotEqual(Local1, 0x77)) { + err(ts, z179, 0x06a, 0, 0, Local1, 0x77) + } else { + OUTP("Ok 2") + } + OUTP(b000) + + } elseif (LEqual(arg0, 3)) { + OUTP("Check Index of Package") + + Index(p000, 1, Local0) + + Store(DerefOf(Local0), Local1) + if (LNotEqual(Local1, 0)) { + err(ts, z179, 0x06b, 0, 0, Local1, 0) + } else { + OUTP("Ok 3") + } + OUTP(Local1) + + } elseif (LEqual(arg0, 4)) { + OUTP("Writing by Index to Package") + + Index(p000, 1, Local0) + m000(Local0) + + Store(DerefOf(Local0), Local1) + + if (LNotEqual(Local1, 0x77)) { + err(ts, z179, 0x06c, 0, 0, Local1, 0x77) + } else { + OUTP("Ok 4") + } + OUTP(Local1) + } + } + + Method(m000) + { + m133(0) + + if (ABUU) { + } else { + m133(1) + } + + m133(2) + m133(3) + m133(4) + } + + CH03(ts, z179, 0x06d, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { m133(0) } + case (2) { m133(1) } + case (3) { m133(2) } + case (4) { m133(3) } + case (5) { m133(4) } + } + CH03(ts, z179, 0x06e, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a133) { IIN0() ms1c(1) Return(POUT) } +Method(b133) { IIN0() ms1c(2) Return(POUT) } +Method(c133) { IIN0() ms1c(3) Return(POUT) } +Method(d133) { IIN0() ms1c(4) Return(POUT) } +Method(e133) { IIN0() ms1c(5) Return(POUT) } + +/* + * Bug 134 issue: + * + * SUMMARY: Writing RefOf reference from inside Method breaks effectively local Arg + */ +Method(ms1d, 1) +{ + Name(ts, "ms1d") + + Method(m134, 1) + { + Name(i000, 0x11) + Name(i001, 0x22) + Name(i002, 0x33) + Name(i003, 0x44) + Name(i004, 0x55) + Name(i005, 0x66) + Name(i006, 0x77) + + Method(m000, 7) + { + OUTP("LocalX case of Method started:") + + Store(RefOf(i000), Local0) + Store(Local0, Local1) + Store(Local1, Local2) + Store(Local2, Local3) + Store(Local3, Local4) + Store(Local4, Local5) + Store(Local5, Local6) + + Store(0x88, Local6) + + if (LAnd(ABUU, LNot(q008))) { + if (LNotEqual(i000, 0x88)) { + err(ts, z179, 0x06f, 0, 0, i000, 0x88) + } + } elseif (LNotEqual(i000, 0x11)) { + err(ts, z179, 0x06f, 0, 0, i000, 0x11) + } else { + if (LNotEqual(Local6, 0x88)) { + err(ts, z179, 0x070, 0, 0, Local6, 0x88) + } else { + OUTP("Ok 0:") + } + OUTP(Local6) + } + + OUTP("LocalX case of Method finished") + } + + Method(m001, 7) + { + OUTP("ArgX case of Method started:") + + Store(RefOf(i000), arg0) + Store(arg0, arg1) + Store(arg1, arg2) + Store(arg2, arg3) + Store(arg3, arg4) + Store(arg4, arg5) + Store(arg5, arg6) + + Store(0x88, arg6) + + if (LAnd(ABUU, LNot(q008))) { + if (LNotEqual(i000, 0x88)) { + err(ts, z179, 0x071, 0, 0, i000, 0x88) + } + } elseif (LNotEqual(i000, 0x11)) { + err(ts, z179, 0x071, 0, 0, i000, 0x11) + } else { + if (LNotEqual(arg6, 0x88)) { + err(ts, z179, 0x072, 0, 0, arg6, 0x88) + } else { + OUTP("Ok 1:") + } + OUTP(arg6) + } + + OUTP("ArgX case of Method finished") + } + + Method(m002, 7) + { + OUTP("references in ArgX case of Method started:") + + Store(RefOf(i000), arg0) + Store(arg0, arg1) + Store(arg1, arg2) + Store(arg2, arg3) + Store(arg3, arg4) + Store(arg4, arg5) + Store(arg5, arg6) + + Store(0x88, arg6) + + if (LAnd(ABUU, LNot(q008))) { + if (LNotEqual(i000, 0x88)) { + err(ts, z179, 0x073, 0, 0, i000, 0x88) + } + } elseif (LNotEqual(i000, 0x11)) { + err(ts, z179, 0x073, 0, 0, i000, 0x11) + OUTP(i000) + } else { + Store(DerefOf(arg6), Local1) + if (LNotEqual(Local1, 0x88)) { + err(ts, z179, 0x074, 0, 0, Local1, 0x88) + } else { + OUTP("Ok 1:") + } + OUTP(arg6) + } + + OUTP("ArgX case of Method finished") + } + + OUTP("Bug 134: ArgX term effectively becomes a LocalX term") + + if (LEqual(arg0, 0)) { + m000(i000,i001,i002,i003,i004,i005,i006) + } elseif (LEqual(arg0, 1)) { + m001(i000,i001,i002,i003,i004,i005,i006) + } elseif (LEqual(arg0, 2)) { + m002(Refof(Local0),Refof(Local1),Refof(Local2),Refof(Local3),Refof(Local4), + Refof(Local5),Refof(Local6)) + } + } + + Method(m000) + { + m134(0) + m134(1) + m134(2) + } + + CH03(ts, z179, 0x075, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { m134(0) } + case (2) { m134(1) } + case (3) { m134(2) } + } + CH03(ts, z179, 0x076, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a134) { IIN0() ms1d(1) Return(POUT) } +Method(b134) { IIN0() ms1d(2) Return(POUT) } +Method(c134) { IIN0() ms1d(3) Return(POUT) } + +/* + * Bug 136 issue: + * + * SUMMARY: CopyObject of named Buffer to the longer named Buffer works incorrectly + */ +Method(ms1e) +{ + Name(ts, "ms1e") + + Method(m136) + { + Name(b000, Buffer(1){0x3c}) + Name(b001, Buffer(3){0x01, 0x02, 0x03}) + + OUTP("Bug 136: CopyObject does not perform an implicit store") + + CopyObject(b000, b001) + + if (LEqual(b000, b001)) { + OUTP("Ok") + } else { + err(ts, z179, 0x077, 0, 0, b000, b001) + } + OUTP(b000) + OUTP(b001) + } + + CH03(ts, z179, 0x078, 0, 0) + m136() + CH03(ts, z179, 0x079, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a136) { IIN0() ms1e() Return(POUT) } + +/* + * Hot issue: + * + * Checks store of a Local Reference into the Package + */ +Method(ms1f, 1) +{ + Name(ts, "ms1f") + + Name(I999, 0) + Name(PREF, Package(4) {0xa5a5a5a5, I999, I999}) + + Method(mlrp, 2) + { + Store(ObjectType(Arg0), Local0) + Store(Arg0, Index(PREF, Arg1)) + CH03(ts, z179, 0x07a, 0, 0) + Store(ObjectType(Index(PREF, Arg1)), Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x07b, 0, 0, Local1, Local0) + } + } + + Method(mlr0) + { + OUTP("Store a Local Reference to Uninit Package element") + + Store("Local0", Local0) + + mlrp(Refof(Local0), 3) + } + + Method(mlr1) + { + OUTP("Store a Local Reference to Integer Package element") + + Store("Local0", Local0) + + mlrp(Refof(Local0), 0) + } + + Method(mlr2) + { + OUTP("Store a Local Reference to Reference Package element") + + Store("Local0", Local0) + + mlrp(Refof(Local0), 1) + } + + Method(mlr3) + { + OUTP("Store a Integer to Reference Package element") + + Store("Local0", Local0) + + mlrp(3, 2) + } + + Method(m000) + { + mlr0() + mlr1() + mlr2() + mlr3() + } + + CH03(ts, z179, 0x07c, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { mlr0() } + case (2) { mlr1() } + case (3) { mlr2() } + case (4) { mlr3() } + } + CH03(ts, z179, 0x07d, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(alrp) { IIN0() ms1f(1) Return(POUT) } +Method(blrp) { IIN0() ms1f(2) Return(POUT) } +Method(clrp) { IIN0() ms1f(3) Return(POUT) } +Method(dlrp) { IIN0() ms1f(4) Return(POUT) } +Method(elrp) { IIN0() ms1f(0) Return(POUT) } + +/* + * Hot issue: + * + * Forward reference within a control method + */ +Method(ms20, 1) +{ + Name(ts, "ms20") + + Name (Y, 2) + + Method(mfr0) + { + OUTP("Forward reference within a control method 0") + + Store (Y, Local0) + if (LNotEqual(Local0, 2)) { + err(ts, z179, 0x07e, 0, 0, Local0, 2) + } + + Name (Y, 1) + + Store (Y, Local0) + if (LNotEqual(Local0, 1)) { + err(ts, z179, 0x07f, 0, 0, Local0, 1) + } + } + Method(mfr1) + { + OUTP("Natural reference within a control method") + + Name (Y, 1) + + Store (^Y, Local0) + + if (LNotEqual(Local0, 2)) { + err(ts, z179, 0x080, 0, 0, Local0, 2) + } + + Store (Y, Local0) + if (LNotEqual(Local0, 1)) { + err(ts, z179, 0x081, 0, 0, Local0, 1) + } + } + + Method(mfr2) + { + OUTP("Forward reference within a control method 2") + + Store (^mfr2.Y, Local0) + CH04(ts, 0, 0xff, z179, 0x082, "^mfr2.Y", Local0) + + Name (Y, 1) + + Store (^mfr2.Y, Local0) + if (LNotEqual(Local0, 1)) { + err(ts, z179, 0x083, 0, 0, Local0, 1) + } + } + + Method(mfr3) + { + OUTP("Forward reference within a control method 3") + + Name (Y, 1) + + Store (^mfr3.Y, Local0) + if (LNotEqual(Local0, 1)) { + err(ts, z179, 0x084, 0, 0, Local0, 1) + } + } + + Method(m000) + { + mfr0() + mfr1() + + if (ABUU) { + } else { + mfr2() + } + + mfr3() + } + + CH03(ts, z179, 0x085, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { mfr0() } + case (2) { mfr1() } + case (3) { mfr2() } + case (4) { mfr3() } + } + CH03(ts, z179, 0x086, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(amfr) { IIN0() ms20(1) Return(POUT) } +Method(bmfr) { IIN0() ms20(2) Return(POUT) } +Method(cmfr) { IIN0() ms20(3) Return(POUT) } +Method(dmfr) { IIN0() ms20(4) Return(POUT) } + +/* + * Hot issue: AE_AML_METHOD_LIMIT + * + * Recursive Serialized method execution + */ +Method(ms21, 1) +{ + Name(ts, "ms21") + + Method(aact, 1, Serialized) + { + if (Arg0) { + Return (Add(Arg0, aact(Subtract(Arg0, 1)))) + } else { + Return (0) + } + } + + Method(mac0) + { + OUTP("Recursive method execution aact(0)") + OUTP(aact(0)) + } + + Method(mac1) + { + OUTP("Recursive method execution aact(1)") + OUTP(aact(1)) + } + + Method(mac2) + { + OUTP("Recursive method execution aact(2)") + OUTP(aact(2)) + } + + Method(mac3) + { + OUTP("Recursive method execution aact(6)") + OUTP(aact(6)) + } + + Method(mac4) + { + OUTP("Recursive method execution aact(513)") + OUTP(aact(513)) + CH04(ts, 0, 0xff, z179, 0x087, "recursion", 513) + } + + Method(m000) + { + mac0() + mac1() + mac2() + mac3() + + if (ABUU) { + } else { + mac4() + } + } + + CH03(ts, z179, 0x088, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { mac0() } + case (2) { mac1() } + case (3) { mac2() } + case (4) { mac3() } + case (5) { mac4() } + } + CH03(ts, z179, 0x089, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(arec) { IIN0() ms21(1) Return(POUT) } +Method(brec) { IIN0() ms21(2) Return(POUT) } +Method(crec) { IIN0() ms21(3) Return(POUT) } +Method(drec) { IIN0() ms21(4) Return(POUT) } +Method(erec) { IIN0() ms21(5) Return(POUT) } + +/* + * Hot issue: + * + * Conditional reference within a control method + */ +Method(ms22, 1) +{ + Name(ts, "ms22") + + Name(iact, 0) + + Method(cact, 1) + { + if (Arg0) { + Name(iact, 0xffffffff) + } + Return (iact) + } + + Method(m000) + { + OUTP("Conditional reference within a control method 0") + + OUTP("expected iact 0:") + Store(cact(0), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x08a, 0, 0, Local0, 0) + } + } + + Method(m001) + { + OUTP("Conditional reference within a control method 1") + + OUTP("expected iact 0xffffffff:") + Store(cact(1), Local0) + + if (LNotEqual(Local0, 0xffffffff)) { + err(ts, z179, 0x08b, 0, 0, Local0, 0xffffffff) + } + } + + CH03(ts, z179, 0x08c, 0, 0) + switch (arg0) { + case (0) { m000() m001() } + case (1) { m000() } + case (2) { m001() } + } + CH03(ts, z179, 0x08d, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(amcr) { IIN0() ms22(1) Return(POUT) } +Method(bmcr) { IIN0() ms22(2) Return(POUT) } + +/* + * Hot issue: + * + * Implicit return + */ +Method(ms23, 1) +{ + Name(ts, "ms23") + + Method(mir0) + { + Name(fl00, 0) + + Method(m001) + { + if (fl00) { + Add (0xabcd, 0) + } elseif (0) { + return (1) + } + + } + + OUTP("Implicit return no operator") + + OUTP("An exception is expected: ...") + Store(m001(), Local0) + CH04(ts, 0, 0xff, z179, 0x08e, 0, 0) + } + + Method(mir1) + { + Name(fl00, 1) + + Method(m001) + { + if (fl00) { + Add (0xabcd, 0) + } else { + return (1) + } + } + + OUTP("Implicit return after Add") + + OUTP("0xabcd expected: ...") + Store(m001(), Local0) + + if (SLCK) { + if (CH03(ts, z179, 0x08f, 0, 0)) {return} + if (LNotEqual(Local0, 0xabcd)) { + err(ts, z179, 0x090, 0, 0, Local0, 0xabcd) + } + } else { + CH04(ts, 0, 0xff, z179, 0x091, 0, 0) + } + } + + Method(mir2) + { + Name(fl00, 0) + + Method(m001) + { + if (fl00) { + Return (0xabce) + } elseif (0) { + return (1) + } + } + + OUTP("Implicit return no operator 2") + + OUTP("An exception is expected: ...") + Store(m001(), Local0) + CH04(ts, 0, 0xff, z179, 0x092, 0, 0) + } + + Method(mir3) + { + Name(fl00, 1) + + Method(m001) + { + if (fl00) { + Return (0xabce) + } else { + return (1) + } + } + + OUTP("Explicit return conditionally") + + OUTP("0xabce expected: ...") + Store(m001(), Local0) + + if (SLCK) { + if (CH03(ts, z179, 0x093, 0, 0)) {return} + if (LNotEqual(Local0, 0xabce)) { + err(ts, z179, 0x094, 0, 0, Local0, 0xabce) + } + } else { + CH04(ts, 0, 0xff, z179, 0x095, 0, 0) + } + } + + Method(mir4) + { + Name(fl00, 0) + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + + Method(m000) + { + Switch (Store(0xabcd000f, i001)) { + Case (0) { + if (fl00) { + Return (0) + } + } + } + } + + OUTP("Implicit return on Switch") + + Store(0xdddd9000, i000) + + Store(m000, i000) + + if (SLCK) { + if (CH03(ts, z179, 0x096, 0, 0)) {return} + if (LNotEqual(i000, 0xabcd000f)) { + err(ts, z179, 0x097, 0, 0, i000, 0xabcd000f) + } + } else { + CH04(ts, 0, 0xff, z179, 0x098, 0, 0) + } + } + + Method(mir5) + { + Name(fl00, 0) + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + + Method(m000) + { + if (Store(0xabcd000d, i001)) { + if (fl00) { + Return (0) + } + } + } + + OUTP("Implicit return on If") + + Store(0xdddd9000, i000) + + Store(m000, i000) + + if (SLCK) { + if (CH03(ts, z179, 0x099, 0, 0)) {return} + if (LNotEqual(i000, 0xabcd000d)) { + err(ts, z179, 0x09a, 0, 0, i000, 0xabcd000d) + } + } else { + CH04(ts, 0, 0xff, z179, 0x09b, 0, 0) + } + } + + Method(mir6) + { + Name(fl00, 0) + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + + Method(m000) + { + While (Store(0xabcd000e, i001)) { + if (fl00) { + Return (0) + } + Break + } + } + + OUTP("Implicit return on While") + + Store(0xdddd9000, i000) + + Store(m000, i000) + + if (SLCK) { + if (CH03(ts, z179, 0x09c, 0, 0)) {return} + if (LNotEqual(i000, 0xabcd000e)) { + err(ts, z179, 0x09d, 0, 0, i000, 0xabcd000e) + } + } else { + CH04(ts, 0, 0xff, z179, 0x09e, 0, 0) + } + } + + Method(m000) + { + mir0() + mir1() + mir2() + mir3() + + if (ABUU) { + } else { + mir4() + } + + if (ABUU) { + } else { + mir5() + } + + if (ABUU) { + } else { + mir6() + } + } + + CH03(ts, z179, 0x09f, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { mir0() } + case (2) { mir1() } + case (3) { mir2() } + case (4) { mir3() } + case (5) { mir4() } + case (6) { mir5() } + case (7) { mir6() } + } + CH03(ts, z179, 0x0a0, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(amir) { IIN0() ms23(1) Return(POUT) } +Method(bmir) { IIN0() ms23(2) Return(POUT) } +Method(cmir) { IIN0() ms23(3) Return(POUT) } +Method(dmir) { IIN0() ms23(4) Return(POUT) } +Method(emir) { IIN0() ms23(5) Return(POUT) } +Method(fmir) { IIN0() ms23(6) Return(POUT) } +Method(gmir) { IIN0() ms23(7) Return(POUT) } + +/* + * Hot issue: + * + * Increment/Decrement with String/Buffer + */ +Method(ms24) +{ + Name(ts, "ms24") + + Method(mmid) + { + Name(s000, "0321") + Name(s001, "0321") + Name(b000, Buffer(3){0x21, 0x03, 0x00}) + Name(b001, Buffer(3){0x21, 0x03, 0x00}) + + OUTP("Increment/Decrement with String/Buffer") + + OUTP(s000) + OUTP(s001) + Subtract(s000, 1, s000) + Decrement(s001) + + Store(ObjectType(s000), Local0) + Store(ObjectType(s001), Local1) + + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0a1, 0, 0, Local0, Local1) + } elseif (LNotEqual(s000, s001)) { + err(ts, z179, 0x0a2, 0, 0, s000, s001) + } else { + OUTP("Ok Subtract/Decrement for String") + } + + OUTP("======") + + OUTP(b000) + OUTP(b001) + Add(b000, 1, b000) + Increment(b001) + + Store(ObjectType(b000), Local0) + Store(ObjectType(b001), Local1) + + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0a3, 0, 0, Local0, Local1) + } elseif (LNotEqual(b000, b001)) { + err(ts, z179, 0x0a4, 0, 0, Local0, Local1) + } else { + OUTP("Ok Add/Increment for Buffer") + } + } + + CH03(ts, z179, 0x0a5, 0, 0) + mmid() + CH03(ts, z179, 0x0a6, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(amid) { IIN0() ms24() Return(POUT) } + + +/* + * Hot issue: + * + * Check Store(..., DeRefof(...)) behavior + */ +Method(ms25, 1) +{ + Name(ts, "ms25") + + Method(msd0) + { + Name(i000, 0xffffffff) + Name(i001, 0x12345678) + + OUTP("Check Store(..., DeRefof(...)) behavior: none DeRefof") + + Store(i001, Refof(i000)) + CH03(ts, z179, 0x0a7, 0, 0) + if (LNotEqual(i000, 0x12345678)) { + err(ts, z179, 0x0a8, 0, 0, i000, 0x12345678) + } + } + + Method(msd1) + { + Name(i000, 0xffffffff) + Name(i001, 0x12345678) + + OUTP("Check Store(..., DeRefof(...)) behavior: Refof(Named)") + + Store(i001, DeRefof(Refof(i000))) + CH03(ts, z179, 0x0a9, 0, 0) + if (LNotEqual(i000, 0x12345678)) { + err(ts, z179, 0x0aa, 0, 0, i000, 0x12345678) + } + } + + Method(msd2) + { + Name(i000, 0xffffffff) + Name(i001, 0x12345678) + + OUTP("Check Store(..., DeRefof(...)) behavior: Refof in LocalX") + + Store(Refof(i000), Local2) + + Store(i001, DeRefof(Local2)) + CH03(ts, z179, 0x0ab, 0, 0) + if (LNotEqual(i000, 0x12345678)) { + err(ts, z179, 0x0ac, 0, 0, i000, 0x12345678) + } + } + + Method(msd3) + { + Name(i000, 0xffffffff) + Name(i001, 0x12345678) + + OUTP("Check Store(..., DeRefof(...)) behavior: DeRefof(2xRefof)") + + Store(Refof(i000), Local1) + Store(Refof(Local1), Local2) + + Store(i001, DeRefof(Local2)) + CH03(ts, z179, 0x0ad, 0, 0) + + if (LNotEqual(i000, 0xffffffff)) { + err(ts, z179, 0x0ae, 0, 0, i000, 0xffffffff) + } + + Store(Derefof(Local1), Local4) + if (CH04(ts, 0, 0xff, z179, 0x0af, 0, 0)) { + } elseif (LNotEqual(Local1, 0x12345678)) { + err(ts, z179, 0x0b0, 0, 0, Local1, 0x12345678) + } + } + + CH03(ts, z179, 0x0b1, 0, 0) + switch (arg0) { + case (0) { msd0() msd1() msd2() msd3() } + case (1) { msd0() } + case (2) { msd1() } + case (3) { msd2() } + case (4) { msd3() } + } + CH03(ts, z179, 0x0b2, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(amsd) { IIN0() ms25(1) Return(POUT) } +Method(bmsd) { IIN0() ms25(2) Return(POUT) } +Method(cmsd) { IIN0() ms25(3) Return(POUT) } +Method(dmsd) { IIN0() ms25(4) Return(POUT) } + +// Video memory address to maintain SystemMemory OpRegions +// Name(VMEM, 0xA0000) // VGA memory +// Name(VMEM, 0xF0000000) // T22 Savage3 +// Name(VMEM, 0xD0000000) // IntelliStation Z Pro NVidia +Name(VMEM, 0xA0000) // VGA memory + +// SystemMemory OpRegions base address is maintained flag +Name(SMBA, 1) + +/* + * Hot issue: + * + * Exceeding Field Unit + */ +Method(ms26, 1) +{ + Name(ts, "ms26") + + OperationRegion(OPR0, SystemMemory, VMEM, 256) + + Method(rfu0) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + g001, 0x80, + } + + Field(OPR0, ByteAcc, NoLock, Preserve) { + Offset(0x8), FU01, 8, + } + + OUTP("Store Integer exceeding Field Unit") + + Store(0, g001) + + Store(FU01, Local0) + Store(0, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0b3, 0, 0, Local0, Local1) + } + + Store(0x5a, FU01) + Store(FU01, Local0) + Store(0x5a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0b4, 0, 0, Local0, Local1) + } + + Store(0x3c69, FU01) + Store(FU01, Local0) + Store(0x69, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0b5, 0, 0, Local0, Local1) + } + } + + Method(rfu1) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + g001, 0x80, + } + + Field(OPR0, ByteAcc, NoLock, Preserve) { + Offset(0x8), FU01, 8, + } + + OUTP("Store Buffer exceeding Field Unit") + + Store(0, g001) + + Store(FU01, Local0) + Store(0, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0b6, 0, 0, Local0, Local1) + } + + Store(0x5a, FU01) + Store(FU01, Local0) + Store(0x5a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0b7, 0, 0, Local0, Local1) + } + + Store(Buffer(){0x3c, 0x69}, FU01) + Store(FU01, Local0) + Store(0x3c, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x69, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0b8, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0b8, 0, 0, Local0, Local1) + } + } + + Method(rfu2) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + g001, 0x80, + } + + Field(OPR0, ByteAcc, NoLock, Preserve) { + Offset(0x8), FU01, 8, + } + + OUTP("Store String exceeding Field Unit") + + Store(0, g001) + + Store(FU01, Local0) + Store(0, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0b9, 0, 0, Local0, Local1) + } + + Store(0x5a, FU01) + Store(FU01, Local0) + Store(0x5a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0ba, 0, 0, Local0, Local1) + } + + Store("79", FU01) + Store(FU01, Local0) + Store(0x37, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x39, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0bb, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0bb, 0, 0, Local0, Local1) + } + } + + Method(rfu3) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + g001, 0x80, + } + + Field(OPR0, ByteAcc, NoLock, Preserve) { + Offset(0x8), FU01, 6, FU02, 2 + } + + OUTP("Store Buffer exceeding 6-bit Field Unit") + + Store(0, g001) + + Store(FU01, Local0) + Store(0, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0bc, 0, 0, Local0, Local1) + } + + Store(0x5a, FU01) + Store(FU01, Local0) + Store(0x1a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0bd, 0, 0, Local0, Local1) + } + + Store(Buffer(){0x7c, 0x69}, FU01) + Store(FU01, Local0) + Store(0x3c, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x29, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0be, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0be, 0, 0, Local0, Local1) + } + + Store(FU02, Local0) + Store(0, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x01, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0bf, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0bf, 0, 0, Local0, Local1) + } + } + + Method(rfu4) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + g001, 0x80, + } + + Field(OPR0, ByteAcc, NoLock, Preserve) { + Offset(0x8), FU01, 6, FU02, 2 + } + + OUTP("Store String exceeding 6-bit Field Unit") + + Store(0, g001) + + Store(FU01, Local0) + Store(0, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c0, 0, 0, Local0, Local1) + } + + Store(0x5a, FU01) + Store(FU01, Local0) + Store(0x1a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c1, 0, 0, Local0, Local1) + } + + Store("79", FU01) + Store(FU01, Local0) + Store(0x37, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x39, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c2, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c2, 0, 0, Local0, Local1) + } + + Store(FU02, Local0) + Store(0, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x01, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c3, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c3, 0, 0, Local0, Local1) + } + } + + Method(rfu5) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + g001, 0x80, + } + + Field(OPR0, ByteAcc, NoLock, Preserve) { + Offset(0x8), FU01, 10, FU02, 6 + } + + OUTP("Store Buffer exceeding 10-bit Field Unit") + + Store(0, g001) + + Store(FU01, Local0) + Store(0, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c4, 0, 0, Local0, Local1) + } + + Store(0x5a, FU01) + Store(FU01, Local0) + Store(0x5a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c5, 0, 0, Local0, Local1) + } + + Store(Buffer(){0x3c, 0x69}, FU01) + Store(FU01, Local0) + Store(0x13c, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c6, 0, 0, Local0, Local1) + } + + Store(FU02, Local0) + Store(0, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x1a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c7, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c7, 0, 0, Local0, Local1) + } + } + + Method(rfu6) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + g001, 0x80, + } + + Field(OPR0, ByteAcc, NoLock, Preserve) { + Offset(0x8), FU01, 10, FU02, 6 + } + + OUTP("Store String exceeding 10-bit Field Unit") + + Store(0, g001) + + Store(FU01, Local0) + Store(0, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c8, 0, 0, Local0, Local1) + } + + Store(0x5a, FU01) + Store(FU01, Local0) + Store(0x5a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0c9, 0, 0, Local0, Local1) + } + + Store("79", FU01) + Store(FU01, Local0) + Store(0x137, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0ca, 0, 0, Local0, Local1) + } + + Store(FU02, Local0) + Store(0, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x0e, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0cb, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0cb, 0, 0, Local0, Local1) + } + } + + Method(rfu7) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + g001, 0x80, + } + + Field(OPR0, ByteAcc, NoLock, Preserve) { + Offset(0x8), FU01, 10, FU02, 6 + } + + OUTP("Store 3-byte Buffer exceeding 10-bit Field Unit") + + Store(0, g001) + + Store(FU01, Local0) + Store(0, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0cc, 0, 0, Local0, Local1) + } + + Store(0x5a, FU01) + Store(FU01, Local0) + Store(0x5a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0cd, 0, 0, Local0, Local1) + } + + Store(Buffer(){0x3c, 0x69, 0xa5}, FU01) + Store(FU01, Local0) + Store(0x13c, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0xa5, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0ce, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0ce, 0, 0, Local0, Local1) + } + + Store(FU02, Local0) + Store(0, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x1a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0cf, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0cf, 0, 0, Local0, Local1) + } + } + + Method(rfu8) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + g001, 0x80, + } + + Field(OPR0, ByteAcc, NoLock, Preserve) { + Offset(0x8), FU01, 10, FU02, 6 + } + + OUTP("Store 3-char String exceeding 10-bit Field Unit") + + Store(0, g001) + + Store(FU01, Local0) + Store(0, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0d0, 0, 0, Local0, Local1) + } + + Store(0x5a, FU01) + Store(FU01, Local0) + Store(0x5a, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0d1, 0, 0, Local0, Local1) + } + + Store("795", FU01) + Store(FU01, Local0) + Store(0x137, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x35, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0d2, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0d2, 0, 0, Local0, Local1) + } + + Store(FU02, Local0) + Store(0, Local1) + if (LAnd(ABUU, LNot(q009))) { + Store(0x0e, Local1) + if (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0d3, 0, 0, Local0, Local1) + } + } elseif (LNotEqual(Local0, Local1)) { + err(ts, z179, 0x0d3, 0, 0, Local0, Local1) + } + } + + Method(m000) + { + rfu0() + rfu1() + rfu2() + rfu3() + rfu4() + rfu5() + rfu6() + rfu7() + rfu8() + } + + CH03(ts, z179, 0x0d4, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { rfu0() } + case (2) { rfu1() } + case (3) { rfu2() } + case (4) { rfu3() } + case (5) { rfu4() } + case (6) { rfu5() } + case (7) { rfu6() } + case (8) { rfu7() } + case (9) { rfu8() } + } + CH03(ts, z179, 0x0d5, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(arfu) { IIN0() ms26(1) Return(POUT) } +Method(brfu) { IIN0() ms26(2) Return(POUT) } +Method(crfu) { IIN0() ms26(3) Return(POUT) } +Method(drfu) { IIN0() ms26(4) Return(POUT) } +Method(erfu) { IIN0() ms26(5) Return(POUT) } +Method(frfu) { IIN0() ms26(6) Return(POUT) } +Method(grfu) { IIN0() ms26(7) Return(POUT) } +Method(hrfu) { IIN0() ms26(8) Return(POUT) } +Method(irfu) { IIN0() ms26(9) Return(POUT) } + + +/* + * Hot issue: + * + * Check IndexField implementation + */ +Method(ms27, 1) +{ + Name(ts, "ms27") + + OperationRegion(OPR0, SystemMemory, VMEM, 256) + + Field(OPR0, ByteAcc, NoLock, Preserve) { + tot0, 32, + tot1, 32, + } + + Method(ifd0) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx1, 4, + dta1, 3, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, WriteAsZeros) { + re10, 3, + re11, 3, + re12, 3, + re13, 3, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(Ones, ^re10)} + Case (1) {Store(Ones, ^re11)} + Case (2) {Store(Ones, ^re12)} + Case (3) {Store(Ones, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x0d6, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x0d7, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField ByteAcc 4-3 Ones write 3-3-3-3") + + TRY0(0, 0, 0x7) + TRY0(1, 0, 0x0) + + Store(0x1, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x07, Local0) + } + TRY0(2, 0, Local0) + + TRY0(3, 0, 0x06) + } + + Method(ifd1) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx1, 8, + dta1, 8, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, WriteAsZeros) { + re10, 8, + re11, 8, + re12, 8, + re13, 8, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(0x12345678, ^re10)} + Case (1) {Store(0x12345678, ^re11)} + Case (2) {Store(0x12345678, ^re12)} + Case (3) {Store(0x12345678, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x0de, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x0df, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField ByteAcc 0x12345678 write 8-8-8-8") + + TRY0(0, 0, 0x78) + TRY0(1, 1, 0x78) + TRY0(2, 2, 0x78) + TRY0(3, 3, 0x78) + } + + Method(ifd2) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx1, 8, + dta1, 8, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, WriteAsZeros) { + , 7, + re10, 1, + re11, 1, + Offset(2), + re12, 4, + re13, 4, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(Ones, ^re10)} + Case (1) {Store(Ones, ^re11)} + Case (2) {Store(Ones, ^re12)} + Case (3) {Store(Ones, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x0e6, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x0e7, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField ByteAcc Ones write Offset (0:7)1-(1:0)1-(2:0)4-4") + + TRY0(0, 0, 0x80) + + Store(0x01, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0xff, Local0) + } + TRY0(1, 1, Local0) + + Store(0x0f, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0xff, Local0) + } + TRY0(2, 2, Local0) + + TRY0(3, 2, 0xf0) + } + + Method(ifd3) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx1, 8, + dta1, 8, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, WriteAsZeros) { + Offset(1), + re10, 8, + Offset(2), + re11, 8, + Offset(7), + re12, 8, + Offset(16), + re13, 8, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(0x12345678, ^re10)} + Case (1) {Store(0x12345678, ^re11)} + Case (2) {Store(0x12345678, ^re12)} + Case (3) {Store(0x12345678, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x0ee, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x0ef, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField ByteAcc 0x12345678 write Offset (1:0)8-(2:0)8-(7:0)8-(16:0)8") + + TRY0(0, 1, 0x78) + TRY0(1, 2, 0x78) + TRY0(2, 7, 0x78) + TRY0(3, 16, 0x78) + } + + CH03(ts, z179, 0x0e6, 0, 0) + switch (arg0) { + case (0) { + ifd0() + ifd1() + ifd2() + ifd3() + } + case (1) { ifd0() } + case (2) { ifd1() } + case (3) { ifd2() } + case (4) { ifd3() } + } + CH03(ts, z179, 0x0e7, 0, 0) +} + +Method(mt27, 1) +{ + Name(ts, "mt27") + + OperationRegion(OPR0, SystemMemory, VMEM, 256) + + Field(OPR0, ByteAcc, NoLock, Preserve) { + tot0, 32, + tot1, 32, + } + + Method(ifd4) + { + Field(OPR0, WordAcc, NoLock, WriteAsZeros) { + idx1, 16, + dta1, 16, + } + + IndexField(idx1, dta1, WordAcc, NoLock, WriteAsZeros) { + re10, 8, + re11, 8, + re12, 8, + re13, 8, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(0x12345678, ^re10)} + Case (1) {Store(0x12345678, ^re11)} + Case (2) {Store(0x12345678, ^re12)} + Case (3) {Store(0x12345678, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x0f0, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x0f1, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField WordAcc Ones write 8-8-8-8") + + Store(0x0078, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x5678, Local0) + } + TRY0(0, 0, Local0) + + TRY0(1, 0, 0x7800) + + Store(0x0078, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x5678, Local0) + } + TRY0(2, 2, Local0) + + TRY0(3, 2, 0x7800) + } + + Method(ifd5) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx1, 8, + dta1, 8, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, WriteAsZeros) { + , 1, + re10, 8, + , 1, + re11, 8, + , 1, + re12, 8, + , 1, + re13, 8, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(Ones, ^re10)} + Case (1) {Store(Ones, ^re11)} + Case (2) {Store(Ones, ^re12)} + Case (3) {Store(Ones, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x0f8, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x0f9, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField ByteAcc Ones write (:1)8-(:1)8-(:1)8-(:1)8") + + TRY0(0, 1, 0x1) + TRY0(1, 2, 0x3) + TRY0(2, 3, 0x7) + TRY0(3, 4, 0xf) + } + + Method(ifd6) + { + Field(OPR0, DWordAcc, NoLock, WriteAsZeros) { + idx1, 32, + dta1, 32, + } + + IndexField(idx1, dta1, DWordAcc, NoLock, WriteAsZeros) { + re10, 8, + re11, 8, + re12, 8, + re13, 8, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Store(Zero, tot1) + Switch (arg0) { + Case (0) {Store(Ones, ^re10)} + Case (1) {Store(Ones, ^re11)} + Case (2) {Store(Ones, ^re12)} + Case (3) {Store(Ones, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x100, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x101, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField DWordAcc Ones write 8-8-8-8") + + Store(0xff, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0xffffffff, Local0) + } + TRY0(0, 0, Local0) + + Store(0xff00, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0xffffff00, Local0) + } + TRY0(1, 0, Local0) + + Store(0xff0000, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0xffff0000, Local0) + } + TRY0(2, 0, Local0) + + TRY0(3, 0, 0xff000000) + } + + Method(ifd7) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx1, 8, + dta1, 8, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, WriteAsZeros) { + , 2, + re10, 7, + , 2, + re11, 7, + , 2, + re12, 7, + , 2, + re13, 7, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(Ones, ^re10)} + Case (1) {Store(Ones, ^re11)} + Case (2) {Store(Ones, ^re12)} + Case (3) {Store(Ones, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x108, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x109, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField ByteAcc Ones write (:2)7-(:2)7-(:2)7-(:2)7") + + Store(0x1, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x3, Local0) + } + TRY0(0, 1, Local0) + + Store(0x3, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x7, Local0) + } + TRY0(1, 2, Local0) + + Store(0x7, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0xf, Local0) + } + TRY0(2, 3, Local0) + + Store(0xf, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x1f, Local0) + } + TRY0(3, 4, Local0) + } + + CH03(ts, z179, 0x0e8, 0, 0) + switch (arg0) { + case (0) { + ifd4() + ifd5() + ifd6() + ifd7() + } + case (5) { ifd4() } + case (6) { ifd5() } + case (7) { ifd6() } + case (8) { ifd7() } + } + CH03(ts, z179, 0x0e9, 0, 0) +} + +Method(mu27, 1) +{ + Name(ts, "mu27") + + OperationRegion(OPR0, SystemMemory, VMEM, 256) + + Field(OPR0, ByteAcc, NoLock, Preserve) { + tot0, 32, + tot1, 32, + } + + Method(ifd8) + { + Field(OPR0, DWordAcc, NoLock, WriteAsZeros) { + idx1, 32, + dta1, 32, + } + + IndexField(idx1, dta1, DWordAcc, NoLock, WriteAsZeros) { + Offset(1), + re10, 8, + Offset(4), + re11, 8, + Offset(9), + re12, 8, + Offset(12), + re13, 8, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Store(Zero, tot1) + Switch (arg0) { + Case (0) {Store(0x12345678, ^re10)} + Case (1) {Store(0x12345678, ^re11)} + Case (2) {Store(0x12345678, ^re12)} + Case (3) {Store(0x12345678, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x118, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x119, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField DWordAcc 0x12345678 write Offset (1)8-(4)8-(9)8-(12)8") + + Store(0x7800, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x34567800, Local0) + } + TRY0(0, 0, Local0) + + Store(0x78, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x12345678, Local0) + } + TRY0(1, 4, Local0) + + Store(0x7800, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x34567800, Local0) + } + TRY0(2, 8, Local0) + + Store(0x78, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x12345678, Local0) + } + TRY0(3, 12, Local0) + } + + Method(ifd9) + { + Field(OPR0, WordAcc, NoLock, WriteAsZeros) { + idx1, 16, + dta1, 16, + } + + IndexField(idx1, dta1, WordAcc, NoLock, WriteAsZeros) { + Offset(1), + re10, 8, + Offset(4), + re11, 8, + Offset(9), + re12, 8, + Offset(12), + re13, 8, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(0x12345678, ^re10)} + Case (1) {Store(0x12345678, ^re11)} + Case (2) {Store(0x12345678, ^re12)} + Case (3) {Store(0x12345678, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x120, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x121, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField WordAcc 0x12345678 write Offset (1)8-(4)8-(9)8-(12)8") + + TRY0(0, 0, 0x7800) + + Store(0x78, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x5678, Local0) + } + TRY0(1, 4, Local0) + + TRY0(2, 8, 0x7800) + + Store(0x78, Local0) + if (LAnd(ABUU, LNot(q00a))) { + Store(0x5678, Local0) + } + TRY0(3, 12, Local0) + } + + Method(ifda) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx1, 16, + dta1, 16, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, WriteAsZeros) { + Offset(1), + re10, 8, + Offset(4), + re11, 8, + Offset(9), + re12, 8, + Offset(12), + re13, 8, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(0x12345678, ^re10)} + Case (1) {Store(0x12345678, ^re11)} + Case (2) {Store(0x12345678, ^re12)} + Case (3) {Store(0x12345678, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x128, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x129, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField ByteAcc 0x12345678 write Offset (1)8-(4)8-(9)8-(12)8") + + TRY0(0, 1, 0x78) + TRY0(1, 4, 0x78) + TRY0(2, 9, 0x78) + TRY0(3, 12, 0x78) + } + + Method(ifdb) + { + Field(OPR0, AnyAcc, NoLock, WriteAsZeros) { + idx1, 16, + dta1, 16, + } + + IndexField(idx1, dta1, AnyAcc, NoLock, WriteAsZeros) { + Offset(1), + re10, 8, + Offset(4), + re11, 8, + Offset(9), + re12, 8, + Offset(12), + re13, 8, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(0x12345678, ^re10)} + Case (1) {Store(0x12345678, ^re11)} + Case (2) {Store(0x12345678, ^re12)} + Case (3) {Store(0x12345678, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x130, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x131, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField AnyAcc 0x12345678 write Offset (1)8-(4)8-(9)8-(12)8") + + TRY0(0, 1, 0x78) + TRY0(1, 4, 0x78) + TRY0(2, 9, 0x78) + TRY0(3, 12, 0x78) + } + + CH03(ts, z179, 0x0ea, 0, 0) + switch (arg0) { + case (0) { + ifd8() + ifd9() + ifda() + ifdb() + } + case (9) { ifd8() } + case (10) { ifd9() } + case (11) { ifda() } + case (12) { ifdb() } + } + CH03(ts, z179, 0x0eb, 0, 0) +} + +Method(mv27, 1) +{ + Name(ts, "mv27") + + OperationRegion(OPR0, SystemMemory, VMEM, 256) + + Field(OPR0, ByteAcc, NoLock, Preserve) { + tot0, 32, + tot1, 32, + } + + Method(ifdc) + { + Field(OPR0, WordAcc, NoLock, WriteAsZeros) { + idx0, 16, + dta0, 16, + } + IndexField(idx0, dta0, WordAcc, NoLock, WriteAsZeros) { + idf0, 8, + Offset(3), + idf1, 8, + Offset(6), + idf2, 8, + Offset(11), + idf3, 8, + } + + Method(TRY0, 4) + { + Store(idx0, Local0) + Store(dta0, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x138, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x139, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField WordAcc read") + + Store(0x1234ffff, tot0) + TRY0(0, 0, 0x1234, idf0) + + Store(0x5678ffff, tot0) + TRY0(2, 2, 0x5678, idf1) + + Store(0x9abcffff, tot0) + TRY0(3, 6, 0x9abc, idf2) + + Store(0xde01ffff, tot0) + TRY0(4, 10, 0xde01, idf3) + } + + Method(TRY4, 5) + { + Method(TRY0, 3) + { + Store(arg0, tot0) + Store(Derefof(arg1), Local0) + Store(tot0, Local1) + Store(DeRefof(Index(arg2, 0)), Local2) + Store(DeRefof(Index(arg2, 1)), Local3) + Store(DeRefof(Index(arg2, 2)), Local4) + + Add(0x140, Multiply(Local2, 2), Local2) + if (LNotEqual(Local0, Local3)) { + err(ts, z179, Local2, 0, 0, Local0, Local3) + } + if (LNotEqual(Local1, Local4)) { + err(ts, z179, Add(Local2, 1), 0, 0, Local1, Local4) + } + } + + Store(DeRefof(Index(arg0, 0)), Local0) + TRY0(Local0, arg1, DeRefof(Index(arg0, 1))) + TRY0(Local0, arg2, DeRefof(Index(arg0, 2))) + TRY0(Local0, arg3, DeRefof(Index(arg0, 3))) + TRY0(Local0, arg4, DeRefof(Index(arg0, 4))) + } + + Method(ifdd) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + idx1, 8, + dta1, 8, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, Preserve) { + , 4, + re10, 1, + re11, 1, + re12, 3, + re13, 3, + } + + OUTP("Check IndexField implementation ByteAcc 4,1-1-3-3") + + Store(Package(){0xa5a5a5a5, + Package(){0, 0x0, 0xa5a5a500}, + Package(){1, 0x1, 0xa5a5a500}, + Package(){2, 0x6, 0xa5a5a501}, + Package(){3, 0x2, 0xa5a5a501},}, + Local0) + + if (LAnd(ABUU, LNot(q00a))) { + Store(0x96, Index(DeRefof(Index(Local0, 3)), 1)) + } + + TRY4(Local0, Refof(re10), Refof(re11), Refof(re12), Refof(re13)) + + + Store(Package(){0x5a5a5a5a, + Package(){4, 0x1, 0x5a5a5a00}, + Package(){5, 0x0, 0x5a5a5a00}, + Package(){6, 0x1, 0x5a5a5a01}, + Package(){7, 0x5, 0x5a5a5a01},}, + Local0) + + if (LAnd(ABUU, LNot(q00a))) { + Store(0x169, Index(DeRefof(Index(Local0, 3)), 1)) + } + + TRY4(Local0, Refof(re10), Refof(re11), Refof(re12), Refof(re13)) + } + + Method(ifde) + { + Field(OPR0, WordAcc, NoLock, Preserve) { + idx1, 16, + dta1, 16, + } + + IndexField(idx1, dta1, WordAcc, NoLock, Preserve) { + , 4, + re10, 1, + re11, 1, + re12, 3, + re13, 3, + } + + OUTP("Check IndexField implementation WordAcc 4,1-1-3-3") + + Store(Package(){0xa5a5a5a5, + Package(){8, 0x0, 0xa5a50000}, + Package(){9, 0x1, 0xa5a50000}, + Package(){10, 0x6, 0xa5a50000}, + Package(){11, 0x2, 0xa5a50000},}, + Local0) + TRY4(Local0, Refof(re10), Refof(re11), Refof(re12), Refof(re13)) + + + Store(Package(){0x5a5a5a5a, + Package(){12, 0x1, 0x5a5a0000}, + Package(){13, 0x0, 0x5a5a0000}, + Package(){14, 0x1, 0x5a5a0000}, + Package(){15, 0x5, 0x5a5a0000},}, + Local0) + TRY4(Local0, Refof(re10), Refof(re11), Refof(re12), Refof(re13)) + } + + Method(ifdf) + { + Field(OPR0, ByteAcc, NoLock, Preserve) { + idx1, 8, + dta1, 8, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, Preserve) { + , 7, + re10, 1, + re11, 1, + Offset(2), + re12, 4, + re13, 4, + } + + OUTP("Check IndexField implementation ByteAcc 7,1-1,O2,4-4") + + Store(Package(){0xa5a5a5a5, + Package(){16, 0x1, 0xa5a5a500}, + Package(){17, 0x1, 0xa5a5a501}, + Package(){18, 0x5, 0xa5a5a502}, + Package(){19, 0xa, 0xa5a5a502},}, + Local0) + TRY4(Local0, Refof(re10), Refof(re11), Refof(re12), Refof(re13)) + + + Store(Package(){0x5a5a5a5a, + Package(){20, 0x0, 0x5a5a5a00}, + Package(){21, 0x0, 0x5a5a5a01}, + Package(){22, 0xa, 0x5a5a5a02}, + Package(){23, 0x5, 0x5a5a5a02},}, + Local0) + TRY4(Local0, Refof(re10), Refof(re11), Refof(re12), Refof(re13)) + } + + CH03(ts, z179, 0x0ec, 0, 0) + switch (arg0) { + case (0) { + ifdc() + ifdd() + ifde() + ifdf() + } + case (13) { ifdc() } + case (14) { ifdd() } + case (15) { ifde() } + case (16) { ifdf() } + } + CH03(ts, z179, 0x0ed, 0, 0) +} + +Method(mw27, 1) +{ + Name(ts, "mw27") + + OperationRegion(OPR0, SystemMemory, VMEM, 256) + + Field(OPR0, ByteAcc, NoLock, Preserve) { + tot0, 32, + tot1, 32, + } + + Method(ife0) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 16, + dta0, 16, + } + IndexField(idx0, dta0, ByteAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 5) + { + Store(arg0, tot0) + Store(Derefof(arg1), Local0) + Store(tot0, Local1) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + } + + OUTP("Check IndexField implementation: ByteAcc2") + + m000(0x0001ffff, Refof(idf0), 0x150, 0x1, 0x00010000) + m000(0x0080ffff, Refof(idf1), 0x152, 0x1, 0x00800000) + m000(0x0001ffff, Refof(idf2), 0x154, 0x1, 0x00010001) + m000(0x0080ffff, Refof(idf3), 0x156, 0x1, 0x00800001) + m000(0x0001ffff, Refof(idf4), 0x158, 0x1, 0x00010002) + m000(0x0080ffff, Refof(idf5), 0x15a, 0x1, 0x00800002) + m000(0x0001ffff, Refof(idf6), 0x15c, 0x1, 0x00010003) + m000(0x0080ffff, Refof(idf7), 0x15e, 0x1, 0x00800003) + } + + Method(ife1) + { + Field(OPR0, WordAcc, NoLock, WriteAsZeros) { + idx0, 16, + dta0, 16, + } + IndexField(idx0, dta0, ByteAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 5) + { + Store(arg0, tot0) + Store(Derefof(arg1), Local0) + Store(tot0, Local1) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + } + + OUTP("Check IndexField implementation: WordAccByteAcc") + + m000(0x0001ffff, Refof(idf0), 0x160, 0x1, 0x00010000) + m000(0x0080ffff, Refof(idf1), 0x162, 0x1, 0x00800000) + m000(0x0001ffff, Refof(idf2), 0x164, 0x1, 0x00010001) + m000(0x0080ffff, Refof(idf3), 0x166, 0x1, 0x00800001) + m000(0x0001ffff, Refof(idf4), 0x168, 0x1, 0x00010002) + m000(0x0080ffff, Refof(idf5), 0x16a, 0x1, 0x00800002) + m000(0x0001ffff, Refof(idf6), 0x16c, 0x1, 0x00010003) + m000(0x0080ffff, Refof(idf7), 0x16e, 0x1, 0x00800003) + } + + Method(ife2) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 16, + dta0, 16, + } + IndexField(idx0, dta0, WordAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 5) + { + Store(arg0, tot0) + Store(Derefof(arg1), Local0) + Store(tot0, Local1) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + } + + OUTP("Check IndexField implementation: ByteAccWordAcc") + + m000(0x0001ffff, Refof(idf0), 0x170, 0x1, 0x00010000) + m000(0x0080ffff, Refof(idf1), 0x172, 0x1, 0x00800000) + m000(0x0001ffff, Refof(idf2), 0x174, 0x0, 0x00010000) + m000(0x0080ffff, Refof(idf3), 0x176, 0x0, 0x00800000) + m000(0x0001ffff, Refof(idf4), 0x178, 0x1, 0x00010002) + m000(0x0080ffff, Refof(idf5), 0x17a, 0x1, 0x00800002) + m000(0x0001ffff, Refof(idf6), 0x17c, 0x0, 0x00010002) + m000(0x0080ffff, Refof(idf7), 0x17e, 0x0, 0x00800002) + } + + Method(ife3) + { + Field(OPR0, WordAcc, NoLock, WriteAsZeros) { + idx0, 16, + dta0, 16, + } + IndexField(idx0, dta0, WordAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 5) + { + Store(arg0, tot0) + Store(Derefof(arg1), Local0) + Store(tot0, Local1) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + } + + OUTP("Check IndexField implementation: WordAcc2") + + m000(0x0001ffff, Refof(idf0), 0x180, 0x1, 0x00010000) + m000(0x0080ffff, Refof(idf1), 0x182, 0x1, 0x00800000) + m000(0x0001ffff, Refof(idf2), 0x184, 0x0, 0x00010000) + m000(0x0080ffff, Refof(idf3), 0x186, 0x0, 0x00800000) + m000(0x0001ffff, Refof(idf4), 0x188, 0x1, 0x00010002) + m000(0x0080ffff, Refof(idf5), 0x18a, 0x1, 0x00800002) + m000(0x0001ffff, Refof(idf6), 0x18c, 0x0, 0x00010002) + m000(0x0080ffff, Refof(idf7), 0x18e, 0x0, 0x00800002) + } + + + CH03(ts, z179, 0x0ee, 0, 0) + switch (arg0) { + case (0) { + ife0() + ife1() + ife2() + ife3() + } + case (17) { ife0() } + case (18) { ife1() } + case (19) { ife2() } + case (20) { ife3() } + } + CH03(ts, z179, 0x0ef, 0, 0) +} + +Method(mx27, 1) +{ + Name(ts, "mx27") + + OperationRegion(OPR0, SystemMemory, VMEM, 256) + + Field(OPR0, ByteAcc, NoLock, Preserve) { + tot0, 32, + tot1, 32, + } + + Method(ife4) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 16, + dta0, 4, + } + IndexField(idx0, dta0, ByteAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 5) + { + Store(arg0, tot0) + Store(Derefof(arg1), Local0) + Store(tot0, Local1) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + } + + OUTP("Check IndexField implementation: ByteAcc2, dta0:4") + + m000(0x0001ffff, Refof(idf0), 0x190, 0x1, 0x00010000) + m000(0xffffffff, Refof(idf1), 0x192, 0x0, 0xffff0000) + m000(0x0001ffff, Refof(idf2), 0x194, 0x1, 0x00010001) + m000(0xffffffff, Refof(idf3), 0x196, 0x0, 0xffff0001) + m000(0x0001ffff, Refof(idf4), 0x198, 0x1, 0x00010002) + m000(0xffffffff, Refof(idf5), 0x19a, 0x0, 0xffff0002) + m000(0x0001ffff, Refof(idf6), 0x19c, 0x1, 0x00010003) + m000(0xffffffff, Refof(idf7), 0x19e, 0x0, 0xffff0003) + } + + Method(ife5) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 8, + dta0, 8, + } + IndexField(idx0, dta0, WordAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 5) + { + Store(arg0, tot0) + Store(Derefof(arg1), Local0) + Store(tot0, Local1) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + } + + OUTP("Check IndexField implementation: ByteAccWordAcc, idx0, 8, dta0, 8") + + m000(0x000001ff, Refof(idf0), 0x1a0, 0x1, 0x00000100) + m000(0x000080ff, Refof(idf1), 0x1a2, 0x1, 0x00008000) + m000(0xffffffff, Refof(idf2), 0x1a4, 0x0, 0xffffff00) + m000(0xffffffff, Refof(idf3), 0x1a6, 0x0, 0xffffff00) + m000(0x000001ff, Refof(idf4), 0x1a8, 0x1, 0x00000102) + m000(0x000080ff, Refof(idf5), 0x1aa, 0x1, 0x00008002) + m000(0xffffffff, Refof(idf6), 0x1ac, 0x0, 0xffffff02) + m000(0xffffffff, Refof(idf7), 0x1ae, 0x0, 0xffffff02) + } + + Method(ife6) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 32, + dta0, 32, + } + IndexField(idx0, dta0, WordAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 6) + { + Store(0xffffffff, tot0) + Store(arg0, tot1) + Store(Derefof(arg1), Local0) + Store(tot1, Local1) + Store(tot0, Local2) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + if (LNotEqual(Local2, arg5)) { + err(ts, z179, Add(arg2, 2), 0, 0, Local2, arg5) + } + } + + OUTP("Check IndexField implementation: ByteAccWordAcc, idx0, 32, dta0, 32") + + m000(0x00000001, Refof(idf0), 0x1b0, 0x1, 0x00000001, 0) + m000(0x00000080, Refof(idf1), 0x1b3, 0x1, 0x00000080, 0) + m000(0x00000100, Refof(idf2), 0x1b6, 0x1, 0x00000100, 0) + m000(0x00008000, Refof(idf3), 0x1b9, 0x1, 0x00008000, 0) + m000(0x00000001, Refof(idf4), 0x1bc, 0x1, 0x00000001, 2) + m000(0x00000080, Refof(idf5), 0x1bf, 0x1, 0x00000080, 2) + m000(0x00000100, Refof(idf6), 0x1c2, 0x1, 0x00000100, 2) + m000(0x00008000, Refof(idf7), 0x1c5, 0x1, 0x00008000, 2) + } + + Method(ife7) + { + Field(OPR0, DWordAcc, NoLock, WriteAsZeros) { + idx0, 32, + dta0, 32, + } + IndexField(idx0, dta0, WordAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 6) + { + Store(0xffffffff, tot0) + Store(arg0, tot1) + Store(Derefof(arg1), Local0) + Store(tot1, Local1) + Store(tot0, Local2) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + if (LNotEqual(Local2, arg5)) { + err(ts, z179, Add(arg2, 2), 0, 0, Local2, arg5) + } + } + + OUTP("Check IndexField implementation: DWordAccWordAcc, idx0, 32, dta0, 32") + + m000(0x00000001, Refof(idf0), 0x1f0, 0x1, 0x00000001, 0) + m000(0x00000080, Refof(idf1), 0x1f3, 0x1, 0x00000080, 0) + m000(0x00000100, Refof(idf2), 0x1f6, 0x1, 0x00000100, 0) + m000(0x00008000, Refof(idf3), 0x1f9, 0x1, 0x00008000, 0) + m000(0x00000001, Refof(idf4), 0x1fc, 0x1, 0x00000001, 2) + m000(0x00000080, Refof(idf5), 0x1ff, 0x1, 0x00000080, 2) + m000(0x00000100, Refof(idf6), 0x202, 0x1, 0x00000100, 2) + m000(0x00008000, Refof(idf7), 0x215, 0x1, 0x00008000, 2) + } + + CH03(ts, z179, 0x1c8, 0, 0) + switch (arg0) { + case (0) { + ife4() + ife5() + ife6() + ife7() + } + case (21) { ife4() } + case (22) { ife5() } + case (23) { ife6() } + case (24) { ife7() } + } + CH03(ts, z179, 0x1c9, 0, 0) +} + +Method(my27, 1) +{ + Name(ts, "my27") + + OperationRegion(OPR0, SystemMemory, VMEM, 256) + + Field(OPR0, ByteAcc, NoLock, Preserve) { + tot0, 32, + tot1, 32, + } + + Method(ife8) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 32, + dta0, 32, + } + IndexField(idx0, dta0, DWordAcc, NoLock, WriteAsZeros) { + idf0, 1, , 14, idf1, 1, + idf2, 1, , 14, idf3, 1, + idf4, 1, , 14, idf5, 1, + idf6, 1, , 14, idf7, 1, + } + Method(m000, 6) + { + Store(0xffffffff, tot0) + Store(arg0, tot1) + Store(Derefof(arg1), Local0) + Store(tot1, Local1) + Store(tot0, Local2) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + if (LNotEqual(Local2, arg5)) { + err(ts, z179, Add(arg2, 2), 0, 0, Local2, arg5) + } + } + + OUTP("Check IndexField implementation: ByteAccDWordAcc, idx0, 32, dta0, 32") + + m000(0x00000001, Refof(idf0), 0x200, 0x1, 0x00000001, 0) + m000(0x00008000, Refof(idf1), 0x203, 0x1, 0x00008000, 0) + m000(0x00010000, Refof(idf2), 0x206, 0x1, 0x00010000, 0) + m000(0x80000000, Refof(idf3), 0x209, 0x1, 0x80000000, 0) + m000(0x00000001, Refof(idf4), 0x20c, 0x1, 0x00000001, 4) + m000(0x00008000, Refof(idf5), 0x20f, 0x1, 0x00008000, 4) + m000(0x00010000, Refof(idf6), 0x212, 0x1, 0x00010000, 4) + m000(0x80000000, Refof(idf7), 0x215, 0x1, 0x80000000, 4) + } + + Method(ife9) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 32, + dta0, 32, + } + IndexField(idx0, dta0, QWordAcc, NoLock, WriteAsZeros) { + idf0, 1, , 14, idf1, 1, + idf2, 1, , 14, idf3, 1, + idf4, 1, , 14, idf5, 1, + idf6, 1, , 14, idf7, 1, + } + Method(m000, 6) + { + Store(0xffffffff, tot0) + Store(arg0, tot1) + Store(Derefof(arg1), Local0) + Store(tot1, Local1) + Store(tot0, Local2) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + if (LNotEqual(Local2, arg5)) { + err(ts, z179, Add(arg2, 2), 0, 0, Local2, arg5) + } + } + + OUTP("Check IndexField implementation: ByteAccQWordAcc, idx0, 32, dta0, 32") + + m000(0x00000001, Refof(idf0), 0x220, 0x1, 0x00000001, 0) + m000(0x00008000, Refof(idf1), 0x223, 0x1, 0x00008000, 0) + m000(0x00010000, Refof(idf2), 0x226, 0x1, 0x00010000, 0) + m000(0x80000000, Refof(idf3), 0x229, 0x1, 0x80000000, 0) + m000(0xffffffff, Refof(idf4), 0x22c, 0x0, 0xffffffff, 0) + m000(0xffffffff, Refof(idf5), 0x22f, 0x0, 0xffffffff, 0) + m000(0xffffffff, Refof(idf6), 0x232, 0x0, 0xffffffff, 0) + m000(0xffffffff, Refof(idf7), 0x235, 0x0, 0xffffffff, 0) + } + + Method(ifea) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 16, + dta0, 16, + } + IndexField(idx0, dta0, ByteAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 4) + { + Store(arg0, tot0) + Switch(arg1) { + case (0) {Store(1, idf0)} + case (1) {Store(1, idf1)} + case (2) {Store(1, idf2)} + case (3) {Store(1, idf3)} + case (4) {Store(1, idf4)} + case (5) {Store(1, idf5)} + case (6) {Store(1, idf6)} + case (7) {Store(1, idf7)} + } + Store(tot0, Local0) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + } + + OUTP("Check IndexField implementation: ByteAcc2, Store") + + m000(0xffffffff, 0, 0x240, 0x00010000) + m000(0xffffffff, 1, 0x241, 0x00800000) + m000(0xffffffff, 2, 0x242, 0x00010001) + m000(0xffffffff, 3, 0x243, 0x00800001) + m000(0xffffffff, 4, 0x244, 0x00010002) + m000(0xffffffff, 5, 0x245, 0x00800002) + m000(0xffffffff, 6, 0x246, 0x00010003) + m000(0xffffffff, 7, 0x247, 0x00800003) + } + + Method(ifeb) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 16, + dta0, 16, + } + IndexField(idx0, dta0, WordAcc, NoLock, WriteAsZeros) { + idf0, 1, , 6, idf1, 1, + idf2, 1, , 6, idf3, 1, + idf4, 1, , 6, idf5, 1, + idf6, 1, , 6, idf7, 1, + } + Method(m000, 4) + { + Store(arg0, tot0) + Switch(arg1) { + case (0) {Store(1, idf0)} + case (1) {Store(1, idf1)} + case (2) {Store(1, idf2)} + case (3) {Store(1, idf3)} + case (4) {Store(1, idf4)} + case (5) {Store(1, idf5)} + case (6) {Store(1, idf6)} + case (7) {Store(1, idf7)} + } + Store(tot0, Local0) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + } + + OUTP("Check IndexField implementation: ByteAccWordAcc, Store") + + m000(0xffffffff, 0, 0x248, 0x00010000) + m000(0xffffffff, 1, 0x249, 0x00800000) + m000(0xffffffff, 2, 0x24a, 0x01000000) + m000(0xffffffff, 3, 0x24b, 0x80000000) + m000(0xffffffff, 4, 0x24c, 0x00010002) + m000(0xffffffff, 5, 0x24d, 0x00800002) + m000(0xffffffff, 6, 0x24e, 0x01000002) + m000(0xffffffff, 7, 0x24f, 0x80000002) + } + + CH03(ts, z179, 0x1ca, 0, 0) + switch (arg0) { + case (0) { + ife8() + + if (ABUU) { + } else { + ife9() + } + + if (ABUU) { + } else { + ifea() + } + + if (ABUU) { + } else { + ifeb() + } + } + case (25) { ife8() } + case (26) { ife9() } + case (27) { ifea() } + case (28) { ifeb() } + } + CH03(ts, z179, 0x1cb, 0, 0) +} + +Method(mz27, 1) +{ + Name(ts, "mz27") + + OperationRegion(OPR0, SystemMemory, VMEM, 256) + + Field(OPR0, ByteAcc, NoLock, Preserve) { + tot0, 32, + tot1, 32, + } + + Method(ifec) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 32, + dta0, 32, + } + IndexField(idx0, dta0, DWordAcc, NoLock, WriteAsZeros) { + idf0, 1, , 14, idf1, 1, + idf2, 1, , 14, idf3, 1, + idf4, 1, , 14, idf5, 1, + idf6, 1, , 14, idf7, 1, + } + Method(m000, 5) + { + Store(0xffffffff, tot0) + Store(arg0, tot1) + Switch(arg1) { + case (0) {Store(1, idf0)} + case (1) {Store(1, idf1)} + case (2) {Store(1, idf2)} + case (3) {Store(1, idf3)} + case (4) {Store(1, idf4)} + case (5) {Store(1, idf5)} + case (6) {Store(1, idf6)} + case (7) {Store(1, idf7)} + } + Store(tot1, Local0) + Store(tot0, Local1) + + if (LNotEqual(Local0, arg3)) { + err(ts, z179, arg2, 0, 0, Local0, arg3) + } + if (LNotEqual(Local1, arg4)) { + err(ts, z179, Add(arg2, 1), 0, 0, Local1, arg4) + } + } + + OUTP("Check IndexField implementation: ByteAccDWordAcc, Store") + + m000(0xffffffff, 0, 0x250, 0x00000001, 0) + m000(0xffffffff, 1, 0x252, 0x00008000, 0) + m000(0xffffffff, 2, 0x254, 0x00010000, 0) + m000(0xffffffff, 3, 0x256, 0x80000000, 0) + m000(0xffffffff, 4, 0x258, 0x00000001, 4) + m000(0xffffffff, 5, 0x25a, 0x00008000, 4) + m000(0xffffffff, 6, 0x25c, 0x00010000, 4) + m000(0xffffffff, 7, 0x25e, 0x80000000, 4) + } + + Method(ifed) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 8, + dta0, 24, + } + IndexField(idx0, dta0, ByteAcc, NoLock, WriteAsZeros) { + , 15, + idf0, 1 + } + + OUTP("Check IndexField implementation: dta wider than idf Access width") + + Store(0x3FF, idf0) + + Store(tot0, Local0) + if (LNotEqual(Local0, 0x8001)) { + err(ts, z179, 0x260, 0, 0, Local0, 0x8001) + } + } + + Method(ifee) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx0, 8, + dta0, 24, + } + IndexField(idx0, dta0, ByteAcc, NoLock, WriteAsZeros) { + , 7, + idf0, 1 + } + + OUTP("Check IndexField implementation: dta wider than idf Access width 2") + + Store(0xFF, idf0) + + Store(tot0, Local0) + if (LNotEqual(Local0, 0x8000)) { + err(ts, z179, 0x261, 0, 0, Local0, 0x8000) + } + } + + Method(ifef) + { + Field(OPR0, ByteAcc, NoLock, WriteAsZeros) { + idx1, 8, + dta1, 8, + } + + IndexField(idx1, dta1, ByteAcc, NoLock, WriteAsZeros) { + , 2, + re10, 6, + , 3, + re11, 5, + , 4, + re12, 4, + , 5, + re13, 3, + } + + Method(TRY0, 3) + { + Store(Zero, tot0) + Switch (arg0) { + Case (0) {Store(Ones, ^re10)} + Case (1) {Store(Ones, ^re11)} + Case (2) {Store(Ones, ^re12)} + Case (3) {Store(Ones, ^re13)} + } + + Store(idx1, Local0) + Store(dta1, Local1) + + Multiply(arg0, 2, Local2) + if (LNotEqual(Local0, arg1)) { + err(ts, z179, Add(0x262, Local2), 0, 0, Local0, arg1) + } + if (LNotEqual(Local1, arg2)) { + err(ts, z179, Add(0x263, Local2), 0, 0, Local1, arg2) + } + } + + OUTP("Check IndexField ByteAcc Ones write (:2)6-(:3)5-(:4)4-(:5)3") + + TRY0(0, 0, 0xfc) + TRY0(1, 1, 0xf8) + TRY0(2, 2, 0xf0) + TRY0(3, 3, 0xe0) + } + + CH03(ts, z179, 0x1cc, 0, 0) + switch (arg0) { + case (0) { + ifec() + ifed() + ifee() + ifef() + } + case (29) { ifec() } + case (30) { ifed() } + case (31) { ifee() } + case (32) { ifef() } + } + CH03(ts, z179, 0x1cd, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(aifd) { IIN0() ms27(1) Return(POUT) } +Method(bifd) { IIN0() ms27(2) Return(POUT) } +Method(cifd) { IIN0() ms27(3) Return(POUT) } +Method(difd) { IIN0() ms27(4) Return(POUT) } +Method(sifd) { IIN0() ms27(0) Return(POUT) } +Method(eifd) { IIN0() mt27(5) Return(POUT) } +Method(fifd) { IIN0() mt27(6) Return(POUT) } +Method(gifd) { IIN0() mt27(7) Return(POUT) } +Method(hifd) { IIN0() mt27(8) Return(POUT) } +Method(tifd) { IIN0() mt27(0) Return(POUT) } +Method(iifd) { IIN0() mu27(9) Return(POUT) } +Method(jifd) { IIN0() mu27(10) Return(POUT) } +Method(kifd) { IIN0() mu27(11) Return(POUT) } +Method(lifd) { IIN0() mu27(12) Return(POUT) } +Method(uifd) { IIN0() mu27(0) Return(POUT) } +Method(mifd) { IIN0() mv27(13) Return(POUT) } +Method(nifd) { IIN0() mv27(14) Return(POUT) } +Method(oifd) { IIN0() mv27(15) Return(POUT) } +Method(pifd) { IIN0() mv27(16) Return(POUT) } +Method(vifd) { IIN0() mv27(0) Return(POUT) } +Method(aife) { IIN0() mw27(17) Return(POUT) } +Method(bife) { IIN0() mw27(18) Return(POUT) } +Method(cife) { IIN0() mw27(19) Return(POUT) } +Method(dife) { IIN0() mw27(20) Return(POUT) } +Method(wife) { IIN0() mw27(0) Return(POUT) } +Method(eife) { IIN0() mx27(21) Return(POUT) } +Method(fife) { IIN0() mx27(22) Return(POUT) } +Method(gife) { IIN0() mx27(23) Return(POUT) } +Method(hife) { IIN0() mx27(24) Return(POUT) } +Method(xife) { IIN0() mx27(0) Return(POUT) } +Method(iife) { IIN0() my27(25) Return(POUT) } +Method(jife) { IIN0() my27(26) Return(POUT) } +Method(kife) { IIN0() my27(27) Return(POUT) } +Method(life) { IIN0() my27(28) Return(POUT) } +Method(yife) { IIN0() my27(0) Return(POUT) } +Method(mife) { IIN0() mz27(29) Return(POUT) } +Method(nife) { IIN0() mz27(30) Return(POUT) } +Method(oife) { IIN0() mz27(31) Return(POUT) } +Method(pife) { IIN0() mz27(32) Return(POUT) } +Method(zife) { IIN0() mz27(0) Return(POUT) } + +/* + * Hot issue: + * + * Check BankField implementation + */ +Method(ms28) +{ + Name(ts, "ms28") + + OperationRegion(OPR0, SystemMemory, 0, 256) + + Field(OPR0, ByteAcc, NoLock, Preserve) { + tot0, 32, + tot1, 32, + } + + Method(bfd0) + { + Field (OPR0, ByteAcc, NoLock, Preserve) { + bnk0, 8 + } + Field (OPR0, ByteAcc, NoLock, Preserve) { + tot0, 80 + } + + BankField (OPR0, bnk0, 0, ByteAcc, NoLock, Preserve) { + Offset(8), + bf00, 8, + } + + BankField (OPR0, bnk0, 1, ByteAcc, NoLock, Preserve) { + Offset(9), + bf01, 8, + } + + OUTP("Check BankField implementation") + + // Deal with 0-th bank layout: + + Store(0, bnk0) + if (LNotEqual(bnk0, 0)) { + err(ts, z179, 0x270, 0, 0, bnk0, 0) + } + + Store(0x87, bf00) + if (LNotEqual(bnk0, 0)) { + err(ts, z179, 0x271, 0, 0, bnk0, 0) + } + + if (LNotEqual(bf00, 0x87)) { + err(ts, z179, 0x272, 0, 0, bf00, 0x87) + } + + // Deal with 1-th bank layout: + + Store(1, bnk0) + if (LNotEqual(bnk0, 1)) { + err(ts, z179, 0x273, 0, 0, bnk0, 1) + } + + Store(0x96, bf01) + + if (LNotEqual(bnk0, 1)) { + err(ts, z179, 0x274, 0, 0, bnk0, 1) + } + + if (LNotEqual(bf01, 0x96)) { + err(ts, z179, 0x275, 0, 0, bf01, 0x96) + } + } + + CH03(ts, z179, 0x276, 0, 0) + bfd0() + CH03(ts, z179, 0x277, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(abfd) { IIN0() ms28() Return(POUT) } + +Mutex (C152, 0) +Mutex (C153, 0) +Mutex (C154, 0) +Mutex (C155, 0) +Mutex (C156, 0) +Mutex (C159, 0) + +/* + * Hot issue: + * + * Check Acquire/Release + */ +Method(ms29, 1) +{ + Name(ts, "ms29") + + Method (C157, 1, NotSerialized) + { + if (arg0) { + Store(Acquire (C154, 0xFFFF), Local0) + } else { + Store(Acquire (C154, 0), Local0) + } + Return (Local0) + } + + Method (C158, 0, NotSerialized) + { + Release (C154) + } + + Method (C160, 0, NotSerialized) + { + Release (C152) + } + + Method(mut0) + { + OUTP("Check Release by different ASL Methods") + C160() + CH04(ts, 0, 0xff, z179, 0x278, 0, 0) + } + + Method(mut1) + { + OUTP("Check Acquire/Release by different ASL Methods") + + OUTP("Acquire") + Store(C157(1), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x279, 0, 0, Local0, 0) + } + + OUTP("Release") + C158() + } + + Method(mut2) + { + OUTP("Check Acquire/Acquire by the different Method's calls") + + OUTP("Acquire 1") + Store(C157(1), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x27a, 0, 0, Local0, 0) + } + + OUTP("Acquire 2") + Store(C157(1), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x27b, 0, 0, Local0, 0) + } + } + + Method(mut3) + { + OUTP("Check Acquire/Acquire in one Method") + + OUTP("Acquire 1") + Store(Acquire (C155, 0xFFFF), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x27c, 0, 0, Local0, 0) + } + + OUTP("Acquire 2") + Store(Acquire (C155, 0xFFFF), Local0) + + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x27d, 0, 0, Local0, 0) + } + } + + Method(mut4) + { + OUTP("Check Acquire/Release/Release by different ASL Methods") + + OUTP("Acquire") + Store(C157(1), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x27e, 0, 0, Local0, 0) + } + + OUTP("Release 1") + C158() + + OUTP("Release 2") + C158() + + CH04(ts, 0, 0xff, z179, 0x27f, 0, 0) + } + + Method(mut5) + { + OUTP("Check Acquire(,0xFFFF)/Acquire(,0) in one Method") + + OUTP("Acquire( , 0xFFFF) 1") + Store(Acquire (C156, 0xFFFF), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x280, 0, 0, Local0, 0) + } + + OUTP("Acquire( , 0) 2") + Store(Acquire (C156, 0), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x281, 0, 0, Local0, 0) + } + } + + Method(mut6) + { + OUTP("Check Acquire2/Release2 in one Method") + + OUTP("Acquire 1") + Store(Acquire (C153, 0xFFFF), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x282, 0, 0, Local0, 0) + } + + OUTP("Acquire 2") + Store(Acquire (C153, 0xFFFF), Local0) + + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x283, 0, 0, Local0, 0) + } + + OUTP("Release 1") + Release (C153) + + OUTP("Release 2") + Release (C153) + } + + Method(mut7) + { + OUTP("Check Acquire2/Release3 in one Method") + + OUTP("Acquire 1") + Store(Acquire (C159, 0xFFFF), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x284, 0, 0, Local0, 0) + } + + OUTP("Acquire 2") + Store(Acquire (C159, 0xFFFF), Local0) + + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x285, 0, 0, Local0, 0) + } + + OUTP("Release 1") + Release (C159) + + OUTP("Release 2") + Release (C159) + + OUTP("Release 3") + Release (C159) + CH04(ts, 0, 0xff, z179, 0x286, 0, 0) + } + + Method(mut8) + { + OUTP("Check Acquire2/Release2 in one Method") + + OUTP("Acquire 1") + Store(Acquire (C153, 0xFFFF), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x287, 0, 0, Local0, 0) + } + + OUTP("Acquire 2") + Store(Acquire (C153, 0xFFFF), Local0) + + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x288, 0, 0, Local0, 0) + } + + OUTP("Release 1") + Release (C153) + + OUTP("Release 2") + Release (C153) + } + + Method(mut9) + { + Mutex (C159, 0) + + OUTP("Check Acquire2/Release2 in one Method for dynamic Mutex") + + OUTP("Acquire 1") + Store(Acquire (C159, 0xFFFF), Local0) + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x289, 0, 0, Local0, 0) + } + + OUTP("Acquire 2") + Store(Acquire (C159, 0xFFFF), Local0) + + + if (LNotEqual(Local0, 0)) { + err(ts, z179, 0x290, 0, 0, Local0, 0) + } + + OUTP("Release 1") + Release (C159) + + OUTP("Release 2") + Release (C159) + + OUTP("Release 3") + Release (C159) + CH04(ts, 0, 0xff, z179, 0x291, 0, 0) + } + + Method(m000) + { + if (ABUU) { + } else { + mut0() + } + + mut1() + + if (ABUU) { + } else { + mut3() + } + + if (ABUU) { + } else { + mut4() + } + + mut5() + mut6() + + if (ABUU) { + } else { + mut7() + } + + mut8() + + if (ABUU) { + } else { + mut9() + } + } + + CH03(ts, z179, 0x292, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { mut0() } + case (2) { mut1() } + case (3) { mut2() } + case (4) { mut3() } + case (5) { mut4() } + case (6) { mut5() } + case (7) { mut6() } + case (8) { mut7() } + case (9) { mut8() } + case (10) { mut9() } + } + CH03(ts, z179, 0x293, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(amut) { IIN0() ms29(1) Return(POUT) } +Method(bmut) { IIN0() ms29(2) Return(POUT) } +Method(cmut) { IIN0() ms29(3) Return(POUT) } +Method(dmut) { IIN0() ms29(4) Return(POUT) } +Method(emut) { IIN0() ms29(5) Return(POUT) } +Method(fmut) { IIN0() ms29(6) Return(POUT) } +Method(gmut) { IIN0() ms29(7) Return(POUT) } +Method(hmut) { IIN0() ms29(8) Return(POUT) } +Method(imut) { IIN0() ms29(9) Return(POUT) } +Method(jmut) { IIN0() ms29(10) Return(POUT) } +Method(kmut) { IIN0() ms29(0) Return(POUT) } + +// LEqual implementation for Buffers to use on MS +Method(BCMP, 2) +{ + if (ABUU) { + Store(Sizeof(Arg0), Local0) + + if (LNotEqual(Local0, Sizeof(Arg1))) { + return (0) + } + + Store(Sizeof(Arg0), Local0) + + while(Local0) { + Decrement(Local0) + Store(Derefof(Index(Arg0, Local0)), Local1) + Store(Derefof(Index(Arg1, Local0)), Local2) + if (LNotEqual(Local1, Local2)) { + return (0) + } + } + return (1) + } else { + return (LEqual(arg0, arg1)) + } +} + +/* + * Hot issue: + * + * Check ToBuffer optional store (Bug 194) + */ +Method(ms2a, 1) +{ + Name(ts, "ms2a") + Name(F64, 0) + + Method(tob0) + { + + Method(m000, 1) + { + Name(b000, Buffer(1){0x3c}) + Name(b001, Buffer(3){0x01, 0x02, 0x03}) + + if (arg0) { + OUTP("ToBuffer(b001, b000)") + ToBuffer(b001, b000) + } else { + OUTP("ToBuffer(b000, b001)") + ToBuffer(b000, b001) + } + + if (LNot(BCMP(b000, b001))) { + err(ts, z179, Add(0x294, arg0), 0, 0, b000, b001) + } + } + + OUTP("Check ToBuffer optional store behaves like CopyObject") + + m000(0) + m000(1) + } + + Method(tob1) + { + OUTP("Check ToBuffer(0x456789ab)") + Store(ToBuffer(0x456789ab), Local0) + if (F64) { + Store(Buffer(8){0xab, 0x89, 0x67, 0x45}, Local1) + } else { + Store(Buffer(4){0xab, 0x89, 0x67, 0x45}, Local1) + } + if (LNot(BCMP(Local1, Local0))) { + err(ts, z179, 0x296, 0, 0, Local0, Local1) + } + } + + Method(tob2) + { + OUTP("Check ToBuffer(\"456789ab\")") + Store(ToBuffer("456789ab"), Local0) + Store(Buffer(){"456789ab"}, Local1) + if (LNot(BCMP(Local1, Local0))) { + err(ts, z179, 0x297, 0, 0, Local0, Local1) + } + } + + Method(tob3) + { + OUTP("Check ToBuffer(Buffer(4){0x45, 0x67, 0x89, 0xab})") + Store(ToBuffer(Buffer(4){0x45, 0x67, 0x89, 0xab}), Local0) + Store(Buffer(4){0x45, 0x67, 0x89, 0xab}, Local1) + if (LNot(BCMP(Local1, Local0))) { + err(ts, z179, 0x298, 0, 0, Local0, Local1) + } + } + + Method(tob4) + { + OUTP("Check ToBuffer(0x456789ab, Local0)") + ToBuffer(0x456789ab, Local0) + if (F64) { + Store(Buffer(8){0xab, 0x89, 0x67, 0x45}, Local1) + } else { + Store(Buffer(4){0xab, 0x89, 0x67, 0x45}, Local1) + } + if (LNot(BCMP(Local1, Local0))) { + err(ts, z179, 0x299, 0, 0, Local0, Local1) + } + } + + Method(tob5) + { + OUTP("Check ToBuffer(\"456789ab\", Local0)") + ToBuffer("456789ab", Local0) + Store(Buffer(){"456789ab"}, Local1) + if (LNot(BCMP(Local1, Local0))) { + err(ts, z179, 0x29a, 0, 0, Local0, Local1) + } + } + + Method(tob6) + { + OUTP("Check ToBuffer(Buffer(4){0x45, 0x67, 0x89, 0xab}, Local0)") + ToBuffer(Buffer(4){0x45, 0x67, 0x89, 0xab}, Local0) + Store(Buffer(4){0x45, 0x67, 0x89, 0xab}, Local1) + if (LNot(BCMP(Local1, Local0))) { + err(ts, z179, 0x29b, 0, 0, Local0, Local1) + } + } + + Method(tob7) + { + Name(i000, 0) + + OUTP("Check ToBuffer(0x456789ab, i000)") + ToBuffer(0x456789ab, i000) + if (F64) { + Store(Buffer(8){0xab, 0x89, 0x67, 0x45}, Local1) + } else { + Store(Buffer(4){0xab, 0x89, 0x67, 0x45}, Local1) + } + Store(ObjectType(i000), Local2) + if (LNotEqual(Local2, 3)) { + err(ts, z179, 0x29c, 0, 0, Local2, 3) + } elseif (LNot(BCMP(Local1, i000))) { + err(ts, z179, 0x29d, 0, 0, i000, Local1) + } + } + + Method(tob8) + { + Name(s000, "s000") + + OUTP("Check ToBuffer(\"456789ab\", s000)") + ToBuffer("456789ab", s000) + Store(Buffer(){"456789ab"}, Local1) + Store(ObjectType(s000), Local2) + if (LNotEqual(Local2, 3)) { + err(ts, z179, 0x29e, 0, 0, Local2, 3) + } elseif (LNot(BCMP(Local1, s000))) { + err(ts, z179, 0x29f, 0, 0, s000, Local1) + } + } + + Method(tob9) + { + Name(b000, Buffer(2){}) + + OUTP("Check ToBuffer(Buffer(4){0x45, 0x67, 0x89, 0xab}, b000)") + ToBuffer(Buffer(4){0x45, 0x67, 0x89, 0xab}, b000) + Store(Buffer(4){0x45, 0x67, 0x89, 0xab}, Local1) + Store(ObjectType(b000), Local2) + if (LNotEqual(Local2, 3)) { + err(ts, z179, 0x2a0, 0, 0, Local2, 3) + } elseif (LNot(BCMP(Local1, b000))) { + err(ts, z179, 0x2a1, 0, 0, b000, Local1) + } + } + + Method(toba) + { + + Method(m000, 1) + { + Name(b000, Buffer(1){0x3c}) + Name(b001, Buffer(3){0x01, 0x02, 0x03}) + + if (arg0) { + OUTP("Store(b001, b000)") + Store(b001, b000) + + Store(Buffer(1){0x01}, Local0) + if (LNot(BCMP(b000, Local0))) { + err(ts, z179, Add(0x2a2, arg0), 0, 0, b000, Local0) + } + } else { + OUTP("Store(b000, b001)") + Store(b000, b001) + + Store(Buffer(3){0x3c}, Local0) + if (LNot(BCMP(b001, Local0))) { + err(ts, z179, Add(0x2a2, arg0), 0, 0, b001, Local0) + } + } + } + + OUTP("Check if Store fails the same way as ToBuffer optional store") + + m000(0) + m000(1) + } + + Method(m000) + { + if (ABUU) { + } else { + tob0() + tob1() + tob2() + tob3() + tob4() + tob5() + tob6() + tob7() + tob8() + tob9() + } + + toba() + } + + if (ABUU) { + } elseif (LEqual(SizeOf(F64), 8)) { + Store (1, F64) + } + + CH03(ts, z179, 0x2a4, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { tob0() } + case (2) { tob1() } + case (3) { tob2() } + case (4) { tob3() } + case (5) { tob4() } + case (6) { tob5() } + case (7) { tob6() } + case (8) { tob7() } + case (9) { tob8() } + case (10) { tob9() } + case (11) { toba() } + } + CH03(ts, z179, 0x2a5, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(atob) { IIN0() ms2a(1) Return(POUT) } +Method(btob) { IIN0() ms2a(2) Return(POUT) } +Method(ctob) { IIN0() ms2a(3) Return(POUT) } +Method(dtob) { IIN0() ms2a(4) Return(POUT) } +Method(etob) { IIN0() ms2a(5) Return(POUT) } +Method(ftob) { IIN0() ms2a(6) Return(POUT) } +Method(gtob) { IIN0() ms2a(7) Return(POUT) } +Method(htob) { IIN0() ms2a(8) Return(POUT) } +Method(itob) { IIN0() ms2a(9) Return(POUT) } +Method(jtob) { IIN0() ms2a(10) Return(POUT) } +Method(ktob) { IIN0() ms2a(11) Return(POUT) } + +/* + * Hot issue: + * + * Check Package size calculation + */ +Method(ms2b, 1) +{ + Name(ts, "ms2b") + + Method(pac0) + { + Name(p000, Package(5){1, 2, 3}) + + OUTP("Check if Package list < explicit size the last is in use") + + Store(SizeOf(p000), Local0) + if (LNotEqual(Local0, 5)) { + err(ts, z179, 0x2a6, 0, 0, Local0, 5) + } + } + + Method(pac1) + { + Name(p000, Package(5){1, 2, 3}) + + OUTP("Check if Package list < explicit size there are undef elements") + + Store(ObjectType(Index(p000, 2)), Local0) + if (Local0) { + } else { + err(ts, z179, 0x2a7, 0, 0, Local0, 1) + } + + Store(ObjectType(Index(p000, 3)), Local0) + if (Local0) { + err(ts, z179, 0x2a8, 0, 0, Local0, 0) + } + } + + // This test actually should be used with Package(3){1, 2, 3, 4, 5}) + // declaration, but iASL reports "Initializer list too long" error. + // Uncomment, set 'fopt' below to 1 and use it with -f iASL option + Method(pac2) + { + Name(fopt, 0) +// Name(p000, Package(3){1, 2, 3, 4, 5}) + Name(p000, Package(3){1, 2, 3}) + + OUTP("Check if Package list > explicit size the former is in use") + + if (fopt) { + Store(SizeOf(p000), Local0) + } else { + Store(5, Local0) + } + if (LNotEqual(Local0, 5)) { + err(ts, z179, 0x2a9, 0, 0, Local0, 5) + } + } + + CH03(ts, z179, 0x2ab, 0, 0) + switch (arg0) { + case (0) { pac0() pac1() pac2() } + case (1) { pac0() } + case (2) { pac1() } + case (3) { pac2() } + } + CH03(ts, z179, 0x2ac, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(apac) { IIN0() ms2b(1) Return(POUT) } +Method(bpac) { IIN0() ms2b(2) Return(POUT) } +Method(cpac) { IIN0() ms2b(3) Return(POUT) } + +/* + * Hot issue: + * + * Check Switch implementation + * + * isw0 test should expectedly fail + */ +Method(ms2c, 1) +{ + Name(ts, "ms2c") + + Method(sw00) + { + Method(m000, 1) + { + Store(0, Local1) + + switch (arg0) { + case (1) { Store(1, Local1) } + case (2) { Store(2, Local1) } + } + + return (Local1) + } + + OUTP("Check Switch implementation 0: standalone") + + Store(2, Local0) + Store(0, Local1) + + switch (Local0) { + case (1) { Store(1, Local1) } + case (2) { Store(2, Local1) } + } + + if (LNotEqual(Local1, 2)) { + err(ts, z179, 0x2ad, 0, 0, Local1, 2) + } + + Store(m000(1), Local1) + + if (LNotEqual(Local1, 1)) { + err(ts, z179, 0x2ae, 0, 0, Local1, 1) + } + } + + Method(sw01) + { + OUTP("Check While implementation 1: standalone") + + Store(2, Local0) + Store(0, Local1) + + while (Local0) { + if (LEqual(Local0, 1)) { + Increment(Local1) + } else { + Increment(Local1) + } + Decrement(Local0) + } + if (LNotEqual(Local1, 2)) { + err(ts, z179, 0x2af, 0, 0, Local1, 2) + } + } + + Method(sw02) + { + OUTP("Check Switch implementation 2: inside While (1 step)") + + Store(1, Local0) + Store(0, Local1) + Store(0, Local2) + + while (Local0) { + switch (Local0) { + case (1) { Increment(Local1) } + case (2) { Increment(Local2) } + } + Decrement(Local0) + } + if (LNotEqual(Local1, 1)) { + err(ts, z179, 0x2b0, 0, 0, Local1, 1) + } + if (LNotEqual(Local2, 0)) { + err(ts, z179, 0x2b1, 0, 0, Local2, 0) + } + } + + Method(sw03) + { + OUTP("Check Switch implementation 3: inside While (2 steps)") + + Store(2, Local0) + Store(0, Local1) + Store(0, Local2) + + while (Local0) { + switch (Local0) { + case (1) { Increment(Local1) } + case (2) { Increment(Local2) } + } + Decrement(Local0) + } + if (LNotEqual(Local1, 1)) { + err(ts, z179, 0x2b2, 0, 0, Local1, 1) + } + if (LNotEqual(Local2, 1)) { + err(ts, z179, 0x2b3, 0, 0, Local2, 1) + } + } + + Method(sw04) + { + OUTP("Check Switch implementation 4: inside While 2, 2 Breaks") + + Store(2, Local0) + Store(0, Local1) + Store(0, Local2) + + while (Local0) { + switch (Local0) { + case (1) { + Increment(Local1) + Break + } + case (2) { + Increment(Local2) + Break + } + } + Decrement(Local0) + } + if (LNotEqual(Local0, 2)) { + err(ts, z179, 0x2b4, 0, 0, Local0, 2) + } + if (LNotEqual(Local1, 0)) { + err(ts, z179, 0x2b5, 0, 0, Local1, 0) + } + if (LNotEqual(Local2, 1)) { + err(ts, z179, 0x2b6, 0, 0, Local2, 1) + } + } + + Method(sw05) + { + OUTP("Check Switch implementation 5: inside While 1, 2 Breaks") + + Store(1, Local0) + Store(0, Local1) + Store(0, Local2) + + while (Local0) { + switch (Local0) { + case (1) { + Increment(Local1) + Break + } + case (2) { + Increment(Local2) + Break + } + } + Decrement(Local0) + } + if (LNotEqual(Local0, 1)) { + err(ts, z179, 0x2b7, 0, 0, Local0, 1) + } + if (LNotEqual(Local1, 1)) { + err(ts, z179, 0x2b8, 0, 0, Local1, 1) + } + if (LNotEqual(Local2, 0)) { + err(ts, z179, 0x2b9, 0, 0, Local2, 0) + } + } + + + Method(sw06) + { + OUTP("Check Switch implementation 6: inside While 2, 1 Break") + + Store(2, Local0) + Store(0, Local1) + Store(0, Local2) + + while (Local0) { + switch (Local0) { + case (1) { + Increment(Local1) + } + case (2) { + Increment(Local2) + Break + } + } + Decrement(Local0) + } + if (LNotEqual(Local0, 2)) { + err(ts, z179, 0x2ba, 0, 0, Local0, 2) + } + if (LNotEqual(Local1, 0)) { + err(ts, z179, 0x2bb, 0, 0, Local1, 0) + } + if (LNotEqual(Local2, 1)) { + err(ts, z179, 0x2bc, 0, 0, Local2, 1) + } + } + + Method(sw07) + { + OUTP("Check While implementation 7: Name inside, 1 step") + + Store(1, Local0) + Store(0, Local1) + + while (Local0) { + Name(WHIN, Ones) + + if (Local1) { + CH04(ts, 0, 0xff, z179, 0x2bd, 0, 0) + } else { + CH03(ts, z179, 0x2be, 0, 0) + } + Store(Local1, WHIN) + Decrement(Local0) + Increment(Local1) + } + } + + Method(sw08) + { + OUTP("Check While implementation 8: Name inside, 2 steps") + + Store(2, Local0) + Store(0, Local1) + + while (Local0) { + Name(WHIN, Ones) + + if (Local1) { + CH04(ts, 0, 0xff, z179, 0x2bf, 0, 0) + } else { + CH03(ts, z179, 0x2c0, 0, 0) + } + Store(Local1, WHIN) + Decrement(Local0) + Increment(Local1) + } + } + + Method(m000) + { + sw00() + sw01() + sw02() + sw03() + + if (LAnd(ABUU, LNot(q00a))) { + } else { + sw04() + sw05() + sw06() + } + + sw07() + + if (ABUU) { + } else { + sw08() + } + } + + CH03(ts, z179, 0x2c1, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { sw00() } + case (2) { sw01() } + case (3) { sw02() } + case (4) { sw03() } + case (5) { sw04() } + case (6) { sw05() } + case (7) { sw06() } + case (8) { sw07() } + case (9) { sw08() } + } + CH03(ts, z179, 0x2c2, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(asw0) { IIN0() ms2c(1) Return(POUT) } +Method(bsw0) { IIN0() ms2c(2) Return(POUT) } +Method(csw0) { IIN0() ms2c(3) Return(POUT) } +Method(dsw0) { IIN0() ms2c(4) Return(POUT) } +Method(esw0) { IIN0() ms2c(5) Return(POUT) } +Method(fsw0) { IIN0() ms2c(6) Return(POUT) } +Method(gsw0) { IIN0() ms2c(7) Return(POUT) } +Method(hsw0) { IIN0() ms2c(8) Return(POUT) } +Method(isw0) { IIN0() ms2c(9) Return(POUT) } + +/* + * Hot issue: + * + * Recursive method with local named + * + * bwac & cwac tests should expectedly fail + */ +Method(ms2d, 1) +{ + Name(ts, "ms2d") + Name(Y, 0) + + Method (M001, 1, NotSerialized) + { + Name (X, Zero) + + If (Y) { + If (y300) { + CH03(ts, z179, 0x3c3, 0, 0) + } else { + CH04(ts, 0, 0xff, z179, 0x2c3, 0, 0) + } + } else { + CH03(ts, z179, 0x2c4, 0, 0) + } + + Increment (Y) + Increment (X) + + Decrement (Arg0) + If (LGreater (Arg0, Zero)) { + M001 (Arg0) + } + } + + Method(wac0) + { + OUTP("Recursive method with local named execution 1") + + Store(0, Y) + M001 (0x1) + } + + Method(wac1) + { + OUTP("Recursive method with local named execution 2") + + Store(0, Y) + M001 (0x2) + } + + Method(wac2) + { + OUTP("Recursive method with local named execution 4") + + Store(0, Y) + M001 (0x4) + } + + Method(m000) + { + wac0() + + if (ABUU) { + } else { + wac1() + } + + if (ABUU) { + } else { + wac2() + } + } + + CH03(ts, z179, 0x2c5, 0, 0) + switch (arg0) { + case (0) { m000() } + case (1) { wac0() } + case (2) { wac1() } + case (3) { wac2() } + } + CH03(ts, z179, 0x2c6, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(awac) { IIN0() ms2d(1) Return(POUT) } +Method(bwac) { IIN0() ms2d(2) Return(POUT) } +Method(cwac) { IIN0() ms2d(3) Return(POUT) } +Method(dwac) { IIN0() ms2d(4) Return(POUT) } + +/* + * Hot issue: + * + * Recursive method with local named: handmade asynchronous test: + * - bzac can be called many times + * - after azac any bzac should fail, but then after czac succeed again + * - 3 consecutive execution of dzac in the different instances of ABBU + * should show actual behavior, on acpiexec run "thr 4 1 dzac" + */ + +Event(EV00) + +Method (MZAC, 1, NotSerialized) +{ + Name (X, Zero) + Increment (X) + OUTP(X) + + If (LGreater (Arg0, Zero)) + { + // Block on event + Wait(EV00, 0xFFFF) + } +} + +Method(zac0) +{ + OUTP("Method with local named execution 1: Block") + + MZAC (0x1) +} + +Method(zac1) +{ + OUTP("Method with local named execution 2: Pass") + + MZAC (0x0) +} + +Method(zac2) +{ + Sleep(5000) + + OUTP("Method with local named execution 3: Signal") + + Signal (EV00) +} + +Name(zacz, 5) +Method(zac3) +{ + Sleep(1000) + Decrement(zacz) + + if (LEqual(zacz, 4)) {zac0()} + elseif (LEqual(zacz, 2)) {zac2()} + else {zac1()} + + Return (zacz) +} + +/* Methods to run manually (for ABBU only) */ +Method(azac) { IIN0() zac0() Return(POUT) } +Method(bzac) { IIN0() zac1() Return(POUT) } +Method(czac) { IIN0() zac2() Return(POUT) } +Method(dzac) { IIN0() zac3() Return(POUT) } + +/* + * Hot issue: + * + * Example from Bob, + * Buffer is not shortened on storing short string + */ +Method(ms2e) +{ + Name(ts, "ms2e") + + Name (BUF0, Buffer (12) {}) + + OUTP("Buffer is not shortened on storing short string") + + CH03(ts, z179, 0x2c7, 0, 0) + + Store ("ABCD", BUF0) + + Store(SizeOf (BUF0), Local0) + + if (LNotEqual(Local0, 12)) { + err(ts, z179, 0x2c8, 0, 0, Local0, 12) + } + + CH03(ts, z179, 0x2c9, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(abuf) { IIN0() ms2e() Return(POUT) } + +/* + * Bug 246 issue: + * + * SUMMARY: Switch implementation can cause AE_ALREADY_EXISTS exception + * when Switch is within While + */ +Method(ms2f, 1) +{ + Name(ts, "ms2f") + + Method(B246) + { + Name(LN00, 2) + + OUTP("Switch implementation can cause AE_ALREADY_EXISTS 1") + + Store(0, Local1) + + while (LN00) { + switch (LN00) { + case (1) { + Add(Local1, 1, Local1) + } + case (2) { + Add(Local1, 2, Local1) + } + } + Decrement(LN00) + } + + if (LNotEqual(Local1, 3)) { + err(ts, z179, 0x2ca, 0, 0, Local1, 3) + } + } + + Method(U246) + { + Name(LN00, 1) + + OUTP("Switch implementation can cause AE_ALREADY_EXISTS 2") + + Store(0, Local1) + + while (LN00) { + switch (LN00) { + case (1) { + Add(Local1, 1, Local1) + } + case (2) { + Add(Local1, 2, Local1) + } + } + Decrement(LN00) + } + + if (LNotEqual(Local1, 1)) { + err(ts, z179, 0x2cb, 0, 0, Local1, 1) + } + } + + CH03(ts, z179, 0x2cc, 0, 0) + switch (arg0) { + case (0) { b246() u246() } + case (1) { b246() } + case (2) { u246() } + } + CH03(ts, z179, 0x2cd, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a246) { IIN0() ms2f(1) Return(POUT) } +Method(b246) { IIN0() ms2f(2) Return(POUT) } + +/* + * Bug 247 issue: + * + * SUMMARY: ASL compiler incorrectly implements Break within Switch + */ +Method(ms30) +{ + Name(ts, "ms30") + + // This test actually should be used without "while (1) { ... Break}" + // wrapping, but iASL reports "Initializer list too long" error. + // Comment the wrappers and compile with -f iASL option. + Method(B247) + { + Method(m000, 4) + { + Name(LN00, 2) + Name(CH10, 0) + Name(CH11, 0) + Name(CH20, 0) + Name(CH21, 0) + + OUTP(arg0) + +// Workaround for "No enclosing While statement" iASl error +while (1) { + switch (arg3) { + case (1) { + if (Arg1) { + Store(1, CH10) + Break + } + Store(1, CH11) + } + case (2) { + if (Arg2) { + Store(1, CH20) + Break + } + Store(1, CH21) + } + } +Break } + + if (LEqual(Arg3, 1)) { + if (LNotEqual(CH10, Arg1)) { + err(ts, z179, 0x2ce, 0, 0, CH10, Arg1) + } + if (LEqual(CH11, Arg1)) { + err(ts, z179, 0x2cf, 0, 0, CH11, Arg1) + } + } + if (LEqual(Arg3, 2)) { + if (LNotEqual(CH20, Arg2)) { + err(ts, z179, 0x2d0, 0, 0, CH20, Arg2) + } + if (LEqual(CH21, Arg2)) { + err(ts, z179, 0x2d1, 0, 0, CH21, Arg2) + } + } + } + + OUTP("Switch implementation can cause AE_ALREADY_EXISTS 3") + + m000("Break 100", 0, 0, 1) + m000("Break 101", 0, 1, 1) + m000("Break 110", 1, 0, 1) + m000("Break 111", 1, 1, 1) + m000("Break 200", 0, 0, 2) + m000("Break 201", 0, 1, 2) + m000("Break 210", 1, 0, 2) + m000("Break 211", 1, 1, 2) + } + + CH03(ts, z179, 0x2d2, 0, 0) + b247() + CH03(ts, z179, 0x2d3, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(a247) { IIN0() ms30() Return(POUT) } + +/* + * Hot issue: + * + * Load ASL operator + */ +Method(ms31, 1) +{ + Name(ts, "ms31") + + // Originated from table/ssdt0.asl: iasl -tc ssdt0.asl + Name(BUF0, Buffer() { + 0x53,0x53,0x44,0x54,0x34,0x00,0x00,0x00, /* 00000000 "SSDT4..." */ + 0x02,0xDE,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 "..Intel." */ + 0x4D,0x61,0x6E,0x79,0x00,0x00,0x00,0x00, /* 00000010 "Many...." */ + 0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */ + 0x15,0x12,0x06,0x20,0x14,0x0F,0x5C,0x53, /* 00000020 "... ..\S" */ + 0x53,0x30,0x30,0x00,0xA4,0x0D,0x5C,0x53, /* 00000028 "S00...\S" */ + 0x53,0x30,0x30,0x00, + }) + + OperationRegion (IST0, SystemMemory, VMEM, 0x34) + + Field(IST0, ByteAcc, NoLock, Preserve) { + RFU0, 0x1a0, + } + + Name(DDBH, 0) + + External(\SS00) + + Method(m000) + { + OUTP("ldt0: Simple Load/Unload(Field, LocalX) test") + + Store(BUF0, RFU0) + + Load(RFU0, Local0) + CH03(ts, z179, 0x2d4, 0, 0) + OUTP("SSDT loaded") + + UnLoad(Local0) + CH03(ts, z179, 0x2d5, 0, 0) + OUTP("SSDT unloaded") + } + + // Manual test for ABBU + Method(m001) + { + OUTP("ldt1: Simple Load(OpRegion, LocalX) test") + + Store(BUF0, RFU0) + + Load(IST0, Local0) + CH03(ts, z179, 0x2d6, 0, 0) + OUTP("SSDT loaded") + } + + Method(m002) + { + OUTP("ldt2: Simple Load/Unload(OpRegion, LocalX) test") + + Store(BUF0, RFU0) + + Load(IST0, DDBH) + CH03(ts, z179, 0x2d7, 0, 0) + OUTP("SSDT loaded") + + Unload(DDBH) + CH03(ts, z179, 0x2d8, 0, 0) + OUTP("SSDT unloaded") + } + + Method(m003) + { + OUTP("ldt3: Simple Load/ObjectType(DDBHandle) test") + + Store(BUF0, RFU0) + + Load(IST0, Local0) + CH03(ts, z179, 0x2d9, 0, 0) + OUTP("SSDT loaded") + + Store(ObjectType(Local0), Local1) + if (LNotEqual(15, Local1)) { + err(ts, z179, 0x2da, 0, 0, Local1, 15) + } + + Unload(DDBH) + CH03(ts, z179, 0x2db, 0, 0) + OUTP("SSDT unloaded") + } + + // Manual test for ABBU: hangs on MS + Method(m013) + { + OUTP("ldt13: Simple Load/ObjectType(DDBHandle) test") + + Store(BUF0, RFU0) + + Load(IST0, Local0) + CH03(ts, z179, 0x2dc, 0, 0) + OUTP("SSDT loaded") + + Store(ObjectType(Local0), Local1) + if (LNotEqual(15, Local1)) { + err(ts, z179, 0x2dd, 0, 0, Local1, 15) + } + } + + Method(m004) + { + Name(DDBH, 0) + + OUTP("ldt4: Simple Load/ObjectType(Named DDBHandle) test") + + Store(BUF0, RFU0) + + Load(IST0, DDBH) + CH03(ts, z179, 0x2de, 0, 0) + OUTP("SSDT loaded") + + Store(ObjectType(DDBH), Local1) + if (LNotEqual(15, Local1)) { + err(ts, z179, 0x2df, 0, 0, Local1, 15) + } + + UnLoad(DDBH) + CH03(ts, z179, 0x2e0, 0, 0) + OUTP("SSDT unloaded") + } + + // Manual test for ABBU: hangs on MS + Method(m014) + { + Name(DDBH, 0) + + OUTP("ldt14: Simple Load/ObjectType(Named DDBHandle) test") + + Store(BUF0, RFU0) + + Load(IST0, DDBH) + CH03(ts, z179, 0x2e1, 0, 0) + OUTP("SSDT loaded") + + Store(ObjectType(DDBH), Local1) + if (LNotEqual(15, Local1)) { + err(ts, z179, 0x2e2, 0, 0, Local1, 15) + } + } + + Method(m005) + { + Name(PAC0, Package(1){}) + + OUTP("ldt5: Simple Load(OpRegion, Indexed DDBHandle) test") + + Store(BUF0, RFU0) + + Load(IST0, Index(PAC0, 0)) + CH03(ts, z179, 0x2e3, 0, 0) + OUTP("SSDT loaded") + + Store(Derefof(Index(PAC0, 0)), Local0) + + UnLoad(Local0) + CH03(ts, z179, 0x2e4, 0, 0) + OUTP("SSDT unloaded") + } + + // Manual test for ABBU + Method(m015) + { + Name(PAC0, Package(1){}) + + OUTP("ldt15: Simple Load(OpRegion, Indexed DDBHandle) test") + + Store(BUF0, RFU0) + + Load(IST0, Index(PAC0, 0)) + CH03(ts, z179, 0x2e5, 0, 0) + OUTP("SSDT loaded") + } + + Method(m006) + { + OUTP("ldt6: Complex Load(OpRegion, LocalX) - CondRefof test") + + Store(BUF0, RFU0) + + Store(CondRefof(\SS00, Local1), Local2) + OUTP("CondRefof before Load") + if (Local2) { + err(ts, z179, 0x2e6, 0, 0, Local2, 0) + } + + Load(IST0, Local0) + CH03(ts, z179, 0x2e7, 0, 0) + + Store(CondRefof(\SS00, Local3), Local4) + OUTP("CondRefof after Load") + if (Local4) { + } else { + err(ts, z179, 0x2e8, 0, 0, Local4, 1) + } + + UnLoad(Local0) + CH03(ts, z179, 0x2e9, 0, 0) + + Store(CondRefof(\SS00, Local5), Local6) + OUTP("CondRefof after UnLoad") + if (Local6) { + err(ts, z179, 0x2ea, 0, 0, Local6, 0) + } + } + + // Manual test for ABBU + Method(m016) + { + OUTP("ldt16: Complex Load(OpRegion, LocalX) - CondRefof test") + + Store(BUF0, RFU0) + + Store(CondRefof(\SS00, Local1), Local2) + OUTP("CondRefof before Load") + if (Local2) { + err(ts, z179, 0x2eb, 0, 0, Local2, 0) + } + + Load(IST0, Local0) + CH03(ts, z179, 0x2ec, 0, 0) + + Store(CondRefof(\SS00, Local3), Local4) + OUTP("CondRefof after Load") + if (Local4) { + } else { + err(ts, z179, 0x2ed, 0, 0, Local4, 1) + } + } + + Method(m010) + { + m000() + + if (y290) { + m002() + } + + if (LAnd(y260, y290)) { + m003() + } + + if (LAnd(y260, y290)) { + m004() + } + + if (LAnd(y261, y290)) { + m005() + } + + if (y290) { + m006() + } + } + + CH03(ts, z179, 0x2ee, 0, 0) + switch (arg0) { + case (0) { m010() } + case (1) { m000() } + case (2) { m001() } + case (3) { m002() } + case (4) { m003() } + case (5) { m004() } + case (6) { m005() } + case (7) { m006() } + case (8) { m013() } + case (9) { m014() } + case (10) { m015() } + case (11) { m016() } + } + CH03(ts, z179, 0x2ef, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(aldt) { IIN0() ms31(1) Return(POUT) } +Method(bldt) { IIN0() ms31(2) Return(POUT) } +Method(cldt) { IIN0() ms31(3) Return(POUT) } +Method(dldt) { IIN0() ms31(4) Return(POUT) } +Method(eldt) { IIN0() ms31(5) Return(POUT) } +Method(fldt) { IIN0() ms31(6) Return(POUT) } +Method(gldt) { IIN0() ms31(7) Return(POUT) } +Method(hldt) { IIN0() ms31(8) Return(POUT) } +Method(ildt) { IIN0() ms31(9) Return(POUT) } +Method(jldt) { IIN0() ms31(10) Return(POUT) } +Method(kldt) { IIN0() ms31(11) Return(POUT) } + +/* + * Hot issue: + * + * CondRefOf ASL operator + */ +Method(ms32, 1) +{ + Name(ts, "ms32") + + Method(m000) + { + OUTP("cnr0: Simple CondRefof() positive test") + + Store(CondRefof(\_SB.ABBU.IMAX), Local0) + CH03(ts, z179, 0x2f0, 0, 0) + } + + Method(m001) + { + OUTP("cnr1: Simple CondRefof( , ) positive test 2") + + Store(CondRefof(\_SB.ABBU._HID, Local1), Local0) + CH03(ts, z179, 0x2f1, 0, 0) + + if (Local0) { + } else { + err(ts, z179, 0x2f2, 0, 0, Local0, 1) + } + } + + Method(m002) + { + Name(I000, 0x76543210) + + OUTP("cnr2: Simple CondRefof( , ) positive test for dynamic object") + + Store(CondRefof(^m002.I000, Local1), Local0) + if (Local0) { + Store(Derefof(Local1), Local2) + if (LNotEqual(0x76543210, Local2)) { + err(ts, z179, 0x2f3, 0, 0, Local2, 0x76543210) + } + } else { + err(ts, z179, 0x2f4, 0, 0, Local0, 1) + } + } + + Method(m003) + { + OUTP("cnr3: Simple CondRefof( , ) negative test for dynamic object") + + Store(CondRefof(^M003.I000, Local1), Local0) + if (Local0) { + err(ts, z179, 0x2f5, 0, 0, Local0, 1) + } + + Name(I000, 1) + + Store(CondRefof(^M003.I000, Local1), Local0) + if (Local0) { + } else { + err(ts, z179, 0x2f6, 0, 0, Local0, 0) + } + } + + Method(m004) + { + OUTP("cnr4: Simple CondRefof(_OSI, Local0) test") + + OUTP("if (CondRefOf (_OSI, Local0))") + if (CondRefOf (_OSI, Local0)) + { + OUTP("True") + OUTP("_OSI (\"Windows 2001\"):") + if (\_OSI ("Windows 2001")) + { + OUTP("True") + } else { + OUTP("False") + } + } else { + OUTP("False") + } + CH03(ts, z179, 0x2f7, 0, 0) + } + + Method(m010) + { + m000() + m001() + m002() + m003() + m004() + } + + CH03(ts, z179, 0x2f8, 0, 0) + switch (arg0) { + case (0) { m010() } + case (1) { m000() } + case (2) { m001() } + case (3) { m002() } + case (4) { m003() } + case (5) { m004() } + } + CH03(ts, z179, 0x2f9, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(acnr) { IIN0() ms32(1) Return(POUT) } +Method(bcnr) { IIN0() ms32(2) Return(POUT) } +Method(ccnr) { IIN0() ms32(3) Return(POUT) } +Method(dcnr) { IIN0() ms32(4) Return(POUT) } +Method(ecnr) { IIN0() ms32(5) Return(POUT) } + +/* + * Hot issue: + * + * Check storing of a Device into LocalX + */ +Method(ms33, 1) +{ + Name(ts, "ms33") + + Method(asdl) + { + OUTP("Store _SB.ABBU Device object into LocalX, don't check the type") + + Store(\_SB.ABBU, Local0) + + if (LOr(ABUU, SLCK)) { + CH03(ts, z179, 0x2fa, 0, 0) + } else { + CH04(ts, 0, 0xff, z179, 0x2fb, 0, 0) + } + } + + Method(bsdl) + { + OUTP("Store _SB.ABBU Device object into LocalX") + + Store(\_SB.ABBU, Local0) + + if (LOr(ABUU, SLCK)) { + Store(ObjectType(Local0), Local1) + if (LNotEqual(6, Local1)) { + err(ts, z179, 0x2fc, 0, 0, Local1, 6) + } + } else { + CH04(ts, 0, 0xff, z179, 0x2fd, 0, 0) + } + } + + Method(csdl) + { + Device(DLOC) {} + + OUTP("Store an improper dynamic Device object into LocalX") + + Store(DLOC, Local0) + + if (LOr(ABUU, SLCK)) { + Store(ObjectType(Local0), Local1) + if (LNotEqual(6, Local1)) { + err(ts, z179, 0x2fe, 0, 0, Local1, 6) + } else { + OUTP("Ok: ObjectType succeeded") + } + } else { + CH04(ts, 0, 0xff, z179, 0x2ff, 0, 0) + } + } + + Method(dsdl) + { + External(\_SB.LNKA) + + OUTP("Store _SB.LNKA Device object into LocalX") + + if (CondRefof(\_SB.LNKA, Local2)) { + } else { + OUTP("CondRefof for _SB.LNKA returns FALSE") + return + } + + Store(\_SB.LNKA, Local0) + + if (LOr(ABUU, SLCK)) { + Store(ObjectType(Local0), Local1) + if (LNotEqual(6, Local1)) { + err(ts, z179, 0x2a0, 0, 0, Local1, 6) + } + } else { + CH04(ts, 0, 0xff, z179, 0x2a1, 0, 0) + } + } + + CH03(ts, z179, 0x2a2, 0, 0) + switch (arg0) { + case (0) { + asdl() + bsdl() + csdl() + dsdl() + } + case (1) { asdl() } + case (2) { bsdl() } + case (3) { csdl() } + case (4) { dsdl() } + } + CH03(ts, z179, 0x2a3, 0, 0) +} + +/* Methods to run manually (for ABBU only) */ +Method(asdl) { IIN0() ms33(1) Return(POUT) } +Method(bsdl) { IIN0() ms33(2) Return(POUT) } +Method(csdl) { IIN0() ms33(3) Return(POUT) } +Method(dsdl) { IIN0() ms33(4) Return(POUT) } + +Method(msfe) +{ + // Bug 63 issues + SRMT("ms10") + ms10(0) + + // Bug 83 issues + SRMT("ms11") + ms11(0) + + // Bug 100 issues + SRMT("ms12") + ms12() + + // Bug 113 issues + SRMT("ms13") + ms13(0) + + // Bug 114 issues + SRMT("ms14") + ms14(0) + + // Bug 115 issues + SRMT("ms15") + ms15(0) + + // Bug 118 issues + SRMT("ms16") + ms16(0) + + // Bug 126 issues + SRMT("ms17") + ms17(0) + + // Bug 127 issues + SRMT("ms18") + if (ABUU) { + BLCK() + } else { + ms18() + } + + // Bug 128 issues + SRMT("ms19") + ms19(0) + + // Bug 131 issues + SRMT("ms1a") + ms1a(0) + + // Bug 132 issues + SRMT("ms1b") + ms1b(0) + + // Bug 133 issues + SRMT("ms1c") + ms1c(0) + + // Bug 134 issues + SRMT("ms1d") + ms1d(0) + + // Bug 136 issues + SRMT("ms1e") + if (ABUU) { + BLCK() + } else { + ms1e() + } + + // Local Reference into the Package issues + SRMT("ms1f") + ms1f(0) + + // Forward reference within a control method + SRMT("ms20") + ms20(0) + + // Recursive method execution + SRMT("ms21") + ms21(0) + + // Conditional reference within a control method + SRMT("ms22") + ms22(0) + + // Implicit return + SRMT("ms23") + ms23(0) + + // Increment/Decrement with String/Buffer + SRMT("ms24") + if (ABUU) { + BLCK() + } else { + ms24() + } + + // Check Store(..., DeRefof(...)) behavior + SRMT("ms25") + if (ABUU) { + BLCK() + } else { + ms25(0) + } + + // Exceeding Field Unit + SRMT("ms26") + if (SMBA) { + ms26(0) + } else { + BLCK() + } + + // Check IndexField implementation + SRMT("ms27") + if (SMBA) { + ms27(0) + } else { + BLCK() + } + + SRMT("mt27") + if (SMBA) { + mt27(0) + } else { + BLCK() + } + + SRMT("mu27") + if (SMBA) { + mu27(0) + } else { + BLCK() + } + + SRMT("mv27") + if (SMBA) { + mv27(0) + } else { + BLCK() + } + + SRMT("mw27") + if (SMBA) { + mw27(0) + } else { + BLCK() + } + + SRMT("mx27") + if (SMBA) { + mx27(0) + } else { + BLCK() + } + + SRMT("my27") + if (SMBA) { + my27(0) + } else { + BLCK() + } + + SRMT("mz27") + if (SMBA) { + mz27(0) + } else { + BLCK() + } + + // Check BankField implementation + SRMT("ms28") + if (SMBA) { + ms28() + } else { + BLCK() + } + + // Check Acquire/Release + SRMT("ms29") + ms29(0) + + // Check ToBuffer optional store + SRMT("ms2a") + ms2a(0) + + // Check Package size calculation + SRMT("ms2b") + ms2b(0) + + // Check Switch implementation + SRMT("ms2c") + ms2c(0) + + // Recursive method with local named + SRMT("ms2d") + ms2d(0) + + // Buffer is not shortened on storing short string + SRMT("ms2e") + ms2e() + + // Bug 246 issues + SRMT("ms2f") + ms2f(0) + + // Bug 247 issues + SRMT("ms30") + if (ABUU) { + BLCK() + } else { + ms30() + } + + // Load ASL operator + SRMT("ms31") + if (ABUU) { + BLCK() + } else { + ms31(0) + } + + // CondRefOf ASL operator + SRMT("ms32") + ms32(0) + + // Storing of a Device into LocalX + SRMT("ms33") + ms33(0) +} + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/ns4.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/ns4.asl new file mode 100644 index 000000000..a671a0cc1 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/ns4.asl @@ -0,0 +1,88 @@ +/* + * Tests originated from namespace/ns4 + */ + +/* + * Calls to methods instead of Add + */ + +/* +in progress +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! z100 ???????????????????????????? +// ?????????????????????????????????????????????????? +*/ +Name(z100, 100) + +Method(m401, 1) +{ + Name(ts, "m401") + Name(i000, 0x00000001) + Name(i001, 0) + Name(p000, Package() {1,2,3,4}) + + CH03(ts, z100, 0x000, 0, 0) + + Store(arg0, i001) + + Method(MAdd, 2) + { + Add(arg0, arg1, Local0) + Return (Local0) + } + + Method(m001) + { + Method(m002) + { + Method(m003) + { + Method(m004) + { + Method(m005) + { + Method(m006) + { + Method(m007) + { + /* + * Because of the stack overflow issues on MS + * the number of method calls eliminated. + */ + Return (0) + } + Store(0x07000000, i000) + Return (MAdd(i000, m007())) + } + Store(0x00600000, i000) + Return (MAdd(i000, m006())) + } + Store(0x00050000, i000) + Return (MAdd(i000, m005())) + } + Store(0x00004000, i000) + Return (MAdd(i000, m004())) + } + Store(0x00000300, i000) + Return (MAdd(i000, m003())) + } + Store(0x00000020, i000) + Return (MAdd(i000, m002())) + } + Store(MAdd(i000, m001()), Local0) + + if (LNotEqual(Local0, 0x07654321)) { + err(ts, z100, 0x001, 0, 0, Local0, 0x07654321) + } + + if (LNotEqual(i000, 0x07000000)) { + err(ts, z100, 0x002, 0, 0, i000, 0x07000000) + } + + CH03(ts, z100, 0x003, 0, 0) +} + +Method(n004) +{ + SRMT("m401-0") + m401(0) +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/ns6.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/ns6.asl new file mode 100644 index 000000000..844a21033 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/ns6.asl @@ -0,0 +1,46 @@ +/* + * Tests originated from namespace/ns6 + */ + + +/* +in progress +SEE: +do the same as ns3.asl but +complex +some pass by arg/local/ store/copy to other Named and some +directly (locally/globally allocated objects) + +*/ + + +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! z101 ???????????????????????????? +// ?????????????????????????????????????????????????? +Name(z101, 101) + +Method(m600) +{ + Name(ts, "m600") + Name(i000, 0xabcd0000) + Method(m000, 1) + { + Store(0x11223344, i000) + if (LNotEqual(arg0, 0xabcd0000)) { + err(ts, z101, 0x000, 0, 0, arg0, 0xabcd0000) + } + } + + m000(i000) + + if (LNotEqual(i000, 0x11223344)) { + err(ts, z101, 0x001, 0, 0, i000, 0x11223344) + } +} + +Method(n006) +{ + SRMT("m600") + m600() +} + + diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/recursion/rec_abbu.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/recursion/rec_abbu.asl new file mode 100644 index 000000000..d09c6dc9c --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/recursion/rec_abbu.asl @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests to check recursive calls of methods for different structure of + * sub-trees containig the point from where the call is made and the point + * which is just the invoked method, and different relative disposition of + * those sub-trees containig the points. + */ + +Name(z171, 171) + + +Processor(pr00, 0, 0x000, 0x008) +{ + Name(i000, 0xabcd0000) +} + +Name(i000, 0) + +Method(mr00) +{ + Name(ts, "mr00") + + Device(d100) + { + Name(i200, 0xabcd0200) + Name(i201, 0xabcd0201) + } + + Device(d101) + { + Name(i202, 0xabcd0202) + Method(m203) + { + Name(i300, 0xabcd0300) + Name(i301, 0xabcd0301) + Store("---------------------------------------- Run m203", Debug) + Increment(i000) + if (LLess(i000, 3)) { + m203() + } + } + Name(i204, 0xabcd0204) + } + Device(d102) + { + Name(i205, 0xabcd0205) + Name(i206, 0xabcd0206) + } + d101.m203() +} + +Method(mr01) +{ +/* + CH03(ts, z169, 0x100, 0, 0) + + mm00() + + if (LNotEqual(i000, 0xabcd0000)) { + err(ts, z169, 0x000, 0, 0, i000, 0xabcd0000) + } + + CH03(ts, z169, 0x101, 0, 0) +*/ +} + +Method(mrff) +{ + Name(run0, 1) + + SRMT("mr00") + mr00() +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/recursion/rec_aslts.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/recursion/rec_aslts.asl new file mode 100644 index 000000000..73e4eeec4 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/recursion/rec_aslts.asl @@ -0,0 +1,357 @@ +/* + * Copyright (c) 2006, Intel Corp. + * Copyright (C) 2006, Valery Podrezov <valery.a.podrezov@intel.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Tests to check recursive calls of methods for different structure of + * sub-trees containig the point from where the call is made and the point + * which is just the invoked method, and different relative disposition of + * those sub-trees containig the points. + */ + +Name(z172, 172) + +Name(IG00, 0) +Name(IG01, 0) +Name(IG02, 0) +Name(IG03, 0) // Do anything once only + +Name(RC00, 5) +Name(RCFF, 1) + +Processor(pr00, 0, 0x000, 0x008) +{ + Name(i000, 0xabcd0000) +} + +// Initialize sub-test +Method(mrfd) +{ + Store(0, IG00) + Store(0, IG01) + Store(0, IG02) + Store(0, IG03) +} + +// Printing +Method(mrfe, 1) +{ + if (RCFF) { + Store(arg0, Debug) + } +} + +/* + * 0-th level method M0 is recursively invoked from + * the same M0 method. + */ +Method(mr00) +{ + Name(ts, "mr00") + Name(i000, 0xabcd0000) + + mrfe(ts) + + Store(IG00, i000) + Increment(IG00) + Increment(IG02) + if (LLess(IG00, RC00)) { + mr00() + } + + Decrement(IG00) + if (LNotEqual(i000, IG00)) { + err(ts, z172, 0x000, 0, 0, i000, IG00) + } + + if (LNotEqual(IG02, RC00)) { + if (LNot(IG03)) { + Store(1, IG03) + err(ts, z172, 0x000, 0, 0, IG02, RC00) + } + } +} + +/* + * 0-th level method M0 invokes recursively 0-th level method M1 + * which, in its turn, invokes recursively M0 + * M0 and M1 are respectively the preceding and the following peers each to other + */ +Method(mr01, 1) +{ + Name(ts, "mr01") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + + mrfe(ts) + + Store(IG00, i000) + Store(arg0, i001) + Increment(IG00) + Increment(IG02) + if (LLess(IG00, RC00)) { + mr02(IG00) + } + + Decrement(IG00) + if (LNotEqual(i000, IG00)) { + err(ts, z172, 0x000, 0, 0, i000, IG00) + } + if (LNotEqual(i001, arg0)) { + err(ts, z172, 0x000, 0, 0, i001, arg0) + } + + Multiply(RC00, 2, Local0) + Decrement(Local0) + if (LNotEqual(IG02, Local0)) { + if (LNot(IG03)) { + Store(1, IG03) + err(ts, z172, 0x000, 0, 0, IG02, Local0) + } + } +} + +Method(mr02, 1) +{ + Name(ts, "mr02") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + + mrfe(ts) + + Store(IG01, i000) + Store(arg0, i001) + Increment(IG01) + Increment(IG02) + if (LLess(IG01, RC00)) { + mr01(IG01) + } + + Decrement(IG01) + if (LNotEqual(i000, IG01)) { + err(ts, z172, 0x000, 0, 0, i000, IG01) + } + if (LNotEqual(i001, arg0)) { + err(ts, z172, 0x000, 0, 0, i001, arg0) + } + + Multiply(RC00, 2, Local0) + Decrement(Local0) + if (LNotEqual(IG02, Local0)) { + if (LNot(IG03)) { + Store(1, IG03) + err(ts, z172, 0x000, 0, 0, IG02, Local0) + } + } +} + +/* + * 2-th level method M0 is recursively invoked from + * the same M0 method. + */ +Method(mr03) +{ + Name(ts, "mr03") + + Device(d100) + { + Name(i200, 0xabcd0200) + Name(i201, 0xabcd0201) + } + + Device(d101) + { + Name(i202, 0xabcd0202) + Method(m203) + { + Name(i300, 0xabcd0300) + Name(i301, 0xabcd0301) + + mrfe("m203") + + Store(IG00, i300) + Increment(IG00) + Increment(IG02) + if (LLess(IG00, RC00)) { + m203() + } + + Decrement(IG00) + if (LNotEqual(i300, IG00)) { + err(ts, z172, 0x000, 0, 0, i300, IG00) + } + + } + Name(i204, 0xabcd0204) + } + Device(d102) + { + Name(i205, 0xabcd0205) + Name(i206, 0xabcd0206) + } + + d101.m203() + + if (LNotEqual(IG02, RC00)) { + if (LNot(IG03)) { + Store(1, IG03) + err(ts, z172, 0x000, 0, 0, IG02, RC00) + } + } +} + +/* + * 2-th level method M0 invokes recursively 0-th level method M1, + * which is not on a path of M0-sub-tree, M1, in its turn, invokes + * recursively M0. It is capable because the sub-tree of M0 has been + * created at the moment when M1 is invoked. + * Note: we can't run M1 in the first turn by that same reason -- + * sub-tree of M0 would be not created in that case and we fall to + * AE_NOT_FOUND exception. + */ +Method(mr04) +{ + Name(ts, "mr04") + + Device(d100) + { + Name(i200, 0xabcd0200) + Name(i201, 0xabcd0201) + } + + Device(d101) + { + Name(i202, 0xabcd0202) + Method(m203, 1) + { + Name(i300, 0xabcd0300) + Name(i301, 0xabcd0301) + + mrfe("m203") + + Store(IG00, i300) + Increment(IG00) + Increment(IG02) + if (LLess(IG00, RC00)) { + mr05(IG00) + } + + Decrement(IG00) + if (LNotEqual(i300, IG00)) { + err(ts, z172, 0x000, 0, 0, i300, IG00) + } + + } + Name(i204, 0xabcd0204) + } + Device(d102) + { + Name(i205, 0xabcd0205) + Name(i206, 0xabcd0206) + } + + d101.m203(0) + + if (LNotEqual(IG02, RC00)) { + if (LNot(IG03)) { + Store(1, IG03) + err(ts, z172, 0x000, 0, 0, IG02, RC00) + } + } +} + +Method(mr05, 1) +{ + Name(ts, "mr05") + Name(i000, 0xabcd0000) + Name(i001, 0xabcd0001) + + mrfe(ts) + + Store(IG01, i000) + Store(arg0, i001) + Increment(IG01) + Increment(IG02) + if (LLess(IG01, RC00)) { + ^mr04.d101.m203(IG01) + } + + Decrement(IG01) + if (LNotEqual(i000, IG01)) { + err(ts, z172, 0x000, 0, 0, i000, IG01) + } + if (LNotEqual(i001, arg0)) { + err(ts, z172, 0x000, 0, 0, i001, arg0) + } + + Multiply(RC00, 2, Local0) + Decrement(Local0) + if (LNotEqual(IG02, Local0)) { + if (LNot(IG03)) { + Store(1, IG03) + err(ts, z172, 0x000, 0, 0, IG02, Local0) + } + } +} + + +Method(mrff) +{ + Name(ts, "mrff") + Name(run0, 1) + + CH03(ts, z172, 0x000, 0, 0) + + SRMT("mr00") + mrfd() + mr00() + + SRMT("mr01") + mrfd() + mr01(0) + + SRMT("mr02") + mrfd() + mr02(0) + + SRMT("mr03") + mrfd() + mr03() + + SRMT("mr04") + mrfd() + mr04() + +/* +test --- run mr05 and expect exception +*/ + + + + CH03(ts, z172, 0x000, 0, 0) +} diff --git a/tests/aslts/src/runtime/collections/Identity2MS/abbu/run_points.asl b/tests/aslts/src/runtime/collections/Identity2MS/abbu/run_points.asl new file mode 100644 index 000000000..15319b5e2 --- /dev/null +++ b/tests/aslts/src/runtime/collections/Identity2MS/abbu/run_points.asl @@ -0,0 +1,48 @@ +/* Methods to run manually (for ABBU only) */ + +Method(lf00) { IIN0() mf00() Return(POUT) } +Method(lf01) { IIN0() mf01() Return(POUT) } +Method(lf02) { IIN0() mf02() Return(POUT) } +Method(lf03) { IIN0() mf03() Return(POUT) } +Method(lf04) { IIN0() mf04() Return(POUT) } +Method(lf05) { IIN0() mf05() Return(POUT) } +Method(lf06) { IIN0() mf06() Return(POUT) } +Method(lf07) { IIN0() mf07() Return(POUT) } +Method(lf08) { IIN0() mf08() Return(POUT) } +Method(lf09) { IIN0() mf09() Return(POUT) } +Method(lf0a) { IIN0() mf0a() Return(POUT) } +Method(lf0b) { IIN0() mf0b() Return(POUT) } +Method(lf0c) { IIN0() mf0c() Return(POUT) } +Method(lf0d) { IIN0() mf0d() Return(POUT) } +Method(lf0e) { IIN0() mf0e() Return(POUT) } +Method(lf0f) { IIN0() mf0f() Return(POUT) } +Method(lf10) { IIN0() mf10() Return(POUT) } +Method(lf11) { IIN0() mf11() Return(POUT) } +Method(lf12) { IIN0() mf12() Return(POUT) } +Method(lf13) { IIN0() mf13() Return(POUT) } +Method(lf14) { IIN0() mf14() Return(POUT) } +Method(lf15) { IIN0() mf15() Return(POUT) } +Method(lf16) { IIN0() mf16() Return(POUT) } +Method(lf17) { IIN0() mf17() Return(POUT) } +Method(lf18) { IIN0() mf18() Return(POUT) } +Method(lf19) { IIN0() mf19() Return(POUT) } +Method(lf1a) { IIN0() mf1a() Return(POUT) } +Method(lf1b) { IIN0() mf1b() Return(POUT) } +Method(lf1c) { IIN0() mf1c() Return(POUT) } +Method(lf1d) { IIN0() mf1d() Return(POUT) } +Method(lf1e) { IIN0() mf1e() Return(POUT) } +Method(lf1f) { IIN0() mf1f() Return(POUT) } +Method(lf20) { IIN0() mf20() Return(POUT) } +Method(lf21) { IIN0() mf21() Return(POUT) } +Method(lf22) { IIN0() mf22() Return(POUT) } +Method(lf23) { IIN0() mf23() Return(POUT) } +Method(lf24) { IIN0() mf24() Return(POUT) } +Method(lf25) { IIN0() mf25() Return(POUT) } +Method(lf26) { IIN0() mf26() Return(POUT) } +Method(lf27) { IIN0() mf27() Return(POUT) } +Method(lf28) { IIN0() mf28() Return(POUT) } +Method(lf29) { IIN0() mf29(0) Return(POUT) } +Method(lf2a) { IIN0() mf2a(0) Return(POUT) } +Method(lf2b) { IIN0() mf2b() Return(POUT) } +Method(lf2c) { IIN0() mf2c(0) Return(POUT) } +Method(lf2d) { IIN0() mt0e() Return(POUT) } |