1    /*
2     * Some or all of this work - Copyright (c) 2006 - 2021, Intel Corp.
3     * All rights reserved.
4     *
5     * Redistribution and use in source and binary forms, with or without modification,
6     * are permitted provided that the following conditions are met:
7     *
8     * Redistributions of source code must retain the above copyright notice,
9     * this list of conditions and the following disclaimer.
10     * Redistributions in binary form must reproduce the above copyright notice,
11     * this list of conditions and the following disclaimer in the documentation
12     * and/or other materials provided with the distribution.
13     * Neither the name of Intel Corporation nor the names of its contributors
14     * may be used to endorse or promote products derived from this software
15     * without specific prior written permission.
16     *
17     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18     * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20     * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21     * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23     * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25     * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
26     * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27     */
28    /*
29     * Mutex
30     *
31     * declarations for common use
32     */
33    Name (MAX0, 0x10) /* Number of different Levels of mutexes */
34    Name (HLMX, 0x0F) /* Highest Level of mutex */
35    Name (MAX1, 0x12) /* Max number of mutexes of the same level */
36    Name (UNIM, 0x12) /* Undefined index of mutex */
37    Name (MAX2, Buffer (MAX0)
38    {
39        /* 0000 */  0x12, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,  // ........
40        /* 0008 */  0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04   // ........
41    })
42    /*
43     * GLLL - Level of mutex for Global Lock.
44     * GLIX - Index of mutex for Global Lock.
45     *
46     * The Global Lock in tests is represented as mutex of 0-th Level 1-th Index.
47     */
48    Name (GLLL, 0x00) /* Level of mutex for GL */
49    Name (GLIX, 0x01) /* Index of mutex for GL */
50    /*
51     * Flag of Global lock.
52     * If non-zero then actually the Global lock is used in tests
53     * instead of the usual mutex T001 (of level 0 index 1).
54     */
55    Name (GL00, 0x00)
56    Name (MIN0, 0x04)  /* Minimal number of mutexes of the same level in groups below */
57    Name (MIN1, 0x05)  /* Minimal number of threads corresponding to min0 */
58    /*
59     * See TOV0 and TOV0 below,
60     * all other opcodes of TimeOutValue correspond to 0xffff.
61     */
62    Name (TOV0, 0x05) /* opcode of TimeOutValue corresponding to 0 milliseconds */
63    Name (TOV1, 0x06) /* opcode of TimeOutValue corresponding to 1 milliseconds */
64    Name (TOVF, 0x00) /* opcode of TimeOutValue corresponding to 0xffff (endless) */
65    /* Level 0 */
66
67    Mutex (T000, 0x00)
68    Mutex (T001, 0x00) /* used in case when the flag of the Global Lock (GL00) is zero */
69    Mutex (T002, 0x00)
70    Mutex (T003, 0x00)
71    Mutex (T004, 0x00)
72    Mutex (T005, 0x00)
73    Mutex (T006, 0x00)
74    Mutex (T007, 0x00)
75    Mutex (T008, 0x00)
76    Mutex (T009, 0x00)
77    Mutex (T00A, 0x00)
78    Mutex (T00B, 0x00)
79    Mutex (T00C, 0x00)
80    Mutex (T00D, 0x00)
81    Mutex (T00E, 0x00)
82    Mutex (T00F, 0x00)
83    Mutex (T010, 0x00)
84    Mutex (T011, 0x00)
85    /* Level 1 */
86
87    Mutex (T100, 0x01)
88    Mutex (T101, 0x01)
89    Mutex (T102, 0x01)
90    Mutex (T103, 0x01)
91    /* Level 2 */
92
93    Mutex (T200, 0x02)
94    Mutex (T201, 0x02)
95    Mutex (T202, 0x02)
96    Mutex (T203, 0x02)
97    /* Level 3 */
98
99    Mutex (T300, 0x03)
100    Mutex (T301, 0x03)
101    Mutex (T302, 0x03)
102    Mutex (T303, 0x03)
103    /* Level 4 */
104
105    Mutex (T400, 0x04)
106    Mutex (T401, 0x04)
107    Mutex (T402, 0x04)
108    Mutex (T403, 0x04)
109    /* Level 5 */
110
111    Mutex (T500, 0x05)
112    Mutex (T501, 0x05)
113    Mutex (T502, 0x05)
114    Mutex (T503, 0x05)
115    /* Level 6 */
116
117    Mutex (T600, 0x06)
118    Mutex (T601, 0x06)
119    Mutex (T602, 0x06)
120    Mutex (T603, 0x06)
121    /* Level 7 */
122
123    Mutex (T700, 0x07)
124    Mutex (T701, 0x07)
125    Mutex (T702, 0x07)
126    Mutex (T703, 0x07)
127    /* Level 8 */
128
129    Mutex (T800, 0x08)
130    Mutex (T801, 0x08)
131    Mutex (T802, 0x08)
132    Mutex (T803, 0x08)
133    Mutex (T804, 0x08) /* used in functional/synchronization */
134    Mutex (T805, 0x08) /* used in functional/synchronization */
135    /* Level 9 */
136
137    Mutex (T900, 0x09)
138    Mutex (T901, 0x09)
139    Mutex (T902, 0x09)
140    Mutex (T903, 0x09)
141    /* Level 10 */
142
143    Mutex (TA00, 0x0A)
144    Mutex (TA01, 0x0A)
145    Mutex (TA02, 0x0A)
146    Mutex (TA03, 0x0A)
147    /* Level 11 */
148
149    Mutex (TB00, 0x0B)
150    Mutex (TB01, 0x0B)
151    Mutex (TB02, 0x0B)
152    Mutex (TB03, 0x0B)
153    /* Level 12 */
154
155    Mutex (TC00, 0x0C)
156    Mutex (TC01, 0x0C)
157    Mutex (TC02, 0x0C)
158    Mutex (TC03, 0x0C)
159    /* Level 13 */
160
161    Mutex (TD00, 0x0D)
162    Mutex (TD01, 0x0D)
163    Mutex (TD02, 0x0D)
164    Mutex (TD03, 0x0D)
165    /* Level 14 */
166
167    Mutex (TE00, 0x0E)
168    Mutex (TE01, 0x0E)
169    Mutex (TE02, 0x0E)
170    Mutex (TE03, 0x0E)
171    /* Level 15 */
172
173    Mutex (TF00, 0x0F)
174    Mutex (TF01, 0x0F)
175    Mutex (TF02, 0x0F)
176    Mutex (TF03, 0x0F)
177    /*
178     *
179     * Methods to manage mutexes declared above
180     *
181     */
182    /*
183     * Set flag of Global lock
184     *
185     * arg0 - new value of flag of GL
186     *
187     * Return:
188     *   old value of flag of GL
189     */
190    Method (M078, 1, NotSerialized)
191    {
192        Local7 = GL00 /* \GL00 */
193        GL00 = Arg0
194        Return (Local7)
195    }
196
197    /*
198     * Acquire mutex of level 0
199     *
200     * arg0 - Index of mutex
201     * arg1 - opcode of exception to be generated or zero
202     * arg2 - opcode of TimeOutValue (unfortunately, ACPA doesn't allow TermArg there)
203     *        0 - 0
204     *        1 - 1
205     *        otherwise - oxffff
206     */
207    Method (MA00, 3, Serialized)
208    {
209        Local0 = 0x01
210        Switch (ToInteger (Arg0))
211        {
212            Case (0x00)
213            {
214                If (Arg1)
215                {
216                    Acquire (T000, 0xFFFF)
217                }
218                ElseIf ((Arg2 == TOV0))
219                {
220                    Local0 = Acquire (T000, 0x0000)
221                }
222                ElseIf ((Arg2 == TOV1))
223                {
224                    Local0 = Acquire (T000, 0x0001)
225                }
226                Else
227                {
228                    Local0 = Acquire (T000, 0xFFFF)
229                }
230            }
231            Case (0x01)
232            {
233                If (GL00)
234                {
235                    If (Arg1)
236                    {
237                        Acquire (\_GL, 0xFFFF)
238                    }
239                    ElseIf ((Arg2 == TOV0))
240                    {
241                        Local0 = Acquire (\_GL, 0x0000)
242                    }
243                    ElseIf ((Arg2 == TOV1))
244                    {
245                        Local0 = Acquire (\_GL, 0x0001)
246                    }
247                    Else
248                    {
249                        Local0 = Acquire (\_GL, 0xFFFF)
250                    }
251                }
252                ElseIf (Arg1)
253                {
254                    Acquire (T001, 0xFFFF)
255                }
256                ElseIf ((Arg2 == TOV0))
257                {
258                    Local0 = Acquire (T001, 0x0000)
259                }
260                ElseIf ((Arg2 == TOV1))
261                {
262                    Local0 = Acquire (T001, 0x0001)
263                }
264                Else
265                {
266                    Local0 = Acquire (T001, 0xFFFF)
267                }
268            }
269            Case (0x02)
270            {
271                If (Arg1)
272                {
273                    Acquire (T002, 0xFFFF)
274                }
275                ElseIf ((Arg2 == TOV0))
276                {
277                    Local0 = Acquire (T002, 0x0000)
278                }
279                ElseIf ((Arg2 == TOV1))
280                {
281                    Local0 = Acquire (T002, 0x0001)
282                }
283                Else
284                {
285                    Local0 = Acquire (T002, 0xFFFF)
286                }
287            }
288            Case (0x03)
289            {
290                If (Arg1)
291                {
292                    Acquire (T003, 0xFFFF)
293                }
294                ElseIf ((Arg2 == TOV0))
295                {
296                    Local0 = Acquire (T003, 0x0000)
297                }
298                ElseIf ((Arg2 == TOV1))
299                {
300                    Local0 = Acquire (T003, 0x0001)
301                }
302                Else
303                {
304                    Local0 = Acquire (T003, 0xFFFF)
305                }
306            }
307            Case (0x04)
308            {
309                If (Arg1)
310                {
311                    Acquire (T004, 0xFFFF)
312                }
313                ElseIf ((Arg2 == TOV0))
314                {
315                    Local0 = Acquire (T004, 0x0000)
316                }
317                ElseIf ((Arg2 == TOV1))
318                {
319                    Local0 = Acquire (T004, 0x0001)
320                }
321                Else
322                {
323                    Local0 = Acquire (T004, 0xFFFF)
324                }
325            }
326            Case (0x05)
327            {
328                If (Arg1)
329                {
330                    Acquire (T005, 0xFFFF)
331                }
332                ElseIf ((Arg2 == TOV0))
333                {
334                    Local0 = Acquire (T005, 0x0000)
335                }
336                ElseIf ((Arg2 == TOV1))
337                {
338                    Local0 = Acquire (T005, 0x0001)
339                }
340                Else
341                {
342                    Local0 = Acquire (T005, 0xFFFF)
343                }
344            }
345            Case (0x06)
346            {
347                If (Arg1)
348                {
349                    Acquire (T006, 0xFFFF)
350                }
351                ElseIf ((Arg2 == TOV0))
352                {
353                    Local0 = Acquire (T006, 0x0000)
354                }
355                ElseIf ((Arg2 == TOV1))
356                {
357                    Local0 = Acquire (T006, 0x0001)
358                }
359                Else
360                {
361                    Local0 = Acquire (T006, 0xFFFF)
362                }
363            }
364            Case (0x07)
365            {
366                If (Arg1)
367                {
368                    Acquire (T007, 0xFFFF)
369                }
370                ElseIf ((Arg2 == TOV0))
371                {
372                    Local0 = Acquire (T007, 0x0000)
373                }
374                ElseIf ((Arg2 == TOV1))
375                {
376                    Local0 = Acquire (T007, 0x0001)
377                }
378                Else
379                {
380                    Local0 = Acquire (T007, 0xFFFF)
381                }
382            }
383            Case (0x08)
384            {
385                If (Arg1)
386                {
387                    Acquire (T008, 0xFFFF)
388                }
389                ElseIf ((Arg2 == TOV0))
390                {
391                    Local0 = Acquire (T008, 0x0000)
392                }
393                ElseIf ((Arg2 == TOV1))
394                {
395                    Local0 = Acquire (T008, 0x0001)
396                }
397                Else
398                {
399                    Local0 = Acquire (T008, 0xFFFF)
400                }
401            }
402            Case (0x09)
403            {
404                If (Arg1)
405                {
406                    Acquire (T009, 0xFFFF)
407                }
408                ElseIf ((Arg2 == TOV0))
409                {
410                    Local0 = Acquire (T009, 0x0000)
411                }
412                ElseIf ((Arg2 == TOV1))
413                {
414                    Local0 = Acquire (T009, 0x0001)
415                }
416                Else
417                {
418                    Local0 = Acquire (T009, 0xFFFF)
419                }
420            }
421            Case (0x0A)
422            {
423                If (Arg1)
424                {
425                    Acquire (T00A, 0xFFFF)
426                }
427                ElseIf ((Arg2 == TOV0))
428                {
429                    Local0 = Acquire (T00A, 0x0000)
430                }
431                ElseIf ((Arg2 == TOV1))
432                {
433                    Local0 = Acquire (T00A, 0x0001)
434                }
435                Else
436                {
437                    Local0 = Acquire (T00A, 0xFFFF)
438                }
439            }
440            Case (0x0B)
441            {
442                If (Arg1)
443                {
444                    Acquire (T00B, 0xFFFF)
445                }
446                ElseIf ((Arg2 == TOV0))
447                {
448                    Local0 = Acquire (T00B, 0x0000)
449                }
450                ElseIf ((Arg2 == TOV1))
451                {
452                    Local0 = Acquire (T00B, 0x0001)
453                }
454                Else
455                {
456                    Local0 = Acquire (T00B, 0xFFFF)
457                }
458            }
459            Case (0x0C)
460            {
461                If (Arg1)
462                {
463                    Acquire (T00C, 0xFFFF)
464                }
465                ElseIf ((Arg2 == TOV0))
466                {
467                    Local0 = Acquire (T00C, 0x0000)
468                }
469                ElseIf ((Arg2 == TOV1))
470                {
471                    Local0 = Acquire (T00C, 0x0001)
472                }
473                Else
474                {
475                    Local0 = Acquire (T00C, 0xFFFF)
476                }
477            }
478            Case (0x0D)
479            {
480                If (Arg1)
481                {
482                    Acquire (T00D, 0xFFFF)
483                }
484                ElseIf ((Arg2 == TOV0))
485                {
486                    Local0 = Acquire (T00D, 0x0000)
487                }
488                ElseIf ((Arg2 == TOV1))
489                {
490                    Local0 = Acquire (T00D, 0x0001)
491                }
492                Else
493                {
494                    Local0 = Acquire (T00D, 0xFFFF)
495                }
496            }
497            Case (0x0E)
498            {
499                If (Arg1)
500                {
501                    Acquire (T00E, 0xFFFF)
502                }
503                ElseIf ((Arg2 == TOV0))
504                {
505                    Local0 = Acquire (T00E, 0x0000)
506                }
507                ElseIf ((Arg2 == TOV1))
508                {
509                    Local0 = Acquire (T00E, 0x0001)
510                }
511                Else
512                {
513                    Local0 = Acquire (T00E, 0xFFFF)
514                }
515            }
516            Case (0x0F)
517            {
518                If (Arg1)
519                {
520                    Acquire (T00F, 0xFFFF)
521                }
522                ElseIf ((Arg2 == TOV0))
523                {
524                    Local0 = Acquire (T00F, 0x0000)
525                }
526                ElseIf ((Arg2 == TOV1))
527                {
528                    Local0 = Acquire (T00F, 0x0001)
529                }
530                Else
531                {
532                    Local0 = Acquire (T00F, 0xFFFF)
533                }
534            }
535            Case (0x10)
536            {
537                If (Arg1)
538                {
539                    Acquire (T010, 0xFFFF)
540                }
541                ElseIf ((Arg2 == TOV0))
542                {
543                    Local0 = Acquire (T010, 0x0000)
544                }
545                ElseIf ((Arg2 == TOV1))
546                {
547                    Local0 = Acquire (T010, 0x0001)
548                }
549                Else
550                {
551                    Local0 = Acquire (T010, 0xFFFF)
552                }
553            }
554            Case (0x11)
555            {
556                If (Arg1)
557                {
558                    Acquire (T011, 0xFFFF)
559                }
560                ElseIf ((Arg2 == TOV0))
561                {
562                    Local0 = Acquire (T011, 0x0000)
563                }
564                ElseIf ((Arg2 == TOV1))
565                {
566                    Local0 = Acquire (T011, 0x0001)
567                }
568                Else
569                {
570                    Local0 = Acquire (T011, 0xFFFF)
571                }
572            }
573
574        }
575
576        Return (Local0)
577    }
578
579    /*
580     * Acquire mutex of level 1
581     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
582     */
583    Method (MA01, 3, Serialized)
584    {
585        Local0 = 0x01
586        Switch (ToInteger (Arg0))
587        {
588            Case (0x00)
589            {
590                If (Arg1)
591                {
592                    Acquire (T100, 0xFFFF)
593                }
594                ElseIf ((Arg2 == TOV0))
595                {
596                    Local0 = Acquire (T100, 0x0000)
597                }
598                ElseIf ((Arg2 == TOV1))
599                {
600                    Local0 = Acquire (T100, 0x0001)
601                }
602                Else
603                {
604                    Local0 = Acquire (T100, 0xFFFF)
605                }
606            }
607            Case (0x01)
608            {
609                If (Arg1)
610                {
611                    Acquire (T101, 0xFFFF)
612                }
613                ElseIf ((Arg2 == TOV0))
614                {
615                    Local0 = Acquire (T101, 0x0000)
616                }
617                ElseIf ((Arg2 == TOV1))
618                {
619                    Local0 = Acquire (T101, 0x0001)
620                }
621                Else
622                {
623                    Local0 = Acquire (T101, 0xFFFF)
624                }
625            }
626            Case (0x02)
627            {
628                If (Arg1)
629                {
630                    Acquire (T102, 0xFFFF)
631                }
632                ElseIf ((Arg2 == TOV0))
633                {
634                    Local0 = Acquire (T102, 0x0000)
635                }
636                ElseIf ((Arg2 == TOV1))
637                {
638                    Local0 = Acquire (T102, 0x0001)
639                }
640                Else
641                {
642                    Local0 = Acquire (T102, 0xFFFF)
643                }
644            }
645            Case (0x03)
646            {
647                If (Arg1)
648                {
649                    Acquire (T103, 0xFFFF)
650                }
651                ElseIf ((Arg2 == TOV0))
652                {
653                    Local0 = Acquire (T103, 0x0000)
654                }
655                ElseIf ((Arg2 == TOV1))
656                {
657                    Local0 = Acquire (T103, 0x0001)
658                }
659                Else
660                {
661                    Local0 = Acquire (T103, 0xFFFF)
662                }
663            }
664
665        }
666
667        Return (Local0)
668    }
669
670    /*
671     * Acquire mutex of level 2
672     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
673     */
674    Method (MA02, 3, Serialized)
675    {
676        Local0 = 0x01
677        Switch (ToInteger (Arg0))
678        {
679            Case (0x00)
680            {
681                If (Arg1)
682                {
683                    Acquire (T200, 0xFFFF)
684                }
685                ElseIf ((Arg2 == TOV0))
686                {
687                    Local0 = Acquire (T200, 0x0000)
688                }
689                ElseIf ((Arg2 == TOV1))
690                {
691                    Local0 = Acquire (T200, 0x0001)
692                }
693                Else
694                {
695                    Local0 = Acquire (T200, 0xFFFF)
696                }
697            }
698            Case (0x01)
699            {
700                If (Arg1)
701                {
702                    Acquire (T201, 0xFFFF)
703                }
704                ElseIf ((Arg2 == TOV0))
705                {
706                    Local0 = Acquire (T201, 0x0000)
707                }
708                ElseIf ((Arg2 == TOV1))
709                {
710                    Local0 = Acquire (T201, 0x0001)
711                }
712                Else
713                {
714                    Local0 = Acquire (T201, 0xFFFF)
715                }
716            }
717            Case (0x02)
718            {
719                If (Arg1)
720                {
721                    Acquire (T202, 0xFFFF)
722                }
723                ElseIf ((Arg2 == TOV0))
724                {
725                    Local0 = Acquire (T202, 0x0000)
726                }
727                ElseIf ((Arg2 == TOV1))
728                {
729                    Local0 = Acquire (T202, 0x0001)
730                }
731                Else
732                {
733                    Local0 = Acquire (T202, 0xFFFF)
734                }
735            }
736            Case (0x03)
737            {
738                If (Arg1)
739                {
740                    Acquire (T203, 0xFFFF)
741                }
742                ElseIf ((Arg2 == TOV0))
743                {
744                    Local0 = Acquire (T203, 0x0000)
745                }
746                ElseIf ((Arg2 == TOV1))
747                {
748                    Local0 = Acquire (T203, 0x0001)
749                }
750                Else
751                {
752                    Local0 = Acquire (T203, 0xFFFF)
753                }
754            }
755
756        }
757
758        Return (Local0)
759    }
760
761    /*
762     * Acquire mutex of level 3
763     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
764     */
765    Method (MA03, 3, Serialized)
766    {
767        Local0 = 0x01
768        Switch (ToInteger (Arg0))
769        {
770            Case (0x00)
771            {
772                If (Arg1)
773                {
774                    Acquire (T300, 0xFFFF)
775                }
776                ElseIf ((Arg2 == TOV0))
777                {
778                    Local0 = Acquire (T300, 0x0000)
779                }
780                ElseIf ((Arg2 == TOV1))
781                {
782                    Local0 = Acquire (T300, 0x0001)
783                }
784                Else
785                {
786                    Local0 = Acquire (T300, 0xFFFF)
787                }
788            }
789            Case (0x01)
790            {
791                If (Arg1)
792                {
793                    Acquire (T301, 0xFFFF)
794                }
795                ElseIf ((Arg2 == TOV0))
796                {
797                    Local0 = Acquire (T301, 0x0000)
798                }
799                ElseIf ((Arg2 == TOV1))
800                {
801                    Local0 = Acquire (T301, 0x0001)
802                }
803                Else
804                {
805                    Local0 = Acquire (T301, 0xFFFF)
806                }
807            }
808            Case (0x02)
809            {
810                If (Arg1)
811                {
812                    Acquire (T302, 0xFFFF)
813                }
814                ElseIf ((Arg2 == TOV0))
815                {
816                    Local0 = Acquire (T302, 0x0000)
817                }
818                ElseIf ((Arg2 == TOV1))
819                {
820                    Local0 = Acquire (T302, 0x0001)
821                }
822                Else
823                {
824                    Local0 = Acquire (T302, 0xFFFF)
825                }
826            }
827            Case (0x03)
828            {
829                If (Arg1)
830                {
831                    Acquire (T303, 0xFFFF)
832                }
833                ElseIf ((Arg2 == TOV0))
834                {
835                    Local0 = Acquire (T303, 0x0000)
836                }
837                ElseIf ((Arg2 == TOV1))
838                {
839                    Local0 = Acquire (T303, 0x0001)
840                }
841                Else
842                {
843                    Local0 = Acquire (T303, 0xFFFF)
844                }
845            }
846
847        }
848
849        Return (Local0)
850    }
851
852    /*
853     * Acquire mutex of level 4
854     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
855     */
856    Method (MA04, 3, Serialized)
857    {
858        Local0 = 0x01
859        Switch (ToInteger (Arg0))
860        {
861            Case (0x00)
862            {
863                If (Arg1)
864                {
865                    Acquire (T400, 0xFFFF)
866                }
867                ElseIf ((Arg2 == TOV0))
868                {
869                    Local0 = Acquire (T400, 0x0000)
870                }
871                ElseIf ((Arg2 == TOV1))
872                {
873                    Local0 = Acquire (T400, 0x0001)
874                }
875                Else
876                {
877                    Local0 = Acquire (T400, 0xFFFF)
878                }
879            }
880            Case (0x01)
881            {
882                If (Arg1)
883                {
884                    Acquire (T401, 0xFFFF)
885                }
886                ElseIf ((Arg2 == TOV0))
887                {
888                    Local0 = Acquire (T401, 0x0000)
889                }
890                ElseIf ((Arg2 == TOV1))
891                {
892                    Local0 = Acquire (T401, 0x0001)
893                }
894                Else
895                {
896                    Local0 = Acquire (T401, 0xFFFF)
897                }
898            }
899            Case (0x02)
900            {
901                If (Arg1)
902                {
903                    Acquire (T402, 0xFFFF)
904                }
905                ElseIf ((Arg2 == TOV0))
906                {
907                    Local0 = Acquire (T402, 0x0000)
908                }
909                ElseIf ((Arg2 == TOV1))
910                {
911                    Local0 = Acquire (T402, 0x0001)
912                }
913                Else
914                {
915                    Local0 = Acquire (T402, 0xFFFF)
916                }
917            }
918            Case (0x03)
919            {
920                If (Arg1)
921                {
922                    Acquire (T403, 0xFFFF)
923                }
924                ElseIf ((Arg2 == TOV0))
925                {
926                    Local0 = Acquire (T403, 0x0000)
927                }
928                ElseIf ((Arg2 == TOV1))
929                {
930                    Local0 = Acquire (T403, 0x0001)
931                }
932                Else
933                {
934                    Local0 = Acquire (T403, 0xFFFF)
935                }
936            }
937
938        }
939
940        Return (Local0)
941    }
942
943    /*
944     * Acquire mutex of level 5
945     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
946     */
947    Method (MA05, 3, Serialized)
948    {
949        Local0 = 0x01
950        Switch (ToInteger (Arg0))
951        {
952            Case (0x00)
953            {
954                If (Arg1)
955                {
956                    Acquire (T500, 0xFFFF)
957                }
958                ElseIf ((Arg2 == TOV0))
959                {
960                    Local0 = Acquire (T500, 0x0000)
961                }
962                ElseIf ((Arg2 == TOV1))
963                {
964                    Local0 = Acquire (T500, 0x0001)
965                }
966                Else
967                {
968                    Local0 = Acquire (T500, 0xFFFF)
969                }
970            }
971            Case (0x01)
972            {
973                If (Arg1)
974                {
975                    Acquire (T501, 0xFFFF)
976                }
977                ElseIf ((Arg2 == TOV0))
978                {
979                    Local0 = Acquire (T501, 0x0000)
980                }
981                ElseIf ((Arg2 == TOV1))
982                {
983                    Local0 = Acquire (T501, 0x0001)
984                }
985                Else
986                {
987                    Local0 = Acquire (T501, 0xFFFF)
988                }
989            }
990            Case (0x02)
991            {
992                If (Arg1)
993                {
994                    Acquire (T502, 0xFFFF)
995                }
996                ElseIf ((Arg2 == TOV0))
997                {
998                    Local0 = Acquire (T502, 0x0000)
999                }
1000                ElseIf ((Arg2 == TOV1))
1001                {
1002                    Local0 = Acquire (T502, 0x0001)
1003                }
1004                Else
1005                {
1006                    Local0 = Acquire (T502, 0xFFFF)
1007                }
1008            }
1009            Case (0x03)
1010            {
1011                If (Arg1)
1012                {
1013                    Acquire (T503, 0xFFFF)
1014                }
1015                ElseIf ((Arg2 == TOV0))
1016                {
1017                    Local0 = Acquire (T503, 0x0000)
1018                }
1019                ElseIf ((Arg2 == TOV1))
1020                {
1021                    Local0 = Acquire (T503, 0x0001)
1022                }
1023                Else
1024                {
1025                    Local0 = Acquire (T503, 0xFFFF)
1026                }
1027            }
1028
1029        }
1030
1031        Return (Local0)
1032    }
1033
1034    /*
1035     * Acquire mutex of level 6
1036     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1037     */
1038    Method (MA06, 3, Serialized)
1039    {
1040        Local0 = 0x01
1041        Switch (ToInteger (Arg0))
1042        {
1043            Case (0x00)
1044            {
1045                If (Arg1)
1046                {
1047                    Acquire (T600, 0xFFFF)
1048                }
1049                ElseIf ((Arg2 == TOV0))
1050                {
1051                    Local0 = Acquire (T600, 0x0000)
1052                }
1053                ElseIf ((Arg2 == TOV1))
1054                {
1055                    Local0 = Acquire (T600, 0x0001)
1056                }
1057                Else
1058                {
1059                    Local0 = Acquire (T600, 0xFFFF)
1060                }
1061            }
1062            Case (0x01)
1063            {
1064                If (Arg1)
1065                {
1066                    Acquire (T601, 0xFFFF)
1067                }
1068                ElseIf ((Arg2 == TOV0))
1069                {
1070                    Local0 = Acquire (T601, 0x0000)
1071                }
1072                ElseIf ((Arg2 == TOV1))
1073                {
1074                    Local0 = Acquire (T601, 0x0001)
1075                }
1076                Else
1077                {
1078                    Local0 = Acquire (T601, 0xFFFF)
1079                }
1080            }
1081            Case (0x02)
1082            {
1083                If (Arg1)
1084                {
1085                    Acquire (T602, 0xFFFF)
1086                }
1087                ElseIf ((Arg2 == TOV0))
1088                {
1089                    Local0 = Acquire (T602, 0x0000)
1090                }
1091                ElseIf ((Arg2 == TOV1))
1092                {
1093                    Local0 = Acquire (T602, 0x0001)
1094                }
1095                Else
1096                {
1097                    Local0 = Acquire (T602, 0xFFFF)
1098                }
1099            }
1100            Case (0x03)
1101            {
1102                If (Arg1)
1103                {
1104                    Acquire (T603, 0xFFFF)
1105                }
1106                ElseIf ((Arg2 == TOV0))
1107                {
1108                    Local0 = Acquire (T603, 0x0000)
1109                }
1110                ElseIf ((Arg2 == TOV1))
1111                {
1112                    Local0 = Acquire (T603, 0x0001)
1113                }
1114                Else
1115                {
1116                    Local0 = Acquire (T603, 0xFFFF)
1117                }
1118            }
1119
1120        }
1121
1122        Return (Local0)
1123    }
1124
1125    /*
1126     * Acquire mutex of level 7
1127     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1128     */
1129    Method (MA07, 3, Serialized)
1130    {
1131        Local0 = 0x01
1132        Switch (ToInteger (Arg0))
1133        {
1134            Case (0x00)
1135            {
1136                If (Arg1)
1137                {
1138                    Acquire (T700, 0xFFFF)
1139                }
1140                ElseIf ((Arg2 == TOV0))
1141                {
1142                    Local0 = Acquire (T700, 0x0000)
1143                }
1144                ElseIf ((Arg2 == TOV1))
1145                {
1146                    Local0 = Acquire (T700, 0x0001)
1147                }
1148                Else
1149                {
1150                    Local0 = Acquire (T700, 0xFFFF)
1151                }
1152            }
1153            Case (0x01)
1154            {
1155                If (Arg1)
1156                {
1157                    Acquire (T701, 0xFFFF)
1158                }
1159                ElseIf ((Arg2 == TOV0))
1160                {
1161                    Local0 = Acquire (T701, 0x0000)
1162                }
1163                ElseIf ((Arg2 == TOV1))
1164                {
1165                    Local0 = Acquire (T701, 0x0001)
1166                }
1167                Else
1168                {
1169                    Local0 = Acquire (T701, 0xFFFF)
1170                }
1171            }
1172            Case (0x02)
1173            {
1174                If (Arg1)
1175                {
1176                    Acquire (T702, 0xFFFF)
1177                }
1178                ElseIf ((Arg2 == TOV0))
1179                {
1180                    Local0 = Acquire (T702, 0x0000)
1181                }
1182                ElseIf ((Arg2 == TOV1))
1183                {
1184                    Local0 = Acquire (T702, 0x0001)
1185                }
1186                Else
1187                {
1188                    Local0 = Acquire (T702, 0xFFFF)
1189                }
1190            }
1191            Case (0x03)
1192            {
1193                If (Arg1)
1194                {
1195                    Acquire (T703, 0xFFFF)
1196                }
1197                ElseIf ((Arg2 == TOV0))
1198                {
1199                    Local0 = Acquire (T703, 0x0000)
1200                }
1201                ElseIf ((Arg2 == TOV1))
1202                {
1203                    Local0 = Acquire (T703, 0x0001)
1204                }
1205                Else
1206                {
1207                    Local0 = Acquire (T703, 0xFFFF)
1208                }
1209            }
1210
1211        }
1212
1213        Return (Local0)
1214    }
1215
1216    /*
1217     * Acquire mutex of level 8
1218     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1219     */
1220    Method (MA08, 3, Serialized)
1221    {
1222        Local0 = 0x01
1223        Switch (ToInteger (Arg0))
1224        {
1225            Case (0x00)
1226            {
1227                If (Arg1)
1228                {
1229                    Acquire (T800, 0xFFFF)
1230                }
1231                ElseIf ((Arg2 == TOV0))
1232                {
1233                    Local0 = Acquire (T800, 0x0000)
1234                }
1235                ElseIf ((Arg2 == TOV1))
1236                {
1237                    Local0 = Acquire (T800, 0x0001)
1238                }
1239                Else
1240                {
1241                    Local0 = Acquire (T800, 0xFFFF)
1242                }
1243            }
1244            Case (0x01)
1245            {
1246                If (Arg1)
1247                {
1248                    Acquire (T801, 0xFFFF)
1249                }
1250                ElseIf ((Arg2 == TOV0))
1251                {
1252                    Local0 = Acquire (T801, 0x0000)
1253                }
1254                ElseIf ((Arg2 == TOV1))
1255                {
1256                    Local0 = Acquire (T801, 0x0001)
1257                }
1258                Else
1259                {
1260                    Local0 = Acquire (T801, 0xFFFF)
1261                }
1262            }
1263            Case (0x02)
1264            {
1265                If (Arg1)
1266                {
1267                    Acquire (T802, 0xFFFF)
1268                }
1269                ElseIf ((Arg2 == TOV0))
1270                {
1271                    Local0 = Acquire (T802, 0x0000)
1272                }
1273                ElseIf ((Arg2 == TOV1))
1274                {
1275                    Local0 = Acquire (T802, 0x0001)
1276                }
1277                Else
1278                {
1279                    Local0 = Acquire (T802, 0xFFFF)
1280                }
1281            }
1282            Case (0x03)
1283            {
1284                If (Arg1)
1285                {
1286                    Acquire (T803, 0xFFFF)
1287                }
1288                ElseIf ((Arg2 == TOV0))
1289                {
1290                    Local0 = Acquire (T803, 0x0000)
1291                }
1292                ElseIf ((Arg2 == TOV1))
1293                {
1294                    Local0 = Acquire (T803, 0x0001)
1295                }
1296                Else
1297                {
1298                    Local0 = Acquire (T803, 0xFFFF)
1299                }
1300            }
1301
1302        }
1303
1304        Return (Local0)
1305    }
1306
1307    /*
1308     * Acquire mutex of level 9
1309     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1310     */
1311    Method (MA09, 3, Serialized)
1312    {
1313        Local0 = 0x01
1314        Switch (ToInteger (Arg0))
1315        {
1316            Case (0x00)
1317            {
1318                If (Arg1)
1319                {
1320                    Acquire (T900, 0xFFFF)
1321                }
1322                ElseIf ((Arg2 == TOV0))
1323                {
1324                    Local0 = Acquire (T900, 0x0000)
1325                }
1326                ElseIf ((Arg2 == TOV1))
1327                {
1328                    Local0 = Acquire (T900, 0x0001)
1329                }
1330                Else
1331                {
1332                    Local0 = Acquire (T900, 0xFFFF)
1333                }
1334            }
1335            Case (0x01)
1336            {
1337                If (Arg1)
1338                {
1339                    Acquire (T901, 0xFFFF)
1340                }
1341                ElseIf ((Arg2 == TOV0))
1342                {
1343                    Local0 = Acquire (T901, 0x0000)
1344                }
1345                ElseIf ((Arg2 == TOV1))
1346                {
1347                    Local0 = Acquire (T901, 0x0001)
1348                }
1349                Else
1350                {
1351                    Local0 = Acquire (T901, 0xFFFF)
1352                }
1353            }
1354            Case (0x02)
1355            {
1356                If (Arg1)
1357                {
1358                    Acquire (T902, 0xFFFF)
1359                }
1360                ElseIf ((Arg2 == TOV0))
1361                {
1362                    Local0 = Acquire (T902, 0x0000)
1363                }
1364                ElseIf ((Arg2 == TOV1))
1365                {
1366                    Local0 = Acquire (T902, 0x0001)
1367                }
1368                Else
1369                {
1370                    Local0 = Acquire (T902, 0xFFFF)
1371                }
1372            }
1373            Case (0x03)
1374            {
1375                If (Arg1)
1376                {
1377                    Acquire (T903, 0xFFFF)
1378                }
1379                ElseIf ((Arg2 == TOV0))
1380                {
1381                    Local0 = Acquire (T903, 0x0000)
1382                }
1383                ElseIf ((Arg2 == TOV1))
1384                {
1385                    Local0 = Acquire (T903, 0x0001)
1386                }
1387                Else
1388                {
1389                    Local0 = Acquire (T903, 0xFFFF)
1390                }
1391            }
1392
1393        }
1394
1395        Return (Local0)
1396    }
1397
1398    /*
1399     * Acquire mutex of level 10
1400     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1401     */
1402    Method (MA0A, 3, Serialized)
1403    {
1404        Local0 = 0x01
1405        Switch (ToInteger (Arg0))
1406        {
1407            Case (0x00)
1408            {
1409                If (Arg1)
1410                {
1411                    Acquire (TA00, 0xFFFF)
1412                }
1413                ElseIf ((Arg2 == TOV0))
1414                {
1415                    Local0 = Acquire (TA00, 0x0000)
1416                }
1417                ElseIf ((Arg2 == TOV1))
1418                {
1419                    Local0 = Acquire (TA00, 0x0001)
1420                }
1421                Else
1422                {
1423                    Local0 = Acquire (TA00, 0xFFFF)
1424                }
1425            }
1426            Case (0x01)
1427            {
1428                If (Arg1)
1429                {
1430                    Acquire (TA01, 0xFFFF)
1431                }
1432                ElseIf ((Arg2 == TOV0))
1433                {
1434                    Local0 = Acquire (TA01, 0x0000)
1435                }
1436                ElseIf ((Arg2 == TOV1))
1437                {
1438                    Local0 = Acquire (TA01, 0x0001)
1439                }
1440                Else
1441                {
1442                    Local0 = Acquire (TA01, 0xFFFF)
1443                }
1444            }
1445            Case (0x02)
1446            {
1447                If (Arg1)
1448                {
1449                    Acquire (TA02, 0xFFFF)
1450                }
1451                ElseIf ((Arg2 == TOV0))
1452                {
1453                    Local0 = Acquire (TA02, 0x0000)
1454                }
1455                ElseIf ((Arg2 == TOV1))
1456                {
1457                    Local0 = Acquire (TA02, 0x0001)
1458                }
1459                Else
1460                {
1461                    Local0 = Acquire (TA02, 0xFFFF)
1462                }
1463            }
1464            Case (0x03)
1465            {
1466                If (Arg1)
1467                {
1468                    Acquire (TA03, 0xFFFF)
1469                }
1470                ElseIf ((Arg2 == TOV0))
1471                {
1472                    Local0 = Acquire (TA03, 0x0000)
1473                }
1474                ElseIf ((Arg2 == TOV1))
1475                {
1476                    Local0 = Acquire (TA03, 0x0001)
1477                }
1478                Else
1479                {
1480                    Local0 = Acquire (TA03, 0xFFFF)
1481                }
1482            }
1483
1484        }
1485
1486        Return (Local0)
1487    }
1488
1489    /*
1490     * Acquire mutex of level 11
1491     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1492     */
1493    Method (MA0B, 3, Serialized)
1494    {
1495        Local0 = 0x01
1496        Switch (ToInteger (Arg0))
1497        {
1498            Case (0x00)
1499            {
1500                If (Arg1)
1501                {
1502                    Acquire (TB00, 0xFFFF)
1503                }
1504                ElseIf ((Arg2 == TOV0))
1505                {
1506                    Local0 = Acquire (TB00, 0x0000)
1507                }
1508                ElseIf ((Arg2 == TOV1))
1509                {
1510                    Local0 = Acquire (TB00, 0x0001)
1511                }
1512                Else
1513                {
1514                    Local0 = Acquire (TB00, 0xFFFF)
1515                }
1516            }
1517            Case (0x01)
1518            {
1519                If (Arg1)
1520                {
1521                    Acquire (TB01, 0xFFFF)
1522                }
1523                ElseIf ((Arg2 == TOV0))
1524                {
1525                    Local0 = Acquire (TB01, 0x0000)
1526                }
1527                ElseIf ((Arg2 == TOV1))
1528                {
1529                    Local0 = Acquire (TB01, 0x0001)
1530                }
1531                Else
1532                {
1533                    Local0 = Acquire (TB01, 0xFFFF)
1534                }
1535            }
1536            Case (0x02)
1537            {
1538                If (Arg1)
1539                {
1540                    Acquire (TB02, 0xFFFF)
1541                }
1542                ElseIf ((Arg2 == TOV0))
1543                {
1544                    Local0 = Acquire (TB02, 0x0000)
1545                }
1546                ElseIf ((Arg2 == TOV1))
1547                {
1548                    Local0 = Acquire (TB02, 0x0001)
1549                }
1550                Else
1551                {
1552                    Local0 = Acquire (TB02, 0xFFFF)
1553                }
1554            }
1555            Case (0x03)
1556            {
1557                If (Arg1)
1558                {
1559                    Acquire (TB03, 0xFFFF)
1560                }
1561                ElseIf ((Arg2 == TOV0))
1562                {
1563                    Local0 = Acquire (TB03, 0x0000)
1564                }
1565                ElseIf ((Arg2 == TOV1))
1566                {
1567                    Local0 = Acquire (TB03, 0x0001)
1568                }
1569                Else
1570                {
1571                    Local0 = Acquire (TB03, 0xFFFF)
1572                }
1573            }
1574
1575        }
1576
1577        Return (Local0)
1578    }
1579
1580    /*
1581     * Acquire mutex of level 12
1582     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1583     */
1584    Method (MA0C, 3, Serialized)
1585    {
1586        Local0 = 0x01
1587        Switch (ToInteger (Arg0))
1588        {
1589            Case (0x00)
1590            {
1591                If (Arg1)
1592                {
1593                    Acquire (TC00, 0xFFFF)
1594                }
1595                ElseIf ((Arg2 == TOV0))
1596                {
1597                    Local0 = Acquire (TC00, 0x0000)
1598                }
1599                ElseIf ((Arg2 == TOV1))
1600                {
1601                    Local0 = Acquire (TC00, 0x0001)
1602                }
1603                Else
1604                {
1605                    Local0 = Acquire (TC00, 0xFFFF)
1606                }
1607            }
1608            Case (0x01)
1609            {
1610                If (Arg1)
1611                {
1612                    Acquire (TC01, 0xFFFF)
1613                }
1614                ElseIf ((Arg2 == TOV0))
1615                {
1616                    Local0 = Acquire (TC01, 0x0000)
1617                }
1618                ElseIf ((Arg2 == TOV1))
1619                {
1620                    Local0 = Acquire (TC01, 0x0001)
1621                }
1622                Else
1623                {
1624                    Local0 = Acquire (TC01, 0xFFFF)
1625                }
1626            }
1627            Case (0x02)
1628            {
1629                If (Arg1)
1630                {
1631                    Acquire (TC02, 0xFFFF)
1632                }
1633                ElseIf ((Arg2 == TOV0))
1634                {
1635                    Local0 = Acquire (TC02, 0x0000)
1636                }
1637                ElseIf ((Arg2 == TOV1))
1638                {
1639                    Local0 = Acquire (TC02, 0x0001)
1640                }
1641                Else
1642                {
1643                    Local0 = Acquire (TC02, 0xFFFF)
1644                }
1645            }
1646            Case (0x03)
1647            {
1648                If (Arg1)
1649                {
1650                    Acquire (TC03, 0xFFFF)
1651                }
1652                ElseIf ((Arg2 == TOV0))
1653                {
1654                    Local0 = Acquire (TC03, 0x0000)
1655                }
1656                ElseIf ((Arg2 == TOV1))
1657                {
1658                    Local0 = Acquire (TC03, 0x0001)
1659                }
1660                Else
1661                {
1662                    Local0 = Acquire (TC03, 0xFFFF)
1663                }
1664            }
1665
1666        }
1667
1668        Return (Local0)
1669    }
1670
1671    /*
1672     * Acquire mutex of level 13
1673     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1674     */
1675    Method (MA0D, 3, Serialized)
1676    {
1677        Local0 = 0x01
1678        Switch (ToInteger (Arg0))
1679        {
1680            Case (0x00)
1681            {
1682                If (Arg1)
1683                {
1684                    Acquire (TD00, 0xFFFF)
1685                }
1686                ElseIf ((Arg2 == TOV0))
1687                {
1688                    Local0 = Acquire (TD00, 0x0000)
1689                }
1690                ElseIf ((Arg2 == TOV1))
1691                {
1692                    Local0 = Acquire (TD00, 0x0001)
1693                }
1694                Else
1695                {
1696                    Local0 = Acquire (TD00, 0xFFFF)
1697                }
1698            }
1699            Case (0x01)
1700            {
1701                If (Arg1)
1702                {
1703                    Acquire (TD01, 0xFFFF)
1704                }
1705                ElseIf ((Arg2 == TOV0))
1706                {
1707                    Local0 = Acquire (TD01, 0x0000)
1708                }
1709                ElseIf ((Arg2 == TOV1))
1710                {
1711                    Local0 = Acquire (TD01, 0x0001)
1712                }
1713                Else
1714                {
1715                    Local0 = Acquire (TD01, 0xFFFF)
1716                }
1717            }
1718            Case (0x02)
1719            {
1720                If (Arg1)
1721                {
1722                    Acquire (TD02, 0xFFFF)
1723                }
1724                ElseIf ((Arg2 == TOV0))
1725                {
1726                    Local0 = Acquire (TD02, 0x0000)
1727                }
1728                ElseIf ((Arg2 == TOV1))
1729                {
1730                    Local0 = Acquire (TD02, 0x0001)
1731                }
1732                Else
1733                {
1734                    Local0 = Acquire (TD02, 0xFFFF)
1735                }
1736            }
1737            Case (0x03)
1738            {
1739                If (Arg1)
1740                {
1741                    Acquire (TD03, 0xFFFF)
1742                }
1743                ElseIf ((Arg2 == TOV0))
1744                {
1745                    Local0 = Acquire (TD03, 0x0000)
1746                }
1747                ElseIf ((Arg2 == TOV1))
1748                {
1749                    Local0 = Acquire (TD03, 0x0001)
1750                }
1751                Else
1752                {
1753                    Local0 = Acquire (TD03, 0xFFFF)
1754                }
1755            }
1756
1757        }
1758
1759        Return (Local0)
1760    }
1761
1762    /*
1763     * Acquire mutex of level 14
1764     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1765     */
1766    Method (MA0E, 3, Serialized)
1767    {
1768        Local0 = 0x01
1769        Switch (ToInteger (Arg0))
1770        {
1771            Case (0x00)
1772            {
1773                If (Arg1)
1774                {
1775                    Acquire (TE00, 0xFFFF)
1776                }
1777                ElseIf ((Arg2 == TOV0))
1778                {
1779                    Local0 = Acquire (TE00, 0x0000)
1780                }
1781                ElseIf ((Arg2 == TOV1))
1782                {
1783                    Local0 = Acquire (TE00, 0x0001)
1784                }
1785                Else
1786                {
1787                    Local0 = Acquire (TE00, 0xFFFF)
1788                }
1789            }
1790            Case (0x01)
1791            {
1792                If (Arg1)
1793                {
1794                    Acquire (TE01, 0xFFFF)
1795                }
1796                ElseIf ((Arg2 == TOV0))
1797                {
1798                    Local0 = Acquire (TE01, 0x0000)
1799                }
1800                ElseIf ((Arg2 == TOV1))
1801                {
1802                    Local0 = Acquire (TE01, 0x0001)
1803                }
1804                Else
1805                {
1806                    Local0 = Acquire (TE01, 0xFFFF)
1807                }
1808            }
1809            Case (0x02)
1810            {
1811                If (Arg1)
1812                {
1813                    Acquire (TE02, 0xFFFF)
1814                }
1815                ElseIf ((Arg2 == TOV0))
1816                {
1817                    Local0 = Acquire (TE02, 0x0000)
1818                }
1819                ElseIf ((Arg2 == TOV1))
1820                {
1821                    Local0 = Acquire (TE02, 0x0001)
1822                }
1823                Else
1824                {
1825                    Local0 = Acquire (TE02, 0xFFFF)
1826                }
1827            }
1828            Case (0x03)
1829            {
1830                If (Arg1)
1831                {
1832                    Acquire (TE03, 0xFFFF)
1833                }
1834                ElseIf ((Arg2 == TOV0))
1835                {
1836                    Local0 = Acquire (TE03, 0x0000)
1837                }
1838                ElseIf ((Arg2 == TOV1))
1839                {
1840                    Local0 = Acquire (TE03, 0x0001)
1841                }
1842                Else
1843                {
1844                    Local0 = Acquire (TE03, 0xFFFF)
1845                }
1846            }
1847
1848        }
1849
1850        Return (Local0)
1851    }
1852
1853    /*
1854     * Acquire mutex of level 15
1855     * (Index of mux, opcode of exception to be generated or zero, opcode of TimeOutValue)
1856     */
1857    Method (MA0F, 3, Serialized)
1858    {
1859        Local0 = 0x01
1860        Switch (ToInteger (Arg0))
1861        {
1862            Case (0x00)
1863            {
1864                If (Arg1)
1865                {
1866                    Acquire (TF00, 0xFFFF)
1867                }
1868                ElseIf ((Arg2 == TOV0))
1869                {
1870                    Local0 = Acquire (TF00, 0x0000)
1871                }
1872                ElseIf ((Arg2 == TOV1))
1873                {
1874                    Local0 = Acquire (TF00, 0x0001)
1875                }
1876                Else
1877                {
1878                    Local0 = Acquire (TF00, 0xFFFF)
1879                }
1880            }
1881            Case (0x01)
1882            {
1883                If (Arg1)
1884                {
1885                    Acquire (TF01, 0xFFFF)
1886                }
1887                ElseIf ((Arg2 == TOV0))
1888                {
1889                    Local0 = Acquire (TF01, 0x0000)
1890                }
1891                ElseIf ((Arg2 == TOV1))
1892                {
1893                    Local0 = Acquire (TF01, 0x0001)
1894                }
1895                Else
1896                {
1897                    Local0 = Acquire (TF01, 0xFFFF)
1898                }
1899            }
1900            Case (0x02)
1901            {
1902                If (Arg1)
1903                {
1904                    Acquire (TF02, 0xFFFF)
1905                }
1906                ElseIf ((Arg2 == TOV0))
1907                {
1908                    Local0 = Acquire (TF02, 0x0000)
1909                }
1910                ElseIf ((Arg2 == TOV1))
1911                {
1912                    Local0 = Acquire (TF02, 0x0001)
1913                }
1914                Else
1915                {
1916                    Local0 = Acquire (TF02, 0xFFFF)
1917                }
1918            }
1919            Case (0x03)
1920            {
1921                If (Arg1)
1922                {
1923                    Acquire (TF03, 0xFFFF)
1924                }
1925                ElseIf ((Arg2 == TOV0))
1926                {
1927                    Local0 = Acquire (TF03, 0x0000)
1928                }
1929                ElseIf ((Arg2 == TOV1))
1930                {
1931                    Local0 = Acquire (TF03, 0x0001)
1932                }
1933                Else
1934                {
1935                    Local0 = Acquire (TF03, 0xFFFF)
1936                }
1937            }
1938
1939        }
1940
1941        Return (Local0)
1942    }
1943
1944    /*
1945     * Release mutex of level 0
1946     *
1947     * arg0 - Index of mutex
1948     */
1949    Method (MA10, 1, Serialized)
1950    {
1951        Switch (ToInteger (Arg0))
1952        {
1953            Case (0x00)
1954            {
1955                Release (T000)
1956            }
1957            Case (0x01)
1958            {
1959                If (GL00)
1960                {
1961                    Release (\_GL)
1962                }
1963                Else
1964                {
1965                    Release (T001)
1966                }
1967            }
1968            Case (0x02)
1969            {
1970                Release (T002)
1971            }
1972            Case (0x03)
1973            {
1974                Release (T003)
1975            }
1976            Case (0x04)
1977            {
1978                Release (T004)
1979            }
1980            Case (0x05)
1981            {
1982                Release (T005)
1983            }
1984            Case (0x06)
1985            {
1986                Release (T006)
1987            }
1988            Case (0x07)
1989            {
1990                Release (T007)
1991            }
1992            Case (0x08)
1993            {
1994                Release (T008)
1995            }
1996            Case (0x09)
1997            {
1998                Release (T009)
1999            }
2000            Case (0x0A)
2001            {
2002                Release (T00A)
2003            }
2004            Case (0x0B)
2005            {
2006                Release (T00B)
2007            }
2008            Case (0x0C)
2009            {
2010                Release (T00C)
2011            }
2012            Case (0x0D)
2013            {
2014                Release (T00D)
2015            }
2016            Case (0x0E)
2017            {
2018                Release (T00E)
2019            }
2020            Case (0x0F)
2021            {
2022                Release (T00F)
2023            }
2024            Case (0x10)
2025            {
2026                Release (T010)
2027            }
2028            Case (0x11)
2029            {
2030                Release (T011)
2031            }
2032
2033        }
2034    }
2035
2036    /*
2037     * Release mutex of level 1 (Index of mux)
2038     */
2039    Method (MA11, 1, Serialized)
2040    {
2041        Switch (ToInteger (Arg0))
2042        {
2043            Case (0x00)
2044            {
2045                Release (T100)
2046            }
2047            Case (0x01)
2048            {
2049                Release (T101)
2050            }
2051            Case (0x02)
2052            {
2053                Release (T102)
2054            }
2055            Case (0x03)
2056            {
2057                Release (T103)
2058            }
2059
2060        }
2061    }
2062
2063    /*
2064     * Release mutex of level 2 (Index of mux)
2065     */
2066    Method (MA12, 1, Serialized)
2067    {
2068        Switch (ToInteger (Arg0))
2069        {
2070            Case (0x00)
2071            {
2072                Release (T200)
2073            }
2074            Case (0x01)
2075            {
2076                Release (T201)
2077            }
2078            Case (0x02)
2079            {
2080                Release (T202)
2081            }
2082            Case (0x03)
2083            {
2084                Release (T203)
2085            }
2086
2087        }
2088    }
2089
2090    /*
2091     * Release mutex of level 3 (Index of mux)
2092     */
2093    Method (MA13, 1, Serialized)
2094    {
2095        Switch (ToInteger (Arg0))
2096        {
2097            Case (0x00)
2098            {
2099                Release (T300)
2100            }
2101            Case (0x01)
2102            {
2103                Release (T301)
2104            }
2105            Case (0x02)
2106            {
2107                Release (T302)
2108            }
2109            Case (0x03)
2110            {
2111                Release (T303)
2112            }
2113
2114        }
2115    }
2116
2117    /*
2118     * Release mutex of level 4 (Index of mux)
2119     */
2120    Method (MA14, 1, Serialized)
2121    {
2122        Switch (ToInteger (Arg0))
2123        {
2124            Case (0x00)
2125            {
2126                Release (T400)
2127            }
2128            Case (0x01)
2129            {
2130                Release (T401)
2131            }
2132            Case (0x02)
2133            {
2134                Release (T402)
2135            }
2136            Case (0x03)
2137            {
2138                Release (T403)
2139            }
2140
2141        }
2142    }
2143
2144    /*
2145     * Release mutex of level 5 (Index of mux)
2146     */
2147    Method (MA15, 1, Serialized)
2148    {
2149        Switch (ToInteger (Arg0))
2150        {
2151            Case (0x00)
2152            {
2153                Release (T500)
2154            }
2155            Case (0x01)
2156            {
2157                Release (T501)
2158            }
2159            Case (0x02)
2160            {
2161                Release (T502)
2162            }
2163            Case (0x03)
2164            {
2165                Release (T503)
2166            }
2167
2168        }
2169    }
2170
2171    /*
2172     * Release mutex of level 6 (Index of mux)
2173     */
2174    Method (MA16, 1, Serialized)
2175    {
2176        Switch (ToInteger (Arg0))
2177        {
2178            Case (0x00)
2179            {
2180                Release (T600)
2181            }
2182            Case (0x01)
2183            {
2184                Release (T601)
2185            }
2186            Case (0x02)
2187            {
2188                Release (T602)
2189            }
2190            Case (0x03)
2191            {
2192                Release (T603)
2193            }
2194
2195        }
2196    }
2197
2198    /*
2199     * Release mutex of level 7 (Index of mux)
2200     */
2201    Method (MA17, 1, Serialized)
2202    {
2203        Switch (ToInteger (Arg0))
2204        {
2205            Case (0x00)
2206            {
2207                Release (T700)
2208            }
2209            Case (0x01)
2210            {
2211                Release (T701)
2212            }
2213            Case (0x02)
2214            {
2215                Release (T702)
2216            }
2217            Case (0x03)
2218            {
2219                Release (T703)
2220            }
2221
2222        }
2223    }
2224
2225    /*
2226     * Release mutex of level 8 (Index of mux)
2227     */
2228    Method (MA18, 1, Serialized)
2229    {
2230        Switch (ToInteger (Arg0))
2231        {
2232            Case (0x00)
2233            {
2234                Release (T800)
2235            }
2236            Case (0x01)
2237            {
2238                Release (T801)
2239            }
2240            Case (0x02)
2241            {
2242                Release (T802)
2243            }
2244            Case (0x03)
2245            {
2246                Release (T803)
2247            }
2248
2249        }
2250    }
2251
2252    /*
2253     * Release mutex of level 9 (Index of mux)
2254     */
2255    Method (MA19, 1, Serialized)
2256    {
2257        Switch (ToInteger (Arg0))
2258        {
2259            Case (0x00)
2260            {
2261                Release (T900)
2262            }
2263            Case (0x01)
2264            {
2265                Release (T901)
2266            }
2267            Case (0x02)
2268            {
2269                Release (T902)
2270            }
2271            Case (0x03)
2272            {
2273                Release (T903)
2274            }
2275
2276        }
2277    }
2278
2279    /*
2280     * Release mutex of level 10 (Index of mux)
2281     */
2282    Method (MA1A, 1, Serialized)
2283    {
2284        Switch (ToInteger (Arg0))
2285        {
2286            Case (0x00)
2287            {
2288                Release (TA00)
2289            }
2290            Case (0x01)
2291            {
2292                Release (TA01)
2293            }
2294            Case (0x02)
2295            {
2296                Release (TA02)
2297            }
2298            Case (0x03)
2299            {
2300                Release (TA03)
2301            }
2302
2303        }
2304    }
2305
2306    /*
2307     * Release mutex of level 11 (Index of mux)
2308     */
2309    Method (MA1B, 1, Serialized)
2310    {
2311        Switch (ToInteger (Arg0))
2312        {
2313            Case (0x00)
2314            {
2315                Release (TB00)
2316            }
2317            Case (0x01)
2318            {
2319                Release (TB01)
2320            }
2321            Case (0x02)
2322            {
2323                Release (TB02)
2324            }
2325            Case (0x03)
2326            {
2327                Release (TB03)
2328            }
2329
2330        }
2331    }
2332
2333    /*
2334     * Release mutex of level 12 (Index of mux)
2335     */
2336    Method (MA1C, 1, Serialized)
2337    {
2338        Switch (ToInteger (Arg0))
2339        {
2340            Case (0x00)
2341            {
2342                Release (TC00)
2343            }
2344            Case (0x01)
2345            {
2346                Release (TC01)
2347            }
2348            Case (0x02)
2349            {
2350                Release (TC02)
2351            }
2352            Case (0x03)
2353            {
2354                Release (TC03)
2355            }
2356
2357        }
2358    }
2359
2360    /*
2361     * Release mutex of level 13 (Index of mux)
2362     */
2363    Method (MA1D, 1, Serialized)
2364    {
2365        Switch (ToInteger (Arg0))
2366        {
2367            Case (0x00)
2368            {
2369                Release (TD00)
2370            }
2371            Case (0x01)
2372            {
2373                Release (TD01)
2374            }
2375            Case (0x02)
2376            {
2377                Release (TD02)
2378            }
2379            Case (0x03)
2380            {
2381                Release (TD03)
2382            }
2383
2384        }
2385    }
2386
2387    /*
2388     * Release mutex of level 14 (Index of mux)
2389     */
2390    Method (MA1E, 1, Serialized)
2391    {
2392        Switch (ToInteger (Arg0))
2393        {
2394            Case (0x00)
2395            {
2396                Release (TE00)
2397            }
2398            Case (0x01)
2399            {
2400                Release (TE01)
2401            }
2402            Case (0x02)
2403            {
2404                Release (TE02)
2405            }
2406            Case (0x03)
2407            {
2408                Release (TE03)
2409            }
2410
2411        }
2412    }
2413
2414    /*
2415     * Release mutex of level 15 (Index of mux)
2416     */
2417    Method (MA1F, 1, Serialized)
2418    {
2419        Switch (ToInteger (Arg0))
2420        {
2421            Case (0x00)
2422            {
2423                Release (TF00)
2424            }
2425            Case (0x01)
2426            {
2427                Release (TF01)
2428            }
2429            Case (0x02)
2430            {
2431                Release (TF02)
2432            }
2433            Case (0x03)
2434            {
2435                Release (TF03)
2436            }
2437
2438        }
2439    }
2440
2441    /*
2442     * Get name of mutex
2443     *
2444     * arg0 - string
2445     * arg1 - Level of mutex
2446     * arg2 - Index of mutex
2447     */
2448    Method (M21E, 3, NotSerialized)
2449    {
2450        Concatenate (Arg0, "Level ", Local0)
2451        Concatenate (Local0, Arg1, Local1)
2452        Concatenate (Local1, ", Index ", Local0)
2453        Concatenate (Local0, Arg2, Local1)
2454        If ((Arg1 == GLLL))
2455        {
2456            If ((Arg2 == GLIX))
2457            {
2458                If (GL00)
2459                {
2460                    Concatenate (Local1, " (Global lock)", Local1)
2461                }
2462            }
2463        }
2464
2465        Return (Local1)
2466    }
2467