Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1498 | serge | 1 | /* |
2 | * Some or all of this work - Copyright (c) 2006 - 2010, Intel Corp. |
||
3 | * All rights reserved. |
||
4 | * |
||
5 | * Redistribution and use in source and binary forms, with or without modification, |
||
6 | * are permitted provided that the following conditions are met: |
||
7 | * |
||
8 | * Redistributions of source code must retain the above copyright notice, |
||
9 | * this list of conditions and the following disclaimer. |
||
10 | * Redistributions in binary form must reproduce the above copyright notice, |
||
11 | * this list of conditions and the following disclaimer in the documentation |
||
12 | * and/or other materials provided with the distribution. |
||
13 | * Neither the name of Intel Corporation nor the names of its contributors |
||
14 | * may be used to endorse or promote products derived from this software |
||
15 | * without specific prior written permission. |
||
16 | * |
||
17 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||
18 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||
19 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||
20 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
||
21 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
||
22 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||
23 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
||
25 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
||
26 | * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
27 | */ |
||
28 | |||
29 | // |
||
30 | // |
||
31 | // Grammar.asl - Minimally excercises most ASL constructs |
||
32 | // |
||
33 | // NOTE -- use: iasl -f -of grammar.asl to compile |
||
34 | // |
||
35 | // This 1) Ignores errors (checks compiler error handling) |
||
36 | // 2) Disables constant folding |
||
37 | // |
||
38 | // |
||
39 | |||
40 | /******************************************************************************* |
||
41 | Compilation should look like this: |
||
42 | |||
43 | C:\acpica\tests\misc>iasl -f -of grammar.asl |
||
44 | |||
45 | Intel ACPI Component Architecture |
||
46 | ASL Optimizing Compiler version 20090422 [Apr 22 2009] |
||
47 | Copyright (C) 2000 - 2009 Intel Corporation |
||
48 | Supports ACPI Specification Revision 3.0a |
||
49 | |||
50 | grammar.asl 187: Name (_NPK, Package (8) |
||
51 | Warning 1098 - ^ Unknown reserved name (_NPK) |
||
52 | |||
53 | grammar.asl 510: NAME (ESC1, "abcdefg\x00hijklmn") |
||
54 | Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL |
||
55 | |||
56 | grammar.asl 511: NAME (ESC2, "abcdefg\000hijklmn") |
||
57 | Warning 1042 - ^ Invalid Hex/Octal Escape - Non-ASCII or NULL |
||
58 | |||
59 | grammar.asl 601: Method (RCIV, 1) |
||
60 | Warning 1087 - ^ Not all control paths return a value (RCIV) |
||
61 | |||
62 | grammar.asl 608: RCIV (Subtract (Arg0, 1)) |
||
63 | Remark 5073 - ^ Recursive method call (RCIV) |
||
64 | |||
65 | grammar.asl 937: Method (_ERR, 2) |
||
66 | Warning 1077 - ^ Reserved method has too few arguments (_ERR requires 3) |
||
67 | |||
68 | grammar.asl 1377: Store (0x1234567887654321, QWD2) |
||
69 | Warning 1032 - ^ 64-bit integer in 32-bit table, truncating |
||
70 | |||
71 | grammar.asl 1379: if (LNotEqual (Local0, 0x1234567887654321)) |
||
72 | Warning 1032 - 64-bit integer in 32-bit table, truncating ^ |
||
73 | |||
74 | grammar.asl 1459: SizeOf (BUFO) |
||
75 | Warning 1105 - ^ Result is not used, operator has no effect |
||
76 | |||
77 | grammar.asl 1485: Acquire (MTX2, 1) |
||
78 | Warning 1104 - ^ Possible operator timeout is ignored |
||
79 | |||
80 | grammar.asl 1633: Add (Local0, Local1) |
||
81 | Warning 1105 - ^ Result is not used, operator has no effect |
||
82 | |||
83 | grammar.asl 1804: Method (COND) |
||
84 | Warning 1087 - ^ Not all control paths return a value (COND) |
||
85 | |||
86 | grammar.asl 6010: Name (_HID, "*PNP0A06") |
||
87 | Error 4001 - ^ String must be entirely alphanumeric (*PNP0A06) |
||
88 | |||
89 | grammar.asl 6461: Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."}) |
||
90 | Warning 1038 - Invalid or unknown escape sequence ^ |
||
91 | |||
92 | grammar.asl 6800: And (Local0, 1, Local0) // Local0 &= 1 |
||
93 | Error 4050 - ^ Method local variable is not initialized (Local0) |
||
94 | |||
95 | grammar.asl 6886: Name (_HID, "*PNP0C0A") // Control Method Battey ID |
||
96 | Error 4001 - ^ String must be entirely alphanumeric (*PNP0C0A) |
||
97 | |||
98 | ASL Input: grammar.asl - 10254 lines, 322162 bytes, 4810 keywords |
||
99 | AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes |
||
100 | |||
101 | Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations |
||
102 | |||
103 | ***************************************************************************************************/ |
||
104 | |||
105 | DefinitionBlock ( |
||
106 | "grammar.aml", //Output filename |
||
107 | "DSDT", //Signature |
||
108 | 0x01, //DSDT Revision ---> 32-bit table |
||
109 | "Intel", //OEMID |
||
110 | "GRMTEST", //TABLE ID |
||
111 | 0x20090511 //OEM Revision |
||
112 | ) |
||
113 | { |
||
114 | |||
115 | External (\ABCD, UnknownObj) |
||
116 | |||
117 | |||
118 | /* Device with _STA and _INI */ |
||
119 | |||
120 | Device (A1) |
||
121 | { |
||
122 | Method (_STA) |
||
123 | { |
||
124 | Return (0x0F) |
||
125 | } |
||
126 | |||
127 | Method (_INI) |
||
128 | { |
||
129 | Return |
||
130 | } |
||
131 | } |
||
132 | |||
133 | /* Device with no _STA, has _INI */ |
||
134 | |||
135 | Device (A2) |
||
136 | { |
||
137 | Method (_INI) |
||
138 | { |
||
139 | Return |
||
140 | } |
||
141 | } |
||
142 | |||
143 | /* Device with _STA, no _INI */ |
||
144 | |||
145 | Device (A3) |
||
146 | { |
||
147 | Method (_STA) |
||
148 | { |
||
149 | Return (0x0F) |
||
150 | } |
||
151 | } |
||
152 | |||
153 | /* Device with _STA and _INI, but not present */ |
||
154 | |||
155 | Device (A4) |
||
156 | { |
||
157 | Method (_STA) |
||
158 | { |
||
159 | Return (Zero) |
||
160 | } |
||
161 | |||
162 | Method (_INI) |
||
163 | { |
||
164 | Return |
||
165 | } |
||
166 | } |
||
167 | |||
168 | |||
169 | /* Resource descriptors */ |
||
170 | |||
171 | Device (IRES) |
||
172 | { |
||
173 | Name (PRT0, ResourceTemplate () |
||
174 | { |
||
175 | IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15} |
||
176 | |||
177 | StartDependentFn (1,1) |
||
178 | { |
||
179 | IRQNoFlags () {0,1,2} |
||
180 | } |
||
181 | EndDependentFn () |
||
182 | }) |
||
183 | |||
184 | Method (_CRS, 0, NotSerialized) |
||
185 | { |
||
186 | Store ("_CRS:", Debug) |
||
187 | Store (PRT0, Debug) |
||
188 | Return (PRT0) |
||
189 | } |
||
190 | |||
191 | Method (_SRS, 1, Serialized) |
||
192 | { |
||
193 | Store ("_SRS:", Debug) |
||
194 | Store (Arg0, Debug) |
||
195 | Return (Zero) |
||
196 | } |
||
197 | } |
||
198 | |||
199 | Name (_NPK, Package () |
||
200 | { |
||
201 | 0x1111, |
||
202 | 0x2222, |
||
203 | 0x3333, |
||
204 | 0x4444 |
||
205 | }) |
||
206 | |||
207 | |||
208 | Device (RES) |
||
209 | { |
||
210 | Name (_PRT, Package (0x04) |
||
211 | { |
||
212 | Package (0x04) |
||
213 | { |
||
214 | 0x0002FFFF, |
||
215 | Zero, |
||
216 | Zero, |
||
217 | Zero |
||
218 | }, |
||
219 | |||
220 | Package (0x04) |
||
221 | { |
||
222 | 0x0002FFFF, |
||
223 | One, |
||
224 | Zero, |
||
225 | Zero |
||
226 | }, |
||
227 | |||
228 | Package (0x04) |
||
229 | { |
||
230 | 0x000AFFFF, |
||
231 | Zero, |
||
232 | Zero, |
||
233 | Zero |
||
234 | }, |
||
235 | |||
236 | Package (0x04) |
||
237 | { |
||
238 | 0x000BFFFF, |
||
239 | Zero, |
||
240 | Zero, |
||
241 | Zero |
||
242 | } |
||
243 | }) |
||
244 | |||
245 | Method (_CRS, 0, NotSerialized) |
||
246 | { |
||
247 | Name (PRT0, ResourceTemplate () |
||
248 | { |
||
249 | WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode, |
||
250 | 0x0000, // Address Space Granularity |
||
251 | 0xFFF2, // Address Range Minimum |
||
252 | 0xFFF3, // Address Range Maximum |
||
253 | 0x0032, // Address Translation Offset |
||
254 | 0x0002,,,) |
||
255 | WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, |
||
256 | 0x0000, // Address Space Granularity |
||
257 | 0x0000, // Address Range Minimum |
||
258 | 0x00FF, // Address Range Maximum |
||
259 | 0x0000, // Address Translation Offset |
||
260 | 0x0100,,,) |
||
261 | WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5, |
||
262 | 0x0000, // Address Space Granularity |
||
263 | 0xA000, // Address Range Minimum |
||
264 | 0xBFFF, // Address Range Maximum |
||
265 | 0x0000, // Address Translation Offset |
||
266 | 0x2000,,,) |
||
267 | IO (Decode16, 0x0CF8, 0x0CFF, 0x01, 0x08) |
||
268 | WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
||
269 | 0x0000, // Address Space Granularity |
||
270 | 0x0000, // Address Range Minimum |
||
271 | 0x0CF7, // Address Range Maximum |
||
272 | 0x0000, // Address Translation Offset |
||
273 | 0x0CF8,,, |
||
274 | , TypeStatic) |
||
275 | WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
||
276 | 0x0000, // Address Space Granularity |
||
277 | 0x0D00, // Address Range Minimum |
||
278 | 0xFFFF, // Address Range Maximum |
||
279 | 0x0000, // Address Translation Offset |
||
280 | 0xF300,,, |
||
281 | , TypeStatic) |
||
282 | DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
||
283 | 0x00000000, // Address Space Granularity |
||
284 | 0x00000000, // Address Range Minimum |
||
285 | 0x00000CF7, // Address Range Maximum |
||
286 | 0x00000000, // Address Translation Offset |
||
287 | 0x00000CF8,,, |
||
288 | , TypeStatic) |
||
289 | DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
||
290 | 0x00000000, // Address Space Granularity |
||
291 | 0x000C8000, // Address Range Minimum |
||
292 | 0x000EFFFF, // Address Range Maximum |
||
293 | 0x00000000, // Address Translation Offset |
||
294 | 0x00028000,,, |
||
295 | , AddressRangeMemory, TypeStatic) |
||
296 | DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5, |
||
297 | 0x00000000, // Address Space Granularity |
||
298 | 0x000C8000, // Address Range Minimum |
||
299 | 0x000EFFFF, // Address Range Maximum |
||
300 | 0x00000000, // Address Translation Offset |
||
301 | 0x00028000,,,) |
||
302 | QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
||
303 | 0x0000000000000000, // Address Space Granularity |
||
304 | 0x0000000000000000, // Address Range Minimum |
||
305 | 0x0000000000000CF7, // Address Range Maximum |
||
306 | 0x0000000000000000, // Address Translation Offset |
||
307 | 0x0000000000000CF8, 0x44, "This is a ResouceSource string", |
||
308 | , TypeStatic) |
||
309 | QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
||
310 | 0x0000000000000000, // Address Space Granularity |
||
311 | 0x0000000000000000, // Address Range Minimum |
||
312 | 0x0000000000000CF7, // Address Range Maximum |
||
313 | 0x0000000000000000, // Address Translation Offset |
||
314 | 0x0000000000000CF8,,, |
||
315 | , TypeStatic) |
||
316 | QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
||
317 | 0x0000000000000000, // Address Space Granularity |
||
318 | 0x0000000000100000, // Address Range Minimum |
||
319 | 0x00000000FFDFFFFF, // Address Range Maximum |
||
320 | 0x0000000000000000, // Address Translation Offset |
||
321 | 0x00000000FFD00000,,, |
||
322 | , AddressRangeMemory, TypeStatic) |
||
323 | QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5, |
||
324 | 0x0000000000000000, // Address Space Granularity |
||
325 | 0x0000000000000000, // Address Range Minimum |
||
326 | 0x0000000000000CF7, // Address Range Maximum |
||
327 | 0x0000000000000000, // Address Translation Offset |
||
328 | 0x0000000000000CF8,,,) |
||
329 | ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
||
330 | 0x0000000000000000, // Address Space Granularity |
||
331 | 0x0000000000000000, // Address Range Minimum |
||
332 | 0x0000000000000CF7, // Address Range Maximum |
||
333 | 0x0000000000000000, // Address Translation Offset |
||
334 | 0x0000000000000CF8, // Address Length |
||
335 | 0x0000000000000000, // Type Specific Attributes |
||
336 | , TypeStatic) |
||
337 | ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
||
338 | 0x0000000000000000, // Address Space Granularity |
||
339 | 0x0000000000100000, // Address Range Minimum |
||
340 | 0x00000000FFDFFFFF, // Address Range Maximum |
||
341 | 0x0000000000000000, // Address Translation Offset |
||
342 | 0x00000000FFD00000, // Address Length |
||
343 | 0x0000000000000000, // Type Specific Attributes |
||
344 | , AddressRangeMemory, TypeStatic) |
||
345 | ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3, |
||
346 | 0x0000000000000000, // Address Space Granularity |
||
347 | 0x0000000000100000, // Address Range Minimum |
||
348 | 0x00000000FFDFFFFF, // Address Range Maximum |
||
349 | 0x0000000000000000, // Address Translation Offset |
||
350 | 0x00000000FFD00000, // Address Length |
||
351 | 0x0000000000000000) // Type Specific Attributes |
||
352 | IO (Decode16, 0x0010, 0x0020, 0x01, 0x10) |
||
353 | IO (Decode16, 0x0090, 0x00A0, 0x01, 0x10) |
||
354 | FixedIO (0x0061, 0x01) |
||
355 | IRQNoFlags () {2} |
||
356 | DMA (Compatibility, BusMaster, Transfer8_16) {4} |
||
357 | DMA (Compatibility, BusMaster, Transfer8) {2,5,7} |
||
358 | Memory32Fixed (ReadWrite, 0x00100000, 0x00000000) |
||
359 | Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000) |
||
360 | Memory32 (ReadOnly, 0x00020000, 0xFFFE0000, 0x00000004, 0x00000200) |
||
361 | Memory24 (ReadOnly, 0x1111, 0x2222, 0x0004, 0x0200) |
||
362 | Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0xE, "\\_SB_.TEST") |
||
363 | { |
||
364 | 0x00000E01, |
||
365 | } |
||
366 | Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx") |
||
367 | { |
||
368 | 0x00000601, |
||
369 | 0x00000003, |
||
370 | 0x00000002, |
||
371 | 0x00000001, |
||
372 | } |
||
373 | Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive) |
||
374 | { |
||
375 | 0xFFFF0000, |
||
376 | 0x00000003, |
||
377 | 0x00000002, |
||
378 | 0x00000001, |
||
379 | 0x00000005, |
||
380 | 0x00000007, |
||
381 | 0x00000009, |
||
382 | } |
||
383 | VendorShort () {0x01, 0x02, 0x03} |
||
384 | VendorLong () |
||
385 | { |
||
386 | 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
||
387 | 0x09 |
||
388 | } |
||
389 | Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000) |
||
390 | Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2) |
||
391 | StartDependentFnNoPri () |
||
392 | { |
||
393 | IRQNoFlags () {0,1,2} |
||
394 | IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15} |
||
395 | } |
||
396 | EndDependentFn () |
||
397 | }) |
||
398 | CreateWordField (PRT0, 0x08, BMIN) |
||
399 | CreateByteField (PRT0, R000._ASZ, RSIZ) |
||
400 | Store (0x03, BMIN) |
||
401 | Return (PRT0) |
||
402 | } |
||
403 | |||
404 | Method (_PRS, 0, NotSerialized) |
||
405 | { |
||
406 | Name (BUF0, ResourceTemplate () |
||
407 | { |
||
408 | StartDependentFn (0x01, 0x02) |
||
409 | { |
||
410 | IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08) |
||
411 | IRQNoFlags () {4} |
||
412 | } |
||
413 | StartDependentFn (0x02, 0x01) |
||
414 | { |
||
415 | IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08) |
||
416 | IRQNoFlags () {4} |
||
417 | } |
||
418 | StartDependentFn (0x00, 0x02) |
||
419 | { |
||
420 | IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08) |
||
421 | IRQNoFlags () {3} |
||
422 | } |
||
423 | StartDependentFn (0x00, 0x02) |
||
424 | { |
||
425 | IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08) |
||
426 | IRQNoFlags () {3} |
||
427 | } |
||
428 | StartDependentFn (0x02, 0x00) |
||
429 | { |
||
430 | IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08) |
||
431 | IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15} |
||
432 | } |
||
433 | EndDependentFn () |
||
434 | }) |
||
435 | Return (BUF0) |
||
436 | } |
||
437 | |||
438 | Method (_SRS, 1, Serialized) |
||
439 | { |
||
440 | Return (Zero) |
||
441 | } |
||
442 | } |
||
443 | |||
444 | |||
445 | Name(\_S0,Package(0x04){ |
||
446 | 0x00, |
||
447 | 0x00, |
||
448 | 0x00, |
||
449 | 0x00 |
||
450 | }) |
||
451 | Name(\_S3,Package(0x04){ |
||
452 | 0x05, |
||
453 | 0x05, |
||
454 | 0x00, |
||
455 | 0x00 |
||
456 | }) |
||
457 | Name(\_S4,Package(0x04){ |
||
458 | 0x06, |
||
459 | 0x06, |
||
460 | 0x00, |
||
461 | 0x00 |
||
462 | }) |
||
463 | Name(\_S5,Package(0x04){ |
||
464 | 0x07, |
||
465 | 0x07, |
||
466 | 0x00, |
||
467 | 0x00 |
||
468 | }) |
||
469 | |||
470 | /* Examine this table header (DSDT) */ |
||
471 | |||
472 | /* |
||
473 | DataTableRegion (HDR, "DSDT", "", "") |
||
474 | Field (HDR, AnyAcc, NoLock, Preserve) |
||
475 | { |
||
476 | SIG, 32, |
||
477 | LENG, 32, |
||
478 | REV, 8, |
||
479 | SUM, 8, |
||
480 | OID, 48, |
||
481 | OTID, 64, |
||
482 | OREV, 32, |
||
483 | CID, 32, |
||
484 | CREV, 32 |
||
485 | } |
||
486 | |||
487 | Method (SIZE) |
||
488 | { |
||
489 | If (LLess (REV, 2)) |
||
490 | { |
||
491 | Store ("32-bit table", Debug) |
||
492 | } |
||
493 | else |
||
494 | { |
||
495 | Store ("64-bit table", Debug) |
||
496 | } |
||
497 | Return (0) |
||
498 | } |
||
499 | |||
500 | */ |
||
501 | Name (SIZE, 0) |
||
502 | |||
503 | /* Custom operation region */ |
||
504 | |||
505 | OperationRegion(MYOP,0x80,0xFD60,0x6) |
||
506 | Field(MYOP,ByteAcc,NoLock,Preserve) |
||
507 | { |
||
508 | MFLD,8 |
||
509 | } |
||
510 | |||
511 | Method (TCOP) |
||
512 | { |
||
513 | Name (_STR, Unicode ("test")) |
||
514 | Store (4, MFLD) |
||
515 | Store (MFLD, Local0) |
||
516 | } |
||
517 | |||
518 | Name (ERRS, 0x0) |
||
519 | |||
520 | /* Warning should be issued for premature string termination */ |
||
521 | |||
522 | NAME (ESC1, "abcdefg\x00hijklmn") |
||
523 | NAME (ESC2, "abcdefg\000hijklmn") |
||
524 | Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\432") |
||
525 | |||
526 | |||
527 | Name(CRSA,ResourceTemplate() |
||
528 | { |
||
529 | WORDBusNumber(ResourceProducer,MinFixed,MaxFixed,PosDecode,0x0000,0x0019,0x001D,0x0000,0x0005) |
||
530 | WORDIO(ResourceProducer,MinFixed,MaxFixed,PosDecode,NonISAOnlyRanges,0x0000,0xC000,0xCFFF,0x0000,0x1000) |
||
531 | DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000) |
||
532 | |||
533 | }) |
||
534 | Name(CRSB,ResourceTemplate() |
||
535 | { |
||
536 | DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000) |
||
537 | |||
538 | }) |
||
539 | |||
540 | Name(CRSC,ResourceTemplate() |
||
541 | { |
||
542 | VendorShort () {0x1, 0x2, 0x3} |
||
543 | }) |
||
544 | Name(CRSD,ResourceTemplate() |
||
545 | { |
||
546 | VendorLong (VNDL) {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9} |
||
547 | }) |
||
548 | |||
549 | Name(CRSE,ResourceTemplate() |
||
550 | { |
||
551 | IRQNoFlags(){3,4,10,11} |
||
552 | IRQNoFlags(xxxt){3,4,10,11} |
||
553 | }) |
||
554 | Name(CRSR, Buffer (Add (SizeOf(CRSA),SizeOf(CRSB))){}) |
||
555 | Method(_CRS,0,NotSerialized) |
||
556 | { |
||
557 | Return(CRSR) |
||
558 | } |
||
559 | |||
560 | |||
561 | // |
||
562 | // Unnamed scope |
||
563 | // |
||
564 | Scope (\) |
||
565 | { |
||
566 | Name(Bxxx,0xFFFFFFFF) |
||
567 | } |
||
568 | |||
569 | Name (LANS, 0x0) |
||
570 | |||
571 | PowerResource(LANP,1,0) |
||
572 | { |
||
573 | Method(_STA){ |
||
574 | If(LEqual(And(LANS,0x30),0x30)){ |
||
575 | Return(One) |
||
576 | } Else { |
||
577 | Return(Zero) |
||
578 | } |
||
579 | } |
||
580 | Method(_ON){ |
||
581 | If(LNot(_STA())){ |
||
582 | Store (0x30, LANS) |
||
583 | } |
||
584 | } |
||
585 | Method(_OFF){ |
||
586 | If(_STA()){ |
||
587 | Store (0, LANS) |
||
588 | } |
||
589 | } |
||
590 | } |
||
591 | |||
592 | |||
593 | /* Can a method define another method? */ |
||
594 | |||
595 | /********************************** |
||
596 | Method (TASK, 2, SERIALIZED) |
||
597 | { |
||
598 | Sleep (100) |
||
599 | |||
600 | Method (TAS2) |
||
601 | { |
||
602 | Sleep (100) |
||
603 | } |
||
604 | |||
605 | TAS2() |
||
606 | Return |
||
607 | |||
608 | } |
||
609 | ************************************/ |
||
610 | |||
611 | /* A recursive method */ |
||
612 | |||
613 | Method (RCIV, 1) |
||
614 | { |
||
615 | Store (Arg0, Debug) |
||
616 | If (Lequal (Arg0, 0)) |
||
617 | { |
||
618 | Return () |
||
619 | } |
||
620 | RCIV (Subtract (Arg0, 1)) |
||
621 | } |
||
622 | |||
623 | Method (RTOP) |
||
624 | { |
||
625 | RCIV (100) |
||
626 | } |
||
627 | |||
628 | |||
629 | Scope(\_PR) |
||
630 | { |
||
631 | Processor(CPU0,0x0,0xFFFFFFFF,0x0) {} |
||
632 | } |
||
633 | |||
634 | Name(B1TP,0xFFFFFFFF) |
||
635 | |||
636 | Name(B2TP,0xFFFFFFFF) |
||
637 | Name(ADPS,0xFFFFFFFF) |
||
638 | Name(B1PS,0xFFFFFFFF) |
||
639 | Name(B1RS,0xFFFFFFFF) |
||
640 | Name(B1CS,0xFFFFFFFF) |
||
641 | Name(B2PS,0xFFFFFFFF) |
||
642 | Name(B2RS,0xFFFFFFFF) |
||
643 | Name(B2CS,0xFFFFFFFF) |
||
644 | Name(B1DC,3000) |
||
645 | Name(B2DC,2600) |
||
646 | Name(B1LF,3000) |
||
647 | Name(B2LF,2600) |
||
648 | Name(BPIF,0) |
||
649 | Name(PBLL,0) |
||
650 | |||
651 | Name(RBIF,Package() |
||
652 | { |
||
653 | 0x1, |
||
654 | 2200, |
||
655 | 2200, |
||
656 | 0x1, |
||
657 | 10800, |
||
658 | 0, |
||
659 | 0, |
||
660 | 1, |
||
661 | 1, |
||
662 | "CA54200-5003/5", |
||
663 | "1", |
||
664 | "LION", |
||
665 | "Fujitsu" |
||
666 | }) |
||
667 | |||
668 | Method(SMWE, 4) |
||
669 | { |
||
670 | return(ONES) |
||
671 | } |
||
672 | |||
673 | Method(SMRE, 4) |
||
674 | { |
||
675 | return(ONES) |
||
676 | } |
||
677 | |||
678 | /* |
||
679 | Method(RDBT,0,Serialized){ |
||
680 | If(LNot(SMWE(0x09,0x15,1,1))){ |
||
681 | Store(0x18,Local2) |
||
682 | } |
||
683 | } |
||
684 | */ |
||
685 | Scope(_SB) |
||
686 | { |
||
687 | |||
688 | Name (SBUF, Buffer (128) {}) |
||
689 | |||
690 | CreateBitField (SBUF, 3, BITY) |
||
691 | CreateByteField (SBUF, 1, BYTY) |
||
692 | CreateWordField (SBUF, 2, WRDZ) |
||
693 | CreateDwordField (SBUF, 4, DWDZ) |
||
694 | CreateQwordField (SBUF, 8, QWDZ) |
||
695 | CreateField (SBUF, 128, 12, FLDZ) |
||
696 | CreateField (SBUF, 148, 96, FLDY) |
||
697 | CreateField (SBUF, 148, 96, \_SB_.FLDW) |
||
698 | |||
699 | Method (_INI) |
||
700 | { |
||
701 | CreateField (\_SB_.SBUF, 148, 96, FLDV) |
||
702 | } |
||
703 | |||
704 | |||
705 | Device(PCI0) |
||
706 | { |
||
707 | Name(_HID,EISAID("PNP0A03")) |
||
708 | Name(_ADR,0x0) |
||
709 | |||
710 | Method(_CRS) |
||
711 | { |
||
712 | Name(PRT0, ResourceTemplate() { |
||
713 | WORDBusNumber( // Bus number resource(0) |
||
714 | ResourceConsumer, // bit 0 of general flags is 1 |
||
715 | MinFixed, // Range is notfixed |
||
716 | MaxFixed, // Range is not fixed |
||
717 | SubDecode, // SubDecode |
||
718 | 0x0000, // Granularity |
||
719 | 0xfff1, // Min |
||
720 | 0xfff2, // Max |
||
721 | 0x0032, // Translation |
||
722 | 0x0002,,, // Range Length |
||
723 | BUS0 |
||
724 | ) } )// PRT0 |
||
725 | |||
726 | CreateWordField(PRT0, BUS0._MIN, BMIN) //Minimum bus number suported under this bridge. |
||
727 | |||
728 | Store(3, BMIN) |
||
729 | Return(PRT0) |
||
730 | |||
731 | } // _CRS |
||
732 | |||
733 | Method(_SRS) |
||
734 | { |
||
735 | Return () |
||
736 | } |
||
737 | |||
738 | Device(EIO) |
||
739 | { |
||
740 | OperationRegion(FJIO,SystemIO,0xFD60,0x6) |
||
741 | Field(FJIO,ByteAcc,NoLock,Preserve) |
||
742 | { |
||
743 | GIDX,8, |
||
744 | |||
745 | GDTA,8, |
||
746 | |||
747 | PIDX,8, |
||
748 | |||
749 | PDTA,8, |
||
750 | |||
751 | SIDX,8, |
||
752 | |||
753 | SDTA,8 |
||
754 | } |
||
755 | IndexField(GIDX,GDTA,ByteAcc,NoLock,Preserve) |
||
756 | { |
||
757 | Offset(0x2), |
||
758 | ,5, |
||
759 | VGAS,2, |
||
760 | Offset(0x4), |
||
761 | ,4, |
||
762 | DCKE,1, |
||
763 | Offset(0x5), |
||
764 | ,6, |
||
765 | ACPW,1, |
||
766 | |||
767 | Offset(0xA), |
||
768 | B1P,1, |
||
769 | |||
770 | B2P,1, |
||
771 | |||
772 | B1C,1, |
||
773 | |||
774 | B2C,1, |
||
775 | |||
776 | B1ER,1, |
||
777 | |||
778 | B2ER,1, |
||
779 | |||
780 | Offset(0xB), |
||
781 | B1CP,8, |
||
782 | |||
783 | B2CP,8, |
||
784 | |||
785 | BCP,8, |
||
786 | |||
787 | B1VH,8, |
||
788 | |||
789 | B1VL,8, |
||
790 | |||
791 | B2VH,8, |
||
792 | |||
793 | B2VL,8, |
||
794 | |||
795 | B1TM,8, |
||
796 | |||
797 | B2TM,8, |
||
798 | |||
799 | B1CH,8, |
||
800 | |||
801 | B1CL,8, |
||
802 | |||
803 | B2CH,8, |
||
804 | |||
805 | B2CL,8 |
||
806 | } |
||
807 | } |
||
808 | } |
||
809 | } |
||
810 | |||
811 | Method(RDBT,3,Serialized){ |
||
812 | Store(0x1FFF,Local1) |
||
813 | If( Arg0 ){ |
||
814 | Store(0x2FFF,Local1) |
||
815 | } |
||
816 | Store(0x18,Local2) |
||
817 | If( Arg1 ){ |
||
818 | Store(0x10,Local2) |
||
819 | } |
||
820 | If(LNot(SMRE(0x09,0x15,1,RefOf(Local0)))){ |
||
821 | If(LNot(SMWE(0x08,0x14,1,Local1))){ |
||
822 | If(LNot(SMRE(0x09,0x17,Local2,RefOf(Local3)))){ |
||
823 | Store(Local1,Arg2) |
||
824 | } |
||
825 | } |
||
826 | Or(Local0,0xFFF,Local0) |
||
827 | SMWE(0x08,0x14,1,Local0) |
||
828 | } |
||
829 | } |
||
830 | Method(MKWD,2) |
||
831 | { |
||
832 | If(And(Arg1,0x80)) { |
||
833 | Or(0xFFFF0000,Arg0,Local0) |
||
834 | Or(Local0,ShiftLeft(Arg1,8),Local0) |
||
835 | Subtract(Zero,Local0,Local0) |
||
836 | } else { |
||
837 | Store(Arg0,Local0) |
||
838 | Or(Local0,ShiftLeft(Arg1,8),Local0) |
||
839 | } |
||
840 | Return(Local0) |
||
841 | } |
||
842 | |||
843 | Device(CMB1) |
||
844 | { |
||
845 | Name(_HID,EISAID("PNP0C0A")) |
||
846 | Name(_UID,0x1) |
||
847 | Alias(\_SB.PCI0.EIO.B1P,\_SB_.PCI0.XXXX) |
||
848 | Alias(\_SB.PCI0.EIO.B1P,B1P) |
||
849 | Alias(\_SB.PCI0.EIO.B1C,B1C) |
||
850 | Alias(\_SB.PCI0.EIO.B1CH,B1CH) |
||
851 | Alias(\_SB.PCI0.EIO.B1CL,B1CL) |
||
852 | Alias(\_SB.PCI0.EIO.B1VH,B1VH) |
||
853 | Alias(\_SB.PCI0.EIO.B1VL,B1VL) |
||
854 | Alias(\_SB.PCI0.EIO.B1CP,B1CP) |
||
855 | |||
856 | Method(_INI) |
||
857 | { |
||
858 | Store(B1P, B1PS) |
||
859 | Store(B1CP,B1RS) |
||
860 | Store(B1C, B1CS) |
||
861 | } |
||
862 | |||
863 | Method(_BIF){ |
||
864 | RDBT(Zero,Zero,RefOf(B1DC)) |
||
865 | RDBT(Zero,One,RefOf(B1LF)) |
||
866 | Store(B1DC,Index(RBIF,1)) |
||
867 | Store(B1LF,Index(RBIF,2)) |
||
868 | Store("CA54200-5003/5",Index(RBIF,9)) |
||
869 | Store("1",Index(RBIF,10)) |
||
870 | Return(RBIF) |
||
871 | } |
||
872 | |||
873 | Method(_BST) { |
||
874 | |||
875 | _INI() |
||
876 | |||
877 | Store(Zero,Local0) |
||
878 | |||
879 | if (LAnd(B1P,LNot(B1C))){ |
||
880 | Or(Local0,1,Local0) |
||
881 | } |
||
882 | |||
883 | if (LAnd(B1P,B1C)) { |
||
884 | Or(Local0,2,Local0) |
||
885 | } |
||
886 | |||
887 | if (LLessEqual(B1CP,1)) { |
||
888 | Or(Local0,4,Local0) |
||
889 | } |
||
890 | |||
891 | Store(MKWD(B1CL,B1CH),Local1) |
||
892 | |||
893 | Store(Divide(Add(Multiply(B1CP,B1LF),99),100),Local2) |
||
894 | |||
895 | Store(MKWD(B1VL,B1VH),Local3) |
||
896 | |||
897 | Name(STAT,Package(4){}) |
||
898 | Store(Local0,Index(STAT,0)) |
||
899 | Store(Local1,Index(STAT,1)) |
||
900 | Store(Local2,Index(STAT,2)) |
||
901 | Store(Local3,Index(STAT,3)) |
||
902 | |||
903 | If(LNot(BPIF)){ |
||
904 | // \_SB.PCI0.EIO.EC0.IECT() |
||
905 | // \_SB.PCI0.EIO.EC0.SECT() |
||
906 | Store(One,BPIF) |
||
907 | } |
||
908 | return(STAT) |
||
909 | } |
||
910 | |||
911 | } |
||
912 | |||
913 | Device (DEV1) |
||
914 | { |
||
915 | } |
||
916 | |||
917 | Scope(\_TZ) |
||
918 | { |
||
919 | ThermalZone(TZ1) |
||
920 | { |
||
921 | Name(_PSL,Package() |
||
922 | { |
||
923 | \_PR.CPU0 |
||
924 | }) |
||
925 | } |
||
926 | } |
||
927 | |||
928 | Method (TZ2, 0, SERIALIZED) |
||
929 | { |
||
930 | Name(_PSL,Package() |
||
931 | { |
||
932 | \_PR.CPU0 |
||
933 | }) |
||
934 | |||
935 | Return (_PSL) |
||
936 | } |
||
937 | |||
938 | ThermalZone (THM1) |
||
939 | { |
||
940 | } |
||
941 | |||
942 | Method (NOTI) |
||
943 | { |
||
944 | Notify (\DEV1, 0) |
||
945 | Notify (\THM1, 0) |
||
946 | Notify (\_PR.CPU0, 0) |
||
947 | } |
||
948 | |||
949 | Method (_ERR, 2) |
||
950 | { |
||
951 | Increment (ERRS) |
||
952 | Store ("Run-time exception:", Debug) |
||
953 | Store (Arg0, Debug) |
||
954 | Store (Arg1, Debug) |
||
955 | |||
956 | Return (0) // Map error to AE_OK |
||
957 | } |
||
958 | |||
959 | Method (DIV0) |
||
960 | { |
||
961 | Store (1, Local0) |
||
962 | Store (0, Local1) |
||
963 | Divide (Local0, Local1, Local3) |
||
964 | |||
965 | Store ("DIV0 - noabort", Debug) |
||
966 | } |
||
967 | |||
968 | Method (ERR_, 1) |
||
969 | { |
||
970 | if (LEqual (Arg0, 0)) |
||
971 | { |
||
972 | Store ("+*+*+*+* MTHD_ERROR: Results not equal!", Debug) |
||
973 | } |
||
974 | if (LEqual (Arg0, 1)) |
||
975 | { |
||
976 | Store ("+*+*+*+* MTHD_ERROR: Numeric result is incorrect!", Debug) |
||
977 | } |
||
978 | if (LEqual (Arg0, 2)) |
||
979 | { |
||
980 | Store ("+*+*+*+* MTHD_ERROR: Operand was clobbered!", Debug) |
||
981 | } |
||
982 | |||
983 | Notify (DEV1, Arg0) |
||
984 | Increment (ERRS) |
||
985 | } |
||
986 | |||
987 | Method (R226, 2) |
||
988 | { |
||
989 | } |
||
990 | Method (R225, 2) |
||
991 | { |
||
992 | R226 (Arg0, Arg1) |
||
993 | } |
||
994 | Method (R224, 2) |
||
995 | { |
||
996 | R225 (Arg1, Arg0) |
||
997 | } |
||
998 | Method (R223, 2) |
||
999 | { |
||
1000 | R224 (Arg0, Arg1) |
||
1001 | } |
||
1002 | Method (R222, 2) |
||
1003 | { |
||
1004 | R223 (Arg1, Arg0) |
||
1005 | } |
||
1006 | Method (R111) |
||
1007 | { |
||
1008 | Store (0x01010101, Local0) |
||
1009 | R222 (0xABAB, Local0) |
||
1010 | Store (Local0, Local1) |
||
1011 | } |
||
1012 | |||
1013 | Method (MAIN) |
||
1014 | { |
||
1015 | |||
1016 | // SIZE() |
||
1017 | Store (NUM1(), Local0) |
||
1018 | \CMB1._BST() |
||
1019 | RDBT(1,2,3) |
||
1020 | OBJ1(1) |
||
1021 | OBJ2(2) |
||
1022 | CHEK() |
||
1023 | RETZ() |
||
1024 | BITZ() |
||
1025 | LOGS() |
||
1026 | REFS() |
||
1027 | COND() |
||
1028 | TZ2() |
||
1029 | |||
1030 | // |
||
1031 | // iPCO tests added |
||
1032 | // |
||
1033 | Store (\IFEL.TEST(), Local0) |
||
1034 | if (LGreater (Local0, 0)) |
||
1035 | { |
||
1036 | ERR_ (1) |
||
1037 | Return(Local0) |
||
1038 | } |
||
1039 | |||
1040 | Store (\NOSV.TEST(), Local0) |
||
1041 | if (LGreater (Local0, 0)) |
||
1042 | { |
||
1043 | ERR_ (1) |
||
1044 | Return(Local0) |
||
1045 | } |
||
1046 | |||
1047 | Store (\IDXF.TEST(), Local0) |
||
1048 | if (LGreater (Local0, 0)) |
||
1049 | { |
||
1050 | ERR_ (1) |
||
1051 | Return(Local0) |
||
1052 | } |
||
1053 | |||
1054 | Store (\_SB_.NSTL.TEST(), Local0) |
||
1055 | if (LGreater (Local0, 0)) |
||
1056 | { |
||
1057 | ERR_ (1) |
||
1058 | Return(Local0) |
||
1059 | } |
||
1060 | |||
1061 | Store (\RTBF.TEST(), Local0) |
||
1062 | if (LGreater (Local0, 0)) |
||
1063 | { |
||
1064 | ERR_ (1) |
||
1065 | Return(Local0) |
||
1066 | } |
||
1067 | |||
1068 | Store (\_SB_.RTLV.TEST(), Local0) |
||
1069 | if (LGreater (Local0, 0)) |
||
1070 | { |
||
1071 | ERR_ (1) |
||
1072 | Return(Local0) |
||
1073 | } |
||
1074 | |||
1075 | Store (\_SB_.RETP.TEST(), Local0) |
||
1076 | if (LGreater (Local0, 0)) |
||
1077 | { |
||
1078 | ERR_ (1) |
||
1079 | Return(Local0) |
||
1080 | } |
||
1081 | |||
1082 | Store (\WHLR.TEST(), Local0) |
||
1083 | if (LGreater (Local0, 0)) |
||
1084 | { |
||
1085 | ERR_ (1) |
||
1086 | Return(Local0) |
||
1087 | } |
||
1088 | |||
1089 | Store (\ANDO.TEST(), Local0) |
||
1090 | if (LGreater (Local0, 0)) |
||
1091 | { |
||
1092 | ERR_ (1) |
||
1093 | Return(Local0) |
||
1094 | } |
||
1095 | |||
1096 | Store (\BRKP.TEST(), Local0) |
||
1097 | if (LGreater (Local0, 0)) |
||
1098 | { |
||
1099 | ERR_ (1) |
||
1100 | Return(Local0) |
||
1101 | } |
||
1102 | |||
1103 | Store (\ADSU.TEST(), Local0) |
||
1104 | if (LGreater (Local0, 0)) |
||
1105 | { |
||
1106 | ERR_ (1) |
||
1107 | Return(Local0) |
||
1108 | } |
||
1109 | |||
1110 | Store (\INDC.TEST(), Local0) |
||
1111 | if (LGreater (Local0, 0)) |
||
1112 | { |
||
1113 | ERR_ (1) |
||
1114 | Return(Local0) |
||
1115 | } |
||
1116 | |||
1117 | Store (\LOPS.TEST(), Local0) |
||
1118 | if (LGreater (Local0, 0)) |
||
1119 | { |
||
1120 | ERR_ (1) |
||
1121 | Return(Local0) |
||
1122 | } |
||
1123 | |||
1124 | Store (\FDSO.TEST(), Local0) |
||
1125 | if (LGreater (Local0, 0)) |
||
1126 | { |
||
1127 | ERR_ (1) |
||
1128 | Return(Local0) |
||
1129 | } |
||
1130 | |||
1131 | Store (\MLDV.TEST(), Local0) |
||
1132 | if (LGreater (Local0, 0)) |
||
1133 | { |
||
1134 | ERR_ (1) |
||
1135 | Return(Local0) |
||
1136 | } |
||
1137 | |||
1138 | Store (\NBIT.TEST(), Local0) |
||
1139 | if (LGreater (Local0, 0)) |
||
1140 | { |
||
1141 | ERR_ (1) |
||
1142 | Return(Local0) |
||
1143 | } |
||
1144 | |||
1145 | Store (\SHFT.TEST(), Local0) |
||
1146 | if (LGreater (Local0, 0)) |
||
1147 | { |
||
1148 | ERR_ (1) |
||
1149 | Return(Local0) |
||
1150 | } |
||
1151 | |||
1152 | Store (\XORD.TEST(), Local0) |
||
1153 | if (LGreater (Local0, 0)) |
||
1154 | { |
||
1155 | ERR_ (1) |
||
1156 | Return(Local0) |
||
1157 | } |
||
1158 | |||
1159 | Store (\CRBF.TEST(), Local0) |
||
1160 | if (LGreater (Local0, 0)) |
||
1161 | { |
||
1162 | ERR_ (1) |
||
1163 | Return(Local0) |
||
1164 | } |
||
1165 | |||
1166 | Store (\IDX4.TEST(), Local0) |
||
1167 | if (LGreater (Local0, 0)) |
||
1168 | { |
||
1169 | ERR_ (1) |
||
1170 | Return(Local0) |
||
1171 | } |
||
1172 | |||
1173 | Store (\EVNT.TEST(), Local0) |
||
1174 | if (LGreater (Local0, 0)) |
||
1175 | { |
||
1176 | ERR_ (1) |
||
1177 | Return(Local0) |
||
1178 | } |
||
1179 | |||
1180 | Store (\SZLV.TEST(), Local0) |
||
1181 | if (LGreater (Local0, 0)) |
||
1182 | { |
||
1183 | ERR_ (1) |
||
1184 | Return(Local0) |
||
1185 | } |
||
1186 | |||
1187 | Store (\_SB_.BYTF.TEST(), Local0) |
||
1188 | if (LGreater (Local0, 0)) |
||
1189 | { |
||
1190 | ERR_ (1) |
||
1191 | Return(Local0) |
||
1192 | } |
||
1193 | |||
1194 | Store (\DWDF.TEST(), Local0) |
||
1195 | if (LGreater (Local0, 0)) |
||
1196 | { |
||
1197 | ERR_ (1) |
||
1198 | Return(Local0) |
||
1199 | } |
||
1200 | |||
1201 | Store (\DVAX.TEST(), Local0) |
||
1202 | if (LGreater (Local0, 0)) |
||
1203 | { |
||
1204 | ERR_ (1) |
||
1205 | Return(Local0) |
||
1206 | } |
||
1207 | |||
1208 | Store (\IDX6.TEST(), Local0) |
||
1209 | if (LGreater (Local0, 0)) |
||
1210 | { |
||
1211 | ERR_ (1) |
||
1212 | Return(Local0) |
||
1213 | } |
||
1214 | |||
1215 | Store (\IDX5.TEST(), Local0) |
||
1216 | if (LGreater (Local0, 0)) |
||
1217 | { |
||
1218 | ERR_ (1) |
||
1219 | Return(Local0) |
||
1220 | } |
||
1221 | |||
1222 | Store (\_SB_.IDX0.TEST(), Local0) |
||
1223 | if (LGreater (Local0, 0)) |
||
1224 | { |
||
1225 | ERR_ (1) |
||
1226 | Return(Local0) |
||
1227 | } |
||
1228 | |||
1229 | Store (\_SB_.IDX3.TEST(), Local0) |
||
1230 | if (LGreater (Local0, 0)) |
||
1231 | { |
||
1232 | ERR_ (1) |
||
1233 | Return(Local0) |
||
1234 | } |
||
1235 | |||
1236 | Store (\IDX7.TEST(), Local0) |
||
1237 | if (LGreater (Local0, 0)) |
||
1238 | { |
||
1239 | ERR_ (1) |
||
1240 | Return(Local0) |
||
1241 | } |
||
1242 | |||
1243 | Store (\MTCH.TEST(), Local0) |
||
1244 | if (LGreater (Local0, 0)) |
||
1245 | { |
||
1246 | ERR_ (1) |
||
1247 | Return(Local0) |
||
1248 | } |
||
1249 | |||
1250 | Store (\WHLB.TEST(), Local0) |
||
1251 | if (LGreater (Local0, 0)) |
||
1252 | { |
||
1253 | ERR_ (1) |
||
1254 | Return(Local0) |
||
1255 | } |
||
1256 | |||
1257 | Store (\_SB_.IDX2.TEST(), Local0) |
||
1258 | if (LGreater (Local0, 0)) |
||
1259 | { |
||
1260 | ERR_ (1) |
||
1261 | Return(Local0) |
||
1262 | } |
||
1263 | |||
1264 | Store (\SIZO.TEST(), Local0) |
||
1265 | if (LGreater (Local0, 0)) |
||
1266 | { |
||
1267 | ERR_ (1) |
||
1268 | Return(Local0) |
||
1269 | } |
||
1270 | |||
1271 | Store (\_SB_.SMIS.TEST(), Local0) |
||
1272 | if (LGreater (Local0, 0)) |
||
1273 | { |
||
1274 | ERR_ (1) |
||
1275 | Return(Local0) |
||
1276 | } |
||
1277 | |||
1278 | if (LGreater (ERRS, 0)) |
||
1279 | { |
||
1280 | Store ("****** There were errors during the execution of the test ******", Debug) |
||
1281 | } |
||
1282 | |||
1283 | // |
||
1284 | // Last Test |
||
1285 | // |
||
1286 | |||
1287 | Return(0) // Success |
||
1288 | } |
||
1289 | |||
1290 | |||
1291 | Method (OBJ1, 1, SERIALIZED) |
||
1292 | { |
||
1293 | |||
1294 | Store (3, Local0) |
||
1295 | Name(BUFR, Buffer (Local0) {}) |
||
1296 | Name(BUF1, Buffer (4) {1,2,3,4}) |
||
1297 | Name(BUF2, Buffer (4) {}) |
||
1298 | |||
1299 | Store (BUF1, BUF2) |
||
1300 | Mutex (MTX1, 4) |
||
1301 | |||
1302 | Alias (MTX1, MTX2) |
||
1303 | } |
||
1304 | |||
1305 | |||
1306 | Mutex (MTXT, 0) |
||
1307 | Mutex (MTXX, 0) |
||
1308 | |||
1309 | /* |
||
1310 | * Field Creation |
||
1311 | */ |
||
1312 | |||
1313 | Method (FLDS) |
||
1314 | { |
||
1315 | Store ("++++++++ Creating BufferFields", Debug) |
||
1316 | Name (BUF2, Buffer (128) {}) |
||
1317 | |||
1318 | CreateBitField (BUF2, 3, BIT2) |
||
1319 | CreateByteField (BUF2, 1, BYT2) |
||
1320 | CreateWordField (BUF2, 2, WRD2) |
||
1321 | CreateDwordField (BUF2, 4, DWD2) |
||
1322 | CreateQwordField (BUF2, 8, QWD2) |
||
1323 | CreateField (BUF2, 128, 12, FLD2) |
||
1324 | CreateField (BUF2, 148, 96, FLD3) |
||
1325 | |||
1326 | Store (0x1, BIT2) |
||
1327 | Store (BIT2, Local0) |
||
1328 | if (LNotEqual (Local0, 0x1)) |
||
1329 | { |
||
1330 | ERR_ (1) |
||
1331 | } |
||
1332 | else |
||
1333 | { |
||
1334 | Store (DerefOf (Index (BUF2, 0)), Local0) |
||
1335 | if (LNotEqual (Local0, 0x08)) |
||
1336 | { |
||
1337 | ERR_ (1) |
||
1338 | } |
||
1339 | else |
||
1340 | { |
||
1341 | Store ("++++++++ Bit BufferField I/O PASS", Debug) |
||
1342 | } |
||
1343 | } |
||
1344 | |||
1345 | Store (0x1A, BYT2) |
||
1346 | Store (BYT2, Local0) |
||
1347 | if (LNotEqual (Local0, 0x1A)) |
||
1348 | { |
||
1349 | ERR_ (1) |
||
1350 | } |
||
1351 | else |
||
1352 | { |
||
1353 | Store ("++++++++ Byte BufferField I/O PASS", Debug) |
||
1354 | } |
||
1355 | |||
1356 | Store (0x1234, WRD2) |
||
1357 | Store (WRD2, Local0) |
||
1358 | if (LNotEqual (Local0, 0x1234)) |
||
1359 | { |
||
1360 | ERR_ (1) |
||
1361 | } |
||
1362 | else |
||
1363 | { |
||
1364 | Store ("++++++++ Word BufferField I/O PASS", Debug) |
||
1365 | } |
||
1366 | |||
1367 | Store (0x123, FLD2) |
||
1368 | Store (FLD2, Local0) |
||
1369 | if (LNotEqual (Local0, 0x123)) |
||
1370 | { |
||
1371 | ERR_ (1) |
||
1372 | } |
||
1373 | else |
||
1374 | { |
||
1375 | Store ("++++++++ 12-bit BufferField I/O PASS", Debug) |
||
1376 | } |
||
1377 | |||
1378 | Store (0x12345678, DWD2) |
||
1379 | Store (DWD2, Local0) |
||
1380 | if (LNotEqual (Local0, 0x12345678)) |
||
1381 | { |
||
1382 | ERR_ (1) |
||
1383 | } |
||
1384 | else |
||
1385 | { |
||
1386 | Store ("++++++++ Dword BufferField I/O PASS", Debug) |
||
1387 | } |
||
1388 | |||
1389 | Store (0x1234567887654321, QWD2) |
||
1390 | Store (QWD2, Local0) |
||
1391 | if (LNotEqual (Local0, 0x1234567887654321)) |
||
1392 | { |
||
1393 | ERR_ (1) |
||
1394 | } |
||
1395 | else |
||
1396 | { |
||
1397 | Store ("++++++++ Qword BufferField I/O PASS", Debug) |
||
1398 | } |
||
1399 | } |
||
1400 | |||
1401 | |||
1402 | /* Field execution */ |
||
1403 | |||
1404 | Method (FLDX) |
||
1405 | { |
||
1406 | Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve) |
||
1407 | { // Field: SMEM overlay using 32-bit field elements |
||
1408 | SMD0, 32, // 32-bits |
||
1409 | SMD1, 32, // 32-bits |
||
1410 | SMD2, 32, // 32-bits |
||
1411 | SMD3, 32 // 32-bits |
||
1412 | } // Field: SMEM overlay using 32-bit field elements |
||
1413 | Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve) |
||
1414 | { // Field: SMEM overlay using greater than 32-bit field elements |
||
1415 | SME0, 69, // larger than an integer (32 or 64) |
||
1416 | SME1, 97 // larger than an integer |
||
1417 | } // Field: SMEM overlay using greater than 32-bit field elements |
||
1418 | } |
||
1419 | |||
1420 | |||
1421 | Method (MTX_, ) |
||
1422 | { |
||
1423 | /* Test "Force release" of mutex on method exit */ |
||
1424 | |||
1425 | Acquire (MTXT, 0xFFFF) |
||
1426 | Acquire (MTXX, 0xFFFF) |
||
1427 | |||
1428 | Store ("++++++++ Acquiring Mutex MTX2", Debug) |
||
1429 | Acquire (_GL_, 0xFFFF) |
||
1430 | |||
1431 | |||
1432 | Store ("++++++++ Releasing Mutex MTX2", Debug) |
||
1433 | Release (_GL_) |
||
1434 | } |
||
1435 | |||
1436 | |||
1437 | Method (OBJ2, 1) |
||
1438 | { |
||
1439 | Store ("++++++++ Creating Buffer BUFO", Debug) |
||
1440 | Name (BUFO, Buffer (32) {}) |
||
1441 | |||
1442 | Store ("++++++++ Creating OpRegion OPR2", Debug) |
||
1443 | OperationRegion (OPR2, SystemMemory, Arg0, 256) |
||
1444 | |||
1445 | Store ("++++++++ Creating Field(s) in OpRegion OPR2", Debug) |
||
1446 | Field (OPR2, ByteAcc, NoLock, Preserve) |
||
1447 | { |
||
1448 | IDX2, 8, |
||
1449 | DAT2, 8, |
||
1450 | BNK2, 4 |
||
1451 | } |
||
1452 | |||
1453 | Store ("++++++++ Creating BankField BNK2 in OpRegion OPR2", Debug) |
||
1454 | // |
||
1455 | // mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1 |
||
1456 | // |
||
1457 | BankField (OPR2, BNK2, 0, ByteAcc, NoLock, Preserve) |
||
1458 | { |
||
1459 | FET0, 4, |
||
1460 | FET1, 3 |
||
1461 | } |
||
1462 | |||
1463 | Store ("++++++++ Creating IndexField", Debug) |
||
1464 | IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve) |
||
1465 | { |
||
1466 | FET2, 4, |
||
1467 | FET3, 3 |
||
1468 | } |
||
1469 | |||
1470 | Store ("++++++++ SizeOf (BUFO)", Debug) |
||
1471 | SizeOf (BUFO) |
||
1472 | |||
1473 | Store ("++++++++ Store (SizeOf (BUFO), Local0)", Debug) |
||
1474 | Store (SizeOf (BUFO), Local0) |
||
1475 | |||
1476 | Store ("++++++++ Concatenate (\"abd\", \"def\", Local0)", Debug) |
||
1477 | Concatenate ("abd", "def", Local0) |
||
1478 | Store (Local0, Debug) |
||
1479 | |||
1480 | Store ("++++++++ Concatenate (\"abd\", 0x7B, Local0)", Debug) |
||
1481 | Concatenate ("abd", 0x7B, Local0) |
||
1482 | Store (Local0, Debug) |
||
1483 | |||
1484 | Store ("++++++++ Creating Event EVT2", Debug) |
||
1485 | Event (EVT2) |
||
1486 | |||
1487 | Store ("++++++++ Creating Mutex MTX2", Debug) |
||
1488 | Mutex (MTX2, 0) |
||
1489 | |||
1490 | Store ("++++++++ Creating Alias MTXA to MTX2", Debug) |
||
1491 | Alias (MTX2, MTXA) |
||
1492 | |||
1493 | Store ("++++++++ Acquiring Mutex MTX2", Debug) |
||
1494 | Acquire (MTX2, 0xFFFF) |
||
1495 | |||
1496 | Store ("++++++++ Acquiring Mutex MTX2 (2nd acquire)", Debug) |
||
1497 | Acquire (MTX2, 1) |
||
1498 | |||
1499 | Store ("++++++++ Releasing Mutex MTX2", Debug) |
||
1500 | Release (MTX2) |
||
1501 | |||
1502 | // Type 1 opcodes |
||
1503 | |||
1504 | Store ("++++++++ Signalling Event EVT2", Debug) |
||
1505 | Signal (EVT2) |
||
1506 | |||
1507 | Store ("++++++++ Resetting Event EVT2", Debug) |
||
1508 | Reset (EVT2) |
||
1509 | |||
1510 | Store ("++++++++ Signalling Event EVT2", Debug) |
||
1511 | Signal (EVT2) |
||
1512 | |||
1513 | Store ("++++++++ Waiting Event EVT2", Debug) |
||
1514 | Wait (EVT2, 0xFFFF) |
||
1515 | |||
1516 | Store ("++++++++ Sleep", Debug) |
||
1517 | Sleep (100) |
||
1518 | |||
1519 | Store ("++++++++ Stall", Debug) |
||
1520 | Stall (254) |
||
1521 | |||
1522 | Store ("++++++++ NoOperation", Debug) |
||
1523 | Noop |
||
1524 | |||
1525 | // Type 2 Opcodes |
||
1526 | |||
1527 | Store ("++++++++ Return from Method OBJ2", Debug) |
||
1528 | return (4) |
||
1529 | } |
||
1530 | |||
1531 | |||
1532 | Method (NUM1, 0) |
||
1533 | { |
||
1534 | /* ADD */ |
||
1535 | |||
1536 | Store ("++++++++ Add (0x12345678, 0x11111111, Local0)", Debug) |
||
1537 | Add (0x12345678, 0x11111111, Local0) |
||
1538 | |||
1539 | Store ("++++++++ Store (Add (0x12345678, 0x11111111), Local1)", Debug) |
||
1540 | Store (Add (0x12345678, 0x11111111), Local1) |
||
1541 | |||
1542 | Store ("++++++++ Checking result from ADD", Debug) |
||
1543 | if (LNotEqual (Local0, Local1)) |
||
1544 | { |
||
1545 | ERR_ (0) |
||
1546 | } |
||
1547 | |||
1548 | |||
1549 | /* SUBTRACT */ |
||
1550 | |||
1551 | Store ("++++++++ Subtract (0x87654321, 0x11111111, Local4)", Debug) |
||
1552 | Subtract (0x87654321, 0x11111111, Local4) |
||
1553 | |||
1554 | Store ("++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)", Debug) |
||
1555 | Store (Subtract (0x87654321, 0x11111111), Local5) |
||
1556 | |||
1557 | Store ("++++++++ Checking result from SUBTRACT", Debug) |
||
1558 | if (LNotEqual (Local4, Local5)) |
||
1559 | { |
||
1560 | ERR_ (0) |
||
1561 | } |
||
1562 | |||
1563 | |||
1564 | /* MULTIPLY */ |
||
1565 | |||
1566 | Store ("++++++++ Multiply (33, 10, Local6)", Debug) |
||
1567 | Multiply (33, 10, Local6) |
||
1568 | |||
1569 | Store ("++++++++ Store (Multiply (33, 10), Local7)", Debug) |
||
1570 | Store (Multiply (33, 10), Local7) |
||
1571 | |||
1572 | |||
1573 | Store ("++++++++ Checking result from MULTIPLY", Debug) |
||
1574 | if (LNotEqual (Local6, Local7)) |
||
1575 | { |
||
1576 | ERR_ (0) |
||
1577 | } |
||
1578 | |||
1579 | |||
1580 | /* DIVIDE */ |
||
1581 | |||
1582 | Store ("++++++++ Divide (100, 9, Local1, Local2)", Debug) |
||
1583 | Divide (100, 9, Local1, Local2) |
||
1584 | |||
1585 | Store ("++++++++ Store (Divide (100, 9), Local3)", Debug) |
||
1586 | Store (Divide (100, 9), Local3) |
||
1587 | |||
1588 | Store ("++++++++ Checking (quotient) result from DIVIDE", Debug) |
||
1589 | if (LNotEqual (Local2, Local3)) |
||
1590 | { |
||
1591 | ERR_ (0) |
||
1592 | } |
||
1593 | |||
1594 | |||
1595 | /* INCREMENT */ |
||
1596 | |||
1597 | Store ("++++++++ Increment (Local0)", Debug) |
||
1598 | Store (1, Local0) |
||
1599 | Store (2, Local1) |
||
1600 | Increment (Local0) |
||
1601 | |||
1602 | Store ("++++++++ Checking result from INCREMENT", Debug) |
||
1603 | if (LNotEqual (Local0, Local1)) |
||
1604 | { |
||
1605 | ERR_ (0) |
||
1606 | } |
||
1607 | |||
1608 | |||
1609 | /* DECREMENT */ |
||
1610 | |||
1611 | Store ("++++++++ Decrement (Local0)", Debug) |
||
1612 | Store (2, Local0) |
||
1613 | Store (1, Local1) |
||
1614 | Decrement (Local0) |
||
1615 | |||
1616 | Store ("++++++++ Checking result from DECREMENT", Debug) |
||
1617 | if (LNotEqual (Local0, Local1)) |
||
1618 | { |
||
1619 | ERR_ (0) |
||
1620 | } |
||
1621 | |||
1622 | |||
1623 | /* TOBCD */ |
||
1624 | /* FROMBCD */ |
||
1625 | |||
1626 | Store ("++++++++ ToBCD (0x1234, Local5)", Debug) |
||
1627 | ToBCD (0x1234, Local5) |
||
1628 | |||
1629 | Store ("++++++++ FromBCD (Local5, Local6)", Debug) |
||
1630 | FromBCD (Local5, Local6) |
||
1631 | |||
1632 | Store ("++++++++ Return (Local6)", Debug) |
||
1633 | Return (Local6) |
||
1634 | } |
||
1635 | |||
1636 | |||
1637 | Method (CHEK) |
||
1638 | { |
||
1639 | |||
1640 | Store (3, Local0) |
||
1641 | Store (3, Debug) |
||
1642 | Store (Local0, Debug) |
||
1643 | Store (7, Local1) |
||
1644 | |||
1645 | Add (Local0, Local1) |
||
1646 | if (LNotEqual (Local0, 3)) |
||
1647 | { |
||
1648 | ERR_ (2) |
||
1649 | } |
||
1650 | if (LNotEqual (Local1, 7)) |
||
1651 | { |
||
1652 | ERR_ (2) |
||
1653 | } |
||
1654 | |||
1655 | |||
1656 | Add (Local0, Local1, Local2) |
||
1657 | if (LNotEqual (Local0, 3)) |
||
1658 | { |
||
1659 | ERR_ (2) |
||
1660 | } |
||
1661 | if (LNotEqual (Local1, 7)) |
||
1662 | { |
||
1663 | ERR_ (2) |
||
1664 | } |
||
1665 | } |
||
1666 | |||
1667 | |||
1668 | Method (RET1) |
||
1669 | { |
||
1670 | Store (3, Local0) |
||
1671 | Return (Local0) |
||
1672 | } |
||
1673 | |||
1674 | Method (RET2) |
||
1675 | { |
||
1676 | Return (RET1()) |
||
1677 | } |
||
1678 | |||
1679 | Method (RETZ) |
||
1680 | { |
||
1681 | RET2 () |
||
1682 | } |
||
1683 | |||
1684 | |||
1685 | Method (BITZ) |
||
1686 | { |
||
1687 | Store ("++++++++ FindSetLeftBit (0x00100100, Local0)", Debug) |
||
1688 | FindSetLeftBit (0x00100100, Local0) |
||
1689 | if (LNotEqual (Local0, 21)) |
||
1690 | { |
||
1691 | ERR_ (1) |
||
1692 | } |
||
1693 | |||
1694 | Store ("++++++++ FindSetRightBit (0x00100100, Local1)", Debug) |
||
1695 | FindSetRightBit (0x00100100, Local1) |
||
1696 | if (LNotEqual (Local1, 9)) |
||
1697 | { |
||
1698 | ERR_ (1) |
||
1699 | } |
||
1700 | |||
1701 | Store ("++++++++ And (0xF0F0F0F0, 0x11111111, Local2)", Debug) |
||
1702 | And (0xF0F0F0F0, 0x11111111, Local2) |
||
1703 | if (LNotEqual (Local2, 0x10101010)) |
||
1704 | { |
||
1705 | ERR_ (1) |
||
1706 | } |
||
1707 | |||
1708 | Store ("++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)", Debug) |
||
1709 | NAnd (0xF0F0F0F0, 0x11111111, Local3) |
||
1710 | if (LNotEqual (Local3, 0xEFEFEFEF)) |
||
1711 | { |
||
1712 | ERR_ (1) |
||
1713 | } |
||
1714 | |||
1715 | Store ("++++++++ Or (0x11111111, 0x22222222, Local4)", Debug) |
||
1716 | Or (0x11111111, 0x22222222, Local4) |
||
1717 | if (LNotEqual (Local4, 0x33333333)) |
||
1718 | { |
||
1719 | ERR_ (1) |
||
1720 | } |
||
1721 | |||
1722 | Store ("++++++++ NOr (0x11111111, 0x22222222, Local5)", Debug) |
||
1723 | NOr (0x11111111, 0x22222222, Local5) |
||
1724 | if (LNotEqual (Local5, 0xCCCCCCCC)) |
||
1725 | { |
||
1726 | ERR_ (1) |
||
1727 | } |
||
1728 | |||
1729 | Store ("++++++++ XOr (0x11113333, 0x22222222, Local6)", Debug) |
||
1730 | XOr (0x11113333, 0x22222222, Local6) |
||
1731 | if (LNotEqual (Local6, 0x33331111)) |
||
1732 | { |
||
1733 | ERR_ (1) |
||
1734 | } |
||
1735 | |||
1736 | Store ("++++++++ ShiftLeft (0x11112222, 2, Local7)", Debug) |
||
1737 | ShiftLeft (0x11112222, 2, Local7) |
||
1738 | if (LNotEqual (Local7, 0x44448888)) |
||
1739 | { |
||
1740 | ERR_ (1) |
||
1741 | } |
||
1742 | |||
1743 | Store ("++++++++ ShiftRight (Local7, 2, Local7)", Debug) |
||
1744 | ShiftRight (Local7, 2, Local7) |
||
1745 | if (LNotEqual (Local7, 0x11112222)) |
||
1746 | { |
||
1747 | ERR_ (1) |
||
1748 | } |
||
1749 | |||
1750 | |||
1751 | Store ("++++++++ Not (Local0, Local1)", Debug) |
||
1752 | Store (0x22224444, Local0) |
||
1753 | Not (Local0, Local1) |
||
1754 | if (LNotEqual (Local0, 0x22224444)) |
||
1755 | { |
||
1756 | ERR_ (2) |
||
1757 | } |
||
1758 | |||
1759 | if (LNotEqual (Local1, 0xDDDDBBBB)) |
||
1760 | { |
||
1761 | ERR_ (1) |
||
1762 | } |
||
1763 | |||
1764 | Return (Local7) |
||
1765 | } |
||
1766 | |||
1767 | |||
1768 | Method (LOGS) |
||
1769 | { |
||
1770 | |||
1771 | Store ("++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)", Debug) |
||
1772 | Store (LAnd (0xFFFFFFFF, 0x11111111), Local0) |
||
1773 | |||
1774 | Store ("++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)", Debug) |
||
1775 | Store (LEqual (0xFFFFFFFF, 0x11111111), Local1) |
||
1776 | |||
1777 | Store ("++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)", Debug) |
||
1778 | Store (LGreater (0xFFFFFFFF, 0x11111111), Local2) |
||
1779 | |||
1780 | Store ("++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)", Debug) |
||
1781 | Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3) |
||
1782 | |||
1783 | Store ("++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)", Debug) |
||
1784 | Store (LLess (0xFFFFFFFF, 0x11111111), Local4) |
||
1785 | |||
1786 | Store ("++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)", Debug) |
||
1787 | Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5) |
||
1788 | |||
1789 | Store ("++++++++ Store (LNot (0x31313131), Local6)", Debug) |
||
1790 | Store (0x00001111, Local6) |
||
1791 | Store (LNot (Local6), Local7) |
||
1792 | if (LNotEqual (Local6, 0x00001111)) |
||
1793 | { |
||
1794 | ERR_ (2) |
||
1795 | } |
||
1796 | |||
1797 | if (LNotEqual (Local7, 0x0)) |
||
1798 | { |
||
1799 | ERR_ (1) |
||
1800 | } |
||
1801 | |||
1802 | |||
1803 | Store ("++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)", Debug) |
||
1804 | Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7) |
||
1805 | |||
1806 | Store ("++++++++ Lor (0x0, 0x1)", Debug) |
||
1807 | if (Lor (0x0, 0x1)) |
||
1808 | { |
||
1809 | Store ("+_+_+_+_+ Lor (0x0, 0x1) returned TRUE", Debug) |
||
1810 | } |
||
1811 | |||
1812 | return (Local7) |
||
1813 | } |
||
1814 | |||
1815 | |||
1816 | Method (COND) |
||
1817 | { |
||
1818 | Store ("++++++++ Store (0x4, Local0)", Debug) |
||
1819 | Store (0x4, Local0) |
||
1820 | |||
1821 | Store ("++++++++ While (Local0)", Debug) |
||
1822 | While (Local0) |
||
1823 | { |
||
1824 | Store ("++++++++ Decrement (Local0)", Debug) |
||
1825 | Decrement (Local0) |
||
1826 | } |
||
1827 | |||
1828 | |||
1829 | Store ("++++++++ Store (0x3, Local6)", Debug) |
||
1830 | Store (0x3, Local6) |
||
1831 | |||
1832 | Store ("++++++++ While (Subtract (Local6, 1))", Debug) |
||
1833 | While (Subtract (Local6, 1)) |
||
1834 | { |
||
1835 | Store ("++++++++ Decrement (Local6)", Debug) |
||
1836 | Decrement (Local6) |
||
1837 | } |
||
1838 | |||
1839 | |||
1840 | Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug) |
||
1841 | If (LGreater (0x2, 0x1)) |
||
1842 | { |
||
1843 | Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug) |
||
1844 | If (LEqual (0x11111111, 0x22222222)) |
||
1845 | { |
||
1846 | Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug) |
||
1847 | } |
||
1848 | |||
1849 | else |
||
1850 | { |
||
1851 | Store ("++++++++ [LVL3] If (LNot (0x0))", Debug) |
||
1852 | If (LNot (0x0)) |
||
1853 | { |
||
1854 | Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug) |
||
1855 | If (LAnd (0xEEEEEEEE, 0x2)) |
||
1856 | { |
||
1857 | Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug) |
||
1858 | If (LLess (0x44444444, 0x3)) |
||
1859 | { |
||
1860 | Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug) |
||
1861 | } |
||
1862 | |||
1863 | else |
||
1864 | { |
||
1865 | Store ("++++++++ Exiting from nested IF/ELSE statements", Debug) |
||
1866 | } |
||
1867 | } |
||
1868 | } |
||
1869 | } |
||
1870 | } |
||
1871 | |||
1872 | |||
1873 | Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug) |
||
1874 | If (LGreater (0x2, 0x1)) |
||
1875 | { |
||
1876 | Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug) |
||
1877 | If (LEqual (0x11111111, 0x22222222)) |
||
1878 | { |
||
1879 | Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug) |
||
1880 | } |
||
1881 | |||
1882 | else |
||
1883 | { |
||
1884 | Store ("++++++++ [LVL3] If (LNot (0x0))", Debug) |
||
1885 | If (LNot (0x0)) |
||
1886 | { |
||
1887 | Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug) |
||
1888 | If (LAnd (0xEEEEEEEE, 0x2)) |
||
1889 | { |
||
1890 | Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug) |
||
1891 | If (LLess (0x44444444, 0x3)) |
||
1892 | { |
||
1893 | Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug) |
||
1894 | } |
||
1895 | |||
1896 | else |
||
1897 | { |
||
1898 | Store ("++++++++ Returning from nested IF/ELSE statements", Debug) |
||
1899 | Return (Local6) |
||
1900 | } |
||
1901 | } |
||
1902 | } |
||
1903 | } |
||
1904 | } |
||
1905 | |||
1906 | } |
||
1907 | |||
1908 | |||
1909 | Method (REFS) |
||
1910 | { |
||
1911 | Name (BBUF, Buffer() {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7}) |
||
1912 | |||
1913 | Name (NEST, Package () |
||
1914 | { |
||
1915 | Package () |
||
1916 | { |
||
1917 | 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 |
||
1918 | }, |
||
1919 | Package () |
||
1920 | { |
||
1921 | 0x11, 0x12, 0x12, 0x14, 0x15, 0x16 |
||
1922 | } |
||
1923 | }) |
||
1924 | |||
1925 | /* Parser thinks this is a method invocation!! */ |
||
1926 | |||
1927 | Store (RefOf (MAIN), Local5) |
||
1928 | |||
1929 | // For this to work, ABCD must NOT exist. |
||
1930 | |||
1931 | Store (CondRefOf (ABCD, Local0), Local1) |
||
1932 | if (LNotEqual (Local1, 0)) |
||
1933 | { |
||
1934 | ERR_ (2) |
||
1935 | } |
||
1936 | |||
1937 | Store (CondRefOf (BBUF, Local0), Local1) |
||
1938 | if (LNotEqual (Local1, Ones)) |
||
1939 | { |
||
1940 | ERR_ (2) |
||
1941 | } |
||
1942 | |||
1943 | Store (DeRefOf (Index (BBUF, 3)), Local6) |
||
1944 | if (LNotEqual (Local6, 0xB3)) |
||
1945 | { |
||
1946 | ERR_ (2) |
||
1947 | } |
||
1948 | |||
1949 | Store (DeRefOf (Index (DeRefOf (Index (NEST, 1)), 3)), Local0) |
||
1950 | if (LNotEqual (Local0, 0x14)) |
||
1951 | { |
||
1952 | ERR_ (2) |
||
1953 | } |
||
1954 | |||
1955 | |||
1956 | Store (0x11223344, Local0) |
||
1957 | Store (RefOf (Local0), Local1) |
||
1958 | |||
1959 | Store (DerefOf (Local1), Local2) |
||
1960 | If (LNotEqual (Local2, 0x11223344)) |
||
1961 | { |
||
1962 | ERR_ (2) |
||
1963 | } |
||
1964 | |||
1965 | |||
1966 | /* Parser thinks this is a method invocation!! */ |
||
1967 | |||
1968 | // RefOf (MAIN) |
||
1969 | |||
1970 | |||
1971 | // RefOf (R___) |
||
1972 | // RefOf (BBUF) |
||
1973 | |||
1974 | // Store (RefOf (Local0), Local1) |
||
1975 | |||
1976 | // CondRefOf (BBUF, Local2) |
||
1977 | // CondRefOf (R___, Local3) |
||
1978 | |||
1979 | // Store (DerefOf (Local1), Local4) |
||
1980 | |||
1981 | // Return (Local4) |
||
1982 | } |
||
1983 | |||
1984 | |||
1985 | Method (INDX, 0) |
||
1986 | { |
||
1987 | Name(STAT,Package(4){}) |
||
1988 | Store(0x44443333,Index(STAT,0)) |
||
1989 | } |
||
1990 | |||
1991 | //================================================================= |
||
1992 | //================================================================= |
||
1993 | //===================== iPCO TESTS ================================ |
||
1994 | //================================================================= |
||
1995 | //================================================================= |
||
1996 | // |
||
1997 | // |
||
1998 | // test IfElseOp.asl |
||
1999 | // |
||
2000 | // test for IfOp and ElseOp, including validation of object stack cleanup |
||
2001 | // |
||
2002 | Device (IFEL) |
||
2003 | { |
||
2004 | Name (DWRD, 1) |
||
2005 | Name (RSLT, 0) |
||
2006 | |||
2007 | // IFNR control method executes IfOp branch with NO nested Return |
||
2008 | // and no Else branch |
||
2009 | Method (IFNR) |
||
2010 | { |
||
2011 | Store (DWRD, RSLT) |
||
2012 | If (LEqual (DWRD, 1)) |
||
2013 | { |
||
2014 | Store (0, RSLT) |
||
2015 | } |
||
2016 | } // IFNR |
||
2017 | |||
2018 | // NINR control method does not execute If branch and has no Else branch |
||
2019 | Method (NINR) |
||
2020 | { |
||
2021 | Store (0, RSLT) |
||
2022 | If (LNotEqual (DWRD, 1)) |
||
2023 | { |
||
2024 | Store (DWRD, RSLT) |
||
2025 | } |
||
2026 | } // NINR |
||
2027 | |||
2028 | // IENR control method executes IfOp branch with NO nested Return |
||
2029 | Method (IENR) |
||
2030 | { |
||
2031 | If (LEqual (DWRD, 1)) |
||
2032 | { |
||
2033 | Store (0, RSLT) |
||
2034 | } |
||
2035 | Else |
||
2036 | { |
||
2037 | Store (DWRD, RSLT) |
||
2038 | } |
||
2039 | } // IENR |
||
2040 | |||
2041 | // ELNR control method executes ElseOp branch with NO nested Return |
||
2042 | Method (ELNR) |
||
2043 | { |
||
2044 | If (LNotEqual (DWRD, 1)) |
||
2045 | { |
||
2046 | Store (DWRD, RSLT) |
||
2047 | } |
||
2048 | Else |
||
2049 | { |
||
2050 | Store (0, RSLT) |
||
2051 | } |
||
2052 | } // ELNR |
||
2053 | |||
2054 | // IFRT control method executes IfOp branch with nested Return with |
||
2055 | // no Else branch |
||
2056 | Method (IFRT) |
||
2057 | |||
2058 | { |
||
2059 | If (LEqual (DWRD, 1)) |
||
2060 | { |
||
2061 | Return (0) |
||
2062 | } |
||
2063 | Return (DWRD) |
||
2064 | } // IFRT |
||
2065 | |||
2066 | // IERT control method executes IfOp branch with nested Return with |
||
2067 | // Else branch |
||
2068 | Method (IERT) |
||
2069 | { |
||
2070 | If (LEqual (DWRD, 1)) |
||
2071 | { |
||
2072 | Return (0) |
||
2073 | } |
||
2074 | Else |
||
2075 | { |
||
2076 | Return (DWRD) |
||
2077 | } |
||
2078 | } // IERT |
||
2079 | |||
2080 | // ELRT control method executes ElseOp branch with nested Return |
||
2081 | Method (ELRT) |
||
2082 | { |
||
2083 | If (LNotEqual (DWRD, 1)) |
||
2084 | { |
||
2085 | Return (DWRD) |
||
2086 | } |
||
2087 | Else |
||
2088 | { |
||
2089 | Return (0) |
||
2090 | } |
||
2091 | } // ELRT |
||
2092 | |||
2093 | Method (TEST) |
||
2094 | { |
||
2095 | Store ("++++++++ IfElseOp Test", Debug) |
||
2096 | |||
2097 | // IfOp with NO return value |
||
2098 | IFNR() |
||
2099 | If (LNotEqual (RSLT, 0)) |
||
2100 | { |
||
2101 | Return (RSLT) |
||
2102 | } |
||
2103 | |||
2104 | // IfOp with NO return value |
||
2105 | NINR() |
||
2106 | If (LNotEqual (RSLT, 0)) |
||
2107 | { |
||
2108 | Return (RSLT) |
||
2109 | } |
||
2110 | |||
2111 | // IfOp with NO return value |
||
2112 | IENR() |
||
2113 | If (LNotEqual (RSLT, 0)) |
||
2114 | { |
||
2115 | Return (RSLT) |
||
2116 | } |
||
2117 | |||
2118 | // ElseOp with NO return value |
||
2119 | ELNR() |
||
2120 | If (LNotEqual (RSLT, 0)) |
||
2121 | { |
||
2122 | Return (RSLT) |
||
2123 | } |
||
2124 | |||
2125 | // IfOp with return value |
||
2126 | Store (IFRT, RSLT) |
||
2127 | If (LNotEqual (RSLT, 0)) |
||
2128 | { |
||
2129 | Return (RSLT) |
||
2130 | } |
||
2131 | |||
2132 | // IfOp with return value |
||
2133 | Store (IERT, RSLT) |
||
2134 | If (LNotEqual (RSLT, 0)) |
||
2135 | { |
||
2136 | Return (RSLT) |
||
2137 | } |
||
2138 | |||
2139 | // ElseOp with return value |
||
2140 | Store (ELRT, RSLT) |
||
2141 | If (LNotEqual (RSLT, 0)) |
||
2142 | { |
||
2143 | Return (RSLT) |
||
2144 | } |
||
2145 | |||
2146 | Return (0) |
||
2147 | } // TEST |
||
2148 | } // IFEL |
||
2149 | |||
2150 | // |
||
2151 | // test NoSave.asl |
||
2152 | // |
||
2153 | // |
||
2154 | // Internal test cases to validate IfOp (Operator (,,)) where Operator |
||
2155 | // target is ZeroOp to throw away the results. |
||
2156 | // Includes internal test cases for logical operators with no destination |
||
2157 | // operands. |
||
2158 | // |
||
2159 | Device (NOSV) |
||
2160 | { |
||
2161 | Method (TEST) |
||
2162 | { |
||
2163 | Store ("++++++++ NoSave Test", Debug) |
||
2164 | |||
2165 | Name (WRD, 0x1234) |
||
2166 | |||
2167 | // |
||
2168 | // Begin test of nested operators without saving results |
||
2169 | // |
||
2170 | |||
2171 | // Test If (And ()) with no save of And result |
||
2172 | If (And (3, 1, )) |
||
2173 | { |
||
2174 | Store (1, WRD) // pass -- just do something |
||
2175 | } |
||
2176 | else |
||
2177 | { |
||
2178 | Return (1) // fail |
||
2179 | } |
||
2180 | |||
2181 | // Test If (And ()) with no save of And result |
||
2182 | If (And (4, 1, )) |
||
2183 | { |
||
2184 | Return (2) // fail |
||
2185 | } |
||
2186 | else |
||
2187 | { |
||
2188 | Store (2, WRD) // pass -- just do something |
||
2189 | } |
||
2190 | |||
2191 | |||
2192 | // Test If (NAnd ()) with no save of NAnd result |
||
2193 | If (NAnd (3, 1, )) |
||
2194 | { |
||
2195 | Store (3, WRD) // pass -- just do something |
||
2196 | } |
||
2197 | else |
||
2198 | { |
||
2199 | Return (3) // fail |
||
2200 | } |
||
2201 | |||
2202 | // Test If (NAnd ()) with no save of NAnd result |
||
2203 | If (NAnd (0xFFFFFFFF, 0xFFFFFFFF, )) |
||
2204 | { |
||
2205 | Return (4) // fail |
||
2206 | } |
||
2207 | else |
||
2208 | { |
||
2209 | Store (4, WRD) // pass -- just do something |
||
2210 | } |
||
2211 | |||
2212 | |||
2213 | // Test If (NOr ()) with no save of NOr result |
||
2214 | If (NOr (0, 1, )) |
||
2215 | { |
||
2216 | Store (5, WRD) // pass -- just do something |
||
2217 | } |
||
2218 | else |
||
2219 | { |
||
2220 | Return (5) // fail |
||
2221 | } |
||
2222 | |||
2223 | // Test If (NOr ()) with no save of NOr result |
||
2224 | If (NOr (0xFFFFFFFE, 1, )) |
||
2225 | { |
||
2226 | Return (6) // fail |
||
2227 | } |
||
2228 | else |
||
2229 | { |
||
2230 | Store (6, WRD) // pass -- just do something |
||
2231 | } |
||
2232 | |||
2233 | |||
2234 | // Test If (Not ()) with no save of Not result |
||
2235 | If (Not (1, )) |
||
2236 | { |
||
2237 | Store (7, WRD) // pass -- just do something |
||
2238 | } |
||
2239 | else |
||
2240 | { |
||
2241 | Return (7) // fail |
||
2242 | } |
||
2243 | |||
2244 | // Test If (Not ()) with no save of Not result |
||
2245 | If (Not (0xFFFFFFFF, )) |
||
2246 | { |
||
2247 | Return (8) // fail |
||
2248 | } |
||
2249 | else |
||
2250 | { |
||
2251 | Store (8, WRD) // pass -- just do something |
||
2252 | } |
||
2253 | |||
2254 | |||
2255 | // Test If (Or ()) with no save of Or result |
||
2256 | If (Or (3, 1, )) |
||
2257 | { |
||
2258 | Store (9, WRD) // pass -- just do something |
||
2259 | } |
||
2260 | else |
||
2261 | { |
||
2262 | Return (9) // fail |
||
2263 | } |
||
2264 | |||
2265 | // Test If (Or ()) with no save of Or result |
||
2266 | If (Or (0, 0, )) |
||
2267 | { |
||
2268 | Return (10) // fail |
||
2269 | } |
||
2270 | else |
||
2271 | { |
||
2272 | Store (10, WRD) // pass -- just do something |
||
2273 | } |
||
2274 | |||
2275 | |||
2276 | // Test If (XOr ()) with no save of XOr result |
||
2277 | If (XOr (3, 1, )) |
||
2278 | { |
||
2279 | Store (11, WRD) // pass -- just do something |
||
2280 | } |
||
2281 | else |
||
2282 | { |
||
2283 | Return (11) // fail |
||
2284 | } |
||
2285 | |||
2286 | // Test If (XOr ()) with no save of XOr result |
||
2287 | If (XOr (3, 3, )) |
||
2288 | { |
||
2289 | Return (12) // fail |
||
2290 | } |
||
2291 | else |
||
2292 | { |
||
2293 | Store (12, WRD) // pass -- just do something |
||
2294 | } |
||
2295 | |||
2296 | |||
2297 | // |
||
2298 | // Begin test of logical operators with no destination operands |
||
2299 | // |
||
2300 | |||
2301 | // Test If (LAnd ()) with no save of LAnd result |
||
2302 | If (LAnd (3, 3)) |
||
2303 | { |
||
2304 | Store (21, WRD) // pass -- just do something |
||
2305 | } |
||
2306 | else |
||
2307 | { |
||
2308 | Return (21) // fail |
||
2309 | } |
||
2310 | |||
2311 | // Test If (LAnd ()) with no save of LAnd result |
||
2312 | If (LAnd (3, 0)) |
||
2313 | { |
||
2314 | Return (22) // fail |
||
2315 | } |
||
2316 | else |
||
2317 | { |
||
2318 | Store (22, WRD) // pass -- just do something |
||
2319 | } |
||
2320 | |||
2321 | // Test If (LAnd ()) with no save of LAnd result |
||
2322 | If (LAnd (0, 3)) |
||
2323 | { |
||
2324 | Return (23) // fail |
||
2325 | } |
||
2326 | else |
||
2327 | { |
||
2328 | Store (23, WRD) // pass -- just do something |
||
2329 | } |
||
2330 | |||
2331 | // Test If (LAnd ()) with no save of LAnd result |
||
2332 | If (LAnd (0, 0)) |
||
2333 | { |
||
2334 | Return (24) // fail |
||
2335 | } |
||
2336 | else |
||
2337 | { |
||
2338 | Store (24, WRD) // pass -- just do something |
||
2339 | } |
||
2340 | |||
2341 | |||
2342 | // Test If (LEqual ()) with no save of LEqual result |
||
2343 | If (LEqual (3, 3)) |
||
2344 | { |
||
2345 | Store (31, WRD) // pass -- just do something |
||
2346 | } |
||
2347 | else |
||
2348 | { |
||
2349 | Return (31) // fail |
||
2350 | } |
||
2351 | |||
2352 | // Test If (LEqual ()) with no save of LEqual result |
||
2353 | If (LEqual (1, 3)) |
||
2354 | { |
||
2355 | Return (32) // fail |
||
2356 | } |
||
2357 | else |
||
2358 | { |
||
2359 | Store (32, WRD) // pass -- just do something |
||
2360 | } |
||
2361 | |||
2362 | |||
2363 | // Test If (LGreater ()) with no save of LGreater result |
||
2364 | If (LGreater (3, 1)) |
||
2365 | { |
||
2366 | Store (41, WRD) // pass -- just do something |
||
2367 | } |
||
2368 | else |
||
2369 | { |
||
2370 | Return (41) // fail |
||
2371 | } |
||
2372 | |||
2373 | // Test If (LGreater ()) with no save of LGreater result |
||
2374 | If (LGreater (4, 4)) |
||
2375 | { |
||
2376 | Return (42) // fail |
||
2377 | } |
||
2378 | else |
||
2379 | { |
||
2380 | Store (42, WRD) // pass -- just do something |
||
2381 | } |
||
2382 | |||
2383 | // Test If (LGreater ()) with no save of LGreater result |
||
2384 | If (LGreater (1, 4)) |
||
2385 | { |
||
2386 | Return (43) // fail |
||
2387 | } |
||
2388 | else |
||
2389 | { |
||
2390 | Store (43, WRD) // pass -- just do something |
||
2391 | } |
||
2392 | |||
2393 | // Test If (LGreaterEqual ()) with no save of LGreaterEqual result |
||
2394 | If (LGreaterEqual (3, 1)) |
||
2395 | { |
||
2396 | Store (44, WRD) // pass -- just do something |
||
2397 | } |
||
2398 | else |
||
2399 | { |
||
2400 | Return (44) // fail |
||
2401 | } |
||
2402 | |||
2403 | // Test If (LGreaterEqual ()) with no save of LGreaterEqual result |
||
2404 | If (LGreaterEqual (3, 3)) |
||
2405 | { |
||
2406 | Store (45, WRD) // pass -- just do something |
||
2407 | } |
||
2408 | else |
||
2409 | { |
||
2410 | Return (45) // fail |
||
2411 | } |
||
2412 | |||
2413 | // Test If (LGreaterEqual ()) with no save of LGreaterEqual result |
||
2414 | If (LGreaterEqual (3, 4)) |
||
2415 | { |
||
2416 | Return (46) // fail |
||
2417 | } |
||
2418 | else |
||
2419 | { |
||
2420 | Store (46, WRD) // pass -- just do something |
||
2421 | } |
||
2422 | |||
2423 | |||
2424 | // Test If (LLess ()) with no save of LLess result |
||
2425 | If (LLess (1, 3)) |
||
2426 | { |
||
2427 | Store (51, WRD) // pass -- just do something |
||
2428 | } |
||
2429 | else |
||
2430 | { |
||
2431 | Return (51) // fail |
||
2432 | } |
||
2433 | |||
2434 | // Test If (LLess ()) with no save of LLess result |
||
2435 | If (LLess (2, 2)) |
||
2436 | { |
||
2437 | Return (52) // fail |
||
2438 | } |
||
2439 | else |
||
2440 | { |
||
2441 | Store (52, WRD) // pass -- just do something |
||
2442 | } |
||
2443 | |||
2444 | // Test If (LLess ()) with no save of LLess result |
||
2445 | If (LLess (4, 2)) |
||
2446 | { |
||
2447 | Return (53) // fail |
||
2448 | } |
||
2449 | else |
||
2450 | { |
||
2451 | Store (53, WRD) // pass -- just do something |
||
2452 | } |
||
2453 | |||
2454 | |||
2455 | // Test If (LLessEqual ()) with no save of LLessEqual result |
||
2456 | If (LLessEqual (1, 3)) |
||
2457 | { |
||
2458 | Store (54, WRD) // pass -- just do something |
||
2459 | } |
||
2460 | else |
||
2461 | { |
||
2462 | Return (54) // fail |
||
2463 | } |
||
2464 | |||
2465 | // Test If (LLessEqual ()) with no save of LLessEqual result |
||
2466 | If (LLessEqual (2, 2)) |
||
2467 | { |
||
2468 | Store (55, WRD) // pass -- just do something |
||
2469 | } |
||
2470 | else |
||
2471 | { |
||
2472 | Return (55) // fail |
||
2473 | } |
||
2474 | |||
2475 | // Test If (LLessEqual ()) with no save of LLessEqual result |
||
2476 | If (LLessEqual (4, 2)) |
||
2477 | { |
||
2478 | Return (56) // fail |
||
2479 | } |
||
2480 | else |
||
2481 | { |
||
2482 | Store (56, WRD) // pass -- just do something |
||
2483 | } |
||
2484 | |||
2485 | |||
2486 | // Test If (LNot ()) with no save of LNot result |
||
2487 | If (LNot (0)) |
||
2488 | { |
||
2489 | Store (61, WRD) // pass -- just do something |
||
2490 | } |
||
2491 | else |
||
2492 | { |
||
2493 | Return (61) // fail |
||
2494 | } |
||
2495 | |||
2496 | // Test If (LNot ()) with no save of LNot result |
||
2497 | If (LNot (1)) |
||
2498 | { |
||
2499 | Return (62) // fail |
||
2500 | } |
||
2501 | else |
||
2502 | { |
||
2503 | Store (62, WRD) // pass -- just do something |
||
2504 | } |
||
2505 | |||
2506 | |||
2507 | // Test If (LNotEqual ()) with no save of LNotEqual result |
||
2508 | If (LNotEqual (3, 3)) |
||
2509 | { |
||
2510 | Return (63) // fail |
||
2511 | } |
||
2512 | else |
||
2513 | { |
||
2514 | Store (63, WRD) // pass -- just do something |
||
2515 | } |
||
2516 | |||
2517 | // Test If (LNotEqual ()) with no save of LNotEqual result |
||
2518 | If (LNotEqual (1, 3)) |
||
2519 | { |
||
2520 | Store (64, WRD) // pass -- just do something |
||
2521 | } |
||
2522 | else |
||
2523 | { |
||
2524 | Return (64) // fail |
||
2525 | } |
||
2526 | |||
2527 | |||
2528 | // Test If (LOr ()) with no save of LOr result |
||
2529 | If (LOr (3, 1)) |
||
2530 | { |
||
2531 | Store (71, WRD) // pass -- just do something |
||
2532 | } |
||
2533 | else |
||
2534 | { |
||
2535 | Return (71) // fail |
||
2536 | } |
||
2537 | |||
2538 | // Test If (LOr ()) with no save of LOr result |
||
2539 | If (LOr (0, 1)) |
||
2540 | { |
||
2541 | Store (72, WRD) // pass -- just do something |
||
2542 | } |
||
2543 | else |
||
2544 | { |
||
2545 | Return (72) // fail |
||
2546 | } |
||
2547 | |||
2548 | // Test If (LOr ()) with no save of LOr result |
||
2549 | If (LOr (3, 0)) |
||
2550 | { |
||
2551 | Store (73, WRD) // pass -- just do something |
||
2552 | } |
||
2553 | else |
||
2554 | { |
||
2555 | Return (73) // fail |
||
2556 | } |
||
2557 | |||
2558 | // Test If (LOr ()) with no save of LOr result |
||
2559 | If (LOr (0, 0)) |
||
2560 | { |
||
2561 | Return (74) // fail |
||
2562 | } |
||
2563 | else |
||
2564 | { |
||
2565 | Store (74, WRD) // pass -- just do something |
||
2566 | } |
||
2567 | |||
2568 | Return (0) |
||
2569 | } // TEST |
||
2570 | } // NOSV |
||
2571 | |||
2572 | |||
2573 | // |
||
2574 | // test IndxFld.asl |
||
2575 | // |
||
2576 | // IndexFld test |
||
2577 | // This is just a subset of the many RegionOp/Index Field test cases. |
||
2578 | // Tests index field element AccessAs macro. |
||
2579 | // |
||
2580 | Device (IDXF) |
||
2581 | { // Test device name |
||
2582 | |||
2583 | OperationRegion (SIO, SystemIO, 0x100, 2) |
||
2584 | Field (SIO, ByteAcc, NoLock, Preserve) |
||
2585 | { |
||
2586 | INDX, 8, |
||
2587 | DATA, 8 |
||
2588 | } |
||
2589 | IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes) |
||
2590 | { |
||
2591 | AccessAs (ByteAcc, 0), |
||
2592 | IFE0, 8, |
||
2593 | IFE1, 8, |
||
2594 | IFE2, 8, |
||
2595 | IFE3, 8, |
||
2596 | IFE4, 8, |
||
2597 | IFE5, 8, |
||
2598 | IFE6, 8, |
||
2599 | IFE7, 8, |
||
2600 | IFE8, 8, |
||
2601 | IFE9, 8, |
||
2602 | } |
||
2603 | |||
2604 | Method (TEST) |
||
2605 | { |
||
2606 | Store ("++++++++ IndxFld Test", Debug) |
||
2607 | |||
2608 | Store (IFE0, Local0) |
||
2609 | Store (IFE1, Local1) |
||
2610 | Store (IFE2, Local2) |
||
2611 | |||
2612 | Return (0) |
||
2613 | } // TEST |
||
2614 | } // IDXF |
||
2615 | |||
2616 | // |
||
2617 | // test NestdLor.asl |
||
2618 | // |
||
2619 | Scope (\_SB) // System Bus |
||
2620 | { // _SB system bus |
||
2621 | |||
2622 | Name (ZER0, 0) |
||
2623 | Name (ZER1, 0) |
||
2624 | Name (ZER2, 0) |
||
2625 | Name (ONE0, 1) |
||
2626 | |||
2627 | Device (NSTL) |
||
2628 | { |
||
2629 | Method (TEST) |
||
2630 | { |
||
2631 | Store ("++++++++ NestdLor Test", Debug) |
||
2632 | |||
2633 | If (Lor (ZER0, Lor (ZER1, Lor (ZER2, ONE0)))) |
||
2634 | { // Indicate Pass |
||
2635 | Store (0x00, Local0) |
||
2636 | } |
||
2637 | |||
2638 | Else |
||
2639 | { // Indicate Fail |
||
2640 | Store (0x01, Local0) |
||
2641 | } |
||
2642 | |||
2643 | Return (Local0) |
||
2644 | } // End Method TEST |
||
2645 | } // Device NSTL |
||
2646 | } // _SB system bus |
||
2647 | |||
2648 | // |
||
2649 | // test RetBuf.asl |
||
2650 | // |
||
2651 | // Test ReturnOp(Buffer) |
||
2652 | // This is required to support Control Method Batteries on |
||
2653 | // Dell Latitude Laptops (e.g., CP1-A) |
||
2654 | // |
||
2655 | Device (RTBF) |
||
2656 | { |
||
2657 | Method (SUBR, 1) |
||
2658 | { |
||
2659 | Return (Arg0) |
||
2660 | } |
||
2661 | |||
2662 | Method (RBUF) |
||
2663 | { // RBUF: Return Buffer from local variable |
||
2664 | Name (ABUF, Buffer() {"ARBITRARY_BUFFER"}) |
||
2665 | |||
2666 | // store local buffer ABUF into Local0 |
||
2667 | Store (ABUF, Local0) |
||
2668 | |||
2669 | // save Local0 object type value into Local1 |
||
2670 | Store (ObjectType (Local0), Local1) |
||
2671 | |||
2672 | // validate Local0 is a Buffer |
||
2673 | If (LNotEqual (Local1, 3)) // Buffer type is 3 |
||
2674 | { |
||
2675 | Return (1) // failure |
||
2676 | } |
||
2677 | |||
2678 | // store value returned by control method SUBR into Local0 |
||
2679 | Store (SUBR (ABUF), Local0) |
||
2680 | |||
2681 | // save Local0 object type value into Local1 |
||
2682 | Store (ObjectType (Local0), Local1) |
||
2683 | |||
2684 | // validate Local0 is a Buffer |
||
2685 | If (LNotEqual (Local1, 3)) // Buffer type is 3 |
||
2686 | { |
||
2687 | Return (2) // failure |
||
2688 | } |
||
2689 | |||
2690 | // allocate buffer using Local1 as buffer size (run-time evaluation) |
||
2691 | Store (5, Local1) |
||
2692 | Name (BUFR, Buffer(Local1) {}) |
||
2693 | |||
2694 | // store value returned by control method SUBR into Local0 |
||
2695 | Store (SUBR (BUFR), Local0) |
||
2696 | |||
2697 | // save Local0 object type value into Local1 |
||
2698 | Store (ObjectType (Local0), Local1) |
||
2699 | |||
2700 | // validate Local0 is a Buffer |
||
2701 | If (LNotEqual (Local1, 3)) // Buffer type is 3 |
||
2702 | { |
||
2703 | Return (3) // failure |
||
2704 | } |
||
2705 | |||
2706 | // store BUFR Buffer into Local0 |
||
2707 | Store (BUFR, Local0) |
||
2708 | |||
2709 | // save Local0 object type value into Local1 |
||
2710 | Store (ObjectType (Local0), Local1) |
||
2711 | |||
2712 | // validate Local0 is a Buffer |
||
2713 | If (LNotEqual (Local1, 3)) // Buffer type is 3 |
||
2714 | { |
||
2715 | Return (4) // failure |
||
2716 | } |
||
2717 | |||
2718 | |||
2719 | // return Local0 Buffer |
||
2720 | Return (Local0) |
||
2721 | } // RBUF |
||
2722 | |||
2723 | Method (TEST) |
||
2724 | { |
||
2725 | Store ("++++++++ RetBuf Test", Debug) |
||
2726 | |||
2727 | // store RBUF Buffer return value into Local0 |
||
2728 | Store (RBUF, Local0) |
||
2729 | |||
2730 | // save Local0 object type value into Local1 |
||
2731 | Store (ObjectType (Local0), Local1) |
||
2732 | |||
2733 | // validate Local0 is a Buffer |
||
2734 | If (LNotEqual (Local1, 3)) // Buffer type is 3 |
||
2735 | { |
||
2736 | Return (10) // failure |
||
2737 | } |
||
2738 | Else |
||
2739 | { |
||
2740 | Return (0) // success |
||
2741 | } |
||
2742 | } // TEST |
||
2743 | } // RTBF |
||
2744 | |||
2745 | // |
||
2746 | // test RetLVal.asl |
||
2747 | // |
||
2748 | // Test ReturnOp(Lvalue) |
||
2749 | // This is required to support _PSR on IBM ThinkPad 560D and |
||
2750 | // _DCK on Toshiba Tecra 8000. |
||
2751 | // |
||
2752 | |||
2753 | Device (GPE2) |
||
2754 | { |
||
2755 | Method (_L03) |
||
2756 | { |
||
2757 | Store ("Method GPE2._L03 invoked", Debug) |
||
2758 | Return () |
||
2759 | } |
||
2760 | |||
2761 | Method (_E05) |
||
2762 | { |
||
2763 | Store ("Method GPE2._E05 invoked", Debug) |
||
2764 | Return () |
||
2765 | } |
||
2766 | } |
||
2767 | |||
2768 | Device (PRW2) |
||
2769 | { |
||
2770 | Name (_PRW, Package(2) {Package(2){\GPE2, 0x05}, 3}) |
||
2771 | } |
||
2772 | |||
2773 | |||
2774 | Scope (\_GPE) |
||
2775 | { |
||
2776 | Name (ACST, 0xFF) |
||
2777 | |||
2778 | Method (_L08) |
||
2779 | { |
||
2780 | Store ("Method _GPE._L08 invoked", Debug) |
||
2781 | Return () |
||
2782 | } |
||
2783 | |||
2784 | Method (_E09) |
||
2785 | { |
||
2786 | Store ("Method _GPE._E09 invoked", Debug) |
||
2787 | Return () |
||
2788 | } |
||
2789 | |||
2790 | Method (_E11) |
||
2791 | { |
||
2792 | Store ("Method _GPE._E11 invoked", Debug) |
||
2793 | Notify (\PRW1, 2) |
||
2794 | } |
||
2795 | |||
2796 | Method (_L22) |
||
2797 | { |
||
2798 | Store ("Method _GPE._L22 invoked", Debug) |
||
2799 | Return () |
||
2800 | } |
||
2801 | |||
2802 | Method (_L33) |
||
2803 | { |
||
2804 | Store ("Method _GPE._L33 invoked", Debug) |
||
2805 | Return () |
||
2806 | } |
||
2807 | |||
2808 | Method (_E64) |
||
2809 | { |
||
2810 | Store ("Method _GPE._E64 invoked", Debug) |
||
2811 | Return () |
||
2812 | } |
||
2813 | |||
2814 | } // _GPE |
||
2815 | |||
2816 | Device (PRW1) |
||
2817 | { |
||
2818 | Name (_PRW, Package(2) {0x11, 3}) |
||
2819 | } |
||
2820 | |||
2821 | Device (PWRB) |
||
2822 | { |
||
2823 | Name (_HID, EISAID("PNP0C0C")) |
||
2824 | Name (_PRW, Package(2) {0x33, 3}) |
||
2825 | } |
||
2826 | |||
2827 | |||
2828 | Scope (\_SB) // System Bus |
||
2829 | { // _SB system bus |
||
2830 | |||
2831 | Device (ACAD) |
||
2832 | { // ACAD: AC adapter device |
||
2833 | Name (_HID, "ACPI0003") // AC adapter device |
||
2834 | |||
2835 | Name (_PCL, Package () {\_SB}) |
||
2836 | |||
2837 | OperationRegion (AREG, SystemIO, 0x0372, 2) |
||
2838 | Field (AREG, ByteAcc, NoLock, Preserve) |
||
2839 | { |
||
2840 | AIDX, 8, |
||
2841 | ADAT, 8 |
||
2842 | } |
||
2843 | IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve) |
||
2844 | { |
||
2845 | , 1, // skips |
||
2846 | ACIN, 1, |
||
2847 | , 2, // skips |
||
2848 | CHAG, 1, |
||
2849 | , 3, // skips |
||
2850 | , 7, // skips |
||
2851 | ABAT, 1, |
||
2852 | } // IndexField |
||
2853 | |||
2854 | Method (_PSR) |
||
2855 | { |
||
2856 | Store (\_GPE.ACST, Local0) |
||
2857 | Store (ACIN, Local1) |
||
2858 | If (LNotEqual (\_GPE.ACST, Local1)) |
||
2859 | { |
||
2860 | Store (Local1, \_GPE.ACST) |
||
2861 | // This Notify is commented because it causes a |
||
2862 | // method error when running on a system without the |
||
2863 | // specific device. |
||
2864 | // Notify (\_SB_.ACAD, 0) |
||
2865 | } |
||
2866 | Return (Local0) |
||
2867 | } // _PSR |
||
2868 | |||
2869 | Method (_STA) |
||
2870 | { |
||
2871 | Return (0x0F) |
||
2872 | } |
||
2873 | |||
2874 | Method (_INI) |
||
2875 | { |
||
2876 | Store (ACIN, \_GPE.ACST) |
||
2877 | } |
||
2878 | } // ACAD: AC adapter device |
||
2879 | |||
2880 | // test implicit return from control method |
||
2881 | Method (DIS_, 1) |
||
2882 | { |
||
2883 | Store (Arg0, Local0) |
||
2884 | } |
||
2885 | |||
2886 | Device (RTLV) |
||
2887 | { |
||
2888 | // test implicit return inside nested if with explicit return of Lvalue |
||
2889 | Method (_DCK, 1) |
||
2890 | // Arg0: 1 == dock, 0 == undock |
||
2891 | { |
||
2892 | If (Arg0) |
||
2893 | { // dock |
||
2894 | Store (0x87, Local0) |
||
2895 | |||
2896 | If (Local0) |
||
2897 | { |
||
2898 | DIS_ (0x23) |
||
2899 | Return (1) |
||
2900 | } |
||
2901 | |||
2902 | Return (0) |
||
2903 | } // dock |
||
2904 | Else |
||
2905 | { // undock |
||
2906 | Store (Arg0, Local0) |
||
2907 | |||
2908 | If (Local0) |
||
2909 | { |
||
2910 | DIS_ (0x23) |
||
2911 | Return (1) |
||
2912 | } |
||
2913 | |||
2914 | Return (0) |
||
2915 | } // undock |
||
2916 | } // _DCK control method |
||
2917 | |||
2918 | Method (TEST) |
||
2919 | { |
||
2920 | Store ("++++++++ RetLVal Test", Debug) |
||
2921 | |||
2922 | // store _PSR return value into Local0 |
||
2923 | Store (\_SB_.ACAD._PSR, Local0) |
||
2924 | |||
2925 | // save Local0 object type value into Local1 |
||
2926 | Store (ObjectType (Local0), Local1) |
||
2927 | |||
2928 | // validate Local0 is a Number |
||
2929 | If (LNotEqual (Local1, 1)) // Number/Integer type is 1 |
||
2930 | { |
||
2931 | Return (1) // failure |
||
2932 | } |
||
2933 | |||
2934 | // test implicit return inside nested if with explicit return of Lvalue |
||
2935 | Store (_DCK (1), Local2) |
||
2936 | |||
2937 | // save Local2 object type value into Local3 |
||
2938 | Store (ObjectType (Local2), Local3) |
||
2939 | |||
2940 | // validate Local2 is a Number |
||
2941 | If (LNotEqual (Local3, 1)) // Number/Integer type is 1 |
||
2942 | { |
||
2943 | Return (2) // failure |
||
2944 | } |
||
2945 | |||
2946 | If (LNotEqual (Local2, 1)) |
||
2947 | { |
||
2948 | Return (3) // failure |
||
2949 | } |
||
2950 | |||
2951 | Return (0) // success |
||
2952 | } // TEST |
||
2953 | } // RTLV |
||
2954 | } // _SB system bus |
||
2955 | |||
2956 | // |
||
2957 | // test RetPkg.asl |
||
2958 | // |
||
2959 | // Test ReturnOp(Package) |
||
2960 | // This is required to support _PRT on Dell Optiplex Workstations (e.g. GX1) |
||
2961 | // |
||
2962 | |||
2963 | Scope (\_SB) // System Bus |
||
2964 | { // _SB system bus |
||
2965 | Device(LNKA) |
||
2966 | { |
||
2967 | Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link |
||
2968 | Name (_UID, 1) |
||
2969 | } |
||
2970 | Device(LNKB) |
||
2971 | { |
||
2972 | Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link |
||
2973 | Name (_UID, 2) |
||
2974 | } |
||
2975 | Device(LNKC) |
||
2976 | { |
||
2977 | Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link |
||
2978 | Name (_UID, 3) |
||
2979 | } |
||
2980 | Device(LNKD) |
||
2981 | { |
||
2982 | Name (_HID, EISAID("PNP0C0F")) // PCI interrupt link |
||
2983 | Name (_UID, 4) |
||
2984 | } |
||
2985 | |||
2986 | Device (PCI1) |
||
2987 | { // PCI1: Root PCI Bus |
||
2988 | Name (_HID, "PNP0A03") // Need _HID for root device (String format) |
||
2989 | Name (_ADR,0x00000000) |
||
2990 | Name (_CRS,0) |
||
2991 | |||
2992 | Name (_PRT, Package () |
||
2993 | { |
||
2994 | Package () {0x0004ffff, 0, LNKA, 0}, // Slot 1, INTA |
||
2995 | Package () {0x0004ffff, 1, LNKB, 0}, // Slot 1, INTB |
||
2996 | Package () {0x0004ffff, 2, LNKC, 0}, // Slot 1, INTC |
||
2997 | Package () {0x0004ffff, 3, LNKD, 0}, // Slot 1, INTD |
||
2998 | Package () {0x0005ffff, 0, \_SB_.LNKB, 0}, // Slot 2, INTA |
||
2999 | Package () {0x0005ffff, 1, \_SB_.LNKC, 0}, // Slot 2, INTB |
||
3000 | Package () {0x0005ffff, 2, \_SB_.LNKD, 0}, // Slot 2, INTC |
||
3001 | Package () {0x0006ffff, 3, \_SB_.LNKA, 0}, // Slot 2, INTD |
||
3002 | Package () {0x0006ffff, 0, LNKC, 0}, // Slot 3, INTA |
||
3003 | Package () {0x0006ffff, 1, LNKD, 0}, // Slot 3, INTB |
||
3004 | Package () {0x0006ffff, 2, LNKA, 0}, // Slot 3, INTC |
||
3005 | Package () {0x0006ffff, 3, LNKB, 0}, // Slot 3, INTD |
||
3006 | }) |
||
3007 | |||
3008 | Device (PX40) |
||
3009 | { // Map f0 space, Start PX40 |
||
3010 | Name (_ADR,0x00070000) // Address+function. |
||
3011 | } |
||
3012 | } // PCI0: Root PCI Bus |
||
3013 | |||
3014 | Device (RETP) |
||
3015 | { |
||
3016 | Method (RPKG) |
||
3017 | { // RPKG: Return Package from local variable |
||
3018 | |||
3019 | // store _PRT package into Local0 |
||
3020 | Store (\_SB_.PCI1._PRT, Local0) |
||
3021 | |||
3022 | // return Local0 Package |
||
3023 | Return (Local0) |
||
3024 | } // RPKG |
||
3025 | |||
3026 | Method (TEST) |
||
3027 | { |
||
3028 | Store ("++++++++ RetPkg Test", Debug) |
||
3029 | |||
3030 | // store RPKG package return value into Local0 |
||
3031 | Store (RPKG, Local0) |
||
3032 | |||
3033 | // save Local0 object type value into Local1 |
||
3034 | Store (ObjectType (Local0), Local1) |
||
3035 | |||
3036 | // validate Local0 is a Package |
||
3037 | If (LNotEqual (Local1, 4)) // Package type is 4 |
||
3038 | { Return (1) } // failure |
||
3039 | Else |
||
3040 | { Return (0) } // success |
||
3041 | } // TEST |
||
3042 | } // RETP |
||
3043 | } // _SB_ |
||
3044 | |||
3045 | // |
||
3046 | // test WhileRet.asl |
||
3047 | // |
||
3048 | // WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp. |
||
3049 | // |
||
3050 | Device (WHLR) |
||
3051 | { |
||
3052 | Name (LCNT, 0) |
||
3053 | Method (WIR) |
||
3054 | { // WIR: control method that returns inside of IfOp inside of WhileOp |
||
3055 | While (LLess (LCNT, 4)) |
||
3056 | { |
||
3057 | If (LEqual (LCNT, 2)) |
||
3058 | { |
||
3059 | Return (0) |
||
3060 | } |
||
3061 | |||
3062 | Increment (LCNT) |
||
3063 | } |
||
3064 | |||
3065 | Return (LCNT) |
||
3066 | } // WIR: control method that returns inside of IfOp inside of WhileOp |
||
3067 | |||
3068 | Method (TEST) |
||
3069 | { |
||
3070 | Store ("++++++++ WhileRet Test", Debug) |
||
3071 | |||
3072 | Store (WIR, Local0) |
||
3073 | |||
3074 | Return (Local0) |
||
3075 | } // TEST |
||
3076 | } // WHLR |
||
3077 | |||
3078 | // |
||
3079 | // test AndOrOp.asl |
||
3080 | // |
||
3081 | //This code tests the bitwise AndOp and OrOp Operator terms |
||
3082 | // |
||
3083 | //Syntax of Andop term |
||
3084 | //And - Bitwise And |
||
3085 | //AndTerm := And( |
||
3086 | // Source1, //TermArg=>Integer |
||
3087 | // Source2, //TermArg=>Integer |
||
3088 | // Result //Nothing | SuperName |
||
3089 | //) => Integer |
||
3090 | //Source1 and Source2 are evaluated as integer data types, |
||
3091 | // a bit-wise AND is performed, and the result is optionally |
||
3092 | //stored into Result. |
||
3093 | // |
||
3094 | // |
||
3095 | //Syntax of OrOp |
||
3096 | //Or - Bit-wise Or |
||
3097 | //OrTerm := Or( |
||
3098 | // Source1, //TermArg=>Integer |
||
3099 | // Source2 //TermArg=>Integer |
||
3100 | // Result //Nothing | SuperName |
||
3101 | //) => Integer |
||
3102 | //Source1 and Source2 are evaluated as integer data types, |
||
3103 | // a bit-wide OR is performed, and the result is optionally |
||
3104 | //stored in Result |
||
3105 | // |
||
3106 | Device (ANDO) |
||
3107 | { |
||
3108 | OperationRegion (TMEM, SystemMemory, 0xC4, 0x02) |
||
3109 | Field (TMEM, ByteAcc, NoLock, Preserve) |
||
3110 | { |
||
3111 | , 3, |
||
3112 | TOUD, 13 |
||
3113 | } |
||
3114 | |||
3115 | //Create System Memory Operation Region and field overlays |
||
3116 | OperationRegion (RAM, SystemMemory, 0x400000, 0x100) |
||
3117 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
3118 | { |
||
3119 | SMDW, 32, // 32-bit DWORD |
||
3120 | SMWD, 16, // 16-bit WORD |
||
3121 | SMBY, 8, // 8-bit BYTE |
||
3122 | }// Field(RAM) |
||
3123 | |||
3124 | |||
3125 | //And with Byte Data |
||
3126 | Name (BYT1, 0xff) |
||
3127 | Name (BYT2, 0xff) |
||
3128 | Name (BRSL, 0x00) |
||
3129 | |||
3130 | //And with Word Data |
||
3131 | Name (WRD1, 0xffff) |
||
3132 | Name (WRD2, 0xffff) |
||
3133 | Name (WRSL, 0x0000) |
||
3134 | |||
3135 | //And with DWord Data |
||
3136 | Name (DWD1, 0xffffffff) |
||
3137 | Name (DWD2, 0xffffffff) |
||
3138 | Name (DRSL, 0x00000000) |
||
3139 | |||
3140 | Method (ANDP) |
||
3141 | { |
||
3142 | //Check with 1 And 1 on byte data |
||
3143 | And(BYT1, BYT2, BRSL) |
||
3144 | if(LNotEqual(BRSL,0xff)) |
||
3145 | {Return(1)} |
||
3146 | |||
3147 | //Check with 1 And 1 on Word data |
||
3148 | And(WRD1, WRD2, WRSL) |
||
3149 | if(LNotEqual(WRSL,0xffff)) |
||
3150 | { |
||
3151 | Return (1) // failure |
||
3152 | } |
||
3153 | |||
3154 | //Check with 1 And 1 Dword |
||
3155 | And(DWD1, DWD2, DRSL) |
||
3156 | if(LNotEqual(DRSL,0xffffffff)) |
||
3157 | { |
||
3158 | Return (1) // failure |
||
3159 | } |
||
3160 | |||
3161 | //Check with 0 And 0 on byte data |
||
3162 | Store(0x00,BYT1) |
||
3163 | Store(0x00,BYT2) |
||
3164 | Store(0x00,BRSL) |
||
3165 | And(BYT1, BYT2, BRSL) |
||
3166 | if(LNotEqual(BRSL,0x00)) |
||
3167 | { |
||
3168 | Return (1) // failure |
||
3169 | } |
||
3170 | |||
3171 | //Check with 0 And 0 on Word data |
||
3172 | Store (0x0000,WRD1) |
||
3173 | Store (0x0000,WRD2) |
||
3174 | Store (0x0000,WRSL) |
||
3175 | And(WRD1, WRD2, WRSL) |
||
3176 | if(LNotEqual(WRSL,0x0000)) |
||
3177 | { |
||
3178 | Return (1) // failure |
||
3179 | } |
||
3180 | |||
3181 | //Check with 0 And 0 Dword |
||
3182 | Store (0x00000000,DWD1) |
||
3183 | Store (0x00000000,DWD2) |
||
3184 | Store (0x00000000,DRSL) |
||
3185 | And(DWD1, DWD2, DRSL) |
||
3186 | if(LNotEqual(DRSL,0x00000000)) |
||
3187 | { |
||
3188 | Return (1) // failure |
||
3189 | } |
||
3190 | |||
3191 | |||
3192 | //Check with 1 And 0 on byte data |
||
3193 | Store(0x55,BYT1) |
||
3194 | Store(0xAA,BYT2) |
||
3195 | Store(0x00,BRSL) |
||
3196 | And(BYT1, BYT2, BRSL) |
||
3197 | if(LNotEqual(BRSL,0x00)) |
||
3198 | { |
||
3199 | Return (1) // failure |
||
3200 | } |
||
3201 | |||
3202 | //Check with 1 And 0 on Word data |
||
3203 | Store (0x5555,WRD1) |
||
3204 | Store (0xAAAA,WRD2) |
||
3205 | Store (0x0000,WRSL) |
||
3206 | And(WRD1, WRD2, WRSL) |
||
3207 | if(LNotEqual(WRSL,0x0000)) |
||
3208 | { |
||
3209 | Return (1) // failure |
||
3210 | } |
||
3211 | |||
3212 | //Check with 1 And 0 on Dword |
||
3213 | Store (0x55555555,DWD1) |
||
3214 | Store (0xAAAAAAAA,DWD2) |
||
3215 | Store (0x00000000,DRSL) |
||
3216 | And(DWD1, DWD2, DRSL) |
||
3217 | if(LNotEqual(DRSL,0x00000000)) |
||
3218 | { |
||
3219 | Return (1) // failure |
||
3220 | } |
||
3221 | |||
3222 | Store (0x1FFF, TOUD) |
||
3223 | Store (TOUD, Local0) |
||
3224 | if(LNotEqual(Local0,0x1FFF)) |
||
3225 | { |
||
3226 | Return (1) // failure |
||
3227 | } |
||
3228 | |||
3229 | //TBD- Do We need to check for system memory data also for each test case ?? |
||
3230 | |||
3231 | Return(0) |
||
3232 | |||
3233 | }//ANDP |
||
3234 | |||
3235 | Method (OROP) |
||
3236 | { |
||
3237 | |||
3238 | //Check with 1 Ored with 1 on byte data |
||
3239 | Store(0xff,BYT1) |
||
3240 | Store(0xff,BYT2) |
||
3241 | Store(0x00,BRSL) |
||
3242 | Or(BYT1, BYT2, BRSL) |
||
3243 | if(LNotEqual(BRSL,0xff)) |
||
3244 | { |
||
3245 | Return (1) // failure |
||
3246 | } |
||
3247 | |||
3248 | |||
3249 | //Check with 1 Ored with 1 on Word data |
||
3250 | Store(0xffff,WRD1) |
||
3251 | Store(0xffff,WRD2) |
||
3252 | Store(0x0000,WRSL) |
||
3253 | Or(WRD1, WRD2, WRSL) |
||
3254 | if(LNotEqual(WRSL,0xffff)) |
||
3255 | { |
||
3256 | Return (1) // failure |
||
3257 | } |
||
3258 | |||
3259 | //Check with 1 Ored with 1 on Dword data |
||
3260 | Store(0xffffffff,DWD1) |
||
3261 | Store(0xffffffff,DWD2) |
||
3262 | Store(0x00000000,DRSL) |
||
3263 | Or(DWD1, DWD2, DRSL) |
||
3264 | if(LNotEqual(DRSL,0xffffffff)) |
||
3265 | { |
||
3266 | Return (1) // failure |
||
3267 | } |
||
3268 | |||
3269 | //Check with 0 Ored with 0 on byte data |
||
3270 | Store(0x00,BYT1) |
||
3271 | Store(0x00,BYT2) |
||
3272 | Store(0x00,BRSL) |
||
3273 | Or(BYT1, BYT2, BRSL) |
||
3274 | if(LNotEqual(BRSL,0x00)) |
||
3275 | { |
||
3276 | Return (1) // failure |
||
3277 | } |
||
3278 | |||
3279 | //Check with 0 Ored with 0 on Word data |
||
3280 | Store (0x0000,WRD1) |
||
3281 | Store (0x0000,WRD2) |
||
3282 | Store (0x0000,WRSL) |
||
3283 | Or(WRD1, WRD2, WRSL) |
||
3284 | if(LNotEqual(WRSL,0x0000)) |
||
3285 | { |
||
3286 | Return (1) // failure |
||
3287 | } |
||
3288 | |||
3289 | //Check with 0 Ored with 0 Dword data |
||
3290 | Store (0x00000000,DWD1) |
||
3291 | Store (0x00000000,DWD2) |
||
3292 | Store (0x00000000,DRSL) |
||
3293 | Or(DWD1, DWD2, DRSL) |
||
3294 | if(LNotEqual(DRSL,0x00000000)) |
||
3295 | { |
||
3296 | Return (1) // failure |
||
3297 | } |
||
3298 | |||
3299 | |||
3300 | //Check with 1 Ored with 0 on byte data |
||
3301 | Store(0x55,BYT1) |
||
3302 | Store(0xAA,BYT2) |
||
3303 | Store(0x00,BRSL) |
||
3304 | Or(BYT1, BYT2, BRSL) |
||
3305 | if(LNotEqual(BRSL,0xff)) |
||
3306 | { |
||
3307 | Return (1) // failure |
||
3308 | } |
||
3309 | |||
3310 | //Check with 1 Ored with 0 on Word data |
||
3311 | Store (0x5555,WRD1) |
||
3312 | Store (0xAAAA,WRD2) |
||
3313 | Store (0x0000,WRSL) |
||
3314 | Or(WRD1, WRD2, WRSL) |
||
3315 | if(LNotEqual(WRSL,0xffff)) |
||
3316 | { |
||
3317 | Return (1) // failure |
||
3318 | } |
||
3319 | |||
3320 | //Check with 1 Ored with 0 on Dword data |
||
3321 | Store (0x55555555,DWD1) |
||
3322 | Store (0xAAAAAAAA,DWD2) |
||
3323 | Store (0x00000000,DRSL) |
||
3324 | Or(DWD1, DWD2, DRSL) |
||
3325 | if(LNotEqual(DRSL,0xffffffff)) |
||
3326 | { |
||
3327 | Return (1) // failure |
||
3328 | } |
||
3329 | |||
3330 | //TBD - Do We need to check for system memory data also for each test case ?? |
||
3331 | |||
3332 | Return(0) |
||
3333 | |||
3334 | }//OROP |
||
3335 | |||
3336 | Method(TEST) |
||
3337 | { |
||
3338 | Store ("++++++++ AndOrOp Test", Debug) |
||
3339 | |||
3340 | Name(RSLT,1) |
||
3341 | //Call Andop method |
||
3342 | Store(ANDP,RSLT) |
||
3343 | if(LEqual(RSLT,1)) |
||
3344 | { |
||
3345 | Return (RSLT) |
||
3346 | } |
||
3347 | |||
3348 | //Call OrOp Method |
||
3349 | Store(OROP,RSLT) |
||
3350 | if(LEqual(RSLT,1)) |
||
3351 | { |
||
3352 | Return(RSLT) |
||
3353 | } |
||
3354 | |||
3355 | // |
||
3356 | // Return original conditions to allow iterative execution |
||
3357 | // |
||
3358 | Store(0xff,BYT1) |
||
3359 | Store(0xff,BYT2) |
||
3360 | Store(0x00,BRSL) |
||
3361 | Store (0xffff,WRD1) |
||
3362 | Store (0xffff,WRD2) |
||
3363 | Store (0x0000,WRSL) |
||
3364 | Store (0xffffffff,DWD1) |
||
3365 | Store (0xffffffff,DWD2) |
||
3366 | Store (0x00000000,DRSL) |
||
3367 | |||
3368 | Return(0) |
||
3369 | } //TEST |
||
3370 | } //ANDO |
||
3371 | |||
3372 | // |
||
3373 | // test BreakPnt.asl |
||
3374 | // |
||
3375 | // This code tests the BreakPoint opcode term. The syntax of BreakPoint Term is |
||
3376 | // BreakPointTerm := BreakPoint |
||
3377 | // Used for debugging, the Breakpoint opcode stops the execution and enters the AML debugger. |
||
3378 | // In the non-debug version of the interpreter, BreakPoint is equivalent to Noop. |
||
3379 | // |
||
3380 | Device (BRKP) |
||
3381 | { |
||
3382 | Name(CNT0,0) |
||
3383 | |||
3384 | Method (BK1) |
||
3385 | { |
||
3386 | BreakPoint |
||
3387 | Return(0) |
||
3388 | } |
||
3389 | |||
3390 | Method (TEST) |
||
3391 | { |
||
3392 | Store ("++++++++ BreakPnt Test", Debug) |
||
3393 | |||
3394 | Store(0,CNT0) |
||
3395 | |||
3396 | //Check BreakPoint statement |
||
3397 | While(LLess(CNT0,10)) |
||
3398 | { |
||
3399 | Increment(CNT0) |
||
3400 | } |
||
3401 | |||
3402 | //Check the BreakPoint statement |
||
3403 | If(LEqual(CNT0,10)) |
||
3404 | { |
||
3405 | // BreakPoint |
||
3406 | Return(0) |
||
3407 | } |
||
3408 | |||
3409 | //failed |
||
3410 | Return(1) |
||
3411 | } |
||
3412 | } |
||
3413 | |||
3414 | // |
||
3415 | // test AddSubOp.asl |
||
3416 | // |
||
3417 | Device (ADSU) |
||
3418 | { |
||
3419 | // create System Memory Operation Region and field overlays |
||
3420 | OperationRegion (RAM, SystemMemory, 0x400000, 0x100) |
||
3421 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
3422 | { |
||
3423 | SMDW, 32, // 32-bit DWORD |
||
3424 | SMWD, 16, // 16-bit WORD |
||
3425 | SMBY, 8, // 8-bit BYTE |
||
3426 | } // Field(RAM) |
||
3427 | |||
3428 | Method (TEST) |
||
3429 | { |
||
3430 | Store ("++++++++ AddSubOp Test", Debug) |
||
3431 | |||
3432 | Name (DWRD, 0x12345678) |
||
3433 | Name (WRD, 0x1234) |
||
3434 | Name (BYT, 0x12) |
||
3435 | |||
3436 | // Test AddOp with DWORD data |
||
3437 | Store (0x12345678, DWRD) |
||
3438 | Add (DWRD, 7, DWRD) |
||
3439 | If (LNotEqual (DWRD, 0x1234567F)) |
||
3440 | { Return (DWRD) } |
||
3441 | |||
3442 | // Test AddOp with WORD data |
||
3443 | Add (WRD, 5, WRD) |
||
3444 | If (LNotEqual (WRD, 0x1239)) |
||
3445 | { Return (WRD) } |
||
3446 | |||
3447 | // Test AddOp with BYTE data |
||
3448 | Add (BYT, 3, BYT) |
||
3449 | If (LNotEqual (BYT, 0x15)) |
||
3450 | { Return (BYT) } |
||
3451 | |||
3452 | // Test SubtractOp with DWORD data |
||
3453 | Subtract (DWRD, 7, DWRD) |
||
3454 | If (LNotEqual (DWRD, 0x12345678)) |
||
3455 | { Return (DWRD) } |
||
3456 | |||
3457 | // Test SubtractOp with WORD data |
||
3458 | Subtract (WRD, 3, WRD) |
||
3459 | If (LNotEqual (WRD, 0x1236)) |
||
3460 | { Return (WRD) } |
||
3461 | |||
3462 | // Test SubtractOp with BYTE data |
||
3463 | Subtract (BYT, 3, BYT) |
||
3464 | If (LNotEqual (BYT, 0x12)) |
||
3465 | { Return (BYT) } |
||
3466 | |||
3467 | |||
3468 | // test AddOp with DWORD SystemMemory OpRegion |
||
3469 | Store (0x01234567, SMDW) |
||
3470 | Add (SMDW, 8, SMDW) |
||
3471 | If (LNotEqual (SMDW, 0x0123456F)) |
||
3472 | { Return (SMDW) } |
||
3473 | |||
3474 | // test SubtractOp with DWORD SystemMemory OpRegion |
||
3475 | Subtract (SMDW, 7, SMDW) |
||
3476 | If (LNotEqual (SMDW, 0x01234568)) |
||
3477 | { Return (SMDW) } |
||
3478 | |||
3479 | |||
3480 | // test AddOp with WORD SystemMemory OpRegion |
||
3481 | Store (0x0123, SMWD) |
||
3482 | Add (SMWD, 6, SMWD) |
||
3483 | If (LNotEqual (SMWD, 0x0129)) |
||
3484 | { Return (SMWD) } |
||
3485 | |||
3486 | // test SubtractOp with WORD SystemMemory OpRegion |
||
3487 | Subtract (SMWD, 5, SMWD) |
||
3488 | If (LNotEqual (SMWD, 0x0124)) |
||
3489 | { Return (SMWD) } |
||
3490 | |||
3491 | |||
3492 | // test AddOp with BYTE SystemMemory OpRegion |
||
3493 | Store (0x01, SMBY) |
||
3494 | Add (SMBY, 4, SMBY) |
||
3495 | If (LNotEqual (SMBY, 0x05)) |
||
3496 | { Return (SMBY) } |
||
3497 | |||
3498 | // test SubtractOp with BYTE SystemMemory OpRegion |
||
3499 | Subtract (SMBY, 3, SMBY) |
||
3500 | If (LNotEqual (SMBY, 0x02)) |
||
3501 | { Return (SMBY) } |
||
3502 | |||
3503 | Return (0) |
||
3504 | } // TEST |
||
3505 | } // ADSU |
||
3506 | |||
3507 | // |
||
3508 | // test IncDecOp.asl |
||
3509 | // |
||
3510 | Device (INDC) |
||
3511 | { |
||
3512 | // create System Memory Operation Region and field overlays |
||
3513 | OperationRegion (RAM, SystemMemory, 0x400000, 0x100) |
||
3514 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
3515 | { |
||
3516 | SMDW, 32, // 32-bit DWORD |
||
3517 | SMWD, 16, // 16-bit WORD |
||
3518 | SMBY, 8, // 8-bit BYTE |
||
3519 | } // Field(RAM) |
||
3520 | |||
3521 | Method (TEST) |
||
3522 | { |
||
3523 | Store ("++++++++ IncDecOp Test", Debug) |
||
3524 | |||
3525 | Name (DWRD, 0x12345678) |
||
3526 | Name (WRD, 0x1234) |
||
3527 | Name (BYT, 0x12) |
||
3528 | |||
3529 | // Test IncrementOp with DWORD data |
||
3530 | Store (0x12345678, DWRD) |
||
3531 | Increment (DWRD) |
||
3532 | If (LNotEqual (DWRD, 0x12345679)) |
||
3533 | { Return (DWRD) } |
||
3534 | |||
3535 | // Test IncrementOp with WORD data |
||
3536 | Increment (WRD) |
||
3537 | If (LNotEqual (WRD, 0x1235)) |
||
3538 | { Return (WRD) } |
||
3539 | |||
3540 | // Test IncrementOp with BYTE data |
||
3541 | Increment (BYT) |
||
3542 | If (LNotEqual (BYT, 0x13)) |
||
3543 | { Return (BYT) } |
||
3544 | |||
3545 | // Test DecrementOp with DWORD data |
||
3546 | Decrement (DWRD) |
||
3547 | If (LNotEqual (DWRD, 0x12345678)) |
||
3548 | { Return (DWRD) } |
||
3549 | |||
3550 | // Test DecrementOp with WORD data |
||
3551 | Decrement (WRD) |
||
3552 | If (LNotEqual (WRD, 0x1234)) |
||
3553 | { Return (WRD) } |
||
3554 | |||
3555 | // Test DecrementOp with BYTE data |
||
3556 | Decrement (BYT) |
||
3557 | If (LNotEqual (BYT, 0x12)) |
||
3558 | { Return (BYT) } |
||
3559 | |||
3560 | |||
3561 | // test IncrementOp with DWORD SystemMemory OpRegion |
||
3562 | Store (0x01234567, SMDW) |
||
3563 | Increment (SMDW) |
||
3564 | If (LNotEqual (SMDW, 0x01234568)) |
||
3565 | { Return (SMDW) } |
||
3566 | |||
3567 | // test DecrementOp with DWORD SystemMemory OpRegion |
||
3568 | Decrement (SMDW) |
||
3569 | If (LNotEqual (SMDW, 0x01234567)) |
||
3570 | { Return (SMDW) } |
||
3571 | |||
3572 | |||
3573 | // test IncrementOp with WORD SystemMemory OpRegion |
||
3574 | Store (0x0123, SMWD) |
||
3575 | Increment (SMWD) |
||
3576 | If (LNotEqual (SMWD, 0x0124)) |
||
3577 | { Return (SMWD) } |
||
3578 | |||
3579 | // test DecrementOp with WORD SystemMemory OpRegion |
||
3580 | Decrement (SMWD) |
||
3581 | If (LNotEqual (SMWD, 0x0123)) |
||
3582 | { Return (SMWD) } |
||
3583 | |||
3584 | |||
3585 | // test IncrementOp with BYTE SystemMemory OpRegion |
||
3586 | Store (0x01, SMBY) |
||
3587 | Increment (SMBY) |
||
3588 | If (LNotEqual (SMBY, 0x02)) |
||
3589 | { Return (SMBY) } |
||
3590 | |||
3591 | // test DecrementOp with BYTE SystemMemory OpRegion |
||
3592 | Decrement (SMBY) |
||
3593 | If (LNotEqual (SMBY, 0x01)) |
||
3594 | { Return (SMBY) } |
||
3595 | |||
3596 | Return (0) |
||
3597 | } // TEST |
||
3598 | } // INDC |
||
3599 | |||
3600 | // |
||
3601 | // test LOps.asl |
||
3602 | // |
||
3603 | //This source tests all the logical operators. Logical operators in ASL are as follows. |
||
3604 | //LAnd, LEqual, LGreater, LLess, LNot, LNotEqual, LOr. |
||
3605 | // Success will return 0 and failure will return a non zero number. Check the source code for |
||
3606 | // non zero number to find where the test failed |
||
3607 | |||
3608 | Device (LOPS) |
||
3609 | { |
||
3610 | //Create System Memory Operation Region and field overlays |
||
3611 | OperationRegion (RAM, SystemMemory, 0x400000, 0x100) |
||
3612 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
3613 | { |
||
3614 | SMDW, 32, // 32-bit DWORD |
||
3615 | SMWD, 16, // 16-bit WORD |
||
3616 | SMBY, 8, // 8-bit BYTE |
||
3617 | }// Field(RAM) |
||
3618 | |||
3619 | //And with Byte Data |
||
3620 | Name (BYT1, 0xff) |
||
3621 | Name (BYT2, 0xff) |
||
3622 | Name (BRSL, 0x00) |
||
3623 | |||
3624 | //And with Word Data |
||
3625 | Name (WRD1, 0xffff) |
||
3626 | Name (WRD2, 0xffff) |
||
3627 | Name (WRSL, 0x0000) |
||
3628 | |||
3629 | //And with DWord Data |
||
3630 | Name (DWD1, 0xffffffff) |
||
3631 | Name (DWD2, 0xffffffff) |
||
3632 | Name (DRSL, 0x00000000) |
||
3633 | |||
3634 | Name(RSLT,1) |
||
3635 | |||
3636 | Method (ANDL,2) // Test Logical And |
||
3637 | { |
||
3638 | //test with the arguments passed |
||
3639 | if(LEqual(Arg0,Arg1)) |
||
3640 | { Store(LAnd(Arg0,Arg1),RSLT) |
||
3641 | if(LNotEqual(Ones,RSLT)) |
||
3642 | {Return(11)} |
||
3643 | } |
||
3644 | |||
3645 | //test with he locals |
||
3646 | Store(Arg0,Local0) |
||
3647 | Store(Arg1,Local1) |
||
3648 | |||
3649 | if(LEqual(Local0,Local1)) |
||
3650 | { |
||
3651 | Store(LAnd(Local0,Local1),RSLT) |
||
3652 | if(LNotEqual(Ones,RSLT)) |
||
3653 | {Return(12)} |
||
3654 | } |
||
3655 | |||
3656 | //test with BYTE data |
||
3657 | if(LEqual(BYT1,BYT2)) |
||
3658 | { Store(LAnd(BYT1,BYT2),BRSL) |
||
3659 | if(LNotEqual(Ones,BRSL)) |
||
3660 | {Return(13)} |
||
3661 | } |
||
3662 | |||
3663 | //test with WORD data |
||
3664 | if(LEqual(WRD1,WRD2)) |
||
3665 | { Store(LAnd(WRD1,WRD2),WRSL) |
||
3666 | if(LNotEqual(Ones,WRSL)) |
||
3667 | {Return(14)} |
||
3668 | } |
||
3669 | |||
3670 | //test with DWORD data |
||
3671 | if(LEqual(DWD1,DWD2)) |
||
3672 | { Store(LAnd(DWD1,DWD2),DRSL) |
||
3673 | if(LNotEqual(Ones,DRSL)) |
||
3674 | {Return(15)} |
||
3675 | } |
||
3676 | |||
3677 | //Test for system memory data for each test case. |
||
3678 | |||
3679 | Store(0xff,BYT1) |
||
3680 | Store(0xff,SMBY) |
||
3681 | Store(0x00,BRSL) |
||
3682 | |||
3683 | //test with BYTE system memory data |
||
3684 | if(LEqual(BYT1,SMBY)) |
||
3685 | { Store(LAnd(BYT1,SMBY),BRSL) |
||
3686 | if(LNotEqual(Ones,BRSL)) |
||
3687 | {Return(16)} |
||
3688 | } |
||
3689 | |||
3690 | Store (0xffff,WRD1) |
||
3691 | Store(0xffff,SMWD) |
||
3692 | Store(0x0000,WRSL) |
||
3693 | //test with WORD system memory data |
||
3694 | if(LEqual(WRD1,SMWD)) |
||
3695 | { Store(LAnd(WRD1,SMWD),WRSL) |
||
3696 | if(LNotEqual(Ones,WRSL)) |
||
3697 | {Return(17)} |
||
3698 | } |
||
3699 | |||
3700 | Store(0x000000,DRSL) |
||
3701 | Store (0xffffff,DWD1) |
||
3702 | Store(0xffffff,SMDW) |
||
3703 | |||
3704 | //test with DWORD system memory data |
||
3705 | if(LEqual(DWD1,SMDW)) |
||
3706 | { Store(LAnd(DWD1,SMDW),DRSL) |
||
3707 | if(LNotEqual(Ones,DRSL)) |
||
3708 | {Return(18)} |
||
3709 | } |
||
3710 | |||
3711 | Return(0) |
||
3712 | |||
3713 | }//ANDL |
||
3714 | |||
3715 | //Test the LOr Operator |
||
3716 | |||
3717 | Method (ORL_,2) |
||
3718 | {//ORL_ |
||
3719 | |||
3720 | //test with the arguments passed |
||
3721 | if(LEqual(Arg0,Arg1)) |
||
3722 | { |
||
3723 | Store(LOr(Arg0,Arg1),RSLT) |
||
3724 | if(LNotEqual(Ones,RSLT)) |
||
3725 | { |
||
3726 | Return(21) |
||
3727 | } |
||
3728 | } |
||
3729 | |||
3730 | //test with he locals |
||
3731 | Store(Arg0,Local0) |
||
3732 | Store(Arg1,Local1) |
||
3733 | |||
3734 | if(LEqual(Local0,Local1)) |
||
3735 | { |
||
3736 | Store(LOr(Local0,Local1),RSLT) |
||
3737 | if(LNotEqual(Ones,RSLT)) |
||
3738 | {Return(22)} |
||
3739 | } |
||
3740 | |||
3741 | //Check with 1 LOred with 0 on byte data |
||
3742 | Store(0xff,BYT1) |
||
3743 | Store(0x00,BYT2) |
||
3744 | Store(0x00,BRSL) |
||
3745 | |||
3746 | if(LNotEqual(BYT1, BYT2)) |
||
3747 | { |
||
3748 | Store(LOr(BYT1, BYT2), BRSL) |
||
3749 | if(LNotEqual(Ones,BRSL)) |
||
3750 | {Return(23)} |
||
3751 | } |
||
3752 | |||
3753 | //Check with 1 LOred with 0 on WORD data |
||
3754 | Store(0xffff,WRD1) |
||
3755 | Store(0x0000,WRD2) |
||
3756 | Store(0x0000,WRSL) |
||
3757 | |||
3758 | if(LNotEqual(WRD1, WRD2)) |
||
3759 | { |
||
3760 | Store(LOr(WRD1, WRD2), WRSL) |
||
3761 | if(LNotEqual(Ones,WRSL)) |
||
3762 | {Return(24)} |
||
3763 | } |
||
3764 | |||
3765 | //Check with 1 LOred with 0 on DWORD data |
||
3766 | Store(0xffffffff,DWD1) |
||
3767 | Store(0x00000000,DWD2) |
||
3768 | Store(0x00000000,DRSL) |
||
3769 | |||
3770 | if(LNotEqual(DWD1, DWD2)) |
||
3771 | { |
||
3772 | Store(LOr(DWD1, DWD2), DRSL) |
||
3773 | if(LNotEqual(Ones,DRSL)) |
||
3774 | {Return(25)} |
||
3775 | } |
||
3776 | |||
3777 | Store(0x00,BYT1) |
||
3778 | Store(0xff,SMBY) |
||
3779 | Store(0x00,BRSL) |
||
3780 | |||
3781 | //test with BYTE system memory data |
||
3782 | if(LEqual(BYT1,SMBY)) |
||
3783 | { Store(LOr(BYT1,SMBY),BRSL) |
||
3784 | if(LNotEqual(Ones,BRSL)) |
||
3785 | {Return(26)} |
||
3786 | } |
||
3787 | |||
3788 | Store (0x0000,WRD1) |
||
3789 | Store(0xffff,SMWD) |
||
3790 | Store(0x0000,WRSL) |
||
3791 | |||
3792 | //test with WORD system memory data |
||
3793 | if(LEqual(WRD1,SMWD)) |
||
3794 | { Store(LOr(WRD1,SMWD),WRSL) |
||
3795 | if(LNotEqual(Ones,WRSL)) |
||
3796 | {Return(27)} |
||
3797 | } |
||
3798 | |||
3799 | |||
3800 | Store(0x00000000,DWD1) |
||
3801 | Store(0xffffffff,SMDW) |
||
3802 | Store(0x00000000,DRSL) |
||
3803 | |||
3804 | //test with DWORD system memory data |
||
3805 | if(LEqual(DWD1,SMDW)) |
||
3806 | { Store(LAnd(DWD1,SMDW),DRSL) |
||
3807 | if(LNotEqual(Ones,DRSL)) |
||
3808 | {Return(28)} |
||
3809 | } |
||
3810 | Return(0) |
||
3811 | |||
3812 | }//ORL_ |
||
3813 | |||
3814 | //This method tests LGreater and LNot operator |
||
3815 | Method(LSGR,2) |
||
3816 | {//LSGR |
||
3817 | |||
3818 | //Test on arguements passed |
||
3819 | |||
3820 | //in test data, Arg1 > Arg0 |
||
3821 | if(LEqual(Ones,LNot(LGreater(Arg1,Arg0)))) |
||
3822 | {Return(31)} |
||
3823 | |||
3824 | //test LLessEqual |
||
3825 | if(LEqual(Ones,LNot(LGreaterEqual(Arg1,Arg0)))) |
||
3826 | {Return(32)} |
||
3827 | |||
3828 | if(LEqual(Ones,LLess(Arg1,Arg0))) |
||
3829 | {Return(33)} |
||
3830 | |||
3831 | //test LLessEqual |
||
3832 | if(LEqual(Ones,LLessEqual(Arg1,Arg0))) |
||
3833 | {Return(34)} |
||
3834 | |||
3835 | Store(Arg0,Local0) |
||
3836 | Store(Arg1,Local1) |
||
3837 | |||
3838 | //test with the locals |
||
3839 | if(LNot(LGreater(Local1,Local0))) |
||
3840 | {Return(35)} |
||
3841 | |||
3842 | //test on Byte data |
||
3843 | Store(0x12,BYT1) |
||
3844 | Store(0x21,BYT2) |
||
3845 | |||
3846 | if(LNot(LGreater(BYT2,BYT1))) |
||
3847 | {Return(36)} |
||
3848 | |||
3849 | if(LNot(LLess(BYT1,BYT2))) |
||
3850 | {Return(37)} |
||
3851 | |||
3852 | //test LGreaterEqual with byte data |
||
3853 | if(LNot(LGreaterEqual(BYT2,BYT1))) |
||
3854 | {Return(38)} |
||
3855 | |||
3856 | //test LLessEqual byte data |
||
3857 | if(LNot(LLessEqual(BYT1,BYT2))) |
||
3858 | {Return(39)} |
||
3859 | |||
3860 | |||
3861 | //test on Word data |
||
3862 | Store(0x1212,WRD1) |
||
3863 | Store(0x2121,WRD2) |
||
3864 | |||
3865 | if(LNot(LGreater(WRD2,WRD1))) |
||
3866 | {Return(310)} |
||
3867 | |||
3868 | if(LNot(LLess(WRD1,WRD2))) |
||
3869 | {Return(311)} |
||
3870 | |||
3871 | //Test LGreaterEqual with Word Data |
||
3872 | if(LNot(LGreaterEqual(WRD2,WRD1))) |
||
3873 | {Return(312)} |
||
3874 | |||
3875 | |||
3876 | //Test LLessEqual with Word Data |
||
3877 | if(LNot(LLessEqual(WRD1,WRD2))) |
||
3878 | {Return(313)} |
||
3879 | |||
3880 | //test on DWord data |
||
3881 | Store(0x12121212,DWD1) |
||
3882 | Store(0x21212121,DWD2) |
||
3883 | |||
3884 | if(LNot(LGreater(DWD2,DWD1))) |
||
3885 | {Return(314)} |
||
3886 | |||
3887 | if(LNot(LLess(DWD1,DWD2))) |
||
3888 | {Return(315)} |
||
3889 | |||
3890 | |||
3891 | //Test LGreaterEqual with Dword |
||
3892 | if(LNot(LGreaterEqual(DWD2,DWD1))) |
||
3893 | {Return(316)} |
||
3894 | |||
3895 | //Test LLessEqual DWord |
||
3896 | if(LNot(LLessEqual(DWD1,DWD2))) |
||
3897 | {Return(317)} |
||
3898 | |||
3899 | Return(0) |
||
3900 | }//LSGR |
||
3901 | |||
3902 | //The test method |
||
3903 | Method(TEST) |
||
3904 | { |
||
3905 | Store ("++++++++ LOps Test", Debug) |
||
3906 | |||
3907 | Store(0,RSLT) |
||
3908 | //Call LAndOp method |
||
3909 | Store(ANDL(2,2),RSLT) |
||
3910 | if(LNotEqual(RSLT,0)) |
||
3911 | {Return(RSLT)} |
||
3912 | |||
3913 | //Call LOrOp Method |
||
3914 | Store(ORL_(5,5),RSLT) |
||
3915 | if(LNotEqual(RSLT,0)) |
||
3916 | {Return(RSLT)} |
||
3917 | |||
3918 | //Call LSGR Method |
||
3919 | Store(LSGR(5,7),RSLT) |
||
3920 | if(LNotEqual(RSLT,0)) |
||
3921 | {Return(RSLT)} |
||
3922 | |||
3923 | Return(0) |
||
3924 | }//TEST |
||
3925 | }//LOPS |
||
3926 | |||
3927 | // |
||
3928 | // test FdSetOps.asl |
||
3929 | // |
||
3930 | // FindSetLeftBit - Find Set Left Bit |
||
3931 | // FindSetLeftBitTerm := FindSetLeftBit |
||
3932 | // ( Source, //TermArg=>Integer |
||
3933 | // Result //Nothing | SuperName |
||
3934 | // ) => Integer |
||
3935 | // Source is evaluated as integer data type, and the one-based bit location of |
||
3936 | // the first MSb (most significant set bit) is optionally stored into Result. |
||
3937 | // The result of 0 means no bit was set, 1 means the left-most bit set is the |
||
3938 | // first bit, 2 means the left-most bit set is the second bit, and so on. |
||
3939 | // FindSetRightBit - Find Set Right Bit |
||
3940 | |||
3941 | // FindSetRightBitTerm := FindSetRightBit |
||
3942 | // ( Source, //TermArg=>Integer |
||
3943 | // Result //Nothing | SuperName |
||
3944 | // ) => Integer |
||
3945 | // Source is evaluated as integer data type, and the one-based bit location of |
||
3946 | // the most LSb (least significant set bit) is optionally stored in Result. |
||
3947 | // The result of 0 means no bit was set, 32 means the first bit set is the |
||
3948 | // 32nd bit, 31 means the first bit set is the 31st bit, and so on. |
||
3949 | |||
3950 | // If the Control method is success Zero is returned. Otherwise a non-zero |
||
3951 | // number is returned. |
||
3952 | // |
||
3953 | Device (FDSO) |
||
3954 | { // FDSO |
||
3955 | |||
3956 | // Create System Memory Operation Region and field overlays |
||
3957 | OperationRegion (RAM, SystemMemory, 0x400000, 0x100) |
||
3958 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
3959 | { |
||
3960 | SMDW, 32, // 32-bit DWORD |
||
3961 | SMWD, 16, // 16-bit WORD |
||
3962 | SMBY, 8, // 8-bit BYTE |
||
3963 | } // Field(RAM) |
||
3964 | |||
3965 | // Byte Data |
||
3966 | Name (BYT1, 1) |
||
3967 | Name (BRSL, 0x00) |
||
3968 | |||
3969 | // Word Data |
||
3970 | Name (WRD1, 0x100) |
||
3971 | Name (WRSL, 0x0000) |
||
3972 | |||
3973 | // DWord Data |
||
3974 | Name (DWD1, 0x10000) |
||
3975 | Name (DRSL, 0x00000000) |
||
3976 | Name (RSLT, 1) |
||
3977 | Name (CNTR, 1) |
||
3978 | |||
3979 | Method (SHFT,2) |
||
3980 | // Arg0 is the actual data and Arg1 is the bit position |
||
3981 | { // SHFT |
||
3982 | Store (Arg0, Local0) |
||
3983 | Store (Arg1, Local1) |
||
3984 | |||
3985 | FindSetLeftBit (Arg0, BRSL) |
||
3986 | If (LNotEqual (BRSL, Arg1)) |
||
3987 | { Return (0x11) } |
||
3988 | If (LNotEqual (Arg0, Local0)) |
||
3989 | { Return (0x12) } |
||
3990 | |||
3991 | FindSetLeftBit (Local0, BRSL) |
||
3992 | If (LNotEqual (BRSL, Local1)) |
||
3993 | { Return (0x13) } |
||
3994 | If (LNotEqual (Arg0, Local0)) |
||
3995 | { Return (0x14) } |
||
3996 | |||
3997 | // test the byte value for SetLeftBit |
||
3998 | Store (7, BYT1) |
||
3999 | FindSetLeftBit (BYT1, BRSL) |
||
4000 | If (LNotEqual (BRSL, 3)) |
||
4001 | { Return (0x15) } |
||
4002 | If (LNotEqual (BYT1, 7)) |
||
4003 | { Return (0x16) } |
||
4004 | |||
4005 | Store (1, BYT1) |
||
4006 | Store (1, CNTR) |
||
4007 | While (LLessEqual (CNTR, 8)) |
||
4008 | { // FindSetLeftBit check loop for byte data |
||
4009 | FindSetLeftBit (BYT1, BRSL) |
||
4010 | If (LNotEqual (BRSL, CNTR)) |
||
4011 | { Return (0x17) } |
||
4012 | |||
4013 | // Shift the bits to check the same |
||
4014 | ShiftLeft (BYT1, 1, BYT1) |
||
4015 | Increment (CNTR) |
||
4016 | } // FindSetLeftBit check loop for byte data |
||
4017 | |||
4018 | |||
4019 | // Check BYTE value for SetRightBit |
||
4020 | Store (7, BYT1) |
||
4021 | FindSetRightBit (BYT1, BRSL) |
||
4022 | If (LNotEqual (BRSL, 1)) |
||
4023 | { Return (0x21) } |
||
4024 | If (LNotEqual (BYT1, 7)) |
||
4025 | { Return (0x22) } |
||
4026 | |||
4027 | Store (1, CNTR) |
||
4028 | Store (0xFF, BYT1) |
||
4029 | While (LLessEqual (CNTR, 8)) |
||
4030 | { // FindSetRightBit check loop for byte data |
||
4031 | FindSetRightBit (BYT1, BRSL) |
||
4032 | If (LNotEqual (BRSL, CNTR)) |
||
4033 | { Return (0x23) } |
||
4034 | |||
4035 | ShiftLeft (BYT1, 1, BYT1) |
||
4036 | Increment (CNTR) |
||
4037 | } // FindSetRightBit check loop for byte data |
||
4038 | |||
4039 | |||
4040 | // Test Word value for SetLeftBit |
||
4041 | Store (9, CNTR) |
||
4042 | Store (0x100, WRD1) |
||
4043 | While (LLessEqual (CNTR, 16)) |
||
4044 | { |
||
4045 | // FindSetLeftBit check loop for Word data |
||
4046 | FindSetLeftBit (WRD1, WRSL) |
||
4047 | If (LNotEqual (WRSL, CNTR)) |
||
4048 | { Return (0x31) } |
||
4049 | |||
4050 | // Shift the bits to check the same |
||
4051 | ShiftLeft (WRD1, 1, WRD1) |
||
4052 | Increment (CNTR) |
||
4053 | } // FindSetLeftBit check loop for Word data |
||
4054 | |||
4055 | // Check Word value for SetRightBit |
||
4056 | Store (9, CNTR) |
||
4057 | Store (0xFF00, WRD1) |
||
4058 | While (LLessEqual (CNTR, 16)) |
||
4059 | { |
||
4060 | // FindSetRightBit check loop for Word data |
||
4061 | FindSetRightBit (WRD1, WRSL) |
||
4062 | If (LNotEqual (WRSL, CNTR)) |
||
4063 | { Return (0x32) } |
||
4064 | |||
4065 | ShiftLeft (WRD1, 1, WRD1) |
||
4066 | Increment (CNTR) |
||
4067 | } // FindSetRightBit check loop for Word data |
||
4068 | |||
4069 | // Test the DWord value for SetLeftBit |
||
4070 | Store (17, CNTR) |
||
4071 | Store (0x10000, DWD1) |
||
4072 | While (LLessEqual (CNTR, 32)) |
||
4073 | { |
||
4074 | // FindSetLeftBit check loop for Dword |
||
4075 | FindSetLeftBit (DWD1, DRSL) |
||
4076 | If (LNotEqual (DRSL, CNTR)) |
||
4077 | { Return (0x41) } |
||
4078 | |||
4079 | // Shift the bits to check the same |
||
4080 | ShiftLeft (DWD1, 1, DWD1) |
||
4081 | Increment (CNTR) |
||
4082 | } // FindSetLeftBit check loop for Dword |
||
4083 | |||
4084 | // Check DWord value for SetRightBit |
||
4085 | Store (17, CNTR) |
||
4086 | Store (0xFFFF0000, DWD1) |
||
4087 | While (LLessEqual (CNTR, 32)) |
||
4088 | { // FindSetRightBit Check loop for DWORD |
||
4089 | FindSetRightBit (DWD1, DRSL) |
||
4090 | If (LNotEqual (DRSL, CNTR)) |
||
4091 | { Return (0x42) } |
||
4092 | |||
4093 | ShiftLeft (DWD1, 1, DWD1) |
||
4094 | Increment (CNTR) |
||
4095 | } // FindSetRightBit Check loop for DWORD |
||
4096 | |||
4097 | Return (0) |
||
4098 | } // SHFT |
||
4099 | |||
4100 | // Test method called from amlexec |
||
4101 | Method (TEST) |
||
4102 | { // TEST |
||
4103 | |||
4104 | Store ("++++++++ FdSetOps Test", Debug) |
||
4105 | |||
4106 | Store (SHFT (0x80, 8), RSLT) |
||
4107 | If (LNotEqual (RSLT, 0)) |
||
4108 | { Return (RSLT) } |
||
4109 | |||
4110 | Return (0) // pass |
||
4111 | } // TEST |
||
4112 | } // Device FDSO |
||
4113 | |||
4114 | // |
||
4115 | // test MulDivOp.asl |
||
4116 | // |
||
4117 | Device (MLDV) |
||
4118 | { |
||
4119 | // create System Memory Operation Region and field overlays |
||
4120 | OperationRegion (RAM, SystemMemory, 0x400000, 0x100) |
||
4121 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
4122 | { |
||
4123 | SMDW, 32, // 32-bit DWORD |
||
4124 | SMWD, 16, // 16-bit WORD |
||
4125 | SMBY, 8, // 8-bit BYTE |
||
4126 | } // Field(RAM) |
||
4127 | |||
4128 | Method (TEST) |
||
4129 | { |
||
4130 | Store ("++++++++ MulDivOp Test", Debug) |
||
4131 | |||
4132 | Name (RMDR, 0) |
||
4133 | Name (DWRD, 0x12345678) |
||
4134 | Name (WRD, 0x1234) |
||
4135 | Name (BYT, 0x12) |
||
4136 | |||
4137 | // Test MultiplyOp with DWORD data |
||
4138 | Store (0x12345678, DWRD) |
||
4139 | Multiply (DWRD, 3, DWRD) |
||
4140 | If (LNotEqual (DWRD, 0x369D0368)) |
||
4141 | { Return (DWRD) } |
||
4142 | |||
4143 | // Test MultiplyOp with WORD data |
||
4144 | Multiply (WRD, 4, WRD) |
||
4145 | If (LNotEqual (WRD, 0x48D0)) |
||
4146 | { Return (WRD) } |
||
4147 | |||
4148 | // Test MultiplyOp with BYTE data |
||
4149 | Multiply (BYT, 5, BYT) |
||
4150 | If (LNotEqual (BYT, 0x5A)) |
||
4151 | { Return (BYT) } |
||
4152 | |||
4153 | // Test DivideOp with DWORD data |
||
4154 | Divide (DWRD, 3, DWRD, RMDR) |
||
4155 | If (LNotEqual (DWRD, 0x12345678)) |
||
4156 | { Return (DWRD) } |
||
4157 | If (LNotEqual (RMDR, 0)) |
||
4158 | { Return (RMDR) } |
||
4159 | |||
4160 | // Test DivideOp with WORD data |
||
4161 | Divide (WRD, 4, WRD, RMDR) |
||
4162 | If (LNotEqual (WRD, 0x1234)) |
||
4163 | { Return (WRD) } |
||
4164 | If (LNotEqual (RMDR, 0)) |
||
4165 | { Return (RMDR) } |
||
4166 | |||
4167 | // Test DivideOp with BYTE data |
||
4168 | Divide (BYT, 5, BYT, RMDR) |
||
4169 | If (LNotEqual (BYT, 0x12)) |
||
4170 | { Return (BYT) } |
||
4171 | If (LNotEqual (RMDR, 0)) |
||
4172 | { Return (RMDR) } |
||
4173 | |||
4174 | |||
4175 | // test MultiplyOp with DWORD SystemMemory OpRegion |
||
4176 | Store (0x01234567, SMDW) |
||
4177 | Multiply (SMDW, 2, SMDW) |
||
4178 | If (LNotEqual (SMDW, 0x02468ACE)) |
||
4179 | { Return (SMDW) } |
||
4180 | |||
4181 | // test DivideOp with DWORD SystemMemory OpRegion |
||
4182 | Divide (SMDW, 3, SMDW, RMDR) |
||
4183 | If (LNotEqual (SMDW, 0x00C22E44)) |
||
4184 | { Return (SMDW) } |
||
4185 | If (LNotEqual (RMDR, 2)) |
||
4186 | { Return (RMDR) } |
||
4187 | |||
4188 | |||
4189 | // test MultiplyOp with WORD SystemMemory OpRegion |
||
4190 | Store (0x0123, SMWD) |
||
4191 | Multiply (SMWD, 3, SMWD) |
||
4192 | If (LNotEqual (SMWD, 0x369)) |
||
4193 | { Return (SMWD) } |
||
4194 | |||
4195 | // test DivideOp with WORD SystemMemory OpRegion |
||
4196 | Divide (SMWD, 2, SMWD, RMDR) |
||
4197 | If (LNotEqual (SMWD, 0x01B4)) |
||
4198 | { Return (SMWD) } |
||
4199 | If (LNotEqual (RMDR, 1)) |
||
4200 | { Return (RMDR) } |
||
4201 | |||
4202 | |||
4203 | // test MultiplyOp with BYTE SystemMemory OpRegion |
||
4204 | Store (0x01, SMBY) |
||
4205 | Multiply (SMBY, 7, SMBY) |
||
4206 | If (LNotEqual (SMBY, 0x07)) |
||
4207 | { Return (SMBY) } |
||
4208 | |||
4209 | // test DivideOp with BYTE SystemMemory OpRegion |
||
4210 | Divide (SMBY, 4, SMBY, RMDR) |
||
4211 | If (LNotEqual (SMBY, 0x01)) |
||
4212 | { Return (SMBY) } |
||
4213 | If (LNotEqual (RMDR, 3)) |
||
4214 | { Return (RMDR) } |
||
4215 | |||
4216 | Return (0) |
||
4217 | } // TEST |
||
4218 | } // MLDV |
||
4219 | |||
4220 | // |
||
4221 | // test NBitOps.asl |
||
4222 | // |
||
4223 | //NAnd - Bit-wise NAnd |
||
4224 | //NAndTerm := NAnd( |
||
4225 | // Source1, //TermArg=>Integer |
||
4226 | // Source2 //TermArg=>Integer |
||
4227 | // Result //Nothing | SuperName |
||
4228 | //) => Integer |
||
4229 | //Source1 and Source2 are evaluated as integer data types, a bit-wise NAND is performed, and the result is optionally |
||
4230 | //stored in Result. |
||
4231 | |||
4232 | //NOr - Bitwise NOr |
||
4233 | //NOrTerm := NOr( |
||
4234 | // Source1, //TermArg=>Integer |
||
4235 | // Source2 //TermArg=>Integer |
||
4236 | // Result //Nothing | SuperName |
||
4237 | //) => Integer |
||
4238 | //Source1 and Source2 are evaluated as integer data types, a bit-wise NOR is performed, and the result is optionally |
||
4239 | //stored in Result. |
||
4240 | // Not - Not |
||
4241 | //NotTerm := Not( |
||
4242 | // Source, //TermArg=>Integer |
||
4243 | // Result //Nothing | SuperName |
||
4244 | //) => Integer |
||
4245 | //Source1 is evaluated as an integer data type, a bit-wise NOT is performed, and the result is optionally stored in |
||
4246 | //Result. |
||
4247 | |||
4248 | //If the Control method is success Zero is returned else a non-zero number is returned |
||
4249 | |||
4250 | Device (NBIT) |
||
4251 | {//NBIT |
||
4252 | |||
4253 | //Create System Memory Operation Region and field overlays |
||
4254 | OperationRegion (RAM, SystemMemory, 0x400000, 0x100) |
||
4255 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
4256 | { |
||
4257 | SMDW, 32, // 32-bit DWORD |
||
4258 | SMWD, 16, // 16-bit WORD |
||
4259 | SMBY, 8, // 8-bit BYTE |
||
4260 | }// Field(RAM) |
||
4261 | |||
4262 | |||
4263 | //And with Byte Data |
||
4264 | Name (BYT1, 0xff) |
||
4265 | Name (BYT2, 0xff) |
||
4266 | Name (BRSL, 0x00) |
||
4267 | |||
4268 | //And with Word Data |
||
4269 | Name (WRD1, 0xffff) |
||
4270 | Name (WRD2, 0xffff) |
||
4271 | Name (WRSL, 0x0000) |
||
4272 | |||
4273 | //And with DWord Data |
||
4274 | Name (DWD1, 0xffffffff) |
||
4275 | Name (DWD2, 0xffffffff) |
||
4276 | Name (DRSL, 0x00000000) |
||
4277 | Name(RSLT,1) |
||
4278 | |||
4279 | |||
4280 | Name(ARSL,0x00) |
||
4281 | Name(LRSL,0x00) |
||
4282 | |||
4283 | Method(NNDB,2) |
||
4284 | {//NNDB |
||
4285 | |||
4286 | Store(0xffffffff,SMDW) |
||
4287 | Store(0xffff,SMWD) |
||
4288 | Store(0xff,SMBY) |
||
4289 | |||
4290 | |||
4291 | NAnd(Arg0,Arg1,ARSL) |
||
4292 | if(LNotEqual(ARSL,0xfffffffd)) |
||
4293 | {Return(11)} |
||
4294 | |||
4295 | Store(Arg0,local0) |
||
4296 | Store(Arg1,Local1) |
||
4297 | |||
4298 | NAnd(Local0,Local1,LRSL) |
||
4299 | if(LNotEqual(LRSL,0xfffffffd)) |
||
4300 | {Return(12)} |
||
4301 | |||
4302 | |||
4303 | //Byte data |
||
4304 | NAnd(BYT1,BYT2,BRSL) |
||
4305 | if(LNotEqual(BRSL,0xffffff00)) |
||
4306 | {Return(13)} |
||
4307 | |||
4308 | //Word Data |
||
4309 | NAnd(WRD1,WRD2,WRSL) |
||
4310 | if(LNotEqual(WRSL,0xffff0000)) |
||
4311 | {Return(14)} |
||
4312 | |||
4313 | //DWord Data |
||
4314 | NAnd(DWD1,DWD2,DRSL) |
||
4315 | if(LNotEqual(DRSL,0x00000000)) |
||
4316 | {Return(15)} |
||
4317 | |||
4318 | //Byte data |
||
4319 | NAnd(SMBY,0xff,BRSL) |
||
4320 | if(LNotEqual(BRSL,0xffffff00)) |
||
4321 | {Return(16)} |
||
4322 | |||
4323 | //Word Data |
||
4324 | NAnd(SMWD,0xffff,WRSL) |
||
4325 | if(LNotEqual(WRSL,0xffff0000)) |
||
4326 | {Return(17)} |
||
4327 | |||
4328 | //DWord Data |
||
4329 | NAnd(SMDW,0xffffffff,DRSL) |
||
4330 | if(LNotEqual(DRSL,0x00000000)) |
||
4331 | {Return(18)} |
||
4332 | |||
4333 | Return(0) |
||
4334 | |||
4335 | }//NNDB |
||
4336 | |||
4337 | Method(NNOR,2) |
||
4338 | {//NNOR |
||
4339 | |||
4340 | NOr(Arg0,Arg1,ARSL) |
||
4341 | if(LNotEqual(ARSL,0xfffffffd)) |
||
4342 | {Return(21)} |
||
4343 | |||
4344 | Store(Arg0,local0) |
||
4345 | Store(Arg1,Local1) |
||
4346 | |||
4347 | NOr(Local0,Local1,LRSL) |
||
4348 | if(LNotEqual(LRSL,0xfffffffd)) |
||
4349 | {Return(22)} |
||
4350 | |||
4351 | |||
4352 | //Byte data |
||
4353 | NOr(BYT1,BYT2,BRSL) |
||
4354 | if(LNotEqual(BRSL,0xffffff00)) |
||
4355 | {Return(23)} |
||
4356 | |||
4357 | //Word Data |
||
4358 | NOr(WRD1,WRD2,WRSL) |
||
4359 | if(LNotEqual(WRSL,0xffff0000)) |
||
4360 | {Return(24)} |
||
4361 | |||
4362 | //DWord Data |
||
4363 | NOr(DWD1,DWD2,DRSL) |
||
4364 | if(LNotEqual(DRSL,0x00000000)) |
||
4365 | {Return(25)} |
||
4366 | |||
4367 | //System Memory Byte data |
||
4368 | NOr(SMBY,0xff,BRSL) |
||
4369 | if(LNotEqual(BRSL,0xffffff00)) |
||
4370 | {Return(26)} |
||
4371 | |||
4372 | //System Memory Word Data |
||
4373 | NOr(SMWD,0xffff,WRSL) |
||
4374 | if(LNotEqual(WRSL,0xffff0000)) |
||
4375 | {Return(27)} |
||
4376 | |||
4377 | //System Memory DWord Data |
||
4378 | NOr(SMDW,0xffffffff,DRSL) |
||
4379 | if(LNotEqual(DRSL,0x00000000)) |
||
4380 | {Return(28)} |
||
4381 | |||
4382 | Return(0) |
||
4383 | |||
4384 | }//NNOR |
||
4385 | |||
4386 | Method(NNOT,2) |
||
4387 | {//NNOT |
||
4388 | |||
4389 | Or(Arg0,Arg1,ARSL) |
||
4390 | Not(ARSL,ARSL) |
||
4391 | if(LNotEqual(ARSL,0xfffffffd)) |
||
4392 | {Return(31)} |
||
4393 | |||
4394 | Store(Arg0,local0) |
||
4395 | Store(Arg1,Local1) |
||
4396 | |||
4397 | Or(Local0,Local1,LRSL) |
||
4398 | Not(LRSL,LRSL) |
||
4399 | if(LNotEqual(LRSL,0xfffffffd)) |
||
4400 | {Return(32)} |
||
4401 | |||
4402 | |||
4403 | //Byte data |
||
4404 | Or(BYT1,BYT2,BRSL) |
||
4405 | Not(BRSL,BRSL) |
||
4406 | if(LNotEqual(BRSL,0xffffff00)) |
||
4407 | {Return(33)} |
||
4408 | |||
4409 | //Word Data |
||
4410 | Or(WRD1,WRD2,WRSL) |
||
4411 | Not(WRSL,WRSL) |
||
4412 | if(LNotEqual(WRSL,0xffff0000)) |
||
4413 | {Return(34)} |
||
4414 | |||
4415 | //DWord Data |
||
4416 | Or(DWD1,DWD2,DRSL) |
||
4417 | Not(DRSL,DRSL) |
||
4418 | if(LNotEqual(DRSL,0x00000000)) |
||
4419 | {Return(35)} |
||
4420 | |||
4421 | //System Memory Byte data |
||
4422 | Or(SMBY,0xff,BRSL) |
||
4423 | Not(BRSL,BRSL) |
||
4424 | if(LNotEqual(BRSL,0xffffff00)) |
||
4425 | {Return(36)} |
||
4426 | |||
4427 | //System Memory Word Data |
||
4428 | Or(SMWD,0xffff,WRSL) |
||
4429 | Not(WRSL,WRSL) |
||
4430 | if(LNotEqual(WRSL,0xffff0000)) |
||
4431 | {Return(37)} |
||
4432 | |||
4433 | //System Memory DWord Data |
||
4434 | Or(SMDW,0xffffffff,DRSL) |
||
4435 | Not(DRSL,DRSL) |
||
4436 | if(LNotEqual(DRSL,0x00000000)) |
||
4437 | {Return(38)} |
||
4438 | |||
4439 | Return(0) |
||
4440 | }//NNOT |
||
4441 | |||
4442 | |||
4443 | Method(TEST) |
||
4444 | { |
||
4445 | |||
4446 | Store ("++++++++ NBitOps Test", Debug) |
||
4447 | |||
4448 | Store(NNDB(2,2),RSLT) |
||
4449 | if(LNotEqual(RSLT,0)) |
||
4450 | {Return(RSLT)} |
||
4451 | |||
4452 | Store(NNOR(2,2),RSLT) |
||
4453 | if(LNotEqual(RSLT,0)) |
||
4454 | {Return(RSLT)} |
||
4455 | |||
4456 | Store(NNOT(2,2),RSLT) |
||
4457 | if(LNotEqual(RSLT,0)) |
||
4458 | {Return(RSLT)} |
||
4459 | |||
4460 | |||
4461 | Return(0) |
||
4462 | } |
||
4463 | |||
4464 | }//Device NBIT |
||
4465 | |||
4466 | // |
||
4467 | // test ShftOp.asl |
||
4468 | // |
||
4469 | //ShiftRightTerm := ShiftRight( |
||
4470 | // Source, //TermArg=>Integer |
||
4471 | // ShiftCount //TermArg=>Integer |
||
4472 | // Result //Nothing | SuperName |
||
4473 | //) => Integer |
||
4474 | //Source and ShiftCount are evaluated as integer data types. Source is shifted right with the most significant bit |
||
4475 | //zeroed ShiftCount times. The result is optionally stored into Result. |
||
4476 | |||
4477 | //ShiftLeft( |
||
4478 | // Source, //TermArg=>Integer |
||
4479 | // ShiftCount //TermArg=>Integer |
||
4480 | // Result //Nothing | SuperName |
||
4481 | //) => Integer |
||
4482 | //Source and ShiftCount are evaluated as integer data types. Source is shifted left with the least significant |
||
4483 | //bit zeroed ShiftCount times. The result is optionally stored into Result. |
||
4484 | |||
4485 | //If the Control method is success Zero is returned else a non-zero number is returned |
||
4486 | Device (SHFT) |
||
4487 | {//SHFT |
||
4488 | |||
4489 | //Create System Memory Operation Region and field overlays |
||
4490 | OperationRegion (RAM, SystemMemory, 0x400000, 0x100) |
||
4491 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
4492 | { |
||
4493 | SMDW, 32, // 32-bit DWORD |
||
4494 | SMWD, 16, // 16-bit WORD |
||
4495 | SMBY, 8, // 8-bit BYTE |
||
4496 | }// Field(RAM) |
||
4497 | |||
4498 | |||
4499 | Name(SHFC,0x00) |
||
4500 | |||
4501 | //And with Byte Data |
||
4502 | Name (BYT1, 0xff) |
||
4503 | Name (BRSL, 0x00) |
||
4504 | |||
4505 | //And with Word Data |
||
4506 | Name (WRD1, 0xffff) |
||
4507 | Name (WRSL, 0x0000) |
||
4508 | |||
4509 | //And with DWord Data |
||
4510 | Name (DWD1, 0xffffffff) |
||
4511 | Name (DRSL, 0x00000000) |
||
4512 | |||
4513 | Name(RSLT,1) |
||
4514 | |||
4515 | Name(ARSL,0x00) |
||
4516 | Name(LRSL,0x00) |
||
4517 | |||
4518 | Method(SLFT,2) |
||
4519 | {//SLFT |
||
4520 | |||
4521 | Store(0xffffffff,SMDW) |
||
4522 | Store(0xffff,SMWD) |
||
4523 | Store(0xff,SMBY) |
||
4524 | |||
4525 | |||
4526 | //Arg0-> 2 & Arg1->2 |
||
4527 | ShiftLeft(Arg0,Arg1,ARSL) |
||
4528 | if(LNotEqual(ARSL,8)) |
||
4529 | {Return(11)} |
||
4530 | |||
4531 | Store(Arg0,local0) |
||
4532 | Store(Arg1,Local1) |
||
4533 | |||
4534 | //Local0->8 and Local1->2 |
||
4535 | ShiftLeft(Local0,Local1,LRSL) |
||
4536 | if(LNotEqual(LRSL,8)) |
||
4537 | {Return(12)} |
||
4538 | |||
4539 | Store(2,SHFC) |
||
4540 | //Byte data |
||
4541 | ShiftLeft(BYT1,SHFC,BRSL) |
||
4542 | if(LNotEqual(BRSL,0x3FC)) |
||
4543 | {Return(13)} |
||
4544 | |||
4545 | Store(4,SHFC) |
||
4546 | //Word Data |
||
4547 | ShiftLeft(WRD1,SHFC,WRSL) |
||
4548 | if(LNotEqual(WRSL,0xFFFF0)) |
||
4549 | {Return(14)} |
||
4550 | |||
4551 | Store(8,SHFC) |
||
4552 | //DWord Data |
||
4553 | ShiftLeft(DWD1,SHFC,DRSL) |
||
4554 | if(LNotEqual(DRSL,0xFFFFFF00)) |
||
4555 | {Return(15)} |
||
4556 | |||
4557 | |||
4558 | //System Memory Byte data |
||
4559 | Store(4,SHFC) |
||
4560 | ShiftLeft(SMBY,SHFC,BRSL) |
||
4561 | if(LNotEqual(BRSL,0xFF0)) |
||
4562 | {Return(16)} |
||
4563 | |||
4564 | //Word Data |
||
4565 | Store(4,SHFC) |
||
4566 | ShiftLeft(SMWD,SHFC,WRSL) |
||
4567 | if(LNotEqual(WRSL,0xffff0)) |
||
4568 | {Return(17)} |
||
4569 | |||
4570 | //DWord Data |
||
4571 | Store(8,SHFC) |
||
4572 | ShiftLeft(SMDW,SHFC,DRSL) |
||
4573 | if(LNotEqual(DRSL,0xFFFFFF00)) |
||
4574 | {Return(18)} |
||
4575 | |||
4576 | Return(0) |
||
4577 | |||
4578 | }//SLFT |
||
4579 | |||
4580 | Method(SRGT,2) |
||
4581 | {//SRGT |
||
4582 | //And with Byte Data |
||
4583 | Store (0xff,BYT1) |
||
4584 | Store (0x00,BRSL) |
||
4585 | |||
4586 | //And with Word Data |
||
4587 | Store (0xffff,WRD1) |
||
4588 | Store (0x0000,WRSL) |
||
4589 | |||
4590 | //And with DWord Data |
||
4591 | Store(0xffffffff,DWD1) |
||
4592 | Store (0x00000000,DRSL) |
||
4593 | |||
4594 | //Reinitialize the result objects |
||
4595 | Store(0x00,ARSL) |
||
4596 | Store(0x00,LRSL) |
||
4597 | |||
4598 | Store(0xffffffff,SMDW) |
||
4599 | Store(0xffff,SMWD) |
||
4600 | Store(0xff,SMBY) |
||
4601 | |||
4602 | //Arg0-> 2 & Arg1->2 |
||
4603 | ShiftRight(Arg0,Arg1,ARSL) |
||
4604 | if(LNotEqual(ARSL,0)) |
||
4605 | {Return(21)} |
||
4606 | |||
4607 | Store(Arg0,local0) |
||
4608 | Store(Arg1,Local1) |
||
4609 | |||
4610 | //Local0->8 and Local1->2 |
||
4611 | ShiftRight(Local0,Local1,LRSL) |
||
4612 | if(LNotEqual(LRSL,0)) |
||
4613 | {Return(22)} |
||
4614 | |||
4615 | Store(2,SHFC) |
||
4616 | //Byte data |
||
4617 | ShiftRight(BYT1,SHFC,BRSL) |
||
4618 | if(LNotEqual(BRSL,0x3F)) |
||
4619 | {Return(23)} |
||
4620 | |||
4621 | Store(4,SHFC) |
||
4622 | //Word Data |
||
4623 | ShiftRight(WRD1,SHFC,WRSL) |
||
4624 | if(LNotEqual(WRSL,0xFFF)) |
||
4625 | {Return(24)} |
||
4626 | |||
4627 | Store(8,SHFC) |
||
4628 | //DWord Data |
||
4629 | ShiftRight(DWD1,SHFC,DRSL) |
||
4630 | if(LNotEqual(DRSL,0xFFFFFF)) |
||
4631 | {Return(25)} |
||
4632 | |||
4633 | //System Memory Byte data |
||
4634 | Store(4,SHFC) |
||
4635 | ShiftRight(SMBY,SHFC,BRSL) |
||
4636 | if(LNotEqual(BRSL,0xF)) |
||
4637 | {Return(26)} |
||
4638 | |||
4639 | //Word Data |
||
4640 | Store(4,SHFC) |
||
4641 | ShiftRight(SMWD,SHFC,WRSL) |
||
4642 | if(LNotEqual(WRSL,0xFFF)) |
||
4643 | {Return(27)} |
||
4644 | |||
4645 | //DWord Data |
||
4646 | Store(8,SHFC) |
||
4647 | ShiftRight(SMDW,SHFC,DRSL) |
||
4648 | if(LNotEqual(DRSL,0xFFFFFF)) |
||
4649 | {Return(28)} |
||
4650 | |||
4651 | Return(0) |
||
4652 | }//SRGT |
||
4653 | |||
4654 | //Test method called from amlexec |
||
4655 | Method(TEST) |
||
4656 | { |
||
4657 | Store ("++++++++ ShftOp Test", Debug) |
||
4658 | |||
4659 | Store(SLFT(2,2),RSLT) |
||
4660 | if(LNotEqual(RSLT,0)) |
||
4661 | {Return(RSLT)} |
||
4662 | Store(SRGT(2,2),RSLT) |
||
4663 | if(LNotEqual(RSLT,0)) |
||
4664 | {Return(RSLT)} |
||
4665 | Return(0) |
||
4666 | } |
||
4667 | |||
4668 | }//Device SHFT |
||
4669 | |||
4670 | // |
||
4671 | // test Xor.asl and slightly modified |
||
4672 | // |
||
4673 | //This code tests the XOR opcode term |
||
4674 | //Syntax of XOR term |
||
4675 | // XOr( |
||
4676 | // Source1 //TermArg=>BufferTerm |
||
4677 | // Source2 //TermArg=>Integer |
||
4678 | // Result //NameString |
||
4679 | // ) |
||
4680 | //"Source1" and "Source2" are evaluated as integers, a bit-wise XOR is performed, and the result is optionally stored in |
||
4681 | // Result |
||
4682 | Device (XORD) |
||
4683 | { |
||
4684 | //This Method tests XOr operator for all the data types i.e. BYTE, WORD and DWORD |
||
4685 | Method (TEST) |
||
4686 | { |
||
4687 | Store ("++++++++ Xor Test", Debug) |
||
4688 | |||
4689 | //Overlay in system memory |
||
4690 | OperationRegion (RAM, SystemMemory, 0x800000, 256) |
||
4691 | Field (RAM, ByteAcc, NoLock, Preserve) |
||
4692 | { |
||
4693 | RES1, 1, //Offset |
||
4694 | BYT1, 8, //First BYTE |
||
4695 | BYT2, 8, //Second BYTE |
||
4696 | RBYT, 8, //Result Byte |
||
4697 | RES2, 1, //Offset |
||
4698 | WRD1, 16, //First WORD field |
||
4699 | WRD2, 16, //Second WORD field |
||
4700 | RWRD, 16, //RSLT WORD field |
||
4701 | RES3, 1, //Offset |
||
4702 | DWD1, 32, //First Dword |
||
4703 | DWD2, 32, //Second Dword |
||
4704 | RDWD, 32, //Result Dword |
||
4705 | RES4, 1, //Offset |
||
4706 | } |
||
4707 | |||
4708 | // Store bits in the single bit fields for checking |
||
4709 | // at the end |
||
4710 | Store(1, RES1) |
||
4711 | Store(1, RES2) |
||
4712 | Store(1, RES3) |
||
4713 | Store(1, RES4) |
||
4714 | |||
4715 | // Check the stored single bits |
||
4716 | if(LNotEqual(RES1, 1)) |
||
4717 | { |
||
4718 | Return(1) |
||
4719 | } |
||
4720 | |||
4721 | if(LNotEqual(RES2, 1)) |
||
4722 | { |
||
4723 | Return(1) |
||
4724 | } |
||
4725 | |||
4726 | if(LNotEqual(RES3, 1)) |
||
4727 | { |
||
4728 | Return(1) |
||
4729 | } |
||
4730 | |||
4731 | if(LNotEqual(RES4, 1)) |
||
4732 | { |
||
4733 | Return(1) |
||
4734 | } |
||
4735 | |||
4736 | //************************************************ |
||
4737 | // (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition |
||
4738 | Store(0x00,BYT1) |
||
4739 | Store(0x00,BYT2) |
||
4740 | XOr(BYT1,BYT2,Local0) |
||
4741 | Store (Local0, RBYT) |
||
4742 | if(LNotEqual(RBYT,0)) |
||
4743 | { Return(1)} |
||
4744 | |||
4745 | // (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition |
||
4746 | Store(0xff,BYT1) |
||
4747 | Store(0xff,BYT2) |
||
4748 | XOr(BYT1,BYT2,Local0) |
||
4749 | Store (Local0, RBYT) |
||
4750 | if(LNotEqual(RBYT,0)) |
||
4751 | { Return(1)} |
||
4752 | |||
4753 | // (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition |
||
4754 | Store(0x55,BYT1) |
||
4755 | Store(0xAA,BYT2) |
||
4756 | XOr(BYT1,BYT2,Local0) |
||
4757 | Store (Local0, RBYT) |
||
4758 | if(LNotEqual(RBYT,0xFF)) |
||
4759 | { Return(1)} |
||
4760 | |||
4761 | //(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition |
||
4762 | Store(0xAA,BYT1) |
||
4763 | Store(0x55,BYT2) |
||
4764 | XOr(BYT1,BYT2,Local0) |
||
4765 | Store (Local0, RBYT) |
||
4766 | if(LNotEqual(RBYT,0xFF)) |
||
4767 | { Return(1)} |
||
4768 | |||
4769 | Store(0x12,BYT1) |
||
4770 | Store(0xED,BYT2) |
||
4771 | |||
4772 | XOr(BYT1,BYT2,Local0) |
||
4773 | Store (Local0, RBYT) |
||
4774 | if(LNotEqual(RBYT,0xFF)) |
||
4775 | { |
||
4776 | Return(1) |
||
4777 | } |
||
4778 | |||
4779 | // Store known values for checking later |
||
4780 | Store(0x12, BYT1) |
||
4781 | if(LNotEqual(BYT1, 0x12)) |
||
4782 | { |
||
4783 | Return(1) |
||
4784 | } |
||
4785 | |||
4786 | Store(0xFE, BYT2) |
||
4787 | if(LNotEqual(BYT2, 0xFE)) |
||
4788 | { |
||
4789 | Return(1) |
||
4790 | } |
||
4791 | |||
4792 | Store(0xAB, RBYT) |
||
4793 | if(LNotEqual(RBYT, 0xAB)) |
||
4794 | { |
||
4795 | Return(1) |
||
4796 | } |
||
4797 | |||
4798 | //*********************************************** |
||
4799 | // (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition |
||
4800 | Store(0x0000,WRD1) |
||
4801 | Store(0x0000,WRD2) |
||
4802 | XOr(WRD1,WRD2,RWRD) |
||
4803 | if(LNotEqual(RWRD,0)) |
||
4804 | { Return(1)} |
||
4805 | |||
4806 | // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition |
||
4807 | Store(0xffff,WRD1) |
||
4808 | Store(0xffff,WRD2) |
||
4809 | XOr(WRD1,WRD2,RWRD) |
||
4810 | if(LNotEqual(RWRD,0)) |
||
4811 | { Return(1)} |
||
4812 | |||
4813 | // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition |
||
4814 | Store(0x5555,WRD1) |
||
4815 | Store(0xAAAA,WRD2) |
||
4816 | XOr(WRD1,WRD2,RWRD) |
||
4817 | if(LNotEqual(RWRD,0xFFFF)) |
||
4818 | { Return(1)} |
||
4819 | |||
4820 | //(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition |
||
4821 | Store(0xAAAA,WRD1) |
||
4822 | Store(0x5555,WRD2) |
||
4823 | XOr(WRD1,WRD2,RWRD) |
||
4824 | if(LNotEqual(RWRD,0xFFFF)) |
||
4825 | { Return(1)} |
||
4826 | |||
4827 | Store(0x1234,WRD1) |
||
4828 | Store(0xEDCB,WRD2) |
||
4829 | XOr(WRD1,WRD2,RWRD) |
||
4830 | if(LNotEqual(RWRD,0xFFFF)) |
||
4831 | { Return(1)} |
||
4832 | |||
4833 | // Store known values for checking later |
||
4834 | Store(0x1234, WRD1) |
||
4835 | if(LNotEqual(WRD1, 0x1234)) |
||
4836 | { |
||
4837 | Return(1) |
||
4838 | } |
||
4839 | |||
4840 | Store(0xFEDC, WRD2) |
||
4841 | if(LNotEqual(WRD2, 0xFEDC)) |
||
4842 | { |
||
4843 | Return(1) |
||
4844 | } |
||
4845 | |||
4846 | Store(0x87AB, RWRD) |
||
4847 | if(LNotEqual(RWRD, 0x87AB)) |
||
4848 | { |
||
4849 | Return(1) |
||
4850 | } |
||
4851 | |||
4852 | |||
4853 | //************************************************** |
||
4854 | // (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition |
||
4855 | Store(0x00000000,DWD1) |
||
4856 | Store(0x00000000,DWD2) |
||
4857 | XOr(DWD1,DWD2,RDWD) |
||
4858 | if(LNotEqual(RDWD,0)) |
||
4859 | { Return(1)} |
||
4860 | |||
4861 | // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition |
||
4862 | Store(0xffffffff,DWD1) |
||
4863 | Store(0xffffffff,DWD2) |
||
4864 | XOr(DWD1,DWD2,RDWD) |
||
4865 | if(LNotEqual(RDWD,0)) |
||
4866 | { Return(1)} |
||
4867 | |||
4868 | // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition |
||
4869 | Store(0x55555555,DWD1) |
||
4870 | Store(0xAAAAAAAA,DWD2) |
||
4871 | XOr(DWD1,DWD2,RDWD) |
||
4872 | if(LNotEqual(RDWD,0xFFFFFFFF)) |
||
4873 | { Return(1)} |
||
4874 | |||
4875 | //(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition |
||
4876 | Store(0xAAAAAAAA,DWD1) |
||
4877 | Store(0x55555555,DWD2) |
||
4878 | XOr(DWD1,DWD2,RDWD) |
||
4879 | if(LNotEqual(RDWD,0xFFFFFFFF)) |
||
4880 | { Return(1)} |
||
4881 | |||
4882 | // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition |
||
4883 | Store(0x12345678,DWD1) |
||
4884 | Store(0xEDCBA987,DWD2) |
||
4885 | XOr(DWD1,DWD2,RDWD) |
||
4886 | if(LNotEqual(RDWD,0xFFFFFFFF)) |
||
4887 | { Return(1)} |
||
4888 | |||
4889 | Store(0x12345678,DWD1) |
||
4890 | if(LNotEqual(DWD1,0x12345678)) |
||
4891 | { |
||
4892 | Return(1) |
||
4893 | } |
||
4894 | |||
4895 | Store(0xFEDCBA98,DWD2) |
||
4896 | if(LNotEqual(DWD2,0xFEDCBA98)) |
||
4897 | { |
||
4898 | Return(1) |
||
4899 | } |
||
4900 | |||
4901 | Store(0x91827364,RDWD) |
||
4902 | if(LNotEqual(RDWD,0x91827364)) |
||
4903 | { |
||
4904 | Return(1) |
||
4905 | } |
||
4906 | |||
4907 | //**************************************************** |
||
4908 | // Check the stored single bits |
||
4909 | if(LNotEqual(RES1, 1)) |
||
4910 | { |
||
4911 | Return(1) |
||
4912 | } |
||
4913 | |||
4914 | if(LNotEqual(RES2, 1)) |
||
4915 | { |
||
4916 | Return(1) |
||
4917 | } |
||
4918 | |||
4919 | if(LNotEqual(RES3, 1)) |
||
4920 | { |
||
4921 | Return(1) |
||
4922 | } |
||
4923 | |||
4924 | if(LNotEqual(RES4, 1)) |
||
4925 | { |
||
4926 | Return(1) |
||
4927 | } |
||
4928 | |||
4929 | // Change all of the single bit fields to zero |
||
4930 | Store(0, RES1) |
||
4931 | Store(0, RES2) |
||
4932 | Store(0, RES3) |
||
4933 | Store(0, RES4) |
||
4934 | |||
4935 | // Now, check all of the fields |
||
4936 | |||
4937 | // Byte |
||
4938 | if(LNotEqual(BYT1, 0x12)) |
||
4939 | { |
||
4940 | Return(1) |
||
4941 | } |
||
4942 | |||
4943 | if(LNotEqual(BYT2, 0xFE)) |
||
4944 | { |
||
4945 | Return(1) |
||
4946 | } |
||
4947 | |||
4948 | if(LNotEqual(RBYT, 0xAB)) |
||
4949 | { |
||
4950 | Return(1) |
||
4951 | } |
||
4952 | |||
4953 | // Word |
||
4954 | if(LNotEqual(WRD1, 0x1234)) |
||
4955 | { |
||
4956 | Return(1) |
||
4957 | } |
||
4958 | |||
4959 | if(LNotEqual(WRD2, 0xFEDC)) |
||
4960 | { |
||
4961 | Return(1) |
||
4962 | } |
||
4963 | |||
4964 | if(LNotEqual(RWRD, 0x87AB)) |
||
4965 | { |
||
4966 | Return(1) |
||
4967 | } |
||
4968 | |||
4969 | // Dword |
||
4970 | if(LNotEqual(DWD1, 0x12345678)) |
||
4971 | { |
||
4972 | Return(1) |
||
4973 | } |
||
4974 | |||
4975 | if(LNotEqual(DWD2, 0xFEDCBA98)) |
||
4976 | { |
||
4977 | Return(1) |
||
4978 | } |
||
4979 | |||
4980 | if(LNotEqual(RDWD, 0x91827364)) |
||
4981 | { |
||
4982 | Return(1) |
||
4983 | } |
||
4984 | |||
4985 | // Bits |
||
4986 | if(LNotEqual(RES1, 0)) |
||
4987 | { |
||
4988 | Return(1) |
||
4989 | } |
||
4990 | |||
4991 | if(LNotEqual(RES2, 0)) |
||
4992 | { |
||
4993 | Return(1) |
||
4994 | } |
||
4995 | |||
4996 | if(LNotEqual(RES3, 0)) |
||
4997 | { |
||
4998 | Return(1) |
||
4999 | } |
||
5000 | |||
5001 | if(LNotEqual(RES4, 0)) |
||
5002 | { |
||
5003 | Return(1) |
||
5004 | } |
||
5005 | |||
5006 | |||
5007 | Return(0) |
||
5008 | } // TEST |
||
5009 | } // XORD |
||
5010 | |||
5011 | // |
||
5012 | // test CrBytFld.asl |
||
5013 | // |
||
5014 | // CrBytFld test |
||
5015 | // Test for CreateByteField. |
||
5016 | // Tests creating byte field overlay of buffer stored in Local0. |
||
5017 | // Tests need to be added for Arg0 and Name buffers. |
||
5018 | // |
||
5019 | Device (CRBF) |
||
5020 | { // Test device name |
||
5021 | Method (TEST) |
||
5022 | { |
||
5023 | Store ("++++++++ CrBytFld Test", Debug) |
||
5024 | |||
5025 | // Local0 is unitialized buffer with 4 elements |
||
5026 | Store (Buffer (4) {}, Local0) |
||
5027 | |||
5028 | // create Byte Field named BF0 based on Local0 element 0 |
||
5029 | CreateByteField (Local0, 0, BF0) |
||
5030 | |||
5031 | // validate CreateByteField did not alter Local0 |
||
5032 | Store (ObjectType (Local0), Local1) // Local1 = Local0 object type |
||
5033 | If (LNotEqual (Local1, 3)) // Buffer object type value is 3 |
||
5034 | { Return (2) } |
||
5035 | |||
5036 | // store something into BF0 |
||
5037 | Store (1, BF0) |
||
5038 | |||
5039 | // validate Store did not alter Local0 object type |
||
5040 | Store (ObjectType (Local0), Local1) // Local1 = Local0 object type |
||
5041 | If (LNotEqual (Local1, 3)) // Buffer object type value is 3 |
||
5042 | { Return (3) } |
||
5043 | |||
5044 | // verify that the Store into BF0 was successful |
||
5045 | If (LNotEqual (BF0, 1)) |
||
5046 | { Return (4) } |
||
5047 | |||
5048 | |||
5049 | // create Byte Field named BF1 based on Local0 element 1 |
||
5050 | CreateByteField (Local0, 1, BF1) |
||
5051 | |||
5052 | // validate CreateByteField did not alter Local0 |
||
5053 | Store (ObjectType (Local0), Local1) // Local1 = Local0 object type |
||
5054 | If (LNotEqual (Local1, 3)) // Buffer object type value is 3 |
||
5055 | { Return (10) } |
||
5056 | |||
5057 | // store something into BF1 |
||
5058 | Store (5, BF1) |
||
5059 | |||
5060 | // validate Store did not alter Local0 object type |
||
5061 | Store (ObjectType (Local0), Local1) // Local1 = Local0 object type |
||
5062 | If (LNotEqual (Local1, 3)) // Buffer object type value is 3 |
||
5063 | { Return (11) } |
||
5064 | |||
5065 | // verify that the Store into BF1 was successful |
||
5066 | If (LNotEqual (BF1, 5)) |
||
5067 | { Return (12) } |
||
5068 | |||
5069 | // verify that the Store into BF1 did not alter BF0 |
||
5070 | If (LNotEqual (BF0, 1)) |
||
5071 | { Return (13) } |
||
5072 | |||
5073 | |||
5074 | // store something into BF0 |
||
5075 | Store (0xFFFF, BF0) |
||
5076 | |||
5077 | // verify that the Store into BF0 was successful |
||
5078 | If (LNotEqual (BF0, 0xFF)) |
||
5079 | { Return (20) } |
||
5080 | |||
5081 | // verify that the Store into BF0 did not alter BF1 |
||
5082 | If (LNotEqual (BF1, 5)) |
||
5083 | { Return (21) } |
||
5084 | |||
5085 | |||
5086 | Return (0) |
||
5087 | } // TEST |
||
5088 | } // CRBF |
||
5089 | |||
5090 | // |
||
5091 | // test IndexOp4.asl |
||
5092 | // |
||
5093 | // IndexOp4 test |
||
5094 | // This is just a subset of the many RegionOp/Index Field test cases. |
||
5095 | // Tests access of index fields smaller than 8 bits. |
||
5096 | // |
||
5097 | Device (IDX4) |
||
5098 | { // Test device name |
||
5099 | |||
5100 | // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion |
||
5101 | // Tests OperationRegion memory access using misaligned BYTE, |
||
5102 | // WORD, and DWORD field element accesses. Validation is performed |
||
5103 | // using both misaligned field entries and aligned field entries. |
||
5104 | // |
||
5105 | // MADM returns 0 if all test cases pass or non-zero identifying |
||
5106 | // the failing test case for debug purposes. This non-zero numbers |
||
5107 | // are not guaranteed to be in perfect sequence (i.e., test case |
||
5108 | // index), but are guaranteed to be unique so the failing test |
||
5109 | // case can be uniquely identified. |
||
5110 | // |
||
5111 | Method (MADM, 1) // Misaligned Dynamic RAM SystemMemory OperationRegion |
||
5112 | // Arg0 -- SystemMemory OperationRegion base address |
||
5113 | { // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion |
||
5114 | OperationRegion (RAM, SystemMemory, Arg0, 0x100) |
||
5115 | Field (RAM, DwordAcc, NoLock, Preserve) |
||
5116 | { // aligned field definition (for verification) |
||
5117 | DWD0, 32, // aligned DWORD field |
||
5118 | DWD1, 32 // aligned DWORD field |
||
5119 | } |
||
5120 | Field (RAM, ByteAcc, NoLock, Preserve) |
||
5121 | { // bit access field definition |
||
5122 | BIT0, 1, // single bit field entry |
||
5123 | BIT1, 1, // single bit field entry |
||
5124 | BIT2, 1, // single bit field entry |
||
5125 | BIT3, 1, // single bit field entry |
||
5126 | BIT4, 1, // single bit field entry |
||
5127 | BIT5, 1, // single bit field entry |
||
5128 | BIT6, 1, // single bit field entry |
||
5129 | BIT7, 1, // single bit field entry |
||
5130 | BIT8, 1, // single bit field entry |
||
5131 | BIT9, 1, // single bit field entry |
||
5132 | BITA, 1, // single bit field entry |
||
5133 | BITB, 1, // single bit field entry |
||
5134 | BITC, 1, // single bit field entry |
||
5135 | BITD, 1, // single bit field entry |
||
5136 | BITE, 1, // single bit field entry |
||
5137 | BITF, 1, // single bit field entry |
||
5138 | BI10, 1, // single bit field entry |
||
5139 | BI11, 1, // single bit field entry |
||
5140 | BI12, 1, // single bit field entry |
||
5141 | BI13, 1, // single bit field entry |
||
5142 | BI14, 1, // single bit field entry |
||
5143 | BI15, 1, // single bit field entry |
||
5144 | BI16, 1, // single bit field entry |
||
5145 | BI17, 1, // single bit field entry |
||
5146 | BI18, 1, // single bit field entry |
||
5147 | BI19, 1, // single bit field entry |
||
5148 | BI1A, 1, // single bit field entry |
||
5149 | BI1B, 1, // single bit field entry |
||
5150 | BI1C, 1, // single bit field entry |
||
5151 | BI1D, 1, // single bit field entry |
||
5152 | BI1E, 1, // single bit field entry |
||
5153 | BI1F, 1 // single bit field entry |
||
5154 | } // bit access field definition |
||
5155 | |||
5156 | Field (RAM, ByteAcc, NoLock, Preserve) |
||
5157 | { // two-bit access field definition |
||
5158 | B2_0, 2, // single bit field entry |
||
5159 | B2_1, 2, // single bit field entry |
||
5160 | B2_2, 2, // single bit field entry |
||
5161 | B2_3, 2, // single bit field entry |
||
5162 | B2_4, 2, // single bit field entry |
||
5163 | B2_5, 2, // single bit field entry |
||
5164 | B2_6, 2, // single bit field entry |
||
5165 | B2_7, 2, // single bit field entry |
||
5166 | B2_8, 2, // single bit field entry |
||
5167 | B2_9, 2, // single bit field entry |
||
5168 | B2_A, 2, // single bit field entry |
||
5169 | B2_B, 2, // single bit field entry |
||
5170 | B2_C, 2, // single bit field entry |
||
5171 | B2_D, 2, // single bit field entry |
||
5172 | B2_E, 2, // single bit field entry |
||
5173 | B2_F, 2 // single bit field entry |
||
5174 | } // bit access field definition |
||
5175 | |||
5176 | // initialize memory contents using aligned field entries |
||
5177 | Store (0x5AA55AA5, DWD0) |
||
5178 | Store (0x5AA55AA5, DWD1) |
||
5179 | |||
5180 | // set memory contents to known values using misaligned field entries |
||
5181 | Store (0, BIT0) |
||
5182 | // verify memory contents using misaligned field entries |
||
5183 | If (LNotEqual (BIT0, 0)) |
||
5184 | { Return (1) } |
||
5185 | // verify memory contents using aligned field entries |
||
5186 | If (LNotEqual (DWD0, 0x5AA55AA4)) |
||
5187 | { Return (2) } |
||
5188 | |||
5189 | // set memory contents to known values using misaligned field entries |
||
5190 | Store (1, BIT1) |
||
5191 | // verify memory contents using misaligned field entries |
||
5192 | If (LNotEqual (BIT1, 1)) |
||
5193 | { Return (3) } |
||
5194 | // verify memory contents using aligned field entries |
||
5195 | If (LNotEqual (DWD0, 0x5AA55AA6)) |
||
5196 | { Return (4) } |
||
5197 | |||
5198 | // set memory contents to known values using misaligned field entries |
||
5199 | Store (0, BIT2) |
||
5200 | // verify memory contents using misaligned field entries |
||
5201 | If (LNotEqual (BIT2, 0)) |
||
5202 | { Return (5) } |
||
5203 | // verify memory contents using aligned field entries |
||
5204 | If (LNotEqual (DWD0, 0x5AA55AA2)) |
||
5205 | { Return (6) } |
||
5206 | |||
5207 | // set memory contents to known values using misaligned field entries |
||
5208 | Store (1, BIT3) |
||
5209 | // verify memory contents using misaligned field entries |
||
5210 | If (LNotEqual (BIT3, 1)) |
||
5211 | { Return (7) } |
||
5212 | // verify memory contents using aligned field entries |
||
5213 | If (LNotEqual (DWD0, 0x5AA55AAA)) |
||
5214 | { Return (8) } |
||
5215 | |||
5216 | // set memory contents to known values using misaligned field entries |
||
5217 | Store (1, BIT4) |
||
5218 | // verify memory contents using misaligned field entries |
||
5219 | If (LNotEqual (BIT4, 1)) |
||
5220 | { Return (9) } |
||
5221 | // verify memory contents using aligned field entries |
||
5222 | If (LNotEqual (DWD0, 0x5AA55ABA)) |
||
5223 | { Return (10) } |
||
5224 | |||
5225 | // set memory contents to known values using misaligned field entries |
||
5226 | Store (0, BIT5) |
||
5227 | // verify memory contents using misaligned field entries |
||
5228 | If (LNotEqual (BIT5, 0)) |
||
5229 | { Return (11) } |
||
5230 | // verify memory contents using aligned field entries |
||
5231 | If (LNotEqual (DWD0, 0x5AA55A9A)) |
||
5232 | { Return (12) } |
||
5233 | |||
5234 | // set memory contents to known values using misaligned field entries |
||
5235 | Store (1, BIT6) |
||
5236 | // verify memory contents using misaligned field entries |
||
5237 | If (LNotEqual (BIT6, 1)) |
||
5238 | { Return (13) } |
||
5239 | // verify memory contents using aligned field entries |
||
5240 | If (LNotEqual (DWD0, 0x5AA55ADA)) |
||
5241 | { Return (14) } |
||
5242 | |||
5243 | // set memory contents to known values using misaligned field entries |
||
5244 | Store (0, BIT7) |
||
5245 | // verify memory contents using misaligned field entries |
||
5246 | If (LNotEqual (BIT7, 0)) |
||
5247 | { Return (15) } |
||
5248 | // verify memory contents using aligned field entries |
||
5249 | If (LNotEqual (DWD0, 0x5AA55A5A)) |
||
5250 | { Return (16) } |
||
5251 | |||
5252 | // set memory contents to known values using misaligned field entries |
||
5253 | Store (1, BIT8) |
||
5254 | // verify memory contents using misaligned field entries |
||
5255 | If (LNotEqual (BIT8, 1)) |
||
5256 | { Return (17) } |
||
5257 | // verify memory contents using aligned field entries |
||
5258 | If (LNotEqual (DWD0, 0x5AA55B5A)) |
||
5259 | { Return (18) } |
||
5260 | |||
5261 | // set memory contents to known values using misaligned field entries |
||
5262 | Store (0, BIT9) |
||
5263 | // verify memory contents using misaligned field entries |
||
5264 | If (LNotEqual (BIT9, 0)) |
||
5265 | { Return (19) } |
||
5266 | // verify memory contents using aligned field entries |
||
5267 | If (LNotEqual (DWD0, 0x5AA5595A)) |
||
5268 | { Return (20) } |
||
5269 | |||
5270 | // set memory contents to known values using misaligned field entries |
||
5271 | Store (1, BITA) |
||
5272 | // verify memory contents using misaligned field entries |
||
5273 | If (LNotEqual (BITA, 1)) |
||
5274 | { Return (21) } |
||
5275 | // verify memory contents using aligned field entries |
||
5276 | If (LNotEqual (DWD0, 0x5AA55D5A)) |
||
5277 | { Return (22) } |
||
5278 | |||
5279 | // set memory contents to known values using misaligned field entries |
||
5280 | Store (0, BITB) |
||
5281 | // verify memory contents using misaligned field entries |
||
5282 | If (LNotEqual (BITB, 0)) |
||
5283 | { Return (23) } |
||
5284 | // verify memory contents using aligned field entries |
||
5285 | If (LNotEqual (DWD0, 0x5AA5555A)) |
||
5286 | { Return (24) } |
||
5287 | |||
5288 | // set memory contents to known values using misaligned field entries |
||
5289 | Store (0, BITC) |
||
5290 | // verify memory contents using misaligned field entries |
||
5291 | If (LNotEqual (BITC, 0)) |
||
5292 | { Return (25) } |
||
5293 | // verify memory contents using aligned field entries |
||
5294 | If (LNotEqual (DWD0, 0x5AA5455A)) |
||
5295 | { Return (26) } |
||
5296 | |||
5297 | // set memory contents to known values using misaligned field entries |
||
5298 | Store (1, BITD) |
||
5299 | // verify memory contents using misaligned field entries |
||
5300 | If (LNotEqual (BITD, 1)) |
||
5301 | { Return (27) } |
||
5302 | // verify memory contents using aligned field entries |
||
5303 | If (LNotEqual (DWD0, 0x5AA5655A)) |
||
5304 | { Return (28) } |
||
5305 | |||
5306 | // set memory contents to known values using misaligned field entries |
||
5307 | Store (0, BITE) |
||
5308 | // verify memory contents using misaligned field entries |
||
5309 | If (LNotEqual (BITE, 0)) |
||
5310 | { Return (29) } |
||
5311 | // verify memory contents using aligned field entries |
||
5312 | If (LNotEqual (DWD0, 0x5AA5255A)) |
||
5313 | { Return (30) } |
||
5314 | |||
5315 | // set memory contents to known values using misaligned field entries |
||
5316 | Store (1, BITF) |
||
5317 | // verify memory contents using misaligned field entries |
||
5318 | If (LNotEqual (BITF, 1)) |
||
5319 | { Return (31) } |
||
5320 | // verify memory contents using aligned field entries |
||
5321 | If (LNotEqual (DWD0, 0x5AA5A55A)) |
||
5322 | { Return (32) } |
||
5323 | |||
5324 | // set memory contents to known values using misaligned field entries |
||
5325 | Store (0, BI10) |
||
5326 | // verify memory contents using misaligned field entries |
||
5327 | If (LNotEqual (BI10, 0)) |
||
5328 | { Return (33) } |
||
5329 | // verify memory contents using aligned field entries |
||
5330 | If (LNotEqual (DWD0, 0x5AA4A55A)) |
||
5331 | { Return (34) } |
||
5332 | |||
5333 | // set memory contents to known values using misaligned field entries |
||
5334 | Store (1, BI11) |
||
5335 | // verify memory contents using misaligned field entries |
||
5336 | If (LNotEqual (BI11, 1)) |
||
5337 | { Return (35) } |
||
5338 | // verify memory contents using aligned field entries |
||
5339 | If (LNotEqual (DWD0, 0x5AA6A55A)) |
||
5340 | { Return (36) } |
||
5341 | |||
5342 | // set memory contents to known values using misaligned field entries |
||
5343 | Store (0, BI12) |
||
5344 | // verify memory contents using misaligned field entries |
||
5345 | If (LNotEqual (BI12, 0)) |
||
5346 | { Return (37) } |
||
5347 | // verify memory contents using aligned field entries |
||
5348 | If (LNotEqual (DWD0, 0x5AA2A55A)) |
||
5349 | { Return (38) } |
||
5350 | |||
5351 | // set memory contents to known values using misaligned field entries |
||
5352 | Store (1, BI13) |
||
5353 | // verify memory contents using misaligned field entries |
||
5354 | If (LNotEqual (BI13, 1)) |
||
5355 | { Return (39) } |
||
5356 | // verify memory contents using aligned field entries |
||
5357 | If (LNotEqual (DWD0, 0x5AAAA55A)) |
||
5358 | { Return (40) } |
||
5359 | |||
5360 | // set memory contents to known values using misaligned field entries |
||
5361 | Store (1, BI14) |
||
5362 | // verify memory contents using misaligned field entries |
||
5363 | If (LNotEqual (BI14, 1)) |
||
5364 | { Return (41) } |
||
5365 | // verify memory contents using aligned field entries |
||
5366 | If (LNotEqual (DWD0, 0x5ABAA55A)) |
||
5367 | { Return (42) } |
||
5368 | |||
5369 | // set memory contents to known values using misaligned field entries |
||
5370 | Store (0, BI15) |
||
5371 | // verify memory contents using misaligned field entries |
||
5372 | If (LNotEqual (BI15, 0)) |
||
5373 | { Return (43) } |
||
5374 | // verify memory contents using aligned field entries |
||
5375 | If (LNotEqual (DWD0, 0x5A9AA55A)) |
||
5376 | { Return (44) } |
||
5377 | |||
5378 | // set memory contents to known values using misaligned field entries |
||
5379 | Store (1, BI16) |
||
5380 | // verify memory contents using misaligned field entries |
||
5381 | If (LNotEqual (BI16, 1)) |
||
5382 | { Return (45) } |
||
5383 | // verify memory contents using aligned field entries |
||
5384 | If (LNotEqual (DWD0, 0x5ADAA55A)) |
||
5385 | { Return (46) } |
||
5386 | |||
5387 | // set memory contents to known values using misaligned field entries |
||
5388 | Store (0, BI17) |
||
5389 | // verify memory contents using misaligned field entries |
||
5390 | If (LNotEqual (BI17, 0)) |
||
5391 | { Return (47) } |
||
5392 | // verify memory contents using aligned field entries |
||
5393 | If (LNotEqual (DWD0, 0x5A5AA55A)) |
||
5394 | { Return (48) } |
||
5395 | |||
5396 | // set memory contents to known values using misaligned field entries |
||
5397 | Store (1, BI18) |
||
5398 | // verify memory contents using misaligned field entries |
||
5399 | If (LNotEqual (BI18, 1)) |
||
5400 | { Return (49) } |
||
5401 | // verify memory contents using aligned field entries |
||
5402 | If (LNotEqual (DWD0, 0x5B5AA55A)) |
||
5403 | { Return (50) } |
||
5404 | |||
5405 | // set memory contents to known values using misaligned field entries |
||
5406 | Store (0, BI19) |
||
5407 | // verify memory contents using misaligned field entries |
||
5408 | If (LNotEqual (BI19, 0)) |
||
5409 | { Return (51) } |
||
5410 | // verify memory contents using aligned field entries |
||
5411 | If (LNotEqual (DWD0, 0x595AA55A)) |
||
5412 | { Return (52) } |
||
5413 | |||
5414 | // set memory contents to known values using misaligned field entries |
||
5415 | Store (1, BI1A) |
||
5416 | // verify memory contents using misaligned field entries |
||
5417 | If (LNotEqual (BI1A, 1)) |
||
5418 | { Return (53) } |
||
5419 | // verify memory contents using aligned field entries |
||
5420 | If (LNotEqual (DWD0, 0x5D5AA55A)) |
||
5421 | { Return (54) } |
||
5422 | |||
5423 | // set memory contents to known values using misaligned field entries |
||
5424 | Store (0, BI1B) |
||
5425 | // verify memory contents using misaligned field entries |
||
5426 | If (LNotEqual (BI1B, 0)) |
||
5427 | { Return (55) } |
||
5428 | // verify memory contents using aligned field entries |
||
5429 | If (LNotEqual (DWD0, 0x555AA55A)) |
||
5430 | { Return (56) } |
||
5431 | |||
5432 | // set memory contents to known values using misaligned field entries |
||
5433 | Store (0, BI1C) |
||
5434 | // verify memory contents using misaligned field entries |
||
5435 | If (LNotEqual (BI1C, 0)) |
||
5436 | { Return (57) } |
||
5437 | // verify memory contents using aligned field entries |
||
5438 | If (LNotEqual (DWD0, 0x455AA55A)) |
||
5439 | { Return (58) } |
||
5440 | |||
5441 | // set memory contents to known values using misaligned field entries |
||
5442 | Store (1, BI1D) |
||
5443 | // verify memory contents using misaligned field entries |
||
5444 | If (LNotEqual (BI1D, 1)) |
||
5445 | { Return (59) } |
||
5446 | // verify memory contents using aligned field entries |
||
5447 | If (LNotEqual (DWD0, 0x655AA55A)) |
||
5448 | { Return (60) } |
||
5449 | |||
5450 | // set memory contents to known values using misaligned field entries |
||
5451 | Store (0, BI1E) |
||
5452 | // verify memory contents using misaligned field entries |
||
5453 | If (LNotEqual (BI1E, 0)) |
||
5454 | { Return (61) } |
||
5455 | // verify memory contents using aligned field entries |
||
5456 | If (LNotEqual (DWD0, 0x255AA55A)) |
||
5457 | { Return (62) } |
||
5458 | |||
5459 | // set memory contents to known values using misaligned field entries |
||
5460 | Store (1, BI1F) |
||
5461 | // verify memory contents using misaligned field entries |
||
5462 | If (LNotEqual (BI1F, 1)) |
||
5463 | { Return (63) } |
||
5464 | // verify memory contents using aligned field entries |
||
5465 | If (LNotEqual (DWD0, 0xA55AA55A)) |
||
5466 | { Return (64) } |
||
5467 | |||
5468 | |||
5469 | // set memory contents to known values using misaligned field entries |
||
5470 | Store (3, B2_0) |
||
5471 | // verify memory contents using misaligned field entries |
||
5472 | If (LNotEqual (B2_0, 3)) |
||
5473 | { Return (65) } |
||
5474 | // verify memory contents using aligned field entries |
||
5475 | If (LNotEqual (DWD0, 0xA55AA55B)) |
||
5476 | { Return (66) } |
||
5477 | |||
5478 | // set memory contents to known values using misaligned field entries |
||
5479 | Store (1, B2_1) |
||
5480 | // verify memory contents using misaligned field entries |
||
5481 | If (LNotEqual (B2_1, 1)) |
||
5482 | { Return (67) } |
||
5483 | // verify memory contents using aligned field entries |
||
5484 | If (LNotEqual (DWD0, 0xA55AA557)) |
||
5485 | { Return (68) } |
||
5486 | |||
5487 | // set memory contents to known values using misaligned field entries |
||
5488 | Store (0, B2_2) |
||
5489 | // verify memory contents using misaligned field entries |
||
5490 | If (LNotEqual (B2_2, 0)) |
||
5491 | { Return (69) } |
||
5492 | // verify memory contents using aligned field entries |
||
5493 | If (LNotEqual (DWD0, 0xA55AA547)) |
||
5494 | { Return (70) } |
||
5495 | |||
5496 | // set memory contents to known values using misaligned field entries |
||
5497 | Store (3, B2_3) |
||
5498 | // verify memory contents using misaligned field entries |
||
5499 | If (LNotEqual (B2_3, 3)) |
||
5500 | { Return (71) } |
||
5501 | // verify memory contents using aligned field entries |
||
5502 | If (LNotEqual (DWD0, 0xA55AA5C7)) |
||
5503 | { Return (72) } |
||
5504 | |||
5505 | // set memory contents to known values using misaligned field entries |
||
5506 | Store (3, B2_4) |
||
5507 | // verify memory contents using misaligned field entries |
||
5508 | If (LNotEqual (B2_4, 3)) |
||
5509 | { Return (73) } |
||
5510 | // verify memory contents using aligned field entries |
||
5511 | If (LNotEqual (DWD0, 0xA55AA7C7)) |
||
5512 | { Return (74) } |
||
5513 | |||
5514 | // set memory contents to known values using misaligned field entries |
||
5515 | Store (0, B2_5) |
||
5516 | // verify memory contents using misaligned field entries |
||
5517 | If (LNotEqual (B2_5, 0)) |
||
5518 | { Return (75) } |
||
5519 | // verify memory contents using aligned field entries |
||
5520 | If (LNotEqual (DWD0, 0xA55AA3C7)) |
||
5521 | { Return (76) } |
||
5522 | |||
5523 | // set memory contents to known values using misaligned field entries |
||
5524 | Store (1, B2_6) |
||
5525 | // verify memory contents using misaligned field entries |
||
5526 | If (LNotEqual (B2_6, 1)) |
||
5527 | { Return (77) } |
||
5528 | // verify memory contents using aligned field entries |
||
5529 | If (LNotEqual (DWD0, 0xA55A93C7)) |
||
5530 | { Return (78) } |
||
5531 | |||
5532 | // set memory contents to known values using misaligned field entries |
||
5533 | Store (1, B2_7) |
||
5534 | // verify memory contents using misaligned field entries |
||
5535 | If (LNotEqual (B2_7, 1)) |
||
5536 | { Return (79) } |
||
5537 | // verify memory contents using aligned field entries |
||
5538 | If (LNotEqual (DWD0, 0xA55A53C7)) |
||
5539 | { Return (80) } |
||
5540 | |||
5541 | // set memory contents to known values using misaligned field entries |
||
5542 | Store (0, B2_8) |
||
5543 | // verify memory contents using misaligned field entries |
||
5544 | If (LNotEqual (B2_8, 0)) |
||
5545 | { Return (81) } |
||
5546 | // verify memory contents using aligned field entries |
||
5547 | If (LNotEqual (DWD0, 0xA55853C7)) |
||
5548 | { Return (82) } |
||
5549 | |||
5550 | // set memory contents to known values using misaligned field entries |
||
5551 | Store (1, B2_9) |
||
5552 | // verify memory contents using misaligned field entries |
||
5553 | If (LNotEqual (B2_9, 1)) |
||
5554 | { Return (83) } |
||
5555 | // verify memory contents using aligned field entries |
||
5556 | If (LNotEqual (DWD0, 0xA55453C7)) |
||
5557 | { Return (84) } |
||
5558 | |||
5559 | // set memory contents to known values using misaligned field entries |
||
5560 | Store (2, B2_A) |
||
5561 | // verify memory contents using misaligned field entries |
||
5562 | If (LNotEqual (B2_A, 2)) |
||
5563 | { Return (85) } |
||
5564 | // verify memory contents using aligned field entries |
||
5565 | If (LNotEqual (DWD0, 0xA56453C7)) |
||
5566 | { Return (86) } |
||
5567 | |||
5568 | // set memory contents to known values using misaligned field entries |
||
5569 | Store (2, B2_B) |
||
5570 | // verify memory contents using misaligned field entries |
||
5571 | If (LNotEqual (B2_B, 2)) |
||
5572 | { Return (87) } |
||
5573 | // verify memory contents using aligned field entries |
||
5574 | If (LNotEqual (DWD0, 0xA5A453C7)) |
||
5575 | { Return (88) } |
||
5576 | |||
5577 | // set memory contents to known values using misaligned field entries |
||
5578 | Store (3, B2_C) |
||
5579 | // verify memory contents using misaligned field entries |
||
5580 | If (LNotEqual (B2_C, 3)) |
||
5581 | { Return (89) } |
||
5582 | // verify memory contents using aligned field entries |
||
5583 | If (LNotEqual (DWD0, 0xA7A453C7)) |
||
5584 | { Return (90) } |
||
5585 | |||
5586 | // set memory contents to known values using misaligned field entries |
||
5587 | Store (3, B2_D) |
||
5588 | // verify memory contents using misaligned field entries |
||
5589 | If (LNotEqual (B2_D, 3)) |
||
5590 | { Return (91) } |
||
5591 | // verify memory contents using aligned field entries |
||
5592 | If (LNotEqual (DWD0, 0xAFA453C7)) |
||
5593 | { Return (92) } |
||
5594 | |||
5595 | // set memory contents to known values using misaligned field entries |
||
5596 | Store (1, B2_E) |
||
5597 | // verify memory contents using misaligned field entries |
||
5598 | If (LNotEqual (B2_E, 1)) |
||
5599 | { Return (93) } |
||
5600 | // verify memory contents using aligned field entries |
||
5601 | If (LNotEqual (DWD0, 0x9FA453C7)) |
||
5602 | { Return (94) } |
||
5603 | |||
5604 | // set memory contents to known values using misaligned field entries |
||
5605 | Store (0, B2_F) |
||
5606 | // verify memory contents using misaligned field entries |
||
5607 | If (LNotEqual (B2_F, 0)) |
||
5608 | { Return (95) } |
||
5609 | // verify memory contents using aligned field entries |
||
5610 | If (LNotEqual (DWD0, 0x1FA453C7)) |
||
5611 | { Return (96) } |
||
5612 | |||
5613 | |||
5614 | Return (0) // pass |
||
5615 | } // MADM: Misaligned Dynamic RAM SystemMemory OperationRegion |
||
5616 | |||
5617 | Method (TEST) |
||
5618 | { |
||
5619 | Store ("++++++++ IndexOp4 Test", Debug) |
||
5620 | |||
5621 | // MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments: |
||
5622 | // Arg0 -- SystemMemory OperationRegion base address |
||
5623 | Store (MADM (0x800000), Local0) |
||
5624 | If (LNotEqual (Local0, 0)) // MADM returns zero if successful |
||
5625 | { Return (Local0) } // failure: return MADM error code |
||
5626 | |||
5627 | Return (Local0) |
||
5628 | } // TEST |
||
5629 | } // IDX4 |
||
5630 | |||
5631 | // |
||
5632 | // test Event.asl |
||
5633 | // |
||
5634 | // EventOp, ResetOp, SignalOp, and WaitOp test cases. |
||
5635 | // |
||
5636 | Device (EVNT) |
||
5637 | { |
||
5638 | Event (EVNT) // event synchronization object |
||
5639 | |||
5640 | Method (TEVN, 1) |
||
5641 | // Arg0: time to Wait for event in milliseconds |
||
5642 | { // TEVN control method to test ResetOp, SignalOp, and WaitOp |
||
5643 | // reset EVNT to initialization (zero) state |
||
5644 | Reset (EVNT) |
||
5645 | |||
5646 | // prime EVNT with two outstanding signals |
||
5647 | Signal (EVNT) |
||
5648 | Signal (EVNT) |
||
5649 | |||
5650 | |||
5651 | // acquire existing signal |
||
5652 | Store (Wait (EVNT, Arg0), Local0) |
||
5653 | |||
5654 | // validate Local0 is a Number |
||
5655 | Store (ObjectType (Local0), Local1) |
||
5656 | If (LNotEqual (Local1, 1)) // Number is type 1 |
||
5657 | { Return (0x21) } // Local1 indicates Local0 is not a Number |
||
5658 | |||
5659 | If (LNotEqual (Local0, 0)) // Number is type 1 |
||
5660 | { Return (0x22) } // timeout occurred without acquiring signal |
||
5661 | |||
5662 | Store ("Acquire 1st existing signal PASS", Debug) |
||
5663 | |||
5664 | |||
5665 | // acquire existing signal |
||
5666 | Store (Wait (EVNT, Arg0), Local0) |
||
5667 | |||
5668 | // validate Local0 is a Number |
||
5669 | Store (ObjectType (Local0), Local1) |
||
5670 | If (LNotEqual (Local1, 1)) // Number is type 1 |
||
5671 | { Return (0x31) } // Local1 indicates Local0 is not a Number |
||
5672 | |||
5673 | If (LNotEqual (Local0, 0)) // Number is type 1 |
||
5674 | { Return (0x32) } // timeout occurred without acquiring signal |
||
5675 | |||
5676 | Store ("Acquire 2nd existing signal PASS", Debug) |
||
5677 | |||
5678 | |||
5679 | // ensure WaitOp timeout test cases do not hang |
||
5680 | if (LEqual (Arg0, 0xFFFF)) |
||
5681 | { Store (0xFFFE, Arg0) } |
||
5682 | |||
5683 | // acquire non-existing signal |
||
5684 | Store (Wait (EVNT, Arg0), Local0) |
||
5685 | |||
5686 | // validate Local0 is a Number |
||
5687 | Store (ObjectType (Local0), Local1) |
||
5688 | If (LNotEqual (Local1, 1)) // Number is type 1 |
||
5689 | { Return (0x41) } // Local1 indicates Local0 is not a Number |
||
5690 | |||
5691 | If (LEqual (Local0, 0)) // Number is type 1 |
||
5692 | { Return (0x42) } // non-existant signal was acquired |
||
5693 | |||
5694 | Store ("Acquire signal timeout PASS", Debug) |
||
5695 | |||
5696 | |||
5697 | // prime EVNT with two outstanding signals |
||
5698 | Signal (EVNT) |
||
5699 | Signal (EVNT) |
||
5700 | |||
5701 | // reset EVNT to initialization (zero) state |
||
5702 | Reset (EVNT) |
||
5703 | |||
5704 | // acquire non-existing signal |
||
5705 | Store (Wait (EVNT, Arg0), Local0) |
||
5706 | |||
5707 | // validate Local0 is a Number |
||
5708 | Store (ObjectType (Local0), Local1) |
||
5709 | If (LNotEqual (Local1, 1)) // Number is type 1 |
||
5710 | { Return (0x51) } // Local1 indicates Local0 is not a Number |
||
5711 | |||
5712 | If (LEqual (Local0, 0)) // Number is type 1 |
||
5713 | { Return (0x52) } // non-existant signal was acquired |
||
5714 | |||
5715 | Store ("Reset signal PASS", Debug) |
||
5716 | |||
5717 | |||
5718 | // acquire non-existing signal using Lvalue timeout |
||
5719 | Store (Wait (EVNT, Zero), Local0) |
||
5720 | |||
5721 | // validate Local0 is a Number |
||
5722 | Store (ObjectType (Local0), Local1) |
||
5723 | If (LNotEqual (Local1, 1)) // Number is type 1 |
||
5724 | { Return (0x61) } // Local1 indicates Local0 is not a Number |
||
5725 | |||
5726 | If (LEqual (Local0, 0)) // Number is type 1 |
||
5727 | { Return (0x62) } // non-existant signal was acquired |
||
5728 | |||
5729 | Store ("Zero Lvalue PASS", Debug) |
||
5730 | |||
5731 | |||
5732 | // acquire non-existing signal using Lvalue timeout |
||
5733 | Store (Wait (EVNT, One), Local0) |
||
5734 | |||
5735 | // validate Local0 is a Number |
||
5736 | Store (ObjectType (Local0), Local1) |
||
5737 | If (LNotEqual (Local1, 1)) // Number is type 1 |
||
5738 | { Return (0x71) } // Local1 indicates Local0 is not a Number |
||
5739 | |||
5740 | If (LEqual (Local0, 0)) // Number is type 1 |
||
5741 | { Return (0x72) } // non-existant signal was acquired |
||
5742 | |||
5743 | Store ("One Lvalue PASS", Debug) |
||
5744 | |||
5745 | // Lvalue Event test cases |
||
5746 | // ILLEGAL SOURCE OPERAND Store (EVNT, Local2) |
||
5747 | |||
5748 | // validate Local2 is an Event |
||
5749 | Store (ObjectType (EVNT), Local1) |
||
5750 | If (LNotEqual (Local1, 7)) // Event is type 7 |
||
5751 | { Return (0x81) } // Local1 indicates Local0 is not a Number |
||
5752 | |||
5753 | // reset EVNT to initialization (zero) state |
||
5754 | Reset (EVNT) |
||
5755 | |||
5756 | // prime EVNT with two outstanding signals |
||
5757 | Signal (EVNT) |
||
5758 | |||
5759 | // acquire existing signal |
||
5760 | Store (Wait (EVNT, Arg0), Local0) |
||
5761 | |||
5762 | // validate Local0 is a Number |
||
5763 | Store (ObjectType (Local0), Local1) |
||
5764 | If (LNotEqual (Local1, 1)) // Number is type 1 |
||
5765 | { Return (0x82) } // Local1 indicates Local0 is not a Number |
||
5766 | |||
5767 | If (LNotEqual (Local0, 0)) // Number is type 1 |
||
5768 | { Return (0x83) } // timeout occurred without acquiring signal |
||
5769 | |||
5770 | Store ("Acquire Lvalue existing signal PASS", Debug) |
||
5771 | |||
5772 | |||
5773 | // acquire non-existing signal |
||
5774 | Store (Wait (EVNT, Arg0), Local0) |
||
5775 | |||
5776 | // validate Local0 is a Number |
||
5777 | Store (ObjectType (Local0), Local1) |
||
5778 | If (LNotEqual (Local1, 1)) // Number is type 1 |
||
5779 | { Return (0x84) } // Local1 indicates Local0 is not a Number |
||
5780 | |||
5781 | If (LEqual (Local0, 0)) // Number is type 1 |
||
5782 | { Return (0x85) } // non-existant signal was acquired |
||
5783 | |||
5784 | Store ("Acquire Lvalue signal timeout PASS", Debug) |
||
5785 | |||
5786 | |||
5787 | Return (0) // success |
||
5788 | } // TEVN control method to test ResetOp, SignalOp, and WaitOp |
||
5789 | |||
5790 | Method (TEST) |
||
5791 | { |
||
5792 | Store ("++++++++ Event Test", Debug) |
||
5793 | |||
5794 | Store (TEVN (100), Local0) |
||
5795 | |||
5796 | Return (Local0) |
||
5797 | } // TEST |
||
5798 | } // EVNT |
||
5799 | |||
5800 | // |
||
5801 | // test SizeOfLv.asl |
||
5802 | // |
||
5803 | // Test for SizeOf (Lvalue) |
||
5804 | // |
||
5805 | // This next section will contain the packages that the SizeOfOp will be |
||
5806 | // exercised on. The first one, PKG0, is a regular package of 3 elements. |
||
5807 | // The 2nd one, PKG1, is a nested package with 3 packages inside it, each |
||
5808 | // with 3 elements. It is expected that SizeOf operator will return the |
||
5809 | // same value for these two packages since they both have 3 elements. The |
||
5810 | // final package, PKG2, has 4 elements and the SizeOf operator is expected |
||
5811 | // to return different results for this package. |
||
5812 | |||
5813 | Name (PKG0, |
||
5814 | Package (3) |
||
5815 | {0x0123, 0x4567, 0x89AB} |
||
5816 | ) // PKG0 |
||
5817 | |||
5818 | Name (PKG1, |
||
5819 | Package (3) |
||
5820 | { |
||
5821 | Package (3) {0x0123, 0x4567, 0x89AB}, |
||
5822 | Package (3) {0xCDEF, 0xFEDC, 0xBA98}, |
||
5823 | Package (3) {0x7654, 0x3210, 0x1234} |
||
5824 | } |
||
5825 | ) // PKG1 |
||
5826 | |||
5827 | Name (PKG2, |
||
5828 | Package (4) |
||
5829 | {0x0123, 0x4567, 0x89AB, 0x8888} |
||
5830 | ) // PKG2 |
||
5831 | |||
5832 | Name (PKG3, |
||
5833 | Package (5) |
||
5834 | {0x0123, 0x4567, 0x89AB, 0x8888, 0x7777} |
||
5835 | ) // PKG3 |
||
5836 | |||
5837 | // End Packages ********************************************************** |
||
5838 | |||
5839 | // The following section will declare the data strings that will be used to |
||
5840 | // exercise the SizeOf operator. STR0 and STR1 are expected to be equal, |
||
5841 | // STR2 is expected to have a different SizeOf value than STR0 and STR1. |
||
5842 | |||
5843 | Name (STR0, "ACPI permits very flexible methods of expressing a system") |
||
5844 | |||
5845 | Name (STR1, "MIKE permits very flexible methods of expressing a system") |
||
5846 | |||
5847 | Name (STR2, "Needless to say, Mike and ACPI are frequently at odds") |
||
5848 | |||
5849 | // This string is being made in case we want to do a SizeOf comparison |
||
5850 | // between strings and packages or buffers |
||
5851 | Name (STR3, "12345") |
||
5852 | |||
5853 | // End Strings ********************************************************** |
||
5854 | |||
5855 | // The following section will declare the buffers that will be used to exercise |
||
5856 | // the SizeOf operator. |
||
5857 | |||
5858 | Name (BUF0, Buffer (10) {}) |
||
5859 | Name (BUF1, Buffer (10) {}) |
||
5860 | Name (BUF2, Buffer (8) {}) |
||
5861 | Name (BUF3, Buffer (5) {}) |
||
5862 | |||
5863 | // End Buffers ********************************************************** |
||
5864 | Device (SZLV) |
||
5865 | { |
||
5866 | |||
5867 | Method (CMPR, 2) |
||
5868 | { |
||
5869 | // CMPR is passed two arguments. If unequal, return 1 to indicate |
||
5870 | // that, otherwise return 0 to indicate SizeOf each is equal. |
||
5871 | |||
5872 | Store (0x01, Local0) |
||
5873 | |||
5874 | if (LEqual (SizeOf(Arg0), SizeOf(Arg1))) |
||
5875 | { |
||
5876 | Store (0x00, Local0) |
||
5877 | } |
||
5878 | |||
5879 | return (Local0) |
||
5880 | } // CMPR |
||
5881 | |||
5882 | |||
5883 | Method (TEST) |
||
5884 | { |
||
5885 | |||
5886 | Store ("++++++++ SizeOfLv Test", Debug) |
||
5887 | |||
5888 | // TBD: SizeOf ("string") |
||
5889 | // SizeOf (Buffer) |
||
5890 | // SizeOf (Package) |
||
5891 | // SizeOf (String) |
||
5892 | // SizeOf (STR0) -- where Name (STR0,...) -- lot's of cases |
||
5893 | // buffer, string, package, |
||
5894 | // SizeOf (METH) -- where METH control method returns |
||
5895 | // buffer, string, package, |
||
5896 | |||
5897 | // TBD: SLOC [SizeOf (Local0)] -- dup SARG |
||
5898 | |||
5899 | // Compare the elements that we expect to be the same. Exit out with an error |
||
5900 | // code on the first failure. |
||
5901 | if (LNotEqual (0x00, CMPR (STR0, STR1))) |
||
5902 | { |
||
5903 | Return (0x01) |
||
5904 | } |
||
5905 | |||
5906 | if (LNotEqual (0x00, CMPR (STR3, BUF3))) |
||
5907 | { |
||
5908 | Return (0x02) |
||
5909 | } |
||
5910 | |||
5911 | if (LNotEqual (0x00, CMPR (STR3, PKG3))) |
||
5912 | { |
||
5913 | Return (0x03) |
||
5914 | } |
||
5915 | |||
5916 | // In the following section, this test will cover the SizeOf |
||
5917 | // operator for Local values. |
||
5918 | // In this case, both Local0 and Local1 should have the same Size |
||
5919 | Store (STR0, Local0) |
||
5920 | Store (STR1, Local1) |
||
5921 | |||
5922 | if (LNotEqual (SizeOf (Local0), SizeOf (Local1))) |
||
5923 | { |
||
5924 | Return (0x04) |
||
5925 | } |
||
5926 | |||
5927 | // Now create a case where Local0 and Local1 are different |
||
5928 | Store (STR2, Local1) |
||
5929 | |||
5930 | if (LEqual (SizeOf (Local0), SizeOf (Local1))) |
||
5931 | { |
||
5932 | Return (0x05) |
||
5933 | } |
||
5934 | |||
5935 | // Finally, check for the return of SizeOf for a known Buffer. Just |
||
5936 | // in case we magically pass above cases due to all Buffers being Zero |
||
5937 | // bytes in size, or Infinity, etc. |
||
5938 | if (LNotEqual (0x05, SizeOf (BUF3))) |
||
5939 | { |
||
5940 | Return (0x06) |
||
5941 | } |
||
5942 | |||
5943 | Return (0) |
||
5944 | } // TEST |
||
5945 | } // SZLV |
||
5946 | |||
5947 | |||
5948 | // |
||
5949 | // test BytField.asl |
||
5950 | // |
||
5951 | // BytField test |
||
5952 | // This is just a subset of the many RegionOp/Index Field test cases. |
||
5953 | // Tests access of TBD. |
||
5954 | // |
||
5955 | Scope (\_SB) // System Bus |
||
5956 | { // _SB system bus |
||
5957 | Device (BYTF) |
||
5958 | { // Test device name |
||
5959 | Method (TEST) |
||
5960 | { |
||
5961 | Store ("++++++++ BytField Test", Debug) |
||
5962 | |||
5963 | Return (\_TZ.C19B.RSLT) |
||
5964 | } // TEST |
||
5965 | } // BYTF |
||
5966 | |||
5967 | Device (C005) |
||
5968 | { // Device C005 |
||
5969 | Device (C013) |
||
5970 | { // Device C013 |
||
5971 | } // Device C013 |
||
5972 | } // Device C005 |
||
5973 | |||
5974 | Method (C115) |
||
5975 | { // C115 control method |
||
5976 | Acquire (\_GL, 0xFFFF) |
||
5977 | Store (\_SB.C005.C013.C058.C07E, Local0) |
||
5978 | Release (\_GL) |
||
5979 | And (Local0, 16, Local0) |
||
5980 | Store (ShiftRight (Local0, 4, ), Local1) |
||
5981 | If (LEqual (Local1, 0)) |
||
5982 | { Return (1) } |
||
5983 | Else |
||
5984 | { Return (0) } |
||
5985 | } // C115 control method |
||
5986 | } // _SB system bus |
||
5987 | |||
5988 | OperationRegion (C018, SystemIO, 0x5028, 4) |
||
5989 | Field (C018, AnyAcc, NoLock, Preserve) |
||
5990 | { // Field overlaying C018 |
||
5991 | C019, 32 |
||
5992 | } // Field overlaying C018 |
||
5993 | |||
5994 | OperationRegion (C01A, SystemIO, 0x5030, 4) |
||
5995 | Field (C01A, ByteAcc, NoLock, Preserve) |
||
5996 | { // Field overlaying C01A |
||
5997 | C01B, 8, |
||
5998 | C01C, 8, |
||
5999 | C01D, 8, |
||
6000 | C01E, 8 |
||
6001 | } // Field overlaying C01A |
||
6002 | |||
6003 | Mutex (\C01F, 0) |
||
6004 | Name (\C020, 0) |
||
6005 | Name (\C021, 0) |
||
6006 | |||
6007 | Method (\C022, 0) |
||
6008 | { // \C022 control method |
||
6009 | Acquire (\C01F, 0xFFFF) |
||
6010 | If (LEqual (\C021, 0)) |
||
6011 | { |
||
6012 | Store (C019, Local0) |
||
6013 | And (Local0, 0xFFFEFFFE, Local0) |
||
6014 | Store (Local0, C019) |
||
6015 | Increment (\C021) |
||
6016 | } |
||
6017 | Release (\C01F) |
||
6018 | } // \C022 control method |
||
6019 | |||
6020 | Scope (\_SB.C005.C013) |
||
6021 | { // Scope \_SB.C005.C013 |
||
6022 | Device (C058) |
||
6023 | { // Device C058 |
||
6024 | Name (_HID, "*PNP0A06") |
||
6025 | |||
6026 | OperationRegion (C059, SystemIO, 0xE0, 2) |
||
6027 | Field (C059, ByteAcc, NoLock, Preserve) |
||
6028 | { // Field overlaying C059 |
||
6029 | C05A, 8, |
||
6030 | C05B, 8 |
||
6031 | } // Field overlaying C059 |
||
6032 | |||
6033 | OperationRegion (C05C, SystemIO, 0xE2, 2) |
||
6034 | Field (C05C, ByteAcc, NoLock, Preserve) |
||
6035 | { // Field overlaying C05C |
||
6036 | C05D, 8, |
||
6037 | C05E, 8 |
||
6038 | } // Field overlaying C05C |
||
6039 | IndexField (C05D, C05E, ByteAcc, NoLock, Preserve) |
||
6040 | { // IndexField overlaying C05D/C05E |
||
6041 | , 0x410, // skip |
||
6042 | C05F, 8, |
||
6043 | C060, 8, |
||
6044 | C061, 8, |
||
6045 | C062, 8, |
||
6046 | C063, 8, |
||
6047 | C064, 8, |
||
6048 | C065, 8, |
||
6049 | C066, 8, |
||
6050 | C067, 8, |
||
6051 | C068, 8, |
||
6052 | C069, 8, |
||
6053 | C06A, 8, |
||
6054 | C06B, 8, |
||
6055 | C06C, 8, |
||
6056 | C06D, 8, |
||
6057 | C06E, 8, |
||
6058 | , 0x70, // skip |
||
6059 | C06F, 8, |
||
6060 | C070, 8, |
||
6061 | C071, 8, |
||
6062 | C072, 8, |
||
6063 | C073, 8, |
||
6064 | C074, 8, |
||
6065 | C075, 8, |
||
6066 | C076, 8, |
||
6067 | C077, 8, |
||
6068 | C078, 8, |
||
6069 | C079, 8, |
||
6070 | C07A, 8, |
||
6071 | C07B, 8, |
||
6072 | C07C, 8, |
||
6073 | C07D, 8, |
||
6074 | C07E, 8 |
||
6075 | } // IndexField overlaying C05D/C05E |
||
6076 | |||
6077 | OperationRegion (C07F, SystemIO, 0xE4, 2) |
||
6078 | Field (C07F, ByteAcc, NoLock, Preserve) |
||
6079 | { // Field overlaying C07F |
||
6080 | C080, 8, |
||
6081 | C081, 8 |
||
6082 | } // Field overlaying C07F |
||
6083 | |||
6084 | OperationRegion (C082, SystemIO, 0xE0, 1) |
||
6085 | Field (C082, ByteAcc, NoLock, Preserve) |
||
6086 | { // Field overlaying C082 |
||
6087 | C083, 8 |
||
6088 | } // Field overlaying C082 |
||
6089 | |||
6090 | OperationRegion (C084, SystemIO, 0xFF, 1) |
||
6091 | Field (C084, ByteAcc, NoLock, Preserve) |
||
6092 | { // Field overlaying C084 |
||
6093 | C085, 8 |
||
6094 | } // Field overlaying C084 |
||
6095 | |||
6096 | OperationRegion (C086, SystemIO, 0xFD, 1) |
||
6097 | Field (C086, ByteAcc, NoLock, Preserve) |
||
6098 | { // Field overlaying C086 |
||
6099 | C087, 8 |
||
6100 | } // Field overlaying C086 |
||
6101 | |||
6102 | Mutex (C088, 0) |
||
6103 | Mutex (C089, 0) |
||
6104 | Mutex (C08A, 0) |
||
6105 | Mutex (C08B, 0) |
||
6106 | Mutex (C08C, 0) |
||
6107 | Mutex (C08D, 0) |
||
6108 | |||
6109 | Name (C08E, 0xFFFFFFFD) |
||
6110 | Name (C08F, 0) |
||
6111 | |||
6112 | Method (C0AA, 4) |
||
6113 | { // C0AA control method |
||
6114 | Store (Buffer (4) {}, Local7) |
||
6115 | CreateByteField (Local7, 0, C0AB) |
||
6116 | CreateByteField (Local7, 1, C0AC) |
||
6117 | CreateByteField (Local7, 2, C0AD) |
||
6118 | CreateByteField (Local7, 3, C0AE) |
||
6119 | Acquire (^C08B, 0xFFFF) |
||
6120 | Acquire (\_GL, 0xFFFF) |
||
6121 | \C022 () |
||
6122 | Store (1, \_SB.C005.C013.C058.C06B) |
||
6123 | While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B))) |
||
6124 | { Stall (100) } |
||
6125 | Store (Arg3, \_SB.C005.C013.C058.C06E) |
||
6126 | Store (Arg2, \_SB.C005.C013.C058.C06D) |
||
6127 | Store (Arg1, \_SB.C005.C013.C058.C06C) |
||
6128 | Store (Arg0, \_SB.C005.C013.C058.C06B) |
||
6129 | While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B))) |
||
6130 | { Stall (100) } |
||
6131 | Store (\_SB.C005.C013.C058.C06E, C0AB) |
||
6132 | Store (\_SB.C005.C013.C058.C06D, C0AC) |
||
6133 | Store (\_SB.C005.C013.C058.C06C, C0AD) |
||
6134 | Store (\_SB.C005.C013.C058.C06B, C0AE) |
||
6135 | If (LNot (LEqual (Arg0, 23))) |
||
6136 | { |
||
6137 | Store (2, \_SB.C005.C013.C058.C06B) |
||
6138 | Stall (100) |
||
6139 | } |
||
6140 | Release (\_GL) |
||
6141 | Release (^C08B) |
||
6142 | Return (Local7) |
||
6143 | } // C0AA control method |
||
6144 | } // Device C058 |
||
6145 | } // Scope \_SB.C005.C013 |
||
6146 | |||
6147 | Scope (\_TZ) |
||
6148 | { // \_TZ thermal zone scope |
||
6149 | Name (C18B, Package (2) |
||
6150 | { |
||
6151 | Package (2) |
||
6152 | { |
||
6153 | Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E}, |
||
6154 | Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2} |
||
6155 | }, |
||
6156 | Package (2) |
||
6157 | { |
||
6158 | Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E}, |
||
6159 | Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2} |
||
6160 | } |
||
6161 | }) // C18B |
||
6162 | |||
6163 | Name (C18C, Package (2) |
||
6164 | { |
||
6165 | Package (2) |
||
6166 | { |
||
6167 | Package (3) {0x64, 0x4B, 0x32}, |
||
6168 | Package (3) {0x64, 0x4B, 0x32} |
||
6169 | } |
||
6170 | }) // C81C |
||
6171 | |||
6172 | Name (C18D, 0) |
||
6173 | Name (C18E, 0) |
||
6174 | Name (C18F, 0) |
||
6175 | Name (C190, 0) |
||
6176 | Name (C191, 3) |
||
6177 | Name (C192, 0) |
||
6178 | Name (C193, 1) |
||
6179 | Name (C194, 2) |
||
6180 | Mutex (C195, 0) |
||
6181 | Name (C196, 1) |
||
6182 | Name (C197, 0x0B9C) |
||
6183 | Name (C198, 0x0B9C) |
||
6184 | Name (C199, 0xFFFFFFFD) |
||
6185 | Name (C19A, 0) |
||
6186 | |||
6187 | Device (C19B) |
||
6188 | { // Device C19B |
||
6189 | Name (RSLT, 0) // default to zero |
||
6190 | |||
6191 | Method (XINI) |
||
6192 | { // _INI control method (Uses Global Lock -- can't run under AcpiExec) |
||
6193 | Store (\_SB.C115, C19A) |
||
6194 | \_TZ.C19C._SCP (0) |
||
6195 | Subtract (0x0EB2, 0x0AAC, Local1) // Local1 = AACh - EB2h |
||
6196 | Divide (Local1, 10, Local0, Local2) // Local0 = Local1 / 10 |
||
6197 | // Local2 = Local1 % 10 |
||
6198 | \_SB.C005.C013.C058.C0AA (14, Local2, 0, 0) |
||
6199 | Store |
||
6200 | (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 0, )), C18D) |
||
6201 | Store |
||
6202 | (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 1, )), C18E) |
||
6203 | Store |
||
6204 | (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 2, )), C18F) |
||
6205 | |||
6206 | Store (1, RSLT) // set RSLT to 1 if _INI control method completes |
||
6207 | } // _INI control method |
||
6208 | |||
6209 | // PowerResource (C19D) {...} |
||
6210 | } // Device C19B |
||
6211 | |||
6212 | ThermalZone (C19C) |
||
6213 | { |
||
6214 | Method (_SCP, 1) |
||
6215 | { // _SCP control method |
||
6216 | Store (Arg0, Local0) |
||
6217 | If (LEqual (Local0, 0)) |
||
6218 | { |
||
6219 | Store (0, \_TZ.C192) |
||
6220 | Store (1, \_TZ.C193) |
||
6221 | Store (2, \_TZ.C194) |
||
6222 | Store (3, \_TZ.C191) |
||
6223 | } |
||
6224 | Else |
||
6225 | { |
||
6226 | Store (0, \_TZ.C191) |
||
6227 | Store (1, \_TZ.C192) |
||
6228 | Store (2, \_TZ.C193) |
||
6229 | Store (3, \_TZ.C194) |
||
6230 | } |
||
6231 | } // _SCP control method |
||
6232 | } // ThermalZone C19C |
||
6233 | } // \_TZ thermal zone scope |
||
6234 | |||
6235 | |||
6236 | // |
||
6237 | // test DwrdFld.asl |
||
6238 | // |
||
6239 | Name (BUFR, buffer(10) {0,0,0,0,0,0,0,0,0,0} ) |
||
6240 | |||
6241 | Device (DWDF) |
||
6242 | { |
||
6243 | Method (TEST) |
||
6244 | { |
||
6245 | Store ("++++++++ DwrdFld Test", Debug) |
||
6246 | |||
6247 | CreateByteField (BUFR, 0, BYTE) |
||
6248 | Store (0xAA, BYTE) |
||
6249 | |||
6250 | CreateWordField (BUFR, 1, WORD) |
||
6251 | Store (0xBBCC, WORD) |
||
6252 | |||
6253 | CreateDWordField (BUFR, 3, DWRD) |
||
6254 | Store (0xDDEEFF00, DWRD) |
||
6255 | |||
6256 | CreateByteField (BUFR, 7, BYT2) |
||
6257 | Store (0x11, BYT2) |
||
6258 | |||
6259 | CreateWordField (BUFR, 8, WRD2) |
||
6260 | Store (0x2233, WRD2) |
||
6261 | |||
6262 | Return (0) |
||
6263 | |||
6264 | } // End Method TEST |
||
6265 | } // Device DWDF |
||
6266 | |||
6267 | // |
||
6268 | // test DivAddx.asl |
||
6269 | // |
||
6270 | Name (B1LO, 0xAA) |
||
6271 | Name (B1HI, 0xBB) |
||
6272 | |||
6273 | Method (MKW_, 2) |
||
6274 | { // This control method will take two bytes and make them into a WORD |
||
6275 | |||
6276 | Multiply (B1HI, 256, Local0) // Make high byte.....high |
||
6277 | Or (Local0, B1LO, Local0) // OR in the low byte |
||
6278 | Return (Local0) // Return the WORD |
||
6279 | |||
6280 | } // MKW_ |
||
6281 | |||
6282 | Device (DVAX) |
||
6283 | { |
||
6284 | Method (TEST) |
||
6285 | { |
||
6286 | |||
6287 | Store ("++++++++ DivAddx Test", Debug) |
||
6288 | |||
6289 | Store (25, B1LO) |
||
6290 | Store (0, B1HI) |
||
6291 | |||
6292 | // We'll multiply 25 * 3 to get 75, add 99 to it then divide |
||
6293 | // by 100. We expect to get 74 for the remainder and 1 for |
||
6294 | // the quotient. |
||
6295 | Divide( |
||
6296 | Add (Multiply (3, MKW_ (B1LO, B1HI)), 0x63), |
||
6297 | // Dividend, |
||
6298 | 100, // Divisor |
||
6299 | Local4, // Remainder |
||
6300 | Local2) // Quotient |
||
6301 | |||
6302 | If (LAnd (LEqual (74, Local4), LEqual (1, Local2))) |
||
6303 | { // Indicate Pass |
||
6304 | Store (0x00, Local0) |
||
6305 | } |
||
6306 | |||
6307 | Else |
||
6308 | { // Indicate Fail |
||
6309 | Store (0x01, Local0) |
||
6310 | } |
||
6311 | |||
6312 | Return (Local0) |
||
6313 | } // End Method TEST |
||
6314 | } // Device DVAX |
||
6315 | |||
6316 | // |
||
6317 | // test IndexFld.asl (IndexOp6.asl) |
||
6318 | // |
||
6319 | // IndexFld test |
||
6320 | // This is just a subset of the many RegionOp/Index Field test cases. |
||
6321 | // Tests index field element AccessAs macro. |
||
6322 | // Also tests name resolution of index field elements with same names |
||
6323 | // but different namespace scopes. |
||
6324 | // |
||
6325 | Device (IDX6) |
||
6326 | { // Test device name |
||
6327 | |||
6328 | OperationRegion (SIO, SystemIO, 0x100, 2) |
||
6329 | Field (SIO, ByteAcc, NoLock, Preserve) |
||
6330 | { |
||
6331 | INDX, 8, |
||
6332 | DATA, 8 |
||
6333 | } |
||
6334 | IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes) |
||
6335 | { |
||
6336 | AccessAs (ByteAcc, 0), |
||
6337 | IFE0, 8, |
||
6338 | IFE1, 8, |
||
6339 | IFE2, 8, |
||
6340 | IFE3, 8, |
||
6341 | IFE4, 8, |
||
6342 | IFE5, 8, |
||
6343 | IFE6, 8, |
||
6344 | IFE7, 8, |
||
6345 | IFE8, 8, |
||
6346 | IFE9, 8, |
||
6347 | } |
||
6348 | |||
6349 | Device (TST_) |
||
6350 | { // TST_: provides a different namespace scope for IFE0 and IFE1 |
||
6351 | OperationRegion (SIO2, SystemIO, 0x100, 2) |
||
6352 | Field (SIO2, ByteAcc, NoLock, Preserve) |
||
6353 | { |
||
6354 | IND2, 8, |
||
6355 | DAT2, 8 |
||
6356 | } |
||
6357 | IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes) |
||
6358 | { |
||
6359 | IFE0, 8, // duplicate IndexField name with different scope |
||
6360 | IFE1, 8 |
||
6361 | } |
||
6362 | } // TST_: provides a different namespace scope for IFE0 and IFE1 |
||
6363 | |||
6364 | Method (TEST) |
||
6365 | { |
||
6366 | Store ("++++++++ IndexOp6 Test", Debug) |
||
6367 | |||
6368 | Store (IFE0, Local0) |
||
6369 | Store (IFE1, Local1) |
||
6370 | Store (IFE2, Local2) |
||
6371 | |||
6372 | // validate name resolution of IndexFields with different scopes |
||
6373 | Store (\IDX6.IFE0, Local3) |
||
6374 | Store (\IDX6.IFE1, Local4) |
||
6375 | // verioading of namespace can resolve following names |
||
6376 | Store (\IDX6.TST_.IFE0, Local5) |
||
6377 | Store (\IDX6.TST_.IFE1, Local6) |
||
6378 | |||
6379 | Return (0) |
||
6380 | } // TEST |
||
6381 | } // IDX6 |
||
6382 | |||
6383 | // |
||
6384 | // test IndexOp5.asl |
||
6385 | // |
||
6386 | // IndexOp5 test |
||
6387 | // This is just a subset of the many RegionOp/Index Field test cases. |
||
6388 | // Tests copying string into buffer then performing IndexOp on result. |
||
6389 | // |
||
6390 | Device (IDX5) |
||
6391 | { // Test device name |
||
6392 | |||
6393 | Name (OSFL, 0) // 0 == Windows 98, 1 == Windows NT |
||
6394 | |||
6395 | // MCTH is a control method to compare two strings. It returns |
||
6396 | // zero if the strings mismatch, or 1 if the strings match. |
||
6397 | // This exercises the test case of copying a string into a buffer |
||
6398 | // and performing an IndexOp on the resulting buffer. |
||
6399 | Method (MCTH, 2) // Control Method to compare two strings |
||
6400 | { // MCTH: Control Method to compare two strings |
||
6401 | // Arg0: first string to compare |
||
6402 | // Arg1: second string to compare |
||
6403 | // Return: zero if strings mismatch, 1 if strings match |
||
6404 | |||
6405 | // check if first string's length is less than second string's length |
||
6406 | If (LLess (SizeOf (Arg0), SizeOf (Arg1))) |
||
6407 | { Return (0) } |
||
6408 | |||
6409 | // increment length to include NULL termination character |
||
6410 | Add (SizeOf (Arg0), 1, Local0) // Local0 = strlen(Arg0) + 1 |
||
6411 | |||
6412 | // create two buffers of size Local0 [strlen(Arg0)+1] |
||
6413 | Name (BUF0, Buffer (Local0) {}) |
||
6414 | Name (BUF1, Buffer (Local0) {}) |
||
6415 | |||
6416 | // copy strings into buffers |
||
6417 | Store (Arg0, BUF0) |
||
6418 | Store (Arg1, BUF1) |
||
6419 | |||
6420 | // validate BUF0 and BUF1 are still buffers |
||
6421 | Store (ObjectType (BUF0), Local1) |
||
6422 | If (LNotEqual (Local1, 3)) // Buffer is type 3 |
||
6423 | { Return (20) } |
||
6424 | Store (ObjectType (BUF1), Local1) |
||
6425 | If (LNotEqual (Local1, 3)) // Buffer is type 3 |
||
6426 | { Return (21) } |
||
6427 | |||
6428 | // Decrement because the Index base below is zero based |
||
6429 | // while Local0 length is one based. |
||
6430 | Decrement (Local0) |
||
6431 | |||
6432 | While (Local0) |
||
6433 | { // loop through all BUF0 buffer elements |
||
6434 | Decrement (Local0) |
||
6435 | |||
6436 | // check if BUF0[n] == BUF1[n] |
||
6437 | If (LEqual (DerefOf (Index (BUF0, Local0, )), |
||
6438 | DerefOf (Index (BUF1, Local0, )))) |
||
6439 | { } // this is how the code was really implemented |
||
6440 | Else |
||
6441 | { Return (Zero) } |
||
6442 | } // loop through all BUF0 buffer elements |
||
6443 | |||
6444 | Return (One) // strings / buffers match |
||
6445 | } // MCTH: Control Method to compare two strings |
||
6446 | |||
6447 | |||
6448 | Method (TEST) |
||
6449 | { |
||
6450 | Store ("++++++++ IndexOp5 Test", Debug) |
||
6451 | |||
6452 | If (MCTH (\_OS, "Microsoft Windows NT")) |
||
6453 | { Store (1, OSFL) } |
||
6454 | |||
6455 | If (LNotEqual (OSFL, 1)) |
||
6456 | { Return (11) } |
||
6457 | |||
6458 | Return (0) |
||
6459 | } // TEST |
||
6460 | } // IDX5 |
||
6461 | |||
6462 | // |
||
6463 | // test IndexOp.asl |
||
6464 | // |
||
6465 | Scope (\_SB) // System Bus |
||
6466 | { // _SB system bus |
||
6467 | |||
6468 | Method (C097) |
||
6469 | { Return (1) } |
||
6470 | |||
6471 | Device (PCI2) |
||
6472 | { // Root PCI Bus |
||
6473 | Name (_HID, EISAID("PNP0A03")) |
||
6474 | Name (_ADR, 0x00000000) |
||
6475 | Name (_CRS, Buffer(26) {"\_SB_.PCI2._CRS..........."}) |
||
6476 | Method (_STA) {Return (0x0F)} |
||
6477 | |||
6478 | Device (ISA) |
||
6479 | { // ISA bridge |
||
6480 | Name (_ADR, 0x00030000) // ISA bus ID |
||
6481 | |||
6482 | Device (EC0) |
||
6483 | { // Embedded Controller |
||
6484 | Name (_GPE, 0) // EC use GPE0 |
||
6485 | Name (_ADR, 0x0030000) // PCI address |
||
6486 | |||
6487 | Method (_STA,0) // EC Status |
||
6488 | { Return(0xF) } // EC is functioning |
||
6489 | |||
6490 | Name (_CRS, ResourceTemplate() |
||
6491 | { |
||
6492 | IO (Decode16, 0x62, 0x62, 1, 1) |
||
6493 | IO (Decode16, 0x66, 0x66, 1, 1) |
||
6494 | } |
||
6495 | ) |
||
6496 | |||
6497 | // create EC's region and field |
||
6498 | OperationRegion (RAM, SystemMemory, 0x400000, 0x100) |
||
6499 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
6500 | { |
||
6501 | // AC information |
||
6502 | ADP, 1, // AC Adapter 1:On-line, 0:Off-line |
||
6503 | AFLT, 1, // AC Adapter Fault 1:Fault 0:Normal |
||
6504 | BAT0, 1, // BAT0 1:present, 0:not present |
||
6505 | , 1, // reserved |
||
6506 | , 28, // filler to force DWORD alignment |
||
6507 | |||
6508 | // CMBatt information |
||
6509 | BPU0, 32, // Power Unit |
||
6510 | BDC0, 32, // Designed Capacity |
||
6511 | BFC0, 32, // Last Full Charge Capacity |
||
6512 | BTC0, 32, // Battery Technology |
||
6513 | BDV0, 32, // Design Voltage |
||
6514 | BST0, 32, // Battery State |
||
6515 | BPR0, 32, // Battery Present Rate |
||
6516 | // (Designed Capacity)x(%)/{(h)x100} |
||
6517 | BRC0, 32, // Battery Remaining Capacity |
||
6518 | // (Designed Capacity)(%)^100 |
||
6519 | BPV0, 32, // Battery Present Voltage |
||
6520 | BTP0, 32, // Trip Point |
||
6521 | BCW0, 32, // Design capacity of Warning |
||
6522 | BCL0, 32, // Design capacity of Low |
||
6523 | BCG0, 32, // capacity granularity 1 |
||
6524 | BG20, 32, // capacity granularity 2 |
||
6525 | BMO0, 32, // Battery model number field |
||
6526 | BIF0, 32, // OEM Information(00h) |
||
6527 | BSN0, 32, // Battery Serial Number |
||
6528 | BTY0, 32, // Battery Type (e.g., "Li-Ion") |
||
6529 | BTY1, 32 // Battery Type (e.g., "Li-Ion") |
||
6530 | } // Field |
||
6531 | } // EC0: Embedded Controller |
||
6532 | } // ISA bridge |
||
6533 | } // PCI2 Root PCI Bus |
||
6534 | |||
6535 | Device (IDX0) |
||
6536 | { // Test device name |
||
6537 | Name (_HID, EISAID ("PNP0C0A")) // Control Method Battey ID |
||
6538 | Name (_PCL, Package() {\_SB}) |
||
6539 | Method (_STA) |
||
6540 | { |
||
6541 | // _STA bits 0-3 indicate existence of battery slot |
||
6542 | // _STA bit 4 indicates battery (not) present |
||
6543 | If (\_SB.PCI2.ISA.EC0.BAT0) |
||
6544 | { Return (0x1F) } // Battery present |
||
6545 | else |
||
6546 | { Return (0x0F) } // Battery not present |
||
6547 | } // _STA |
||
6548 | |||
6549 | Method (_BIF) |
||
6550 | { |
||
6551 | Name (BUFR, Package(13) {}) |
||
6552 | Store (\_SB.PCI2.ISA.EC0.BPU0, Index (BUFR,0)) // Power Unit |
||
6553 | Store (\_SB.PCI2.ISA.EC0.BDC0, Index (BUFR,1)) // Designed Capacity |
||
6554 | Store (\_SB.PCI2.ISA.EC0.BFC0, Index (BUFR,2)) // Last Full Charge Capa. |
||
6555 | Store (\_SB.PCI2.ISA.EC0.BTC0, Index (BUFR,3)) // Battery Technology |
||
6556 | Store (\_SB.PCI2.ISA.EC0.BDV0, Index (BUFR,4)) // Designed Voltage |
||
6557 | Store (\_SB.PCI2.ISA.EC0.BCW0, Index (BUFR,5)) // Designed warning level |
||
6558 | Store (\_SB.PCI2.ISA.EC0.BCL0, Index (BUFR,6)) // Designed Low level |
||
6559 | Store (\_SB.PCI2.ISA.EC0.BCG0, Index (BUFR,7)) // Capacity granularity 1 |
||
6560 | Store (\_SB.PCI2.ISA.EC0.BG20, Index (BUFR,8)) // Capacity granularity 2 |
||
6561 | |||
6562 | Store ("", Index (BUFR,9)) // Model Number |
||
6563 | |||
6564 | Store ("", Index (BUFR,10)) // Serial Number |
||
6565 | |||
6566 | Store ("LiOn", Index (BUFR,11)) // Battery Type |
||
6567 | |||
6568 | Store ("Chicony", Index (BUFR,12)) // OEM Information |
||
6569 | |||
6570 | Return (BUFR) |
||
6571 | } // _BIF |
||
6572 | |||
6573 | Method (_BST) |
||
6574 | { |
||
6575 | Name (BUFR, Package(4) {1, 0x100, 0x76543210, 0x180}) |
||
6576 | Return (BUFR) |
||
6577 | } // _BST |
||
6578 | |||
6579 | Method (_BTP,1) |
||
6580 | { |
||
6581 | Store (arg0, \_SB.PCI2.ISA.EC0.BTP0) // Set Battery Trip point |
||
6582 | } |
||
6583 | |||
6584 | Method (TEST) |
||
6585 | { |
||
6586 | |||
6587 | Store ("++++++++ IndexOp Test", Debug) |
||
6588 | |||
6589 | // test storing into uninitialized package elements |
||
6590 | Name (PBUF, Package(4) {}) // leave unitialized |
||
6591 | Store (0x01234567, Index (PBUF,0)) |
||
6592 | Store (0x89ABCDEF, Index (PBUF,1)) |
||
6593 | Store (0xFEDCBA98, Index (PBUF,2)) |
||
6594 | Store (0x76543210, Index (PBUF,3)) |
||
6595 | |||
6596 | // verify values stored into uninitialized package elements |
||
6597 | If (LNotEqual (DerefOf (Index (PBUF,0)), 0x01234567)) |
||
6598 | { Return (0x10) } |
||
6599 | |||
6600 | If (LNotEqual (DerefOf (Index (PBUF,1)), 0x89ABCDEF)) |
||
6601 | { Return (0x11) } |
||
6602 | |||
6603 | If (LNotEqual (DerefOf (Index (PBUF,2)), 0xFEDCBA98)) |
||
6604 | { Return (0x12) } |
||
6605 | |||
6606 | If (LNotEqual (DerefOf (Index (PBUF,3)), 0x76543210)) |
||
6607 | { Return (0x13) } |
||
6608 | |||
6609 | |||
6610 | // store _BIF package return value into Local0 |
||
6611 | Store (_BIF, Local0) |
||
6612 | |||
6613 | // save Local0 object type value into Local1 |
||
6614 | Store (ObjectType (Local0), Local1) |
||
6615 | |||
6616 | // validate Local0 is a Package |
||
6617 | If (LNotEqual (Local1, 4)) // Package type is 4 |
||
6618 | { Return (0x21) } // failure |
||
6619 | |||
6620 | |||
6621 | // test storing into buffer field elements |
||
6622 | Name (BUFR, Buffer(16) |
||
6623 | { // initial values |
||
6624 | 00, 00, 00, 00, 00, 00, 00, 00, |
||
6625 | 00, 00, 00, 00, 00, 00, 00, 00, |
||
6626 | } |
||
6627 | ) // BUFR |
||
6628 | // test storing into buffer field elements |
||
6629 | Store (0x01234567, Index (BUFR,0)) // should only store 0x67 |
||
6630 | Store (0x89ABCDEF, Index (BUFR,4)) // should only store 0xEF |
||
6631 | Store (0xFEDCBA98, Index (BUFR,8)) // should only store 0x98 |
||
6632 | Store (0x76543210, Index (BUFR,12)) // should only store 0x10 |
||
6633 | |||
6634 | // verify storing into buffer field elements |
||
6635 | If (LNotEqual (DerefOf (Index (BUFR,0)), 0x67)) |
||
6636 | { Return (0x30) } |
||
6637 | |||
6638 | If (LNotEqual (DerefOf (Index (BUFR,1)), 0)) |
||
6639 | { Return (0x31) } |
||
6640 | |||
6641 | If (LNotEqual (DerefOf (Index (BUFR,4)), 0xEF)) |
||
6642 | { Return (0x34) } |
||
6643 | |||
6644 | If (LNotEqual (DerefOf (Index (BUFR,8)), 0x98)) |
||
6645 | { Return (0x38) } |
||
6646 | |||
6647 | If (LNotEqual (DerefOf (Index (BUFR,12)), 0x10)) |
||
6648 | { Return (0x3C) } |
||
6649 | |||
6650 | |||
6651 | Return (0) // pass |
||
6652 | } // TEST |
||
6653 | } // IDX0 |
||
6654 | } // _SB system bus |
||
6655 | |||
6656 | // |
||
6657 | // test BitIndex.asl |
||
6658 | // |
||
6659 | // BitIndex test |
||
6660 | // This is a test case for accessing fields defined as single bits in |
||
6661 | // memory. This is done by creating two index fields that overlay the |
||
6662 | // same DWORD in memory. One field accesses the DWORD as a DWORD, the |
||
6663 | // other accesses individual bits of the same DWORD field in memory. |
||
6664 | // |
||
6665 | Scope (\_SB) // System Bus |
||
6666 | { // _SB system bus |
||
6667 | OperationRegion (RAM, SystemMemory, 0x800000, 0x100) |
||
6668 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
6669 | { // Any access |
||
6670 | TREE, 3, |
||
6671 | WRD0, 16, |
||
6672 | WRD1, 16, |
||
6673 | WRD2, 16, |
||
6674 | WRD3, 16, |
||
6675 | WRD4, 16, |
||
6676 | DWRD, 32, // DWORD field |
||
6677 | } |
||
6678 | Field (RAM, AnyAcc, NoLock, Preserve) |
||
6679 | { // Any access |
||
6680 | THRE, 3, |
||
6681 | WD00, 16, |
||
6682 | WD01, 16, |
||
6683 | WD02, 16, |
||
6684 | WD03, 16, |
||
6685 | WD04, 16, |
||
6686 | BYT0, 8, // Start off with a BYTE |
||
6687 | BIT0, 1, // single-bit field |
||
6688 | BIT1, 1, // single-bit field |
||
6689 | BIT2, 1, // single-bit field |
||
6690 | BIT3, 1, // single-bit field |
||
6691 | BIT4, 1, // single-bit field |
||
6692 | BIT5, 1, // single-bit field |
||
6693 | BIT6, 1, // single-bit field |
||
6694 | BIT7, 1, // single-bit field |
||
6695 | BIT8, 1, // single-bit field |
||
6696 | BIT9, 1, // single-bit field |
||
6697 | BITA, 1, // single-bit field |
||
6698 | BITB, 1, // single-bit field |
||
6699 | BITC, 1, // single-bit field |
||
6700 | BITD, 1, // single-bit field |
||
6701 | BITE, 1, // single-bit field |
||
6702 | BITF, 1, // single-bit field |
||
6703 | BYTZ, 8, // End with a BYTE for a total of 32 bits |
||
6704 | } |
||
6705 | |||
6706 | Device (BITI) |
||
6707 | { // Test device name |
||
6708 | |||
6709 | Method (MBIT) // Test single bit memory accesses |
||
6710 | { |
||
6711 | |||
6712 | If (LNotEqual (DWRD, 0x00)) |
||
6713 | { |
||
6714 | Store (0xFF00, Local0) |
||
6715 | } |
||
6716 | Else |
||
6717 | { |
||
6718 | // Prime Local0 with 0...assume passing condition |
||
6719 | Store (0, Local0) |
||
6720 | |||
6721 | // set memory contents to known values using DWORD field |
||
6722 | Store (0x5A5A5A5A, DWRD) |
||
6723 | |||
6724 | // Given the value programmed into DWRD, only the odd bits |
||
6725 | // of the lower nibble should be set. BIT1, BIT3 should be set. |
||
6726 | // BIT0 and BIT2 should be clear |
||
6727 | |||
6728 | If (BIT0) |
||
6729 | { |
||
6730 | Or (Local0, 0x01, Local0) |
||
6731 | } |
||
6732 | |||
6733 | If (LNot (BIT1)) |
||
6734 | { |
||
6735 | Or (Local0, 0x02, Local0) |
||
6736 | } |
||
6737 | |||
6738 | If (BIT2) |
||
6739 | { |
||
6740 | Or (Local0, 0x04, Local0) |
||
6741 | } |
||
6742 | |||
6743 | If (LNot (BIT3)) |
||
6744 | { |
||
6745 | Or (Local0, 0x08, Local0) |
||
6746 | } |
||
6747 | |||
6748 | // Now check the upper nibble. Only the "even" bits should |
||
6749 | // be set. BIT4, BIT6. BIT5 and BIT7 should be clear. |
||
6750 | If (LNot (BIT4)) |
||
6751 | { |
||
6752 | Or (Local0, 0x10, Local0) |
||
6753 | } |
||
6754 | |||
6755 | If (BIT5) |
||
6756 | { |
||
6757 | Or (Local0, 0x20, Local0) |
||
6758 | } |
||
6759 | |||
6760 | If (LNot (BIT6)) |
||
6761 | { |
||
6762 | Or (Local0, 0x40, Local0) |
||
6763 | } |
||
6764 | |||
6765 | If (BIT7) |
||
6766 | { |
||
6767 | Or (Local0, 0x80, Local0) |
||
6768 | } |
||
6769 | } // End Else DWRD zeroed out |
||
6770 | |||
6771 | Return (Local0) |
||
6772 | } // MBIT: Test single bit memory accesses |
||
6773 | |||
6774 | Method (TEST) |
||
6775 | { |
||
6776 | |||
6777 | Store ("++++++++ BitIndex Test", Debug) |
||
6778 | |||
6779 | // Zero out DWRD |
||
6780 | Store (0x00000000, DWRD) |
||
6781 | |||
6782 | // MBIT returns zero if successful |
||
6783 | // This may be causing problems -- Return (MBIT) |
||
6784 | Store (MBIT, Local0) |
||
6785 | |||
6786 | Return (Local0) |
||
6787 | } // TEST |
||
6788 | } // BITI |
||
6789 | } // _SB system bus |
||
6790 | |||
6791 | // |
||
6792 | // test IndexOp3.asl |
||
6793 | // |
||
6794 | // Additional IndexOp test cases to support ACPICMB (control method battery |
||
6795 | // test) on Compaq laptops. Test cases include storing a package into |
||
6796 | // an IndexOp target and validating that changing source and destination |
||
6797 | // package contents are independent of each other. |
||
6798 | // |
||
6799 | Scope (\_SB) // System Bus |
||
6800 | { // _SB system bus |
||
6801 | |||
6802 | Name (C174, 13) |
||
6803 | Name (C175, 8) |
||
6804 | |||
6805 | Device (C158) |
||
6806 | { // C158: AC Adapter device |
||
6807 | Name (_HID, "ACPI0003") // AC Adapter device |
||
6808 | Name (_PCL, Package (1) {\_SB}) |
||
6809 | |||
6810 | Method (_PSR) |
||
6811 | { |
||
6812 | Acquire (\_GL, 0xFFFF) |
||
6813 | Release (\_GL) |
||
6814 | And (Local0, 1, Local0) // Local0 &= 1 |
||
6815 | Return (Local0) |
||
6816 | } // _PSR |
||
6817 | } // C158: AC Adapter device |
||
6818 | |||
6819 | Name (C176, Package (4) {"Primary", "MultiBay", "DockRight", "DockLeft"}) |
||
6820 | |||
6821 | Name (C177, Package (4) {0x99F5, 0x99F5, 0x995F, 0x995F}) |
||
6822 | |||
6823 | Name (C178, Package (4) |
||
6824 | { |
||
6825 | Package (4) {0, 0, 0x966B, 0x4190}, |
||
6826 | Package (4) {0, 0, 0x966B, 0x4190}, |
||
6827 | Package (4) {0, 0, 0x966B, 0x4190}, |
||
6828 | Package (4) {0, 0, 0x966B, 0x4190} |
||
6829 | }) // C178 |
||
6830 | |||
6831 | Name (C179, Package (4) {0, 0, 0x966B, 0x4190}) |
||
6832 | |||
6833 | Name (C17A, Package (4) |
||
6834 | { |
||
6835 | Package (3) {0, 0, 0}, |
||
6836 | Package (3) {0, 0, 0}, |
||
6837 | Package (3) {0, 0, 0}, |
||
6838 | Package (3) {0, 0, 0} |
||
6839 | }) // C17A |
||
6840 | |||
6841 | Method (C17B, 1) |
||
6842 | { // C17B: _BIF implementation |
||
6843 | Name (C17C, Package (13) |
||
6844 | { // C17C: _BIF control method return package |
||
6845 | 0, // Power Unit (0 ==> mWh and mW) |
||
6846 | 0x99F5, // Design Capacity |
||
6847 | 0x99F5, // Last Full Charge Capacity |
||
6848 | 1, // Battery Technology (1 ==> rechargeable) |
||
6849 | 0x3840, // Design Voltage |
||
6850 | 0x1280, // Design Capacity of Warning |
||
6851 | 0x0AC7, // Design Capacity of Low |
||
6852 | 1, // Battery Capacity Granularity 1 (Low -- Warning) |
||
6853 | 1, // Battery Capacity Granularity 2 (Warning -- Full) |
||
6854 | "2891", // Model Number (ASCIIZ) |
||
6855 | "(-Unknown-)", // Serial Number (ASCIIZ) |
||
6856 | "LIon", // Battery Type (ASCIIZ) |
||
6857 | |||
6858 | }) // C17C: _BIF control method return package |
||
6859 | |||
6860 | And (Arg0, 7, Local0) // Local0 = Arg0 & 7 |
||
6861 | |||
6862 | ShiftRight (Local0, 1, Local4) // Local4 = Local0 >> 1 |
||
6863 | |||
6864 | Store (C179, Index (C178, Local4, )) // C178->Local4 = C179 |
||
6865 | |||
6866 | // verify source and destination packages can be altered independent |
||
6867 | // of each other (i.e., changing one's contents does NOT change other's |
||
6868 | // contents) |
||
6869 | Store (0x1234, Index (C179, 2, )) // C179[2] = 0x1234 |
||
6870 | Store (DerefOf (Index (C179, 2, )), Local2) // Local2 = C179[2] |
||
6871 | if (LNotEqual (Local2, 0x1234)) |
||
6872 | { Return (0x1234) } |
||
6873 | // Local2 = C178[0,2] |
||
6874 | Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 2, )), Local2) |
||
6875 | if (LNotEqual (Local2, 0x966B)) |
||
6876 | { Return (0x1234) } |
||
6877 | |||
6878 | // Restore data to allow iterative execution |
||
6879 | Store (0x966B, Index (C179, 2, )) // C179[2] = 0x966B |
||
6880 | |||
6881 | // C178[0,3] = 0x5678 |
||
6882 | Store (0x5678, Index (DerefOf (Index (C178, 0, )), 3, )) |
||
6883 | // Local2 = C178[0,3] |
||
6884 | Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 3, )), Local2) |
||
6885 | if (LNotEqual (Local2, 0x5678)) |
||
6886 | { Return (0x5678) } |
||
6887 | |||
6888 | Store (DerefOf (Index (C179, 3, )), Local2) // Local2 = C179[3] |
||
6889 | if (LNotEqual (Local2, 0x4190)) |
||
6890 | { Return (0x5678) } |
||
6891 | |||
6892 | // Restore data to allow iterative execution |
||
6893 | Store (0x4190, Index (DerefOf (Index (C178, 0, )), 3, )) // C179[2] = 0x4190 |
||
6894 | |||
6895 | Return (C17C) |
||
6896 | } // C17B: _BIF implementation |
||
6897 | |||
6898 | Device (C154) |
||
6899 | { // C154: Battery 0 |
||
6900 | Name (_HID, "*PNP0C0A") // Control Method Battey ID |
||
6901 | Name (_UID, 0) // first instance |
||
6902 | |||
6903 | Method (_BIF) |
||
6904 | { // _BIF |
||
6905 | Return (C17B (48)) |
||
6906 | } // _BIF |
||
6907 | } // C154: Battery 0 |
||
6908 | |||
6909 | Device (IDX3) |
||
6910 | { |
||
6911 | Method (LCLB) |
||
6912 | { // LCLB control method: test Index(Local#) where Local# is buffer |
||
6913 | // Local0 is index counter |
||
6914 | // Local1 is buffer |
||
6915 | // Local2 receives BUFR[Local0] via Deref(Index(Local1...)) |
||
6916 | // Local3 is Local1 or Local2 object type |
||
6917 | // Local4 is return error code |
||
6918 | |||
6919 | Name (BUFR, Buffer () {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) |
||
6920 | |||
6921 | // save PKG into Local1 |
||
6922 | Store (BUFR, Local1) |
||
6923 | |||
6924 | // save Local2 object type value into Local3 |
||
6925 | Store (ObjectType (Local1), Local3) |
||
6926 | |||
6927 | // validate Local1 is a Buffer |
||
6928 | If (LNotEqual (Local3, 3)) // Buffer type is 3 |
||
6929 | { Return (0x9F) } |
||
6930 | |||
6931 | |||
6932 | Store (0, Local0) |
||
6933 | While (LLess (Local0, 5)) |
||
6934 | { // While (Local0 < 5) |
||
6935 | // Local2 = Local1[Local0] |
||
6936 | Store (DerefOf (Index (Local1, Local0, )), Local2) |
||
6937 | |||
6938 | // save Local2 object type value into Local3 |
||
6939 | Store (ObjectType (Local2), Local3) |
||
6940 | |||
6941 | // validate Local2 is a Number |
||
6942 | If (LNotEqual (Local3, 1)) // Number type is 1 |
||
6943 | { Return (0x9E) } |
||
6944 | |||
6945 | // validate Local1[Local0] value == Local0 |
||
6946 | If (LNotEqual (Local0, Local2)) |
||
6947 | { // Local0 != Local2 == PKG[Local0] |
||
6948 | // Local4 = 0x90 + loop index (Local0) |
||
6949 | Add (0x90, Local0, Local4) |
||
6950 | |||
6951 | // return 0x90 + loop index |
||
6952 | Return (Local4) |
||
6953 | } |
||
6954 | |||
6955 | Increment (Local0) |
||
6956 | } // While (Local0 < 5) |
||
6957 | |||
6958 | Store ("DerefOf(Index(LocalBuffer,,)) PASS", Debug) |
||
6959 | |||
6960 | Return (0) // Pass |
||
6961 | } // LCLB control method: test Index(Local#) where Local# is buffer |
||
6962 | |||
6963 | Method (LCLP) |
||
6964 | { // LCLP control method: test Index(Local#) where Local# is package |
||
6965 | // Local0 is index counter |
||
6966 | // Local1 is package |
||
6967 | // Local2 receives PKG[Local0] via Deref(Index(Local1...)) |
||
6968 | // Local3 is Local1 or Local2 object type |
||
6969 | // Local4 is return error code |
||
6970 | |||
6971 | Name (PKG, Package () {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) |
||
6972 | |||
6973 | // save PKG into Local1 |
||
6974 | Store (PKG, Local1) |
||
6975 | |||
6976 | // save Local2 object type value into Local3 |
||
6977 | Store (ObjectType (Local1), Local3) |
||
6978 | |||
6979 | // validate Local1 is a Package |
||
6980 | If (LNotEqual (Local3, 4)) // Package type is 4 |
||
6981 | { Return (0x8F) } |
||
6982 | |||
6983 | |||
6984 | Store (0, Local0) |
||
6985 | While (LLess (Local0, 5)) |
||
6986 | { // While (Local0 < 5) |
||
6987 | // Local2 = Local1[Local0] |
||
6988 | Store (DerefOf (Index (Local1, Local0, )), Local2) |
||
6989 | |||
6990 | // save Local2 object type value into Local3 |
||
6991 | Store (ObjectType (Local2), Local3) |
||
6992 | |||
6993 | // validate Local2 is a Number |
||
6994 | If (LNotEqual (Local3, 1)) // Number type is 1 |
||
6995 | { Return (0x8E) } |
||
6996 | |||
6997 | // validate Local1[Local0] value == Local0 |
||
6998 | If (LNotEqual (Local0, Local2)) |
||
6999 | { // Local0 != Local2 == PKG[Local0] |
||
7000 | // Local4 = 0x80 + loop index (Local0) |
||
7001 | Add (0x80, Local0, Local4) |
||
7002 | |||
7003 | // return 0x80 + loop index |
||
7004 | Return (Local4) |
||
7005 | } |
||
7006 | |||
7007 | Increment (Local0) |
||
7008 | } // While (Local0 < 5) |
||
7009 | |||
7010 | Store ("DerefOf(Index(LocalPackage,,)) PASS", Debug) |
||
7011 | |||
7012 | Return (0) // Pass |
||
7013 | } // LCLP control method: test Index(Local#) where Local# is package |
||
7014 | |||
7015 | Method (TEST) |
||
7016 | { |
||
7017 | |||
7018 | Store ("++++++++ IndexOp3 Test", Debug) |
||
7019 | |||
7020 | // store _BIF package return value into Local0 |
||
7021 | Store (\_SB.C154._BIF, Local0) |
||
7022 | |||
7023 | // save Local0 object type value into Local1 |
||
7024 | Store (ObjectType (Local0), Local1) |
||
7025 | |||
7026 | // validate Local0 is a Package |
||
7027 | If (LNotEqual (Local1, 4)) // Package type is 4 |
||
7028 | { // failure: did not return a Package (type 4) |
||
7029 | // if Local0 is a Number, it contains an error code |
||
7030 | If (LEqual (Local1, 1)) // Number type is 1 |
||
7031 | { Return (Local0) } // return Local0 error code |
||
7032 | Else // Local0 is not a Number |
||
7033 | { Return (1) } // return default error code |
||
7034 | } // failure: did not return a Package (type 4) |
||
7035 | |||
7036 | // save LCLB control method return value into Local2 |
||
7037 | Store (LCLB, Local2) |
||
7038 | If (LNotEqual (Local2, 0)) |
||
7039 | { Return (Local2) } // return failure code |
||
7040 | |||
7041 | // save LCLP control method return value into Local2 |
||
7042 | Store (LCLP, Local2) |
||
7043 | If (LNotEqual (Local2, 0)) |
||
7044 | { Return (Local2) } // return failure code |
||
7045 | |||
7046 | Return (0) // Pass |
||
7047 | } // TEST |
||
7048 | } // IDX3: Test device name |
||
7049 | } // _SB system bus |
||
7050 | |||
7051 | // |
||
7052 | // MTL developed test to exercise Indexes into buffers |
||
7053 | // |
||
7054 | Device(IDX7) |
||
7055 | { |
||
7056 | |||
7057 | Name (PKG4, Package() { |
||
7058 | 0x2, |
||
7059 | "A short string", |
||
7060 | Buffer() {0xA, 0xB, 0xC, 0xD}, |
||
7061 | 0x1234, |
||
7062 | Package() {IDX7, 0x3} |
||
7063 | }) |
||
7064 | |||
7065 | // |
||
7066 | // Generic Test method |
||
7067 | // |
||
7068 | // This test returns 0xE (14) - ObjectType = Buffer Field |
||
7069 | Method(TST1) |
||
7070 | { |
||
7071 | Name (DEST, Buffer () // 62 characters plus NULL |
||
7072 | {"Destination buffer that is longer than the short source buffer"}) |
||
7073 | |||
7074 | // verify object type returned by Index(Buffer,Element,) |
||
7075 | Store (Index (DEST, 2, ), Local1) |
||
7076 | Store (ObjectType (Local1), Local2) |
||
7077 | If (LEqual(Local2, 14)) |
||
7078 | { |
||
7079 | Return(0) |
||
7080 | } |
||
7081 | Else |
||
7082 | { |
||
7083 | Return(0x1) |
||
7084 | } |
||
7085 | |||
7086 | } |
||
7087 | |||
7088 | Method(TST2) |
||
7089 | { |
||
7090 | Name (BUF0, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5}) |
||
7091 | Store(0x55, Index(BUF0, 2)) |
||
7092 | Store(DerefOf(Index(BUF0, 2)), Local0) |
||
7093 | If (LEqual(Local0, 0x55)) |
||
7094 | { |
||
7095 | Return(0) |
||
7096 | } |
||
7097 | Else |
||
7098 | { |
||
7099 | Return(0x2) |
||
7100 | } |
||
7101 | |||
7102 | |||
7103 | } |
||
7104 | |||
7105 | Method(TST3) |
||
7106 | { |
||
7107 | Name (BUF1, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5}) |
||
7108 | Store(Index(BUF1, 1), Local0) |
||
7109 | Store(DerefOf(Local0), Local1) |
||
7110 | If (LEqual(Local1, 0x2)) |
||
7111 | { |
||
7112 | Return(0) |
||
7113 | } |
||
7114 | Else |
||
7115 | { |
||
7116 | Return(0x3) |
||
7117 | } |
||
7118 | |||
7119 | } |
||
7120 | |||
7121 | Method(TST4) |
||
7122 | { |
||
7123 | // Index (PKG4, 0) is a Number |
||
7124 | Store (Index (PKG4, 0), Local0) |
||
7125 | Store (ObjectType(Local0), Local1) |
||
7126 | If (LEqual(Local1, 0x1)) |
||
7127 | { |
||
7128 | Return(0) |
||
7129 | } |
||
7130 | Else |
||
7131 | { |
||
7132 | Return(0x4) |
||
7133 | } |
||
7134 | |||
7135 | } |
||
7136 | |||
7137 | Method(TST5) |
||
7138 | { |
||
7139 | // Index (PKG4, 1) is a String |
||
7140 | Store (Index (PKG4, 1), Local0) |
||
7141 | Store (ObjectType(Local0), Local1) |
||
7142 | If (LEqual(Local1, 0x2)) |
||
7143 | { |
||
7144 | Return(0) |
||
7145 | } |
||
7146 | Else |
||
7147 | { |
||
7148 | Return(0x5) |
||
7149 | } |
||
7150 | |||
7151 | } |
||
7152 | |||
7153 | Method(TST6) |
||
7154 | { |
||
7155 | // Index (PKG4, 2) is a Buffer |
||
7156 | Store (Index (PKG4, 2), Local0) |
||
7157 | Store (ObjectType(Local0), Local1) |
||
7158 | If (LEqual(Local1, 0x3)) |
||
7159 | { |
||
7160 | Return(0) |
||
7161 | } |
||
7162 | Else |
||
7163 | { |
||
7164 | Return(0x6) |
||
7165 | } |
||
7166 | |||
7167 | } |
||
7168 | |||
7169 | Method(TST7) |
||
7170 | { |
||
7171 | // Index (PKG4, 3) is a Number |
||
7172 | Store (Index (PKG4, 3), Local0) |
||
7173 | Store (ObjectType(Local0), Local1) |
||
7174 | If (LEqual(Local1, 0x1)) |
||
7175 | { |
||
7176 | Return(0) |
||
7177 | } |
||
7178 | Else |
||
7179 | { |
||
7180 | Return(0x7) |
||
7181 | } |
||
7182 | |||
7183 | } |
||
7184 | |||
7185 | Method(TST8) |
||
7186 | { |
||
7187 | // Index (PKG4, 4) is a Package |
||
7188 | Store (Index (PKG4, 4), Local0) |
||
7189 | Store (ObjectType(Local0), Local1) |
||
7190 | If (LEqual(Local1, 0x4)) |
||
7191 | { |
||
7192 | Return(0) |
||
7193 | } |
||
7194 | Else |
||
7195 | { |
||
7196 | Return(0x8) |
||
7197 | } |
||
7198 | |||
7199 | } |
||
7200 | |||
7201 | Method(TST9) |
||
7202 | { |
||
7203 | // DerefOf (Index (PKG4, 0)) is a Number |
||
7204 | Store (DerefOf (Index (PKG4, 0)), Local0) |
||
7205 | If (LEqual(Local0, 0x2)) |
||
7206 | { |
||
7207 | Return(0) |
||
7208 | } |
||
7209 | Else |
||
7210 | { |
||
7211 | Return(0x9) |
||
7212 | } |
||
7213 | |||
7214 | } |
||
7215 | |||
7216 | Method(TSTA) |
||
7217 | { |
||
7218 | // DerefOf (Index (PKG4, 1)) is a String |
||
7219 | Store (DerefOf (Index (PKG4, 1)), Local0) |
||
7220 | Store (SizeOf(Local0), Local1) |
||
7221 | If (LEqual(Local1, 0xE)) |
||
7222 | { |
||
7223 | Return(0) |
||
7224 | } |
||
7225 | Else |
||
7226 | { |
||
7227 | Return(0xA) |
||
7228 | } |
||
7229 | |||
7230 | } |
||
7231 | |||
7232 | Method(TSTB) |
||
7233 | { |
||
7234 | // DerefOf (Index (PKG4, 2)) is a Buffer |
||
7235 | Store (DerefOf (Index (PKG4, 2)), Local0) |
||
7236 | Store (SizeOf(Local0), Local1) |
||
7237 | If (LEqual(Local1, 0x4)) |
||
7238 | { |
||
7239 | Return(0) |
||
7240 | } |
||
7241 | Else |
||
7242 | { |
||
7243 | Return(0xB) |
||
7244 | } |
||
7245 | |||
7246 | } |
||
7247 | |||
7248 | Method(TSTC) |
||
7249 | { |
||
7250 | // DerefOf (Index (PKG4, 3)) is a Number |
||
7251 | Store (DerefOf (Index (PKG4, 3)), Local0) |
||
7252 | If (LEqual(Local0, 0x1234)) |
||
7253 | { |
||
7254 | Return(0) |
||
7255 | } |
||
7256 | Else |
||
7257 | { |
||
7258 | Return(0xC) |
||
7259 | } |
||
7260 | |||
7261 | } |
||
7262 | |||
7263 | Method(TSTD) |
||
7264 | { |
||
7265 | // DerefOf (Index (PKG4, 4)) is a Package |
||
7266 | Store (DerefOf (Index (PKG4, 4)), Local0) |
||
7267 | Store (SizeOf(Local0), Local1) |
||
7268 | If (LEqual(Local1, 0x2)) |
||
7269 | { |
||
7270 | Return(0) |
||
7271 | } |
||
7272 | Else |
||
7273 | { |
||
7274 | Return(0xD) |
||
7275 | } |
||
7276 | |||
7277 | } |
||
7278 | |||
7279 | Method(TSTE) |
||
7280 | { |
||
7281 | // DerefOf (Index (PKG4, 2)) is a Buffer |
||
7282 | Store (DerefOf (Index (PKG4, 2)), Local0) |
||
7283 | // DerefOf (Index (Local0, 1)) is a Number |
||
7284 | Store (DerefOf (Index (Local0, 1)), Local1) |
||
7285 | If (LEqual(Local1, 0xB)) |
||
7286 | { |
||
7287 | Return(0) |
||
7288 | } |
||
7289 | Else |
||
7290 | { |
||
7291 | Return(0xE) |
||
7292 | } |
||
7293 | |||
7294 | } |
||
7295 | |||
7296 | Method (TSTF) |
||
7297 | { |
||
7298 | Name (SRCB, Buffer (12) {}) // 12 characters |
||
7299 | Store ("Short Buffer", SRCB) |
||
7300 | |||
7301 | Name (DEST, Buffer () // 62 characters plus NULL |
||
7302 | {"Destination buffer that is longer than the short source buffer"}) |
||
7303 | |||
7304 | // overwrite DEST contents, starting at buffer position 2 |
||
7305 | Store (SRCB, Index (DEST, 2)) |
||
7306 | |||
7307 | // |
||
7308 | // The DEST buffer element should be replaced with the last element of |
||
7309 | // the SRCB element (i.e. 's'->'r') |
||
7310 | Store (DerefOf (Index (DEST, 2)), Local0) |
||
7311 | |||
7312 | If (LNotEqual (Local0, 0x72)) // 'r' |
||
7313 | { |
||
7314 | // DEST element does not match the value from SRCB |
||
7315 | Return(Or(Local0, 0x1000)) |
||
7316 | } |
||
7317 | |||
7318 | Return(0) |
||
7319 | } |
||
7320 | |||
7321 | Method (TSTG) |
||
7322 | { |
||
7323 | |||
7324 | Name (SRCB, Buffer (12) {}) // 12 characters |
||
7325 | Store ("Short Buffer", SRCB) |
||
7326 | |||
7327 | Name (DEST, Buffer () // 62 characters plus NULL |
||
7328 | {"Destination buffer that is longer than the short source buffer"}) |
||
7329 | |||
7330 | // overwrite DEST contents, starting at buffer position 2 |
||
7331 | Store (SRCB, Index (DEST, 2)) |
||
7332 | |||
7333 | // |
||
7334 | // The next element of DEST should be unchanged |
||
7335 | // |
||
7336 | Store (DerefOf (Index (DEST, 3)), Local0) |
||
7337 | |||
7338 | If (LNotEqual (Local0, 0x74)) // 't' |
||
7339 | { |
||
7340 | // DEST has been changed |
||
7341 | Return(Or(Local0, 0x2000)) |
||
7342 | } |
||
7343 | |||
7344 | // |
||
7345 | // The next element of DEST should be unchanged |
||
7346 | // |
||
7347 | Store (DerefOf (Index (DEST, 4)), Local0) |
||
7348 | |||
7349 | If (LNotEqual (Local0, 0x69)) // 'i' |
||
7350 | { |
||
7351 | // DEST has been changed |
||
7352 | Return(Or(Local0, 0x2100)) |
||
7353 | } |
||
7354 | |||
7355 | // |
||
7356 | // The next element of DEST should be unchanged |
||
7357 | // |
||
7358 | Store (DerefOf (Index (DEST, 5)), Local0) |
||
7359 | |||
7360 | If (LNotEqual (Local0, 0x6E)) // 'n' |
||
7361 | { |
||
7362 | // DEST has been changed |
||
7363 | Return(Or(Local0, 0x2200)) |
||
7364 | } |
||
7365 | |||
7366 | // |
||
7367 | // The next element of DEST should be unchanged |
||
7368 | // |
||
7369 | Store (DerefOf (Index (DEST, 6)), Local0) |
||
7370 | |||
7371 | If (LNotEqual (Local0, 0x61)) // 'a' |
||
7372 | { |
||
7373 | // DEST has been changed |
||
7374 | Return(Or(Local0, 0x2300)) |
||
7375 | } |
||
7376 | |||
7377 | // |
||
7378 | // The next element of DEST should be unchanged |
||
7379 | // |
||
7380 | Store (DerefOf (Index (DEST, 7)), Local0) |
||
7381 | |||
7382 | If (LNotEqual (Local0, 0x74)) // 't' |
||
7383 | { |
||
7384 | // DEST has been changed |
||
7385 | Return(Or(Local0, 0x2400)) |
||
7386 | } |
||
7387 | |||
7388 | // |
||
7389 | // Verify DEST elements beyond end of SRCB buffer copy |
||
7390 | // have not been changed |
||
7391 | Store (DerefOf (Index (DEST, 14)), Local0) |
||
7392 | |||
7393 | If (LNotEqual (Local0, 0x66)) // 'f' |
||
7394 | { |
||
7395 | // DEST has been changed |
||
7396 | Return(Or(Local0, 0x2400)) |
||
7397 | } |
||
7398 | |||
7399 | Return(0) |
||
7400 | } |
||
7401 | |||
7402 | // |
||
7403 | // This test shows that MS ACPI.SYS stores only the lower 8-bits of a 32-bit |
||
7404 | // number into the index'ed buffer |
||
7405 | // |
||
7406 | Method (TSTH) |
||
7407 | { |
||
7408 | // Create a Destination Buffer |
||
7409 | Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"}) |
||
7410 | |||
7411 | // Store a number > UINT8 into an index of the buffer |
||
7412 | Store (0x12345678, Index(DBUF, 2)) |
||
7413 | |||
7414 | // Check the results |
||
7415 | Store (DerefOf (Index (DBUF, 2)), Local0) |
||
7416 | If (LNotEqual (Local0, 0x78)) // 0x78 |
||
7417 | { |
||
7418 | Return(Or(Local0, 0x3000)) |
||
7419 | } |
||
7420 | |||
7421 | Store (DerefOf (Index (DBUF, 3)), Local0) |
||
7422 | If (LNotEqual (Local0, 0x64)) // 'd' |
||
7423 | { |
||
7424 | Return(Or(Local0, 0x3100)) |
||
7425 | } |
||
7426 | |||
7427 | Store (DerefOf (Index (DBUF, 4)), Local0) |
||
7428 | If (LNotEqual (Local0, 0x65)) // 'e' |
||
7429 | { |
||
7430 | Return(Or(Local0, 0x3200)) |
||
7431 | } |
||
7432 | |||
7433 | Store (DerefOf (Index (DBUF, 5)), Local0) |
||
7434 | If (LNotEqual (Local0, 0x66)) // 'f' |
||
7435 | { |
||
7436 | Return(Or(Local0, 0x3300)) |
||
7437 | } |
||
7438 | |||
7439 | Return(0) |
||
7440 | } |
||
7441 | |||
7442 | Method (TSTI) |
||
7443 | { |
||
7444 | // Create a Destination Buffer |
||
7445 | Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"}) |
||
7446 | |||
7447 | // Store a String into an index of the buffer |
||
7448 | Store ("ABCDEFGH", Index(DBUF, 2)) |
||
7449 | |||
7450 | // Check the results |
||
7451 | Store (DerefOf (Index (DBUF, 2)), Local0) |
||
7452 | If (LNotEqual (Local0, 0x48)) // 'H' |
||
7453 | { |
||
7454 | Return(Or(Local0, 0x4000)) |
||
7455 | } |
||
7456 | |||
7457 | Store (DerefOf (Index (DBUF, 3)), Local0) |
||
7458 | If (LNotEqual (Local0, 0x64)) // 'd' |
||
7459 | { |
||
7460 | Return(Or(Local0, 0x4100)) |
||
7461 | } |
||
7462 | |||
7463 | Store (DerefOf (Index (DBUF, 4)), Local0) |
||
7464 | If (LNotEqual (Local0, 0x65)) // 'e' |
||
7465 | { |
||
7466 | Return(Or(Local0, 0x4200)) |
||
7467 | } |
||
7468 | |||
7469 | Store (DerefOf (Index (DBUF, 5)), Local0) |
||
7470 | If (LNotEqual (Local0, 0x66)) // 'f' |
||
7471 | { |
||
7472 | Return(Or(Local0, 0x4300)) |
||
7473 | } |
||
7474 | |||
7475 | Return(0) |
||
7476 | } |
||
7477 | |||
7478 | Method(TSTJ) |
||
7479 | { |
||
7480 | // Create a Destination Buffer |
||
7481 | Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"}) |
||
7482 | |||
7483 | // Store a number > UINT8 into an index of the buffer |
||
7484 | Store (0x1234, Index(DBUF, 2)) |
||
7485 | |||
7486 | // Check the results |
||
7487 | Store (DerefOf (Index (DBUF, 2)), Local0) |
||
7488 | If (LNotEqual (Local0, 0x34)) // 0x34 |
||
7489 | { |
||
7490 | Return(Or(Local0, 0x3000)) |
||
7491 | } |
||
7492 | |||
7493 | Store (DerefOf (Index (DBUF, 3)), Local0) |
||
7494 | If (LNotEqual (Local0, 0x64)) // 'd' |
||
7495 | { |
||
7496 | Return(Or(Local0, 0x3100)) |
||
7497 | } |
||
7498 | |||
7499 | Store (DerefOf (Index (DBUF, 4)), Local0) |
||
7500 | If (LNotEqual (Local0, 0x65)) // 'e' |
||
7501 | { |
||
7502 | Return(Or(Local0, 0x3200)) |
||
7503 | } |
||
7504 | |||
7505 | Store (DerefOf (Index (DBUF, 5)), Local0) |
||
7506 | If (LNotEqual (Local0, 0x66)) // 'f' |
||
7507 | { |
||
7508 | Return(Or(Local0, 0x3300)) |
||
7509 | } |
||
7510 | |||
7511 | Return(0) |
||
7512 | } |
||
7513 | |||
7514 | Method(TSTK) |
||
7515 | { |
||
7516 | // Create a Destination Buffer |
||
7517 | Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"}) |
||
7518 | |||
7519 | // Store a number > UINT8 into an index of the buffer |
||
7520 | Store (0x123456, Index(DBUF, 2)) |
||
7521 | |||
7522 | // Check the results |
||
7523 | Store (DerefOf (Index (DBUF, 2)), Local0) |
||
7524 | If (LNotEqual (Local0, 0x56)) // 0x56 |
||
7525 | { |
||
7526 | Return(Or(Local0, 0x3000)) |
||
7527 | } |
||
7528 | |||
7529 | Store (DerefOf (Index (DBUF, 3)), Local0) |
||
7530 | If (LNotEqual (Local0, 0x64)) // 'd' |
||
7531 | { |
||
7532 | Return(Or(Local0, 0x3100)) |
||
7533 | } |
||
7534 | |||
7535 | Store (DerefOf (Index (DBUF, 4)), Local0) |
||
7536 | If (LNotEqual (Local0, 0x65)) // 'e' |
||
7537 | { |
||
7538 | Return(Or(Local0, 0x3200)) |
||
7539 | } |
||
7540 | |||
7541 | Store (DerefOf (Index (DBUF, 5)), Local0) |
||
7542 | If (LNotEqual (Local0, 0x66)) // 'f' |
||
7543 | { |
||
7544 | Return(Or(Local0, 0x3300)) |
||
7545 | } |
||
7546 | |||
7547 | Return(0) |
||
7548 | } |
||
7549 | |||
7550 | Method(TSTL) |
||
7551 | { |
||
7552 | // Create a Destination Buffer |
||
7553 | Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"}) |
||
7554 | |||
7555 | // Store a number > UINT8 into an index of the buffer |
||
7556 | Store (0x12, Index(DBUF, 2)) |
||
7557 | |||
7558 | // Check the results |
||
7559 | Store (DerefOf (Index (DBUF, 2)), Local0) |
||
7560 | If (LNotEqual (Local0, 0x12)) // 0x12 |
||
7561 | { |
||
7562 | Return(Or(Local0, 0x3000)) |
||
7563 | } |
||
7564 | |||
7565 | Store (DerefOf (Index (DBUF, 3)), Local0) |
||
7566 | If (LNotEqual (Local0, 0x64)) // 'd' |
||
7567 | { |
||
7568 | Return(Or(Local0, 0x3100)) |
||
7569 | } |
||
7570 | |||
7571 | Store (DerefOf (Index (DBUF, 4)), Local0) |
||
7572 | If (LNotEqual (Local0, 0x65)) // 'e' |
||
7573 | { |
||
7574 | Return(Or(Local0, 0x3200)) |
||
7575 | } |
||
7576 | |||
7577 | Store (DerefOf (Index (DBUF, 5)), Local0) |
||
7578 | If (LNotEqual (Local0, 0x66)) // 'f' |
||
7579 | { |
||
7580 | Return(Or(Local0, 0x3300)) |
||
7581 | } |
||
7582 | |||
7583 | Return(0) |
||
7584 | } |
||
7585 | |||
7586 | Method(TEST) |
||
7587 | { |
||
7588 | Store ("++++++++ IndexOp7 Test", Debug) |
||
7589 | |||
7590 | Store(TST1(), Local0) |
||
7591 | if (LGreater (Local0, 0)) |
||
7592 | { |
||
7593 | Return(Local0) |
||
7594 | } |
||
7595 | |||
7596 | Store(TST2(), Local0) |
||
7597 | if (LGreater (Local0, 0)) |
||
7598 | { |
||
7599 | Return(Local0) |
||
7600 | } |
||
7601 | |||
7602 | Store(TST3(), Local0) |
||
7603 | if (LGreater (Local0, 0)) |
||
7604 | { |
||
7605 | Return(Local0) |
||
7606 | } |
||
7607 | |||
7608 | Store(TST4(), Local0) |
||
7609 | if (LGreater (Local0, 0)) |
||
7610 | { |
||
7611 | Return(Local0) |
||
7612 | } |
||
7613 | |||
7614 | Store(TST5(), Local0) |
||
7615 | if (LGreater (Local0, 0)) |
||
7616 | { |
||
7617 | Return(Local0) |
||
7618 | } |
||
7619 | |||
7620 | Store(TST6(), Local0) |
||
7621 | if (LGreater (Local0, 0)) |
||
7622 | { |
||
7623 | Return(Local0) |
||
7624 | } |
||
7625 | |||
7626 | Store(TST7(), Local0) |
||
7627 | if (LGreater (Local0, 0)) |
||
7628 | { |
||
7629 | Return(Local0) |
||
7630 | } |
||
7631 | |||
7632 | Store(TST8(), Local0) |
||
7633 | if (LGreater (Local0, 0)) |
||
7634 | { |
||
7635 | Return(Local0) |
||
7636 | } |
||
7637 | |||
7638 | Store(TST9(), Local0) |
||
7639 | if (LGreater (Local0, 0)) |
||
7640 | { |
||
7641 | Return(Local0) |
||
7642 | } |
||
7643 | |||
7644 | Store(TSTA(), Local0) |
||
7645 | if (LGreater (Local0, 0)) |
||
7646 | { |
||
7647 | Return(Local0) |
||
7648 | } |
||
7649 | |||
7650 | Store(TSTB(), Local0) |
||
7651 | if (LGreater (Local0, 0)) |
||
7652 | { |
||
7653 | Return(Local0) |
||
7654 | } |
||
7655 | |||
7656 | Store(TSTC(), Local0) |
||
7657 | if (LGreater (Local0, 0)) |
||
7658 | { |
||
7659 | Return(Local0) |
||
7660 | } |
||
7661 | |||
7662 | Store(TSTD(), Local0) |
||
7663 | if (LGreater (Local0, 0)) |
||
7664 | { |
||
7665 | Return(Local0) |
||
7666 | } |
||
7667 | |||
7668 | Store(TSTE(), Local0) |
||
7669 | if (LGreater (Local0, 0)) |
||
7670 | { |
||
7671 | Return(Local0) |
||
7672 | } |
||
7673 | |||
7674 | /* No longer ACPI compliant */ |
||
7675 | /* |
||
7676 | Store(TSTF(), Local0) |
||
7677 | if (LGreater (Local0, 0)) |
||
7678 | { |
||
7679 | Return(Local0) |
||
7680 | } |
||
7681 | */ |
||
7682 | |||
7683 | Store(TSTG(), Local0) |
||
7684 | if (LGreater (Local0, 0)) |
||
7685 | { |
||
7686 | Return(Local0) |
||
7687 | } |
||
7688 | |||
7689 | Store(TSTH(), Local0) |
||
7690 | if (LGreater (Local0, 0)) |
||
7691 | { |
||
7692 | Return(Local0) |
||
7693 | } |
||
7694 | |||
7695 | /* No longer ACPI compliant */ |
||
7696 | /* |
||
7697 | Store(TSTI(), Local0) |
||
7698 | if (LGreater (Local0, 0)) |
||
7699 | { |
||
7700 | Return(Local0) |
||
7701 | } |
||
7702 | */ |
||
7703 | Store(TSTJ(), Local0) |
||
7704 | if (LGreater (Local0, 0)) |
||
7705 | { |
||
7706 | Return(Local0) |
||
7707 | } |
||
7708 | |||
7709 | Store(TSTK(), Local0) |
||
7710 | if (LGreater (Local0, 0)) |
||
7711 | { |
||
7712 | Return(Local0) |
||
7713 | } |
||
7714 | |||
7715 | Store(TSTL(), Local0) |
||
7716 | if (LGreater (Local0, 0)) |
||
7717 | { |
||
7718 | Return(Local0) |
||
7719 | } |
||
7720 | |||
7721 | Return(Local0) |
||
7722 | |||
7723 | } |
||
7724 | |||
7725 | } // Device(IDX7) |
||
7726 | |||
7727 | // |
||
7728 | // test MatchOp.asl |
||
7729 | // |
||
7730 | // MatchOp test cases that utilize nested DerefOf(Index(...)) to validate |
||
7731 | // MatchOp, DerefOfOp, and IndexOp of nested packages. |
||
7732 | // |
||
7733 | Device (MTCH) |
||
7734 | { |
||
7735 | |||
7736 | Method (TEST) |
||
7737 | { |
||
7738 | Store ("++++++++ MatchOp Test", Debug) |
||
7739 | |||
7740 | Name (TIM0, Package () |
||
7741 | { |
||
7742 | Package () {0x78, 0xB4, 0xF0, 0x0384}, |
||
7743 | Package () {0x23, 0x21, 0x10, 0}, |
||
7744 | Package () {0x0B, 9, 4, 0}, |
||
7745 | Package () {0x70, 0x49, 0x36, 0x27, 0x19}, |
||
7746 | Package () {0, 1, 2, 1, 2}, |
||
7747 | Package () {0, 0, 0, 1, 1}, |
||
7748 | Package () {4, 3, 2, 0}, |
||
7749 | Package () {2, 1, 0, 0} |
||
7750 | }) // TIM0 |
||
7751 | |||
7752 | Name (TMD0, Buffer (20) {0xFF, 0xFF, 0xFF, 0xFF }) |
||
7753 | CreateDWordField (TMD0, 0, PIO0) // 0xFFFFFFFF |
||
7754 | CreateDWordField (TMD0, 4, DMA0) |
||
7755 | CreateDWordField (TMD0, 8, PIO1) |
||
7756 | CreateDWordField (TMD0, 12, DMA1) |
||
7757 | CreateDWordField (TMD0, 16, CHNF) |
||
7758 | |||
7759 | |||
7760 | // validate PIO0 value |
||
7761 | Store (PIO0, Local3) |
||
7762 | |||
7763 | // save Local3 object type value into Local2 |
||
7764 | Store (ObjectType (Local3), Local2) |
||
7765 | |||
7766 | // validate Local3 is a Number |
||
7767 | If (LNotEqual (Local2, 1)) // Number type is 1 |
||
7768 | { Return (2) } // failure |
||
7769 | |||
7770 | // validate Local3 Number value |
||
7771 | If (LNotEqual (Local3, 0xFFFFFFFF)) // Number value 0xFFFFFFFF |
||
7772 | { Return (3) } // failure |
||
7773 | |||
7774 | Store ("DWordField PASS", Debug) |
||
7775 | |||
7776 | |||
7777 | Store (0, Local5) |
||
7778 | Store (Match (DerefOf (Index (TIM0, 1, )), MLE, Local5, MTR, 0, 0), Local6) |
||
7779 | |||
7780 | // save Local6 object type value into Local2 |
||
7781 | Store (ObjectType (Local6), Local2) |
||
7782 | |||
7783 | // validate Local6 is a Number |
||
7784 | If (LNotEqual (Local2, 1)) // Number type is 1 |
||
7785 | { Return (4) } // failure |
||
7786 | |||
7787 | Store ("Match(DerefOf(Index(TIM0,1)),... PASS", Debug) |
||
7788 | |||
7789 | |||
7790 | // validate following produces a nested package to validate |
||
7791 | // that MatchOp did not corrupt SearchPackage (TIM0) |
||
7792 | Store (DerefOf (Index (TIM0, 1, )), Local4) |
||
7793 | |||
7794 | // save Local4 object type value into Local2 |
||
7795 | Store (ObjectType (Local4), Local2) |
||
7796 | |||
7797 | // validate Local4 is a Package |
||
7798 | If (LNotEqual (Local2, 4)) // Package type is 4 |
||
7799 | { Return (5) } // failure |
||
7800 | |||
7801 | Store ("DerefOf(Index(TIM0,1)),... PASS", Debug) |
||
7802 | |||
7803 | |||
7804 | And (Match (DerefOf (Index (TIM0, 0, )), MGE, PIO0, MTR, 0, 0), 3, Local0) |
||
7805 | |||
7806 | // save Local0 object type value into Local2 |
||
7807 | Store (ObjectType (Local0), Local2) |
||
7808 | |||
7809 | // validate Local0 is a Number |
||
7810 | If (LNotEqual (Local2, 1)) // Number type is 1 |
||
7811 | { Return (6) } // failure |
||
7812 | |||
7813 | // validate Local0 Number value |
||
7814 | If (LNotEqual (Local0, 3)) // Number value 3 |
||
7815 | { Return (7) } // failure |
||
7816 | |||
7817 | Store ("And(Match(DerefOf(Index(TIM0,0)),... PASS", Debug) |
||
7818 | |||
7819 | |||
7820 | // again, validate following produces a nested package |
||
7821 | Store (DerefOf (Index (TIM0, 1, )), Local4) |
||
7822 | |||
7823 | // save Local4 object type value into Local2 |
||
7824 | Store (ObjectType (Local4), Local2) |
||
7825 | |||
7826 | // validate Local4 is a Package |
||
7827 | If (LNotEqual (Local2, 4)) // Package type is 4 |
||
7828 | { Return (8) } // failure |
||
7829 | |||
7830 | Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug) |
||
7831 | |||
7832 | |||
7833 | // again, validate following produces a nested package |
||
7834 | Store (DerefOf (Index (TIM0, 1, )), Local4) |
||
7835 | |||
7836 | // save Local4 object type value into Local2 |
||
7837 | Store (ObjectType (Local4), Local2) |
||
7838 | |||
7839 | // validate Local4 is a Package |
||
7840 | If (LNotEqual (Local2, 4)) // Package type is 4 |
||
7841 | { Return (9) } // failure |
||
7842 | |||
7843 | Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug) |
||
7844 | |||
7845 | |||
7846 | // test nested DerefOf(Index) operators |
||
7847 | Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1) |
||
7848 | |||
7849 | // save Local1 object type value into Local2 |
||
7850 | Store (ObjectType (Local1), Local2) |
||
7851 | |||
7852 | // validate Local1 is a Number |
||
7853 | If (LNotEqual (Local2, 1)) // Number type is 1 |
||
7854 | { Return (10) } // failure |
||
7855 | |||
7856 | // zero indicates pass, non-zero is an error code |
||
7857 | If (LNotEqual (Local1, 0)) |
||
7858 | { Return (11) } // failure |
||
7859 | |||
7860 | Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS", Debug) |
||
7861 | |||
7862 | |||
7863 | // again, validate following produces a nested package |
||
7864 | Store (DerefOf (Index (TIM0, 1, )), Local4) |
||
7865 | |||
7866 | // save Local4 object type value into Local2 |
||
7867 | Store (ObjectType (Local4), Local2) |
||
7868 | |||
7869 | // validate Local4 is a Package |
||
7870 | If (LNotEqual (Local2, 4)) // Package type is 4 |
||
7871 | { Return (12) } // failure |
||
7872 | |||
7873 | Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug) |
||
7874 | |||
7875 | |||
7876 | // retest nested DerefOf(Index) operators |
||
7877 | Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1) |
||
7878 | |||
7879 | // save Local1 object type value into Local2 |
||
7880 | Store (ObjectType (Local1), Local2) |
||
7881 | |||
7882 | // validate Local1 is a Number |
||
7883 | If (LNotEqual (Local2, 1)) // Number type is 1 |
||
7884 | { Return (13) } // failure |
||
7885 | |||
7886 | // zero indicates pass, non-zero is an error code |
||
7887 | If (LNotEqual (Local1, 0)) |
||
7888 | { Return (14) } // failure |
||
7889 | |||
7890 | Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again", Debug) |
||
7891 | |||
7892 | |||
7893 | // again, validate following produces a nested package |
||
7894 | Store (DerefOf (Index (TIM0, 1, )), Local4) |
||
7895 | |||
7896 | // save Local4 object type value into Local2 |
||
7897 | Store (ObjectType (Local4), Local2) |
||
7898 | |||
7899 | // validate Local4 is a Package |
||
7900 | If (LNotEqual (Local2, 4)) // Package type is 4 |
||
7901 | { Return (15) } // failure |
||
7902 | |||
7903 | Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug) |
||
7904 | |||
7905 | |||
7906 | Return (0) // pass |
||
7907 | } // TEST |
||
7908 | } // MTCH |
||
7909 | |||
7910 | // |
||
7911 | // test WhileBrk.asl |
||
7912 | // |
||
7913 | // This code tests the Break term and While term |
||
7914 | // |
||
7915 | // Syntax of Break term |
||
7916 | // BreakTerm := Break |
||
7917 | // The break operation causes the current package execution to complete. |
||
7918 | // |
||
7919 | // Syntax of While Term |
||
7920 | // WhileTerm := While( |
||
7921 | // Predicate //TermArg=>Integer |
||
7922 | // ) {TermList} |
||
7923 | // Predicate is evaluated as an integer. |
||
7924 | // If the integer is non-zero, the list of terms in TermList is executed. |
||
7925 | // The operation repeats until the Predicate evaluates to zero. |
||
7926 | // |
||
7927 | // MTL NOTE: This test has been modified to reflect ACPI 2.0 break |
||
7928 | // NOTE: This test, when run under the MS ACPI.SYS grinds the system to |
||
7929 | // a halt. |
||
7930 | // |
||
7931 | Device (WHLB) |
||
7932 | { |
||
7933 | Name (CNT0, 0) |
||
7934 | Name (CNT1, 0) |
||
7935 | |||
7936 | Method (TEST) |
||
7937 | { |
||
7938 | // Check Break statement nested in If nested in While nested in |
||
7939 | // While only exits inner-most While loop |
||
7940 | Store (0, CNT0) |
||
7941 | |||
7942 | While (LLess (CNT0, 4)) |
||
7943 | { |
||
7944 | Store (0, CNT1) |
||
7945 | While (LLess (CNT1, 10)) |
||
7946 | { |
||
7947 | if (LEqual (CNT1, 1)) |
||
7948 | { |
||
7949 | Break // exit encompassing loop |
||
7950 | } |
||
7951 | |||
7952 | Increment (CNT1) |
||
7953 | } |
||
7954 | |||
7955 | If (LNotEqual (CNT1, 1)) |
||
7956 | { |
||
7957 | // failure |
||
7958 | Return (7) |
||
7959 | } |
||
7960 | |||
7961 | Increment (CNT0) |
||
7962 | } |
||
7963 | |||
7964 | // Verify Break only exited inner-most While loop |
||
7965 | |||
7966 | If (LNotEqual (CNT0, 4)) |
||
7967 | { |
||
7968 | // failure |
||
7969 | Return (8) |
||
7970 | } |
||
7971 | |||
7972 | Store ("While/While/If/Break PASS", Debug) |
||
7973 | |||
7974 | Store ("++++++++ WhileBrk Test", Debug) |
||
7975 | |||
7976 | // Check Break statement nested in While |
||
7977 | Store (0, CNT0) |
||
7978 | |||
7979 | While (LLess (CNT0, 10)) |
||
7980 | { |
||
7981 | Break // exit encompassing package |
||
7982 | Increment (CNT0) |
||
7983 | } |
||
7984 | |||
7985 | If (LNotEqual (CNT0, 0)) // instruction after Break executed |
||
7986 | { |
||
7987 | Return (4) |
||
7988 | } |
||
7989 | |||
7990 | |||
7991 | Store (0, CNT0) |
||
7992 | |||
7993 | // Test While Term |
||
7994 | While (LLess (CNT0, 10)) |
||
7995 | { |
||
7996 | Increment (CNT0) |
||
7997 | } |
||
7998 | |||
7999 | // Check if the while loop was executed until the condition is satisfied. |
||
8000 | If (LNotEqual (CNT0, 10)) |
||
8001 | { |
||
8002 | Return (1) |
||
8003 | } |
||
8004 | |||
8005 | |||
8006 | // While loop in a reverse order |
||
8007 | While (LGreater (CNT0, 0)) |
||
8008 | { |
||
8009 | Decrement (CNT0) |
||
8010 | } |
||
8011 | |||
8012 | // Check if the while loop was executed until the condition is satisfied. |
||
8013 | If (LNotEqual (CNT0, 0)) |
||
8014 | { |
||
8015 | Return (2) |
||
8016 | } |
||
8017 | |||
8018 | |||
8019 | Store ("While/Break PASS", Debug) |
||
8020 | |||
8021 | |||
8022 | // Check Break statement nested in If nested in While |
||
8023 | Store (0, CNT0) |
||
8024 | |||
8025 | While (LLess (CNT0, 10)) |
||
8026 | { |
||
8027 | if (LEqual (CNT0, 5)) |
||
8028 | { |
||
8029 | Break // exit encompassing Package (If) |
||
8030 | |||
8031 | // if we execute the next instruction, |
||
8032 | // Break did not exit the loop |
||
8033 | Store (20, CNT0) // exit While loop with value larger |
||
8034 | // than above |
||
8035 | } |
||
8036 | |||
8037 | Increment (CNT0) // check if Break exited both If and While |
||
8038 | } // While |
||
8039 | |||
8040 | If (LGreater (CNT0, 19)) |
||
8041 | { // instruction after Break inside IfOp executed |
||
8042 | Return (5) |
||
8043 | } |
||
8044 | |||
8045 | // |
||
8046 | // Break will exit out of the while loop, therefore |
||
8047 | // the CNT0 counter should still Increment until 5 |
||
8048 | // |
||
8049 | If (LNotEqual (CNT0, 5)) |
||
8050 | { // instruction after Break inside WhileOp executed |
||
8051 | Return (6) |
||
8052 | } |
||
8053 | Store ("While/If/Break PASS", Debug) |
||
8054 | |||
8055 | |||
8056 | // All the conditions passed |
||
8057 | Return (0) |
||
8058 | } // TEST |
||
8059 | } // WHLB |
||
8060 | |||
8061 | |||
8062 | // |
||
8063 | // test IndexOp2.asl |
||
8064 | // |
||
8065 | // Additional IndexOp test cases to support ACPICMB (control method battery |
||
8066 | // test) on Toshiba Portege 7020CT. Test cases include appropriate bit |
||
8067 | // shifting of Field elements and reading Field elements greater than 64 bits. |
||
8068 | // |
||
8069 | // MTL NOTE: This test has been modified slightly from the original test |
||
8070 | // to take into account ACPI specification limitations. |
||
8071 | // |
||
8072 | Scope (\_SB) // System Bus |
||
8073 | { // _SB system bus |
||
8074 | |||
8075 | Device (MEM) |
||
8076 | { // MEM |
||
8077 | Name (_HID, 0x010CD041) |
||
8078 | Name (_STA, 0x0F) |
||
8079 | |||
8080 | OperationRegion (SMEM, SystemMemory, 0x800000, 0x100) |
||
8081 | Field (SMEM, AnyAcc, NoLock, Preserve) |
||
8082 | { // Field: SMEM overlay using 32-bit field elements |
||
8083 | SMD0, 32, // 32-bits |
||
8084 | SMD1, 32, // 32-bits |
||
8085 | SMD2, 32, // 32-bits |
||
8086 | SMD3, 32 // 32-bits |
||
8087 | } // Field: SMEM overlay using 32-bit field elements |
||
8088 | Field (SMEM, AnyAcc, NoLock, Preserve) |
||
8089 | { // Field: SMEM overlay using greater than 32-bit field elements |
||
8090 | SME0, 69, // larger than an integer (32 or 64) |
||
8091 | SME1, 97 // larger than an integer |
||
8092 | } // Field: SMEM overlay using greater than 32-bit field elements |
||
8093 | |||
8094 | OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000) |
||
8095 | Field (SRAM, AnyAcc, NoLock, Preserve) |
||
8096 | { // Field: SRAM overlay |
||
8097 | , 0x34000, // skip |
||
8098 | IEAX, 0x20, |
||
8099 | IEBX, 0x20, |
||
8100 | IECX, 0x20, |
||
8101 | IEDX, 0x20, |
||
8102 | IESI, 0x20, |
||
8103 | IEDI, 0x20, |
||
8104 | IEBP, 0x20, |
||
8105 | , 0x20, |
||
8106 | OEAX, 0x20, |
||
8107 | OEBX, 0x20, |
||
8108 | OECX, 0x20, |
||
8109 | OEDX, 0x20, |
||
8110 | OESI, 0x20, |
||
8111 | OEDI, 0x20, |
||
8112 | OEBP, 0x20, |
||
8113 | , 0x618, // skip |
||
8114 | ACST, 1, |
||
8115 | BES1, 1, |
||
8116 | BES2, 1, |
||
8117 | , 5, // skip |
||
8118 | BMN1, 0x68, |
||
8119 | BSN1, 0x58, |
||
8120 | BTP1, 0x48, |
||
8121 | BPU1, 0x20, |
||
8122 | BDC1, 0x20, |
||
8123 | BLF1, 0x20, |
||
8124 | BTC1, 0x20, |
||
8125 | BDV1, 0x20, |
||
8126 | BST1, 0x20, |
||
8127 | BPR1, 0x20, |
||
8128 | BRC1, 0x20, |
||
8129 | BPV1, 0x20, |
||
8130 | , 0x20, |
||
8131 | BCW1, 0x20, |
||
8132 | BCL1, 0x20, |
||
8133 | BG11, 0x20, |
||
8134 | BG21, 0x20, |
||
8135 | BOI1, 0x20, |
||
8136 | , 0x530, // skip |
||
8137 | BMN2, 0x68, |
||
8138 | BSN2, 0x58, |
||
8139 | BTP2, 0x48, |
||
8140 | BPU2, 0x20, |
||
8141 | BDC2, 0x20, |
||
8142 | BLF2, 0x20, |
||
8143 | BTC2, 0x20, |
||
8144 | BDV2, 0x20, |
||
8145 | BST2, 0x20, |
||
8146 | BPR2, 0x20, |
||
8147 | BRC2, 0x20, |
||
8148 | BPV2, 0x20, |
||
8149 | , 0x20, |
||
8150 | BCW2, 0x20, |
||
8151 | BCL2, 0x20, |
||
8152 | BG12, 0x20, |
||
8153 | BG22, 0x20, |
||
8154 | BOI2, 0x20, |
||
8155 | , 0x518, // skip |
||
8156 | AC01, 0x10, |
||
8157 | AC11, 0x10, |
||
8158 | PSV1, 0x10, |
||
8159 | CRT1, 0x10, |
||
8160 | TMP1, 0x10, |
||
8161 | AST1, 0x10, |
||
8162 | AC21, 0x10, |
||
8163 | AC31, 0x10, |
||
8164 | AC02, 0x10, |
||
8165 | AC12, 0x10, |
||
8166 | PSV2, 0x10, |
||
8167 | CRT2, 0x10, |
||
8168 | TMP2, 0x10, |
||
8169 | AST2, 0x10, |
||
8170 | AC22, 0x10, |
||
8171 | AC32, 0x10, |
||
8172 | AC03, 0x10, |
||
8173 | AC13, 0x10, |
||
8174 | PSV3, 0x10, |
||
8175 | CRT3, 0x10, |
||
8176 | TMP3, 0x10, |
||
8177 | AST3, 0x10, |
||
8178 | AC23, 0x10, |
||
8179 | AC33, 0x10, |
||
8180 | , 0x80, // skip |
||
8181 | TMPF, 0x10, |
||
8182 | , 0x570, // skip |
||
8183 | FANH, 1, |
||
8184 | FANL, 7, |
||
8185 | TF11, 1, |
||
8186 | TF21, 1, |
||
8187 | TF31, 1, |
||
8188 | , 1, |
||
8189 | TF10, 1, |
||
8190 | TF20, 1, |
||
8191 | TF30, 1, |
||
8192 | , 1, |
||
8193 | TP11, 1, |
||
8194 | TP21, 1, |
||
8195 | TP31, 1, |
||
8196 | , 0x6D, // 109 |
||
8197 | GP50, 1, |
||
8198 | GP51, 1, |
||
8199 | GP52, 1, |
||
8200 | GP53, 1, |
||
8201 | , 4, |
||
8202 | GP60, 1, |
||
8203 | GP61, 1, |
||
8204 | GP62, 1, |
||
8205 | GP63, 1, |
||
8206 | GP64, 1, |
||
8207 | GP65, 1, |
||
8208 | GP66, 1, |
||
8209 | , 1, |
||
8210 | GP70, 1, |
||
8211 | GP71, 1, |
||
8212 | GP72, 1, |
||
8213 | GP73, 1, |
||
8214 | GP74, 1, |
||
8215 | GP75, 1, |
||
8216 | GP76, 1, |
||
8217 | , 1, |
||
8218 | WED0, 1, |
||
8219 | WED1, 1, |
||
8220 | WED2, 1, |
||
8221 | WED3, 1, |
||
8222 | WED4, 1, |
||
8223 | , 3, |
||
8224 | SBL0, 1, |
||
8225 | SBL1, 1, |
||
8226 | SBL2, 1, |
||
8227 | SBL3, 1, |
||
8228 | , 4, |
||
8229 | LIDS, 1, |
||
8230 | VALF, 1, |
||
8231 | , 2, |
||
8232 | DCKI, 1, |
||
8233 | DCKF, 1, |
||
8234 | BT1F, 1, |
||
8235 | BT2F, 1, |
||
8236 | , 0x7D0, // skip |
||
8237 | HKCD, 8, |
||
8238 | , 8, |
||
8239 | DLID, 0x20, |
||
8240 | DSRN, 0x20, |
||
8241 | , 0x20, |
||
8242 | BDID, 0x20, |
||
8243 | DSPW, 1, |
||
8244 | VGAF, 1, |
||
8245 | VWE0, 1, |
||
8246 | VWE1, 1, |
||
8247 | PPSC, 1, |
||
8248 | SPSC, 1, |
||
8249 | EWLD, 1, |
||
8250 | EWPS, 1, |
||
8251 | , 0x1768, // skip |
||
8252 | PRES, 0x8000 |
||
8253 | } // Field: SRAM overlay |
||
8254 | } // MEM |
||
8255 | |||
8256 | Device (BAT1) |
||
8257 | { // BAT1 |
||
8258 | Name (_HID, EISAID ("PNP0C0A")) // Control Method Battey ID |
||
8259 | Name (_UID, 1) |
||
8260 | Name (_PCL, Package (1) {\_SB}) |
||
8261 | |||
8262 | Method (_STA) |
||
8263 | { // _STA |
||
8264 | If (\_SB.MEM.BES1) |
||
8265 | { Return (0x1F) } // battery present |
||
8266 | Else |
||
8267 | { Return (0x0F) } // battery not present |
||
8268 | } // _STA |
||
8269 | |||
8270 | Method (_BIF) |
||
8271 | { // _BIF |
||
8272 | Name (BUFR, Package (13) {}) |
||
8273 | |||
8274 | Store (\_SB.MEM.BPU1, Index (BUFR, 0)) |
||
8275 | Store (\_SB.MEM.BDC1, Index (BUFR, 1)) |
||
8276 | Store (\_SB.MEM.BLF1, Index (BUFR, 2)) |
||
8277 | Store (\_SB.MEM.BTC1, Index (BUFR, 3)) |
||
8278 | Store (\_SB.MEM.BDV1, Index (BUFR, 4)) |
||
8279 | Store (\_SB.MEM.BCW1, Index (BUFR, 5)) |
||
8280 | Store (\_SB.MEM.BCL1, Index (BUFR, 6)) |
||
8281 | Store (\_SB.MEM.BG11, Index (BUFR, 7)) |
||
8282 | Store (\_SB.MEM.BG21, Index (BUFR, 8)) |
||
8283 | Store (\_SB.MEM.BMN1, Index (BUFR, 9)) |
||
8284 | Store (\_SB.MEM.BSN1, Index (BUFR, 10)) |
||
8285 | Store (\_SB.MEM.BTP1, Index (BUFR, 11)) |
||
8286 | Store (\_SB.MEM.BOI1, Index (BUFR, 12)) |
||
8287 | |||
8288 | Return (BUFR) |
||
8289 | } // _BIF |
||
8290 | } // BAT1 |
||
8291 | |||
8292 | Device (IDX2) |
||
8293 | { |
||
8294 | Method (B2IB) |
||
8295 | { // B2IB: store from Buffer into Index'ed Buffer |
||
8296 | |||
8297 | Name (SRCB, Buffer () {"Short Buffer"}) // 12 characters plus NULL |
||
8298 | |||
8299 | Name (DEST, Buffer () // 62 characters plus NULL |
||
8300 | {"Destination buffer that is longer than the short source buffer"}) |
||
8301 | |||
8302 | |||
8303 | // verify object type returned by Index(Buffer,Element,) |
||
8304 | |||
8305 | Store (Index (DEST, 2, ), Local1) |
||
8306 | Store (ObjectType (Local1), Local2) |
||
8307 | |||
8308 | If (LNotEqual (Local2, 14)) // Buffer Field is type 14 |
||
8309 | { |
||
8310 | // Local2 indicates Local1 is not a Buffer Field |
||
8311 | |||
8312 | Return (0x61) |
||
8313 | } |
||
8314 | |||
8315 | // verify object type and value returned by DerefOf(Index(Buffer,Element,)) |
||
8316 | // should return Number containing element value |
||
8317 | |||
8318 | Store (DerefOf (Local1), Local3) |
||
8319 | Store (ObjectType (Local3), Local4) |
||
8320 | |||
8321 | If (LNotEqual (Local4, 1)) // Number is type 1 |
||
8322 | { |
||
8323 | // Local2 indicates Local1 is not a Number |
||
8324 | Return (0x62) |
||
8325 | } |
||
8326 | Else |
||
8327 | { |
||
8328 | If (LNotEqual (Local3, 0x73)) // expect 's' element from DEST |
||
8329 | { |
||
8330 | Return (0x63) |
||
8331 | } |
||
8332 | } |
||
8333 | |||
8334 | Store ("DerefOf(Index(Buffer,,)) PASS", Debug) |
||
8335 | |||
8336 | |||
8337 | // |
||
8338 | // The following sections have been rewritten because storing into |
||
8339 | // an Indexed buffer only changes one byte - the FIRST byte of the |
||
8340 | // buffer is written to the source index. This is the ONLY byte |
||
8341 | // written -- as per ACPI 2.0 |
||
8342 | // |
||
8343 | // Overwrite DEST contents, at buffer position 2 [only] |
||
8344 | |||
8345 | Store (SRCB, Index (DEST, 2, )) |
||
8346 | |||
8347 | // |
||
8348 | // Check that the next byte is not changed |
||
8349 | // |
||
8350 | Store (DerefOf (Index (DEST, 3, )), Local0) |
||
8351 | If (LNotEqual (Local0, 0x74)) // 't' |
||
8352 | { |
||
8353 | // DEST element is not matching original value |
||
8354 | If (LEqual (Local0, 0x68)) |
||
8355 | { |
||
8356 | // DEST element was altered to 'h' |
||
8357 | Return (0x68) |
||
8358 | } |
||
8359 | Else |
||
8360 | { |
||
8361 | // DEST element is an unknown value |
||
8362 | Return (0x69) |
||
8363 | } |
||
8364 | } |
||
8365 | |||
8366 | // |
||
8367 | // Check that the elements beyond the SRCB buffer copy |
||
8368 | // have not been altered. |
||
8369 | // |
||
8370 | Store (DerefOf (Index (DEST, 14)), Local0) |
||
8371 | |||
8372 | // |
||
8373 | // This should be an 'f'. |
||
8374 | // |
||
8375 | If (LNotEqual (Local0, 0x66)) |
||
8376 | { |
||
8377 | // DEST element was zero'd by buffer copy |
||
8378 | If (LEqual (Local0, 0)) |
||
8379 | { |
||
8380 | // DEST element is zero |
||
8381 | Return (0x6A) |
||
8382 | } |
||
8383 | Else |
||
8384 | { |
||
8385 | // DEST element is unknown value |
||
8386 | Return (0x6B) |
||
8387 | } |
||
8388 | } |
||
8389 | |||
8390 | Store ("Store(SRCB,Index(Buffer,,)) PASS", Debug) |
||
8391 | |||
8392 | // |
||
8393 | // verify altering SRCB does NOT alter DEST |
||
8394 | // |
||
8395 | Store (0x6A, Index (SRCB, 1)) // SRCB = "Sjort Buffer" |
||
8396 | |||
8397 | Store (DerefOf (Index (SRCB, 1)), Local0) |
||
8398 | |||
8399 | If (LNotEqual (Local0, 0x6A)) // 'j' |
||
8400 | { |
||
8401 | // SRCB element is unaltered |
||
8402 | Return (0x71) |
||
8403 | } |
||
8404 | |||
8405 | Store (DerefOf (Index (DEST, 3)), Local0) // DEST = "Destination buffer that... |
||
8406 | |||
8407 | If (LNotEqual (Local0, 0x74)) // 't' |
||
8408 | { |
||
8409 | // DEST element is altered |
||
8410 | If (LEqual (Local0, 0x6A)) // 'j' |
||
8411 | { |
||
8412 | // SRCB change altered DEST element |
||
8413 | Return (0x72) |
||
8414 | } |
||
8415 | Else |
||
8416 | { |
||
8417 | // DEST element is unknown value |
||
8418 | Return (0x73) |
||
8419 | } |
||
8420 | } |
||
8421 | |||
8422 | // verify altering DEST does NOT alter SRCB |
||
8423 | |||
8424 | Store (0x6B, Index (DEST, 4, )) // DEST = "DeSkination buffer..." |
||
8425 | |||
8426 | Store (DerefOf (Index (DEST, 4, )), Local0) |
||
8427 | |||
8428 | If (LNotEqual (Local0, 0x6B)) // 'k' |
||
8429 | { |
||
8430 | // DEST element is unaltered |
||
8431 | Return (0x74) |
||
8432 | } |
||
8433 | |||
8434 | Store (DerefOf (Index (SRCB, 2, )), Local0) |
||
8435 | |||
8436 | If (LNotEqual (Local0, 0x6F)) // 'o' |
||
8437 | { // SRC element is altered |
||
8438 | If (LEqual (Local0, 0x6B)) // 'k' |
||
8439 | { |
||
8440 | // DEST change altered SRCB element |
||
8441 | Return (0x75) |
||
8442 | } |
||
8443 | Else |
||
8444 | { |
||
8445 | // SRCB element is unknown value |
||
8446 | Return (0x76) |
||
8447 | } |
||
8448 | } |
||
8449 | |||
8450 | Store ("SRCB and DEST independent PASS", Debug) |
||
8451 | |||
8452 | |||
8453 | // verify string can be written to Index target/destination |
||
8454 | // Only FIRST byte is written |
||
8455 | |||
8456 | Store ("New Buff", Index (DEST, 2, )) // DEST = "DeNkination buffer..." |
||
8457 | |||
8458 | Store (DerefOf (Index (DEST, 2, )), Local0) |
||
8459 | |||
8460 | If (LNotEqual (Local0, 0x4E)) // 'N' |
||
8461 | { |
||
8462 | // DEST element is unaltered |
||
8463 | Return (0x81) |
||
8464 | } |
||
8465 | |||
8466 | Store (DerefOf (Index (DEST, 6, )), Local0) |
||
8467 | |||
8468 | If (LNotEqual (Local0, 0x61)) // 'a' |
||
8469 | { |
||
8470 | // DEST element is unaltered |
||
8471 | Return (0x82) |
||
8472 | } |
||
8473 | |||
8474 | Store (DerefOf (Index (DEST, 10, )), Local0) |
||
8475 | |||
8476 | If (LNotEqual (Local0, 0x6E)) // 'n' |
||
8477 | { |
||
8478 | // DEST element is unaltered |
||
8479 | Return (0x83) |
||
8480 | } |
||
8481 | |||
8482 | Store ("Store(String,Index) PASS", Debug) |
||
8483 | |||
8484 | |||
8485 | Return (0) // pass |
||
8486 | } // B2IB: store from Buffer into Index'ed Buffer |
||
8487 | |||
8488 | Method (FB2P) |
||
8489 | { // FB2P: store from Field Buffer into Index'ed Package |
||
8490 | Name (DEST, Package (2) {}) |
||
8491 | |||
8492 | // initialize memory using 32-bit field elements |
||
8493 | Store (0x01234567, \_SB.MEM.SMD0) |
||
8494 | Store (0x89ABCDEF, \_SB.MEM.SMD1) |
||
8495 | Store (0xFEDCBA98, \_SB.MEM.SMD2) |
||
8496 | Store (0x76543210, \_SB.MEM.SMD3) |
||
8497 | |||
8498 | // move greater than 64-bit buffers into DEST package |
||
8499 | Store (\_SB.MEM.SME0, Index (DEST, 0)) |
||
8500 | Store (\_SB.MEM.SME1, Index (DEST, 1)) |
||
8501 | |||
8502 | // validate DEST contents |
||
8503 | Store (DerefOf (Index (DEST, 0, )), Local0) |
||
8504 | Store (DerefOf (Index (DEST, 1, )), Local1) |
||
8505 | |||
8506 | // verify Local0 and Local1 are Buffers |
||
8507 | Store (ObjectType (Local0), Local2) |
||
8508 | if (LNotEqual (Local2, 3)) // Buffer type is 3 |
||
8509 | { |
||
8510 | Return (0x11) |
||
8511 | } |
||
8512 | |||
8513 | Store (ObjectType (Local1), Local3) |
||
8514 | if (LNotEqual (Local3, 3)) // Buffer type is 3 |
||
8515 | { |
||
8516 | Return (0x12) |
||
8517 | } |
||
8518 | |||
8519 | // validate DEST buffer contents |
||
8520 | Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 0)), Local4) |
||
8521 | If (LNotEqual (Local4, 0x67)) |
||
8522 | { |
||
8523 | Return (0x13) |
||
8524 | } |
||
8525 | |||
8526 | Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 1)), Local4) |
||
8527 | If (LNotEqual (Local4, 0x45)) |
||
8528 | { |
||
8529 | Return (0x14) |
||
8530 | } |
||
8531 | |||
8532 | Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 4)), Local4) |
||
8533 | If (LNotEqual (Local4, 0xEF)) |
||
8534 | { |
||
8535 | Return (0x15) |
||
8536 | } |
||
8537 | |||
8538 | Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 5, )), Local4) |
||
8539 | If (LNotEqual (Local4, 0xCD)) |
||
8540 | { |
||
8541 | Return (0x16) |
||
8542 | } |
||
8543 | |||
8544 | Store ("Store(Mem,PkgElement) PASS", Debug) |
||
8545 | |||
8546 | |||
8547 | // validate changing source \_SB.MEM.SMD* does not impact DEST |
||
8548 | Store (0x12345678, \_SB.MEM.SMD0) |
||
8549 | |||
8550 | Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 0, )), Local5) |
||
8551 | If (LNotEqual (Local5, 0x67)) |
||
8552 | { |
||
8553 | Return (0x21) |
||
8554 | } |
||
8555 | |||
8556 | Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 1, )), Local5) |
||
8557 | If (LNotEqual (Local5, 0x45)) |
||
8558 | { |
||
8559 | Return (0x22) |
||
8560 | } |
||
8561 | |||
8562 | // validate changing DEST does not impact source \_SB.MEM.SMD* |
||
8563 | Store (0x30, Index (DerefOf (Index (DEST, 0)), 0)) |
||
8564 | |||
8565 | Store (DerefOf(Index (DerefOf (Index (DEST, 0)), 0)), Local5) |
||
8566 | If (LNotEqual (Local5, 0x30)) |
||
8567 | { |
||
8568 | Return (0x23) |
||
8569 | } |
||
8570 | |||
8571 | // |
||
8572 | // This section was modified from the original iPCO code because |
||
8573 | // it attempted to compare two buffers. This is not allowed until |
||
8574 | // ACPI v2.0, so the test has been modified to just check the |
||
8575 | // changed \_SB.MEM.SMD0 |
||
8576 | // |
||
8577 | Store (\_SB.MEM.SMD0, Local5) |
||
8578 | |||
8579 | If(LNotEqual(Local5, 0x12345678)) |
||
8580 | { |
||
8581 | Return (0x24) |
||
8582 | } |
||
8583 | |||
8584 | Store ("Mem and Pkg independent PASS", Debug) |
||
8585 | |||
8586 | |||
8587 | Return (0) |
||
8588 | } // FB2P: store from Field Buffer into Index'ed Package |
||
8589 | |||
8590 | Method (TEST) |
||
8591 | { |
||
8592 | Store ("++++++++ IndexOp2 Test", Debug) |
||
8593 | |||
8594 | // store _BIF package return value into Local0 |
||
8595 | |||
8596 | Store (\_SB.BAT1._BIF, Local0) |
||
8597 | |||
8598 | // save Local0 object type value into Local1 |
||
8599 | Store (ObjectType (Local0), Local1) |
||
8600 | |||
8601 | // validate Local0 is a Package |
||
8602 | If (LNotEqual (Local1, 4)) // Package type is 4 |
||
8603 | { |
||
8604 | // failure |
||
8605 | Return (2) |
||
8606 | } |
||
8607 | |||
8608 | // validate source and destination buffers are independent of each |
||
8609 | // of each other (i.e., changing one's contents does not change |
||
8610 | // other's contents) using B2IB (store from Buffer into Index'ed |
||
8611 | // Buffer) and FB2P (store from Field Buffer into Index'ed Package) |
||
8612 | |||
8613 | // call B2IB (store from Buffer into Index'ed Buffer) |
||
8614 | Store (B2IB, Local2) // Local2 is B2IB return value |
||
8615 | |||
8616 | // save Local2 object type value into Local3 |
||
8617 | Store (ObjectType (Local2), Local3) |
||
8618 | |||
8619 | // validate Local2 is a Number |
||
8620 | If (LNotEqual (Local3, 1)) // Number type is 1 |
||
8621 | { |
||
8622 | // failure |
||
8623 | Return (4) |
||
8624 | } |
||
8625 | |||
8626 | // zero indicates pass, non-zero is an error code |
||
8627 | If (LNotEqual (Local2, 0)) |
||
8628 | { |
||
8629 | // return B2IB error code |
||
8630 | Return (Local2) |
||
8631 | } |
||
8632 | |||
8633 | // call FB2P (store from Field Buffer into Index'ed Package) |
||
8634 | Store (FB2P, Local2) // Local2 is FB2P return value |
||
8635 | |||
8636 | // save Local2 object type value into Local3 |
||
8637 | Store (ObjectType (Local2), Local3) |
||
8638 | |||
8639 | // validate Local2 is a Number |
||
8640 | If (LNotEqual (Local3, 1)) // Number type is 1 |
||
8641 | { |
||
8642 | // failure |
||
8643 | Return (5) |
||
8644 | } |
||
8645 | |||
8646 | // zero indicates pass, non-zero is an error code |
||
8647 | If (LNotEqual (Local2, 0)) |
||
8648 | { |
||
8649 | // return FB2P error code |
||
8650 | Return (Local2) |
||
8651 | } |
||
8652 | |||
8653 | |||
8654 | Return (0) |
||
8655 | } // TEST |
||
8656 | } // IDX2: Test device name |
||
8657 | } // _SB system bus |
||
8658 | |||
8659 | // |
||
8660 | // test SizeOf.asl |
||
8661 | // |
||
8662 | // Test for SizeOf |
||
8663 | // test cases include following SizeOf arguments: |
||
8664 | // buffer, buffer field; |
||
8665 | // control method argument, control method local variable; |
||
8666 | // control method return values; |
||
8667 | // direct string, string; |
||
8668 | // package; |
||
8669 | // buffer, package, and string package elements |
||
8670 | // |
||
8671 | // MTL NOTE: This test has been modified to remove any SizeOf(Index(Buff,... |
||
8672 | // calls because it is not legal to perform a SizeOf operation on a Buffer Field. |
||
8673 | // This test has also been extended to test additional Package element sizes. |
||
8674 | // |
||
8675 | Device (SIZO) |
||
8676 | { |
||
8677 | // SAR0 control method validates SizeOf(Arg) |
||
8678 | // SAR0 should only be called by SARG |
||
8679 | Method (SAR0, 2) |
||
8680 | // Arg0 object to determine size of |
||
8681 | // Arg1 expected Arg length |
||
8682 | { // SAR0: SizeOf(Arg) test control method |
||
8683 | // Local0 Arg0 length |
||
8684 | // Local1 Local0 object type |
||
8685 | |||
8686 | // Store first string size (Arg0) into Local7 |
||
8687 | Store (SizeOf (Arg0), Local0) |
||
8688 | |||
8689 | // save Local0 object type value into Local1 |
||
8690 | Store (ObjectType (Local0), Local1) |
||
8691 | |||
8692 | // validate Local0 is a Number |
||
8693 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8694 | { Return (0x21) } |
||
8695 | |||
8696 | // If strings are not of equal size, return error code |
||
8697 | If (LNotEqual (Local0, Arg1)) |
||
8698 | { Return (0x22) } |
||
8699 | |||
8700 | Return (0) |
||
8701 | } // SAR0: SizeOf(Arg) test control method |
||
8702 | |||
8703 | Method (SARG) |
||
8704 | { // SARG: SizeOf(Arg) test control method |
||
8705 | Name (BUFR, Buffer (12) {}) // uninitialized Buffer |
||
8706 | Name (BUF1, Buffer() {0x01, 0x02, 0x03, 0x04, 0x05}) |
||
8707 | Name (PKG0, Package (4) {}) // uninitialized Package |
||
8708 | Name (STR0, "String") |
||
8709 | Name (PKG1, Package (4) |
||
8710 | { |
||
8711 | BUFR, |
||
8712 | "String2", |
||
8713 | STR0, |
||
8714 | PKG0 |
||
8715 | }) // PKG1 |
||
8716 | |||
8717 | Name (PKG2, Package (4) |
||
8718 | { |
||
8719 | Buffer (15) {}, |
||
8720 | "String 1", |
||
8721 | Package (2) {} |
||
8722 | }) // PKG2 |
||
8723 | |||
8724 | // Namespace entry buffer reference |
||
8725 | Store (SAR0 (BUFR, 12), Local0) |
||
8726 | |||
8727 | // save Local0 object type value into Local1 |
||
8728 | Store (ObjectType (Local0), Local1) |
||
8729 | |||
8730 | // validate Local0 is a Number |
||
8731 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8732 | { |
||
8733 | Return (0x23) |
||
8734 | } |
||
8735 | |||
8736 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8737 | { |
||
8738 | Return (Local0) |
||
8739 | } |
||
8740 | |||
8741 | Store ("SizeOf(Arg=BUFR) PASS", Debug) |
||
8742 | |||
8743 | |||
8744 | // Namespace entry package reference |
||
8745 | Store (SAR0 (PKG0, 4), Local0) |
||
8746 | |||
8747 | // save Local0 object type value into Local1 |
||
8748 | Store (ObjectType (Local0), Local1) |
||
8749 | |||
8750 | // validate Local0 is a Number |
||
8751 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8752 | { |
||
8753 | Return (0x24) |
||
8754 | } |
||
8755 | |||
8756 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8757 | { |
||
8758 | Return (Local0) |
||
8759 | } |
||
8760 | |||
8761 | Store ("SizeOf(Arg=PKG0) PASS", Debug) |
||
8762 | |||
8763 | |||
8764 | // Namespace entry string reference |
||
8765 | Store (SAR0 (STR0, 6), Local0) |
||
8766 | |||
8767 | // save Local0 object type value into Local1 |
||
8768 | Store (ObjectType (Local0), Local1) |
||
8769 | |||
8770 | // validate Local0 is a Number |
||
8771 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8772 | { |
||
8773 | Return (0x25) |
||
8774 | } |
||
8775 | |||
8776 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8777 | { |
||
8778 | Return (Local0) |
||
8779 | } |
||
8780 | |||
8781 | Store ("SizeOf(Arg=STR0) PASS", Debug) |
||
8782 | |||
8783 | |||
8784 | // direct string reference |
||
8785 | Store (SAR0 ("String", 6), Local0) |
||
8786 | |||
8787 | // save Local0 object type value into Local1 |
||
8788 | Store (ObjectType (Local0), Local1) |
||
8789 | |||
8790 | // validate Local0 is a Number |
||
8791 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8792 | { |
||
8793 | Return (0x26) |
||
8794 | } |
||
8795 | |||
8796 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8797 | { |
||
8798 | Return (Local0) |
||
8799 | } |
||
8800 | |||
8801 | Store ("SizeOf(Arg=String) PASS", Debug) |
||
8802 | |||
8803 | Store (0x55, Index (BUF1, 2)) |
||
8804 | |||
8805 | /**************************************************** |
||
8806 | // |
||
8807 | // This section is commented because it is illegal to |
||
8808 | // perform a SizeOf operation on a Buffer Field |
||
8809 | // |
||
8810 | // Namespace BufferField reference |
||
8811 | Store (SAR0 (Index (BUFR, 2, ), 10), Local0) |
||
8812 | |||
8813 | // save Local0 object type value into Local1 |
||
8814 | Store (ObjectType (Local0), Local1) |
||
8815 | |||
8816 | // validate Local0 is a Number |
||
8817 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8818 | { Return (0x27) } |
||
8819 | |||
8820 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8821 | { Return (Local0) } |
||
8822 | |||
8823 | Store ("SizeOf(Arg=BufferField) PASS", Debug) |
||
8824 | ****************************************************/ |
||
8825 | |||
8826 | // Namespace BufferPackageElement reference |
||
8827 | // |
||
8828 | Store (SAR0 (Index(PKG1, 0), 12), Local0) |
||
8829 | |||
8830 | // save Local0 object type value into Local1 |
||
8831 | Store (ObjectType (Local0), Local1) |
||
8832 | |||
8833 | // validate Local0 is a Number |
||
8834 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8835 | { |
||
8836 | Return (0x28) |
||
8837 | } |
||
8838 | |||
8839 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8840 | { |
||
8841 | Return (Local0) |
||
8842 | } |
||
8843 | |||
8844 | Store ("SizeOf(Arg=PackageBuffer NTE Reference Element) PASS", Debug) |
||
8845 | |||
8846 | |||
8847 | // Namespace StringPackageElement reference |
||
8848 | Store (SAR0 (Index (PKG1, 1, ), 7), Local0) |
||
8849 | |||
8850 | // save Local0 object type value into Local1 |
||
8851 | Store (ObjectType (Local0), Local1) |
||
8852 | |||
8853 | // validate Local0 is a Number |
||
8854 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8855 | { |
||
8856 | Return (0x29) |
||
8857 | } |
||
8858 | |||
8859 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8860 | { |
||
8861 | Return (Local0) |
||
8862 | } |
||
8863 | |||
8864 | Store ("SizeOf(Arg=Package String Element) PASS", Debug) |
||
8865 | |||
8866 | |||
8867 | // Namespace StringPackageElement reference |
||
8868 | Store (SAR0 (Index (PKG1, 2, ), 6), Local0) |
||
8869 | |||
8870 | // save Local0 object type value into Local1 |
||
8871 | Store (ObjectType (Local0), Local1) |
||
8872 | |||
8873 | // validate Local0 is a Number |
||
8874 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8875 | { |
||
8876 | Return (0x2A) |
||
8877 | } |
||
8878 | |||
8879 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8880 | { |
||
8881 | Return (Local0) |
||
8882 | } |
||
8883 | |||
8884 | Store ("SizeOf(Arg=Package String NTE Reference Element) PASS", Debug) |
||
8885 | |||
8886 | |||
8887 | // Namespace PackagePackageElement reference |
||
8888 | Store (SAR0 (Index (PKG1, 3, ), 4), Local0) |
||
8889 | |||
8890 | // save Local0 object type value into Local1 |
||
8891 | Store (ObjectType (Local0), Local1) |
||
8892 | |||
8893 | // validate Local0 is a Number |
||
8894 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8895 | { |
||
8896 | Return (0x2B) |
||
8897 | } |
||
8898 | |||
8899 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8900 | { |
||
8901 | Return (Local0) |
||
8902 | } |
||
8903 | |||
8904 | Store ("SizeOf(Arg=Package Package NTE Reference Element) PASS", Debug) |
||
8905 | |||
8906 | // Package Buffer Element |
||
8907 | Store (SAR0 (Index (PKG2, 0), 15), Local0) |
||
8908 | |||
8909 | // save Local0 object type value into Local1 |
||
8910 | Store (ObjectType (Local0), Local1) |
||
8911 | |||
8912 | // validate Local0 is a Number |
||
8913 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8914 | { |
||
8915 | Return (0x2B) |
||
8916 | } |
||
8917 | |||
8918 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8919 | { |
||
8920 | Return (Local0) |
||
8921 | } |
||
8922 | |||
8923 | Store ("SizeOf(Arg=Package Buffer Element) PASS", Debug) |
||
8924 | |||
8925 | // Package String Element |
||
8926 | Store (SAR0 (Index (PKG2, 1), 8), Local0) |
||
8927 | |||
8928 | // save Local0 object type value into Local1 |
||
8929 | Store (ObjectType (Local0), Local1) |
||
8930 | |||
8931 | // validate Local0 is a Number |
||
8932 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8933 | { |
||
8934 | Return (0x2B) |
||
8935 | } |
||
8936 | |||
8937 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8938 | { |
||
8939 | Return (Local0) |
||
8940 | } |
||
8941 | |||
8942 | Store ("SizeOf(Arg=Package String Element) PASS", Debug) |
||
8943 | |||
8944 | // Package Package Element |
||
8945 | Store (SAR0 (Index (PKG2, 2), 2), Local0) |
||
8946 | |||
8947 | // save Local0 object type value into Local1 |
||
8948 | Store (ObjectType (Local0), Local1) |
||
8949 | |||
8950 | // validate Local0 is a Number |
||
8951 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8952 | { |
||
8953 | Return (0x2B) |
||
8954 | } |
||
8955 | |||
8956 | If (LNotEqual (Local0, 0)) // Local0 is SAR0 return error code |
||
8957 | { |
||
8958 | Return (Local0) |
||
8959 | } |
||
8960 | |||
8961 | Store ("SizeOf(Arg=Package Package Element) PASS", Debug) |
||
8962 | |||
8963 | Store ("SizeOf(Arg) PASS", Debug) |
||
8964 | |||
8965 | Return (0) |
||
8966 | } // SARG: SizeOf(Arg) test control method |
||
8967 | |||
8968 | Method (SBUF) |
||
8969 | { // SBUF: SizeOf(Buffer) test control method |
||
8970 | Name (BUFR, Buffer (12) {}) |
||
8971 | |||
8972 | // store size of BUFR buffer into Local0 |
||
8973 | Store (SizeOf (BUFR), Local0) |
||
8974 | |||
8975 | // save Local0 object type value into Local1 |
||
8976 | Store (ObjectType (Local0), Local1) |
||
8977 | |||
8978 | // validate Local0 is a Number |
||
8979 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
8980 | { |
||
8981 | Return (0x31) |
||
8982 | } |
||
8983 | |||
8984 | If (LNotEqual (Local0, 12)) // BUFR size is 12 |
||
8985 | { |
||
8986 | Return (0x32) |
||
8987 | } |
||
8988 | |||
8989 | Store ("SizeOf(BUFR) PASS", Debug) |
||
8990 | |||
8991 | Return (0) |
||
8992 | } // SBUF: SizeOf(Buffer) test control method |
||
8993 | |||
8994 | |||
8995 | /**************************************************** |
||
8996 | // |
||
8997 | // This section is commented because it is illegal to |
||
8998 | // perform a SizeOf operation on a Buffer Field |
||
8999 | // |
||
9000 | Method (SIND) |
||
9001 | { // SIND: SizeOf(Index(,,)) test control method |
||
9002 | Name (BUFR, Buffer (12) {}) |
||
9003 | |||
9004 | // store size of Index(BUFR,2,) buffer into Local0 |
||
9005 | Store (SizeOf (Index (BUFR, 2, )), Local0) |
||
9006 | |||
9007 | // save Local0 object type value into Local1 |
||
9008 | Store (ObjectType (Local0), Local1) |
||
9009 | |||
9010 | // validate Local0 is a Number |
||
9011 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
9012 | { |
||
9013 | Return (0x41) |
||
9014 | } |
||
9015 | |||
9016 | If (LNotEqual (Local0, 10)) // 12 - 2 = 10 |
||
9017 | { |
||
9018 | Return (0x42) |
||
9019 | } |
||
9020 | |||
9021 | Store ("SizeOf(Index(BUFR,,)) PASS", Debug) |
||
9022 | |||
9023 | // TBD: strings and packages |
||
9024 | |||
9025 | Return (0) |
||
9026 | } // SIND: SizeOf(Index(,,)) test control method |
||
9027 | ****************************************************/ |
||
9028 | |||
9029 | Method (SLOC) |
||
9030 | { // SLOC: SizeOf(Local) test control method |
||
9031 | Name (BUFR, Buffer (12) {}) // uninitialized Buffer |
||
9032 | Name (STR0, "String") |
||
9033 | Name (PKG0, Package (4) {}) // uninitialized Package |
||
9034 | |||
9035 | |||
9036 | // store BUFR Buffer into Local2 |
||
9037 | Store (BUFR, Local2) |
||
9038 | |||
9039 | // store size of BUFR buffer into Local0 |
||
9040 | Store (SizeOf (Local2), Local0) |
||
9041 | |||
9042 | // save Local0 object type value into Local1 |
||
9043 | Store (ObjectType (Local0), Local1) |
||
9044 | |||
9045 | // validate Local0 is a Number |
||
9046 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
9047 | { |
||
9048 | Return (0x51) |
||
9049 | } |
||
9050 | |||
9051 | If (LNotEqual (Local0, 12)) // BUFR size is 12 |
||
9052 | { |
||
9053 | Return (0x52) |
||
9054 | } |
||
9055 | |||
9056 | Store ("SizeOf(Local2=Buffer) PASS", Debug) |
||
9057 | |||
9058 | |||
9059 | // store STR0 string into Local2 |
||
9060 | Store (STR0, Local2) |
||
9061 | |||
9062 | // store size of STR0 buffer into Local0 |
||
9063 | Store (SizeOf (Local2), Local0) |
||
9064 | |||
9065 | // save Local0 object type value into Local1 |
||
9066 | Store (ObjectType (Local0), Local1) |
||
9067 | |||
9068 | // validate Local0 is a Number |
||
9069 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
9070 | { |
||
9071 | Return (0x53) |
||
9072 | } |
||
9073 | |||
9074 | If (LNotEqual (Local0, 6)) // STR0 size is 6 |
||
9075 | { |
||
9076 | Return (0x54) |
||
9077 | } |
||
9078 | |||
9079 | Store ("SizeOf(Local2=String) PASS", Debug) |
||
9080 | |||
9081 | |||
9082 | // store PKG0 Package into Local2 |
||
9083 | Store (PKG0, Local2) |
||
9084 | |||
9085 | // store size of PKG0 buffer into Local0 |
||
9086 | Store (SizeOf (Local2), Local0) |
||
9087 | |||
9088 | // save Local0 object type value into Local1 |
||
9089 | Store (ObjectType (Local0), Local1) |
||
9090 | |||
9091 | // validate Local0 is a Number |
||
9092 | If (LNotEqual (Local1, 1)) // Number type is 1 |
||
9093 | { |
||
9094 | Return (0x55) |
||
9095 | } |
||
9096 | |||
9097 | If (LNotEqual (Local0, 4)) // PKG0 size is 4 |
||
9098 | { |
||
9099 | Return (0x56) |
||
9100 | } |
||
9101 | |||
9102 | Store ("SizeOf(Local2=Package) PASS", Debug) |
||
9103 | |||
9104 | |||
9105 | Return (0) |
||
9106 | } // SLOC: SizeOf(Local) test control method |
||
9107 | |||
9108 | Method (TEST) |
||
9109 | { |
||
9110 | Store ("++++++++ SizeOf Test", Debug) |
||
9111 | |||
9112 | // Store current operating system string into Local0 |
||
9113 | Store (_OS, Local0) |
||
9114 | |||
9115 | Store (SizeOf (_OS), Local3) |
||
9116 | |||
9117 | // save Local3 object type value into Local4 |
||
9118 | Store (ObjectType (Local3), Local4) |
||
9119 | |||
9120 | // validate Local3 is a Number |
||
9121 | If (LNotEqual (Local4, 1)) // Number type is 1 |
||
9122 | { |
||
9123 | // failure |
||
9124 | Return (0x61) |
||
9125 | } |
||
9126 | |||
9127 | // Store current operating system string into Local0 |
||
9128 | // This verifies above SizeOf(_OS) did not corrupt ACPI namespace |
||
9129 | Store (_OS, Local0) |
||
9130 | |||
9131 | // Store SARG [Validate SizeOf(Arg)] return value into Local1 |
||
9132 | Store (SARG, Local1) |
||
9133 | |||
9134 | // save Local1 object type value into Local2 |
||
9135 | Store (ObjectType (Local1), Local2) |
||
9136 | |||
9137 | // validate Local1 is a Number |
||
9138 | If (LNotEqual (Local2, 1)) // Number type is 1 |
||
9139 | { |
||
9140 | // failure |
||
9141 | Return (0x62) |
||
9142 | } |
||
9143 | |||
9144 | // zero indicates pass, non-zero is an error code |
||
9145 | If (LNotEqual (Local1, 0)) |
||
9146 | { |
||
9147 | // return SARG error code |
||
9148 | Return (Local1) |
||
9149 | } |
||
9150 | |||
9151 | |||
9152 | // Store SBUF [Validate SizeOf(Buffer)] return value into Local1 |
||
9153 | Store (SBUF, Local1) |
||
9154 | |||
9155 | // save Local1 object type value into Local2 |
||
9156 | Store (ObjectType (Local1), Local2) |
||
9157 | |||
9158 | // validate Local1 is a Number |
||
9159 | If (LNotEqual (Local2, 1)) // Number type is 1 |
||
9160 | { |
||
9161 | // failure |
||
9162 | Return (0x63) |
||
9163 | } |
||
9164 | |||
9165 | // zero indicates pass, non-zero is an error code |
||
9166 | If (LNotEqual (Local1, 0)) |
||
9167 | { |
||
9168 | // return SBUF error code |
||
9169 | Return (Local1) |
||
9170 | } |
||
9171 | |||
9172 | /**************************************************** |
||
9173 | // |
||
9174 | // This section is commented because it is illegal to |
||
9175 | // perform a SizeOf operation on a Buffer Field |
||
9176 | // |
||
9177 | // Store SIND [verify SizeOf(Index(,,))] return value into Local1 |
||
9178 | Store (SIND, Local1) |
||
9179 | |||
9180 | // save Local1 object type value into Local2 |
||
9181 | Store (ObjectType (Local1), Local2) |
||
9182 | |||
9183 | // validate Local1 is a Number |
||
9184 | If (LNotEqual (Local2, 1)) // Number type is 1 |
||
9185 | { |
||
9186 | // failure |
||
9187 | Return (0x64) |
||
9188 | } |
||
9189 | |||
9190 | // zero indicates pass, non-zero is an error code |
||
9191 | If (LNotEqual (Local1, 0)) |
||
9192 | { |
||
9193 | // return SARG error code |
||
9194 | Return (Local1) |
||
9195 | } |
||
9196 | ****************************************************/ |
||
9197 | |||
9198 | // Store SLOC [verify SizeOf(Local)] return value into Local1 |
||
9199 | Store (SLOC, Local1) |
||
9200 | |||
9201 | // save Local1 object type value into Local2 |
||
9202 | Store (ObjectType (Local1), Local2) |
||
9203 | |||
9204 | // validate Local1 is a Number |
||
9205 | If (LNotEqual (Local2, 1)) // Number type is 1 |
||
9206 | { |
||
9207 | // failure |
||
9208 | Return (0x65) |
||
9209 | } |
||
9210 | |||
9211 | // zero indicates pass, non-zero is an error code |
||
9212 | If (LNotEqual (Local1, 0)) |
||
9213 | { |
||
9214 | // return SLOC error code |
||
9215 | Return (Local1) |
||
9216 | } |
||
9217 | |||
9218 | |||
9219 | // TBD: SizeOf (METH) -- where METH control method returns |
||
9220 | // buffer, BufferField, string, package, package element |
||
9221 | |||
9222 | |||
9223 | Return (0) |
||
9224 | } // TEST |
||
9225 | } // SIZO |
||
9226 | |||
9227 | // |
||
9228 | // test SmiShare.asl |
||
9229 | // |
||
9230 | Scope (\_SB) // System Bus |
||
9231 | { // _SB system bus |
||
9232 | // Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long |
||
9233 | OperationRegion(RAM1, SystemMemory, 0x400000, 0xA) |
||
9234 | |||
9235 | Field (RAM1, AnyAcc, NoLock, Preserve) |
||
9236 | { |
||
9237 | BI1T, 1, // Create some bits in memory to access |
||
9238 | BI2T, 2, |
||
9239 | BI3T, 3, |
||
9240 | LST2, 2 |
||
9241 | } // End Field RAM1 |
||
9242 | |||
9243 | Field (RAM1, WordAcc, NoLock, WriteAsZeros) |
||
9244 | { |
||
9245 | WRD, 16 |
||
9246 | } // End 2nd Field RAM1 |
||
9247 | |||
9248 | Field (RAM1, ByteAcc, NoLock, WriteAsOnes) |
||
9249 | { |
||
9250 | BYTE, 8 |
||
9251 | } // End 3rd Field RAM1 |
||
9252 | |||
9253 | Field (RAM1, ByteAcc, NoLock, Preserve) |
||
9254 | { |
||
9255 | SMIC, 8, |
||
9256 | SMID, 8 |
||
9257 | } |
||
9258 | |||
9259 | Device (MBIT) |
||
9260 | { |
||
9261 | Method (_INI) |
||
9262 | { |
||
9263 | Store (0, BI1T) |
||
9264 | Store (3, BI2T) |
||
9265 | Store (7, BI3T) |
||
9266 | Store (0, LST2) |
||
9267 | } // End _INI Method |
||
9268 | } // End Device MBIT |
||
9269 | |||
9270 | Device (MWRD) |
||
9271 | { |
||
9272 | Method (_INI) |
||
9273 | { |
||
9274 | Store (0, WRD) |
||
9275 | } // End _INI Method |
||
9276 | } // End Device MWRD |
||
9277 | |||
9278 | Device (MBYT) |
||
9279 | { |
||
9280 | Method (_INI) |
||
9281 | { |
||
9282 | Store (0, BYTE) |
||
9283 | Store (0xC, SMIC) |
||
9284 | Store (0xD, SMID) |
||
9285 | } // End _INI Method |
||
9286 | } // End Device MBYT |
||
9287 | |||
9288 | /* |
||
9289 | // Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long |
||
9290 | OperationRegion(\RAM1, SystemMemory, 0x400000, 0xA) |
||
9291 | |||
9292 | Field (\RAM1, AnyAcc, NoLock, Preserve) |
||
9293 | { |
||
9294 | BI1T, 1, // Create some bits in memory to access |
||
9295 | BI2T, 2, |
||
9296 | BI3T, 3, |
||
9297 | LST2, 2 |
||
9298 | } // End Field RAM1 |
||
9299 | |||
9300 | Field (\RAM1, WordAcc, NoLock, WriteAsZeros) |
||
9301 | { |
||
9302 | WRD, 16 |
||
9303 | } // End 2nd Field RAM1 |
||
9304 | |||
9305 | Field (\RAM1, ByteAcc, NoLock, WriteAsOnes) |
||
9306 | { |
||
9307 | BYTE, 8 |
||
9308 | } // End 3rd Field RAM1 |
||
9309 | |||
9310 | Field (\RAM1, ByteAcc, NoLock, Preserve) |
||
9311 | { |
||
9312 | SMIC, 8, |
||
9313 | SMID, 8 |
||
9314 | } |
||
9315 | */ |
||
9316 | Method (SMIX) |
||
9317 | { |
||
9318 | Return (BYTE) |
||
9319 | } // End SMIX |
||
9320 | |||
9321 | Method (EVNT) |
||
9322 | { |
||
9323 | Store (SMIX, Local0) |
||
9324 | |||
9325 | If (And (Local0, 0x01)) |
||
9326 | { Notify (\_SB_.SMIS, 0x21)} |
||
9327 | |||
9328 | If (And (Local0, 0x02)) |
||
9329 | { Notify (\_SB_.SMIS, 0x22)} |
||
9330 | |||
9331 | If (And (Local0, 0x04)) |
||
9332 | { Notify (\_SB_.SMIS, 0x24)} |
||
9333 | |||
9334 | If (And (Local0, 0x08)) |
||
9335 | { Notify (\_SB_.SMIS, 0x28)} |
||
9336 | |||
9337 | } // End Method EVNT |
||
9338 | |||
9339 | Device (SMIS) |
||
9340 | { |
||
9341 | Method (BINK) |
||
9342 | { |
||
9343 | Store (0, Local0) // Zero out Local0 |
||
9344 | |||
9345 | If (LNotEqual (SMID, 0xD)) |
||
9346 | { Or (0x80, Local0, Local0)} |
||
9347 | |||
9348 | If (LNotEqual (SMIC, 0xC)) |
||
9349 | { Or (0x40, Local0, Local0)} |
||
9350 | |||
9351 | If (LNotEqual (BYTE, 0)) |
||
9352 | { Or (0x20, Local0, Local0)} |
||
9353 | |||
9354 | If (LNotEqual (WRD, 0)) |
||
9355 | { Or (0x10, Local0, Local0)} |
||
9356 | |||
9357 | If (LNotEqual (LST2, 0)) |
||
9358 | { Or (0x8, Local0, Local0)} |
||
9359 | |||
9360 | If (LNotEqual (BI3T, 0x7)) |
||
9361 | { Or (0x4, Local0, Local0)} |
||
9362 | |||
9363 | If (LNotEqual (BI2T, 0x3)) |
||
9364 | { Or (0x2, Local0, Local0)} |
||
9365 | |||
9366 | If (LNotEqual (BI1T, 0)) |
||
9367 | { Or (0x1, Local0, Local0)} |
||
9368 | |||
9369 | Return (Local0) |
||
9370 | } // End Method BINK |
||
9371 | |||
9372 | Method (TEST) |
||
9373 | { |
||
9374 | Store ("++++++++ SmiShare Test", Debug) |
||
9375 | |||
9376 | // Expect EVNT to generate Notify value we just previously |
||
9377 | // stored in BYTE |
||
9378 | Store (0x20, BYTE) |
||
9379 | EVNT () |
||
9380 | Store (0x21, BYTE) |
||
9381 | EVNT () |
||
9382 | Store (0x22, BYTE) |
||
9383 | EVNT () |
||
9384 | Store (0x23, BYTE) |
||
9385 | EVNT () |
||
9386 | |||
9387 | Return (0) // pass |
||
9388 | } // End Method TEST |
||
9389 | } // Device SMIS |
||
9390 | |||
9391 | Device(CNDT) |
||
9392 | { |
||
9393 | Method(TEST) |
||
9394 | { |
||
9395 | If (ECOK) |
||
9396 | { |
||
9397 | return("Broken") |
||
9398 | } |
||
9399 | Else |
||
9400 | { |
||
9401 | return("Works") |
||
9402 | } |
||
9403 | } |
||
9404 | |||
9405 | Method(ECOK) |
||
9406 | { |
||
9407 | Return(0x0) |
||
9408 | } |
||
9409 | } |
||
9410 | |||
9411 | } // _SB system bus |
||
9412 | |||
9413 | |||
9414 | /* Test a very big buffer */ |
||
9415 | |||
9416 | Name(WQAB, Buffer(6756) |
||
9417 | { |
||
9418 | 0x46,0x4F,0x4D,0x42,0x01,0x00,0x00,0x00, |
||
9419 | 0x54,0x1A,0x00,0x00,0xBA,0xAD,0x00,0x00, |
||
9420 | 0x44,0x53,0x00,0x01,0x1A,0x7D,0xDA,0x54, |
||
9421 | 0x98,0xBD,0x92,0x00,0x01,0x06,0x18,0x42, |
||
9422 | 0x10,0x47,0x10,0x92,0x46,0x62,0x02,0x89, |
||
9423 | 0x80,0x90,0x18,0x18,0x14,0x81,0x85,0x00, |
||
9424 | 0x49,0x02,0x88,0xC4,0x41,0xE1,0x20,0xD4, |
||
9425 | 0x9F,0x40,0x7E,0x05,0x20,0x74,0x28,0x40, |
||
9426 | 0xA6,0x00,0x83,0x02,0x9C,0x22,0x88,0xA0, |
||
9427 | 0x57,0x01,0x36,0x05,0x98,0x14,0x60,0x51, |
||
9428 | 0x80,0x76,0x01,0x96,0x05,0xE8,0x16,0x20, |
||
9429 | 0x1D,0x96,0x88,0x04,0x47,0x89,0x01,0x47, |
||
9430 | 0xE9,0xC4,0x16,0x6E,0xD8,0xE0,0x85,0xA2, |
||
9431 | 0x68,0x06,0x51,0x12,0x94,0x8B,0x20,0x5D, |
||
9432 | 0x10,0x52,0x2E,0xC0,0x37,0x82,0x06,0x10, |
||
9433 | 0xA5,0x77,0x01,0xB6,0x05,0x98,0x86,0x27, |
||
9434 | 0xD2,0x20,0xE4,0x60,0x08,0x54,0xCE,0x80, |
||
9435 | 0x20,0x69,0x44,0x21,0x1E,0xA7,0x44,0x08, |
||
9436 | 0x0A,0x84,0x90,0xD4,0xF1,0xA0,0xA0,0x71, |
||
9437 | 0x88,0xAD,0xCE,0x46,0x93,0xA9,0x74,0x7E, |
||
9438 | 0x48,0x82,0x70,0xC6,0x2A,0x7E,0x3A,0x9A, |
||
9439 | 0xD0,0xD9,0x9C,0x60,0xE7,0x18,0x72,0x3C, |
||
9440 | 0x48,0xF4,0x20,0xB8,0x00,0x0F,0x1C,0x2C, |
||
9441 | 0x34,0x84,0x22,0x6B,0x80,0xC1,0x8C,0xDD, |
||
9442 | 0x63,0xB1,0x0B,0x4E,0x0A,0xEC,0x61,0xB3, |
||
9443 | 0x01,0x19,0xA2,0x24,0x38,0xD4,0x11,0xC0, |
||
9444 | 0x12,0x05,0x98,0x1F,0x87,0x0C,0x0F,0x95, |
||
9445 | 0x8C,0x25,0x24,0x1B,0xAB,0x87,0xC2,0xA5, |
||
9446 | 0x40,0x68,0x6C,0x27,0xED,0x19,0x45,0x2C, |
||
9447 | 0x79,0x4A,0x82,0x49,0xE0,0x51,0x44,0x36, |
||
9448 | 0x1A,0x27,0x28,0x1B,0x1A,0x25,0x03,0x42, |
||
9449 | 0x9E,0x05,0x58,0x07,0x26,0x04,0x76,0x2F, |
||
9450 | 0xC0,0x9A,0x00,0x73,0xB3,0x90,0xB1,0xB9, |
||
9451 | 0xE8,0xFF,0x0F,0x71,0xB0,0x31,0xDA,0x9A, |
||
9452 | 0xAE,0x90,0xC2,0xC4,0x88,0x12,0x2C,0x5E, |
||
9453 | 0xC5,0xC3,0x10,0xCA,0x93,0x42,0xA8,0x48, |
||
9454 | 0x95,0xA1,0x68,0xB4,0x51,0x2A,0x14,0xE0, |
||
9455 | 0x4C,0x80,0x30,0x5C,0x1D,0x03,0x82,0x46, |
||
9456 | 0x88,0x15,0x29,0x56,0xFB,0x83,0x20,0xF1, |
||
9457 | 0x2D,0x40,0x54,0x01,0xA2,0x48,0xA3,0x41, |
||
9458 | 0x9D,0x03,0x3C,0x5C,0x0F,0xF5,0xF0,0x3D, |
||
9459 | 0xF6,0x93,0x0C,0x72,0x90,0x67,0xF1,0xA8, |
||
9460 | 0x70,0x9C,0x06,0x49,0xE0,0x0B,0x80,0x4F, |
||
9461 | 0x08,0x1E,0x38,0xDE,0x35,0xA0,0x66,0x7C, |
||
9462 | 0xBC,0x4C,0x10,0x1C,0x6A,0x88,0x1E,0x68, |
||
9463 | 0xB8,0x13,0x38,0x44,0x06,0xE8,0x49,0x3D, |
||
9464 | 0x52,0x60,0x07,0x77,0x32,0xEF,0x01,0xAF, |
||
9465 | 0x0A,0xCD,0x5E,0x12,0x08,0xC1,0xF1,0xF8, |
||
9466 | 0x7E,0xC0,0x26,0x9C,0xC0,0xF2,0x07,0x81, |
||
9467 | 0x1A,0x99,0xA1,0x3D,0xCA,0xD3,0x8A,0x19, |
||
9468 | 0xF2,0x31,0xC1,0x04,0x16,0x0B,0x21,0x05, |
||
9469 | 0x10,0x1A,0x0F,0xF8,0x6F,0x00,0x8F,0x17, |
||
9470 | 0xBE,0x12,0xC4,0xF6,0x80,0x12,0x0C,0x0B, |
||
9471 | 0x21,0x23,0xAB,0xF0,0x78,0xE8,0x28,0x7C, |
||
9472 | 0x95,0x38,0x9C,0xD3,0x8A,0x67,0x82,0xE1, |
||
9473 | 0x20,0xF4,0x05,0x90,0x00,0x51,0xE7,0x0C, |
||
9474 | 0xD4,0x61,0xC1,0xE7,0x04,0x76,0x33,0x38, |
||
9475 | 0x83,0x47,0x00,0x8F,0xE4,0x84,0xFC,0x2B, |
||
9476 | 0xF1,0xC0,0xE0,0x03,0xE2,0xEF,0x1F,0xA7, |
||
9477 | 0xEC,0x11,0x9C,0xA9,0x01,0x7D,0x1C,0xF0, |
||
9478 | 0xFF,0x7F,0x28,0x7C,0x88,0x1E,0xDF,0x29, |
||
9479 | 0x1F,0xAF,0x4F,0x17,0x96,0x35,0x4E,0xE8, |
||
9480 | 0x77,0x08,0x9F,0x38,0x7C,0x64,0x71,0x44, |
||
9481 | 0x08,0x39,0x39,0x05,0xA0,0x81,0x4F,0xF7, |
||
9482 | 0xEC,0x22,0x9C,0xAE,0x27,0xE5,0x40,0xC3, |
||
9483 | 0xA0,0xE3,0x04,0xC7,0x79,0x00,0x1C,0xE3, |
||
9484 | 0x84,0x7F,0x2E,0x80,0x3F,0x40,0x7E,0xCA, |
||
9485 | 0x78,0xC5,0x48,0xE0,0x98,0x23,0x44,0x9F, |
||
9486 | 0x6B,0x3C,0x42,0x2C,0xFC,0x53,0x45,0xE1, |
||
9487 | 0x03,0x21,0x63,0x04,0x17,0xA0,0xC7,0x08, |
||
9488 | 0x7C,0x03,0x8E,0x11,0x7D,0x94,0xE0,0xEA, |
||
9489 | 0x0F,0x1A,0x74,0x80,0xB8,0xFF,0xFF,0x00, |
||
9490 | 0xE1,0x83,0x7A,0x80,0xC0,0x37,0xFA,0xD1, |
||
9491 | 0x03,0x3D,0x2E,0x8B,0x3E,0x0F,0xC8,0xF8, |
||
9492 | 0x89,0x46,0xF3,0xE2,0xA7,0x03,0x7E,0xF8, |
||
9493 | 0x00,0x0F,0xA8,0x87,0x84,0x03,0xC5,0x4C, |
||
9494 | 0x9B,0x83,0x3E,0xBB,0x1C,0x3A,0x76,0xB8, |
||
9495 | 0xE0,0x3F,0x81,0x80,0x4B,0xDE,0x21,0x0C, |
||
9496 | 0x14,0x23,0xC6,0x9F,0x83,0x7C,0x0A,0x03, |
||
9497 | 0xFF,0xFF,0xFF,0x14,0x06,0xFE,0xE1,0xF0, |
||
9498 | 0x20,0x4F,0x07,0x9F,0xB6,0xA8,0x74,0x18, |
||
9499 | 0xD4,0x81,0x0B,0xB0,0x32,0x89,0x08,0xCF, |
||
9500 | 0x12,0xB5,0x41,0xE8,0xD4,0xF0,0x36,0xF1, |
||
9501 | 0xB6,0xE5,0x5B,0x40,0x9C,0xD3,0xEC,0xED, |
||
9502 | 0xC0,0x45,0x30,0x22,0xD4,0x0C,0x45,0x4E, |
||
9503 | 0x5A,0x11,0x63,0x44,0x79,0xDC,0x32,0xCA, |
||
9504 | 0xDB,0xD6,0x0B,0x40,0xBC,0x13,0x7B,0xDE, |
||
9505 | 0x32,0x46,0xF0,0xC8,0x0F,0x5C,0x2C,0xC6, |
||
9506 | 0xEA,0xF5,0x5F,0xF3,0x81,0x0B,0x70,0xF6, |
||
9507 | 0xFF,0x3F,0x70,0x01,0x1C,0x0A,0x7A,0x18, |
||
9508 | 0x42,0x0F,0xC3,0x53,0x39,0x97,0x87,0xC8, |
||
9509 | 0x53,0x89,0x18,0x35,0x4C,0xD4,0x67,0x28, |
||
9510 | 0xDF,0x2D,0x7C,0x20,0x02,0xDF,0x99,0x0B, |
||
9511 | 0xF8,0xFD,0xFF,0x0F,0x44,0x70,0x8E,0x29, |
||
9512 | 0xB8,0x33,0x0D,0x78,0x7C,0xCE,0x40,0x20, |
||
9513 | 0xA7,0xE2,0x43,0x0D,0x60,0x41,0xF4,0x13, |
||
9514 | 0xC2,0x27,0x1A,0x2A,0x13,0x06,0x75,0xA8, |
||
9515 | 0x01,0xAC,0x5C,0x61,0x9E,0x46,0xCF,0xF9, |
||
9516 | 0x59,0xC6,0xA7,0x1A,0x1F,0x4A,0x8D,0x63, |
||
9517 | 0x88,0x97,0x99,0x87,0x1A,0x1F,0x0B,0x5E, |
||
9518 | 0x49,0x7D,0xA8,0x31,0x54,0x9C,0x87,0x1A, |
||
9519 | 0x0F,0x37,0x50,0xD4,0x37,0x9B,0x67,0x1B, |
||
9520 | 0xA3,0xC7,0xF7,0x0D,0xD5,0x10,0x0F,0x35, |
||
9521 | 0x4C,0xF2,0x4A,0x35,0x16,0x1F,0x6A,0xC0, |
||
9522 | 0xF1,0xFF,0x3F,0xD4,0x00,0xFC,0xFF,0xFF, |
||
9523 | 0x1F,0x6A,0x00,0x47,0x47,0x03,0x38,0x47, |
||
9524 | 0x46,0xDC,0xD1,0x00,0x5C,0x87,0x52,0xE0, |
||
9525 | 0x70,0x34,0x00,0x1E,0x47,0x21,0x30,0x5F, |
||
9526 | 0x68,0x7C,0x14,0x02,0x16,0xFF,0xFF,0xA3, |
||
9527 | 0x10,0xF8,0x65,0x9F,0x83,0x50,0x42,0x8F, |
||
9528 | 0x42,0x80,0xA0,0xDB,0xCF,0x53,0xC4,0xB3, |
||
9529 | 0x8F,0x2F,0x3F,0x0F,0x04,0x11,0x5E,0xF3, |
||
9530 | 0x7D,0x0A,0xF2,0x21,0xDF,0x47,0x21,0x06, |
||
9531 | 0x63,0x28,0x5F,0x83,0x7C,0x14,0x62,0x50, |
||
9532 | 0xAF,0x41,0xBE,0xEF,0x1B,0xE4,0xF1,0x22, |
||
9533 | 0x48,0xEC,0x67,0x02,0x1F,0x85,0x98,0xE8, |
||
9534 | 0xA3,0x10,0xA0,0xF0,0xFF,0x7F,0x14,0x02, |
||
9535 | 0xF8,0xFF,0xFF,0x3F,0x0A,0x01,0xCE,0x02, |
||
9536 | 0x1C,0x0D,0x40,0x37,0xAD,0x47,0x21,0xF0, |
||
9537 | 0xDE,0x59,0x4E,0xFB,0x04,0x7C,0x16,0x02, |
||
9538 | 0xCC,0xFE,0xFF,0xCF,0x42,0xC0,0xEC,0x28, |
||
9539 | 0x74,0x14,0x67,0xF9,0x2A,0xF4,0x04,0xF0, |
||
9540 | 0x02,0x10,0x23,0xCC,0x3B,0xD0,0x4B,0x26, |
||
9541 | 0xBB,0x8B,0x1B,0xE7,0xC9,0xE5,0x2C,0x9E, |
||
9542 | 0xC4,0x7D,0x09,0xF2,0x81,0xE2,0x59,0xC8, |
||
9543 | 0x50,0xA7,0x1B,0xF4,0x8D,0xDC,0x03,0x8B, |
||
9544 | 0x19,0x3F,0xC4,0xF3,0x90,0x21,0x9E,0x85, |
||
9545 | 0x00,0x76,0xFD,0xFF,0xCF,0x42,0x00,0xFF, |
||
9546 | 0xFF,0xFF,0x47,0x03,0xF8,0x2F,0x00,0x9F, |
||
9547 | 0x85,0x80,0xE7,0x09,0xE0,0x41,0xDB,0x67, |
||
9548 | 0x21,0x80,0x33,0x87,0xCB,0xF3,0x7F,0x05, |
||
9549 | 0x3A,0x96,0xF7,0x08,0xCF,0xFA,0x24,0x5F, |
||
9550 | 0x2F,0x3D,0xD3,0x87,0x82,0x67,0x21,0x86, |
||
9551 | 0x75,0x18,0x3E,0x0B,0x31,0x88,0x17,0x4D, |
||
9552 | 0x43,0xBC,0x70,0xFA,0x30,0xE0,0xFF,0x3F, |
||
9553 | 0x5E,0xE0,0x57,0x4E,0x03,0x05,0x09,0xF4, |
||
9554 | 0x2C,0x04,0x30,0xFE,0xFF,0x7F,0x16,0x02, |
||
9555 | 0xC8,0xB8,0x46,0x9D,0x85,0x80,0xE5,0x6D, |
||
9556 | 0xE5,0x19,0xDB,0xA7,0x95,0x04,0xFF,0xFF, |
||
9557 | 0x67,0x21,0xC0,0x41,0x2E,0x23,0x07,0x21, |
||
9558 | 0x4C,0xC4,0x87,0x83,0x8F,0x99,0x80,0x9E, |
||
9559 | 0x29,0xBE,0xB8,0x1B,0xE3,0x09,0xE0,0x45, |
||
9560 | 0xE2,0x31,0x93,0x1D,0x35,0x0D,0xF3,0x2C, |
||
9561 | 0x64,0xBC,0xB3,0x78,0x0D,0x78,0x82,0xF7, |
||
9562 | 0xE4,0x9F,0x85,0x18,0xD8,0x61,0x05,0x7B, |
||
9563 | 0x14,0x32,0xA8,0xC1,0x63,0x87,0x08,0x13, |
||
9564 | 0xE8,0x59,0x88,0xC5,0x7D,0xAE,0xE8,0x3C, |
||
9565 | 0xE1,0xB3,0x10,0xF0,0xFE,0xFF,0x9F,0x25, |
||
9566 | 0xE0,0x5E,0x0D,0x9E,0x85,0x00,0x13,0x87, |
||
9567 | 0x0D,0x9F,0x35,0xC0,0x33,0x7C,0x8F,0xEA, |
||
9568 | 0x1C,0x1E,0x8F,0x81,0x7F,0x56,0x1D,0xE7, |
||
9569 | 0x04,0x96,0x7B,0xD1,0xB2,0x71,0xA0,0xA1, |
||
9570 | 0x23,0xB2,0x3A,0x20,0x8D,0x0D,0x73,0x29, |
||
9571 | 0x89,0x7C,0x72,0x6C,0xD4,0x56,0x04,0xA7, |
||
9572 | 0x33,0x93,0x4F,0x00,0xD6,0x42,0x21,0x05, |
||
9573 | 0x34,0x1A,0x8B,0xE1,0x9D,0xF9,0xE8,0x44, |
||
9574 | 0x41,0x0C,0xE8,0xE3,0x90,0x6D,0x1C,0x0A, |
||
9575 | 0x50,0x7B,0xD1,0x14,0xC8,0x39,0x07,0xA3, |
||
9576 | 0x7F,0x76,0x74,0x36,0xBE,0x13,0x70,0x0D, |
||
9577 | 0x10,0x3A,0x25,0x18,0xDA,0x6A,0x04,0xFC, |
||
9578 | 0xFF,0x67,0x89,0x01,0x33,0xFE,0x53,0x8C, |
||
9579 | 0x09,0x7C,0x8E,0xC1,0x1F,0x0C,0xF0,0x03, |
||
9580 | 0x7F,0x31,0xA8,0xFA,0x5E,0xA0,0xFB,0x82, |
||
9581 | 0xD5,0xDD,0x64,0x20,0xCC,0xC8,0x04,0xF5, |
||
9582 | 0x9D,0x0E,0x40,0x01,0xE4,0x0B,0x81,0xCF, |
||
9583 | 0x51,0x0F,0x05,0x6C,0x22,0x21,0xC2,0x44, |
||
9584 | 0x33,0x3A,0x62,0xC2,0xA8,0xE8,0x13,0xA6, |
||
9585 | 0x20,0x9E,0xB0,0x63,0x4D,0x18,0x3D,0x13, |
||
9586 | 0x5F,0x74,0xD8,0x88,0x31,0x21,0xAE,0x1E, |
||
9587 | 0xD0,0x26,0x18,0xD4,0x97,0x22,0x58,0x43, |
||
9588 | 0xE6,0x63,0xF1,0x05,0x02,0x37,0x65,0x30, |
||
9589 | 0xCE,0x89,0x5D,0x13,0x7C,0xD9,0xC1,0xCD, |
||
9590 | 0x19,0x8C,0xF0,0x98,0xBB,0x18,0xBF,0x3A, |
||
9591 | 0x79,0x74,0xFC,0xA0,0xE0,0x1B,0x0E,0xC3, |
||
9592 | 0x7E,0x32,0xF3,0x8C,0xDE,0xCB,0x7C,0x8D, |
||
9593 | 0xC3,0xC0,0x7A,0xBC,0x1C,0xD6,0x68,0x61, |
||
9594 | 0x0F,0xED,0x3D,0xC4,0xFF,0xFF,0x43,0x8C, |
||
9595 | 0xCF,0x13,0xC6,0x08,0xEB,0xDB,0x0B,0x38, |
||
9596 | 0xEE,0x59,0xF0,0xEF,0x1A,0xE0,0xB9,0x84, |
||
9597 | 0xF8,0xAE,0x01,0x30,0xF0,0xFF,0x7F,0xD7, |
||
9598 | 0x00,0x4E,0xD7,0x04,0xDF,0x35,0x80,0xF7, |
||
9599 | 0xD0,0x7D,0xD7,0x00,0xAE,0xD9,0xEF,0x1A, |
||
9600 | 0xA8,0x63,0x80,0x15,0xDE,0x35,0xA0,0x5D, |
||
9601 | 0xD9,0xDE,0xD7,0x9E,0xB0,0xAC,0xE9,0xB2, |
||
9602 | 0x81,0x52,0x73,0xD9,0x00,0x14,0xFC,0xFF, |
||
9603 | 0x2F,0x1B,0x80,0x01,0x29,0x13,0x46,0x85, |
||
9604 | 0x9F,0x30,0x05,0xF1,0x84,0x1D,0xEC,0xB2, |
||
9605 | 0x01,0x8A,0x18,0x97,0x0D,0xD0,0x8F,0xED, |
||
9606 | 0x65,0x03,0x18,0xDC,0x13,0xF8,0x6D,0x03, |
||
9607 | 0x78,0x43,0xFA,0xB6,0x01,0xD6,0xFF,0xFF, |
||
9608 | 0x6D,0x03,0xAC,0xF9,0x6F,0x1B,0x28,0x0E, |
||
9609 | 0xAB,0xBC,0x6D,0x40,0x3C,0xC9,0x33,0x02, |
||
9610 | 0xAB,0xBA,0x6E,0xA0,0xF4,0x5C,0x37,0x00, |
||
9611 | 0x12,0x88,0x99,0x30,0x2A,0xFE,0x84,0x29, |
||
9612 | 0x88,0x27,0xEC,0x68,0xD7,0x0D,0x50,0x04, |
||
9613 | 0xB9,0x6E,0x80,0x7E,0x5E,0x09,0xFE,0xFF, |
||
9614 | 0xAF,0x1B,0xC0,0xE0,0xA2,0x80,0xB9,0x6F, |
||
9615 | 0x00,0x6F,0x58,0x7E,0xDF,0x00,0x7C,0xDC, |
||
9616 | 0xC4,0x31,0xF7,0x0D,0xC0,0xCC,0xFF,0xFF, |
||
9617 | 0xBE,0x01,0xB0,0xE7,0xA2,0x80,0xBB,0x6F, |
||
9618 | 0x00,0xEF,0x8B,0xB4,0xEF,0x1B,0x60,0xFE, |
||
9619 | 0xFF,0xDF,0x37,0xC0,0x28,0x6D,0xFD,0x1E, |
||
9620 | 0x1C,0x3D,0x21,0x78,0x7C,0xB8,0xFB,0xA5, |
||
9621 | 0xC7,0xE7,0xBB,0x39,0x38,0x06,0x79,0x8C, |
||
9622 | 0x87,0x76,0xC0,0xAF,0xEF,0x9E,0x98,0xEF, |
||
9623 | 0xE6,0xC0,0xFF,0x4C,0x70,0x3C,0x18,0x68, |
||
9624 | 0x1C,0x62,0xAB,0x97,0x06,0x72,0x34,0x38, |
||
9625 | 0x3F,0xDC,0x19,0x81,0x61,0x15,0x7F,0xF2, |
||
9626 | 0x47,0x38,0xC7,0xD0,0xD9,0xE1,0x20,0xB1, |
||
9627 | 0x83,0xE0,0xC1,0x56,0x6D,0x02,0x85,0x86, |
||
9628 | 0x50,0x14,0x18,0x14,0x8B,0x0F,0x18,0xF8, |
||
9629 | 0x61,0xB3,0xB3,0x00,0x93,0x04,0x87,0x3A, |
||
9630 | 0x02,0xF8,0x3E,0xD1,0xFC,0x38,0x74,0x37, |
||
9631 | 0x38,0x54,0x8F,0xE5,0xA1,0x80,0x9E,0x01, |
||
9632 | 0x71,0xC7,0x0C,0x32,0x69,0xCF,0x28,0xE2, |
||
9633 | 0x53,0xC2,0x29,0x85,0x49,0xE0,0xF3,0x03, |
||
9634 | 0x43,0xE3,0x04,0xAF,0x0D,0xA1,0xF9,0xFF, |
||
9635 | 0xFF,0xA4,0xC0,0x3C,0xDF,0x31,0x04,0x6C, |
||
9636 | 0x02,0xBB,0xBF,0x64,0xC8,0xDA,0xC0,0x75, |
||
9637 | 0x4B,0x32,0x44,0x6F,0x38,0xB2,0x85,0xA2, |
||
9638 | 0xE9,0x44,0x79,0xDF,0x88,0x62,0x67,0x08, |
||
9639 | 0xC2,0x88,0x12,0x2C,0xC8,0xA3,0x42,0xAC, |
||
9640 | 0x28,0x2F,0x05,0x46,0x88,0x18,0xE2,0x95, |
||
9641 | 0x23,0xD0,0x09,0x87,0x0F,0xF2,0xD8,0x14, |
||
9642 | 0xA7,0xFD,0x41,0x90,0x58,0x4F,0x02,0x8D, |
||
9643 | 0xC5,0x91,0x46,0x83,0x3A,0x07,0x78,0xB8, |
||
9644 | 0x3E,0xC4,0x78,0xF8,0x0F,0x21,0x06,0x39, |
||
9645 | 0xC8,0x73,0x7B,0x54,0x38,0x4E,0x5F,0x25, |
||
9646 | 0x4C,0xF0,0x02,0xE0,0x83,0x0A,0x1C,0xD7, |
||
9647 | 0x80,0x9A,0xF1,0x33,0x06,0x58,0x8E,0xE3, |
||
9648 | 0x3E,0xA9,0xC0,0x1D,0x8F,0xEF,0x07,0x6C, |
||
9649 | 0xC2,0x09,0x2C,0x7F,0x10,0xA8,0xE3,0x0C, |
||
9650 | 0x9F,0xE7,0x0B,0x8B,0x21,0x1F,0x13,0x4C, |
||
9651 | 0x60,0xB1,0x27,0x1B,0x3A,0x1E,0xF0,0xDF, |
||
9652 | 0x63,0x1E,0x2F,0x7C,0x32,0xF1,0x7C,0x4D, |
||
9653 | 0x30,0x22,0x84,0x9C,0x8C,0x07,0x7D,0x87, |
||
9654 | 0xC0,0x5C,0x6F,0xD8,0xB9,0x85,0x8B,0x3A, |
||
9655 | 0x68,0xA0,0x4E,0x0B,0x3E,0x28,0xB0,0x9B, |
||
9656 | 0x11,0xE6,0xB8,0xCE,0xCF,0x2A,0x60,0xF8, |
||
9657 | 0xFF,0x9F,0x55,0x60,0x8F,0x10,0xFE,0xED, |
||
9658 | 0xC1,0xF3,0xF2,0x95,0xE1,0xD5,0x21,0x81, |
||
9659 | 0x43,0x8E,0x10,0x3D,0x2E,0x8F,0x10,0x73, |
||
9660 | 0x3E,0xC2,0x0C,0x11,0x5C,0x67,0x01,0x70, |
||
9661 | 0x0C,0x11,0xF8,0x1C,0x70,0xC0,0x71,0x69, |
||
9662 | 0xE2,0x03,0xF5,0x01,0x07,0x70,0x70,0x4D, |
||
9663 | 0xC3,0x1D,0x70,0xC0,0x71,0x16,0x60,0xFF, |
||
9664 | 0xFF,0xC3,0x0D,0x2C,0x49,0x26,0x0E,0x23, |
||
9665 | 0x18,0x11,0x30,0x28,0x02,0x02,0xA4,0xB3, |
||
9666 | 0x80,0x0F,0x29,0x00,0x1F,0xAE,0x0C,0x0F, |
||
9667 | 0x29,0xD8,0x93,0x86,0x07,0x8E,0x1B,0x85, |
||
9668 | 0x07,0x8D,0x0B,0x30,0x68,0x7A,0xE2,0x80, |
||
9669 | 0x7F,0x4C,0xF0,0x19,0x05,0x1C,0xE3,0x06, |
||
9670 | 0xDF,0x2A,0x0C,0xFC,0xFF,0x3F,0x30,0xCC, |
||
9671 | 0xE1,0xC2,0x63,0x39,0x8A,0xA0,0x07,0x1E, |
||
9672 | 0xD4,0xF7,0x8C,0x33,0xF7,0x24,0x8F,0xD1, |
||
9673 | 0x51,0x0F,0x27,0xF4,0xE4,0x85,0x3B,0x57, |
||
9674 | 0xF9,0x0A,0x71,0x14,0x18,0xB8,0x77,0x29, |
||
9675 | 0x8F,0xCF,0x17,0x2B,0xC3,0x63,0x46,0xFB, |
||
9676 | 0x1E,0x72,0xD6,0x11,0x02,0xE2,0x2F,0x75, |
||
9677 | 0x6C,0xC0,0x60,0x39,0x18,0x00,0x87,0x01, |
||
9678 | 0xE3,0x13,0x0D,0x58,0x67,0x1B,0x3C,0xF4, |
||
9679 | 0x69,0x31,0xC4,0xE3,0x0B,0xFB,0x56,0x61, |
||
9680 | 0x82,0xEA,0x41,0x75,0x12,0xF4,0xD0,0xC0, |
||
9681 | 0x01,0xE8,0xA1,0xC1,0x3F,0xB9,0x90,0xFB, |
||
9682 | 0x2B,0x1D,0x82,0xB5,0xE2,0x69,0xDE,0x47, |
||
9683 | 0x1E,0xF3,0xDC,0xA2,0xBC,0x0D,0x3C,0x07, |
||
9684 | 0xF0,0xD3,0x82,0x87,0xE3,0x63,0x81,0xC7, |
||
9685 | 0xE9,0x4B,0x58,0x82,0xF7,0x1A,0x9F,0x6C, |
||
9686 | 0x1E,0x5C,0x58,0xB2,0x21,0xA0,0x06,0xEB, |
||
9687 | 0x21,0x60,0xA6,0x9A,0xC0,0x49,0x46,0x80, |
||
9688 | 0xCA,0x00,0xA1,0x1B,0xCB,0xE9,0x3E,0x8B, |
||
9689 | 0x84,0x38,0xCD,0x47,0x99,0xC7,0x02,0x8F, |
||
9690 | 0xF5,0xC1,0xC0,0xFF,0x7F,0xCD,0x23,0xD4, |
||
9691 | 0x7D,0xCD,0x33,0x7B,0x3A,0xC0,0xAC,0x22, |
||
9692 | 0xDC,0x7B,0xCE,0x1B,0x86,0xD1,0x9E,0x2D, |
||
9693 | 0x7C,0xCD,0x78,0xD6,0x34,0x42,0x38,0x76, |
||
9694 | 0x83,0xF3,0x48,0x8C,0xF0,0x82,0xC0,0x4E, |
||
9695 | 0x0C,0x0F,0x30,0xC6,0x39,0x79,0xC3,0xFA, |
||
9696 | 0xC2,0xCB,0x40,0x83,0x19,0xDB,0x97,0x01, |
||
9697 | 0x36,0x2A,0xDF,0x88,0xC0,0x97,0xFC,0x62, |
||
9698 | 0x00,0x65,0x16,0xBE,0x9E,0xF8,0xA0,0xC4, |
||
9699 | 0x2E,0x06,0x2C,0xE5,0xC5,0x00,0x54,0x37, |
||
9700 | 0x0C,0x5F,0x0C,0xE0,0x5F,0x89,0x5E,0x0C, |
||
9701 | 0xC0,0x70,0x71,0xF2,0x3D,0xC0,0x1E,0xEE, |
||
9702 | 0xA3,0x74,0x9C,0xBE,0xFD,0xBD,0x19,0xF8, |
||
9703 | 0x6C,0xC0,0x60,0x3C,0xC3,0x30,0xC6,0x08, |
||
9704 | 0xE3,0x51,0x86,0x31,0xC1,0xDC,0xB7,0x03, |
||
9705 | 0xE8,0x39,0x87,0x81,0x4A,0x78,0x3B,0x80, |
||
9706 | 0x72,0x0E,0xE8,0xF2,0x68,0x42,0x4F,0x01, |
||
9707 | 0x4F,0x07,0x3E,0x29,0x1A,0xA2,0xAF,0xB1, |
||
9708 | 0x0A,0x26,0x50,0xC4,0x07,0x0D,0x3E,0xB5, |
||
9709 | 0x28,0x3E,0x15,0x78,0x2D,0xCF,0x4E,0xE1, |
||
9710 | 0xE2,0x9C,0x89,0xA7,0x6A,0x38,0x03,0xBD, |
||
9711 | 0xE6,0x86,0x63,0xFF,0x7F,0x38,0xFC,0xA9, |
||
9712 | 0xE0,0x35,0x80,0x1D,0x24,0x3D,0x2D,0x23, |
||
9713 | 0xC2,0x38,0xA4,0x3C,0x32,0xF8,0xB6,0x18, |
||
9714 | 0xC7,0x90,0x0F,0x91,0xBE,0x13,0x18,0xF2, |
||
9715 | 0x21,0xEF,0x79,0xC7,0xC0,0xAF,0x08,0x71, |
||
9716 | 0x9E,0xB2,0x7C,0x67,0xF0,0x65,0x01,0x7C, |
||
9717 | 0x91,0x2E,0x0B,0x68,0x68,0x9F,0x64,0x7C, |
||
9718 | 0x41,0x30,0xEC,0x89,0xB3,0x00,0x77,0x05, |
||
9719 | 0x50,0x81,0xFA,0xAE,0x00,0xFF,0x42,0xF0, |
||
9720 | 0xAE,0x00,0x86,0x79,0xF9,0x56,0xC0,0x35, |
||
9721 | 0x1D,0x4A,0xD0,0x67,0x12,0x5F,0x17,0x70, |
||
9722 | 0x53,0x64,0xA9,0x8E,0x0A,0xD0,0x53,0x4C, |
||
9723 | 0x02,0x75,0x47,0xF7,0x51,0x01,0xC6,0x4D, |
||
9724 | 0xD9,0x07,0x54,0x76,0x5A,0x60,0x67,0x21, |
||
9725 | 0x76,0x1D,0xC1,0x5D,0x49,0x18,0xCA,0xB3, |
||
9726 | 0x81,0x2F,0x59,0xFC,0x70,0x00,0x03,0xDC, |
||
9727 | 0xB3,0x38,0xC4,0x08,0xB1,0xD9,0x81,0xEB, |
||
9728 | 0x75,0xD2,0x70,0x2F,0x44,0xEC,0xFF,0x7F, |
||
9729 | 0x32,0x00,0xE3,0x51,0x1B,0x1C,0x27,0x9D, |
||
9730 | 0xF0,0x91,0x9E,0x59,0xF8,0x49,0x19,0x30, |
||
9731 | 0x71,0xF2,0x03,0xE3,0xC9,0x1A,0xC6,0x00, |
||
9732 | 0xB8,0xBC,0x57,0x95,0x81,0xFC,0x43,0x90, |
||
9733 | 0x20,0x18,0xD4,0x29,0x19,0x38,0x1C,0xC5, |
||
9734 | 0x70,0xA7,0x64,0x78,0x50,0xF8,0xC3,0x00, |
||
9735 | 0xE6,0x46,0xE8,0x7B,0x82,0xA1,0xDE,0x93, |
||
9736 | 0x0E,0xE3,0x91,0xD0,0x04,0x3E,0x2D,0xC3, |
||
9737 | 0xFA,0xFF,0x9F,0x96,0x81,0xD5,0xB1,0xDD, |
||
9738 | 0x43,0xF6,0x59,0x01,0x77,0x76,0x80,0x3B, |
||
9739 | 0x3D,0x7E,0x7A,0x00,0x9C,0x00,0x3D,0x3D, |
||
9740 | 0x80,0xED,0xBC,0x01,0xF7,0x40,0x80,0x38, |
||
9741 | 0xFE,0xA3,0x82,0x5F,0x59,0x28,0x1C,0x3F, |
||
9742 | 0xB6,0xF3,0x63,0x09,0xEE,0x70,0xE0,0x23, |
||
9743 | 0x83,0x0F,0x90,0xB8,0xA1,0xF8,0x50,0x81, |
||
9744 | 0x3C,0x0B,0x80,0x62,0xF4,0x6C,0x04,0xEC, |
||
9745 | 0x06,0xF3,0xD2,0x12,0xE5,0xFF,0xFF,0xDE, |
||
9746 | 0xC0,0x4E,0x29,0xB8,0x83,0x00,0xF8,0x8E, |
||
9747 | 0x01,0xE0,0x1D,0x0C,0x97,0x35,0x66,0x94, |
||
9748 | 0x10,0x18,0x8D,0x19,0x77,0x08,0xE1,0x27, |
||
9749 | 0x02,0xDC,0x98,0x3D,0x6E,0x8F,0x19,0x77, |
||
9750 | 0x9C,0xE5,0xA3,0x7A,0xCA,0x08,0xE5,0x03, |
||
9751 | 0x07,0x3B,0x67,0xBC,0x11,0xF0,0xA1,0x03, |
||
9752 | 0x8F,0x03,0x0C,0xEE,0x48,0x01,0xC6,0xCB, |
||
9753 | 0x01,0x1B,0x3B,0xB8,0x83,0x90,0x53,0x20, |
||
9754 | 0x4B,0x87,0xD1,0xD8,0x71,0xB2,0x81,0x74, |
||
9755 | 0x8C,0xF1,0x21,0xD7,0x63,0xC7,0x0D,0xD6, |
||
9756 | 0x63,0xC7,0x1D,0x5F,0xB0,0xFF,0xFF,0xE3, |
||
9757 | 0x0B,0x18,0xC6,0xC0,0xC5,0x0F,0x03,0x7D, |
||
9758 | 0xF3,0xF3,0xE8,0x0C,0xEE,0x61,0xFB,0x04, |
||
9759 | 0x13,0xE3,0xF9,0x25,0xC4,0x23,0xCC,0x8B, |
||
9760 | 0x4B,0x84,0xA3,0x08,0xF2,0xE6,0x12,0xE7, |
||
9761 | 0xD5,0x20,0xCC,0x63,0x4B,0x94,0x10,0x11, |
||
9762 | 0x0E,0x26,0xCE,0x13,0x8C,0x11,0x0E,0x3C, |
||
9763 | 0x8A,0x21,0x22,0x9C,0x40,0x88,0x93,0x3E, |
||
9764 | 0xD9,0x20,0xE1,0x63,0x84,0x8D,0xF6,0x04, |
||
9765 | 0xC3,0xC7,0xC2,0xCF,0x2B,0x1E,0x3C,0x3F, |
||
9766 | 0xAD,0xF9,0x2E,0xE8,0xC9,0x9C,0xE3,0x43, |
||
9767 | 0x96,0xA7,0xF6,0x38,0xE9,0xC3,0x2C,0x6E, |
||
9768 | 0x50,0x0F,0x8E,0xEC,0xAE,0xE3,0xE3,0x35, |
||
9769 | 0xF6,0x14,0xE4,0x21,0xF0,0x13,0x81,0x2F, |
||
9770 | 0x88,0x9E,0xAC,0xEF,0x7A,0xEC,0x5E,0x66, |
||
9771 | 0x8C,0xEA,0xA7,0x80,0x3A,0xA6,0x9C,0xC1, |
||
9772 | 0x2B,0x04,0xBB,0xE7,0xF9,0x90,0xED,0xBB, |
||
9773 | 0x24,0x1B,0x05,0xEE,0x90,0xE0,0x33,0x12, |
||
9774 | 0x3F,0x55,0x78,0x18,0x1E,0x05,0x8C,0x19, |
||
9775 | 0xBC,0x23,0x1C,0x5A,0x88,0x03,0x7E,0xDF, |
||
9776 | 0x65,0x43,0x8D,0x71,0x7A,0x3E,0x7F,0xB0, |
||
9777 | 0x41,0xC0,0x87,0x3A,0x54,0x0F,0xF3,0xA8, |
||
9778 | 0x5E,0x0A,0x19,0xCE,0xD9,0xC1,0x1D,0x04, |
||
9779 | 0xF6,0xF8,0xE1,0x41,0xF0,0x9B,0x25,0x1F, |
||
9780 | 0x04,0x3B,0xDF,0xBC,0xC1,0x19,0xE4,0xFF, |
||
9781 | 0x7F,0x0C,0xB0,0xCF,0x54,0x3E,0x9A,0x20, |
||
9782 | 0x8E,0x80,0xE8,0xF3,0x87,0xC7,0xF0,0x26, |
||
9783 | 0xC7,0x87,0x83,0x3D,0x7A,0xE0,0x4E,0x22, |
||
9784 | 0x70,0x8F,0x5D,0x07,0xED,0x6B,0x9C,0x2F, |
||
9785 | 0x5A,0x30,0xEE,0x7B,0xCF,0x22,0xE0,0xC7, |
||
9786 | 0x78,0x6C,0x01,0xC7,0xA1,0x04,0xDC,0xC1, |
||
9787 | 0x8E,0x6B,0x1C,0x42,0x51,0x60,0x74,0x28, |
||
9788 | 0xC1,0xC5,0x00,0x12,0x8C,0x63,0x9C,0xD1, |
||
9789 | 0xD0,0x97,0x48,0x1F,0xD2,0xE0,0x0C,0x1A, |
||
9790 | 0xF6,0x3C,0x9F,0x50,0xB8,0x3D,0x01,0x8A, |
||
9791 | 0x4E,0x28,0x20,0xC3,0x7D,0x06,0xC1,0x9E, |
||
9792 | 0x10,0xF8,0x19,0x84,0xFD,0xFF,0x0F,0x8E, |
||
9793 | 0x1E,0xF7,0x7B,0xA3,0x4F,0x8D,0x6C,0xEE, |
||
9794 | 0x0F,0x01,0x27,0x70,0xEE,0xEC,0xD4,0x8C, |
||
9795 | 0x3B,0x33,0x60,0xCF,0x1F,0x1E,0x02,0x3F, |
||
9796 | 0x17,0x78,0xF8,0x1E,0x02,0x7E,0xF0,0x0F, |
||
9797 | 0xCC,0x06,0x07,0xE3,0x29,0xC2,0xD7,0x0E, |
||
9798 | 0x0E,0xCE,0x4F,0x03,0x06,0xE7,0xAF,0x50, |
||
9799 | 0x9F,0xE7,0x19,0x38,0xF6,0xD4,0xEB,0x7B, |
||
9800 | 0x87,0xE7,0xEB,0x43,0x05,0xFE,0xA6,0xE7, |
||
9801 | 0x43,0x05,0x38,0x0E,0x0F,0xFC,0xB0,0xC2, |
||
9802 | 0x86,0xF0,0x28,0x80,0x3F,0xB5,0xF8,0xF8, |
||
9803 | 0x17,0xE7,0x29,0x82,0xDD,0x46,0xB0,0x87, |
||
9804 | 0x0B,0xC0,0x51,0xB4,0xB3,0x18,0x2A,0xCC, |
||
9805 | 0x59,0x8C,0xFC,0xFF,0xCF,0x51,0xA8,0xB3, |
||
9806 | 0x18,0x3D,0x5C,0x00,0x2E,0x04,0x1F,0x0F, |
||
9807 | 0x40,0x73,0x10,0x78,0x5C,0xF0,0x85,0xE0, |
||
9808 | 0x48,0x0E,0xE4,0xE9,0x00,0xF0,0x19,0x4A, |
||
9809 | 0xC3,0xA1,0x09,0x13,0x03,0x06,0x75,0x3E, |
||
9810 | 0xF0,0x09,0xC5,0xC7,0x0E,0x7E,0x36,0xF0, |
||
9811 | 0x8D,0xDC,0x43,0xE5,0xA7,0x66,0x5F,0xF2, |
||
9812 | 0x11,0xE0,0x02,0x75,0xA0,0x61,0xA0,0x46, |
||
9813 | 0xE4,0x23,0xD2,0xFF,0xFF,0xB9,0x0D,0x1B, |
||
9814 | 0x60,0x68,0xF4,0x1C,0x0E,0xE3,0x80,0xEB, |
||
9815 | 0x73,0x38,0x76,0x40,0x3E,0x87,0xC3,0x3F, |
||
9816 | 0x47,0xC3,0x1F,0x1B,0x3B,0xDD,0xF3,0x81, |
||
9817 | 0xC1,0xBA,0x7E,0x63,0x06,0x06,0xB6,0x6F, |
||
9818 | 0x91,0x07,0x06,0x1C,0x51,0xCF,0xC6,0x57, |
||
9819 | 0x08,0x0F,0x0C,0x6C,0x80,0x1E,0x18,0xF0, |
||
9820 | 0x89,0x05,0x21,0x27,0x03,0x43,0x9D,0x32, |
||
9821 | 0x8C,0x1C,0xF3,0x89,0xC3,0xC3,0xF0,0xA1, |
||
9822 | 0x22,0xEA,0x33,0xC0,0x23,0x1E,0x1B,0x1B, |
||
9823 | 0xFB,0xFF,0x8F,0x0D,0x2C,0xC7,0x16,0x8F, |
||
9824 | 0x0D,0xFC,0x47,0x78,0xFC,0xD8,0xE0,0x8C, |
||
9825 | 0xE5,0xD1,0xC4,0x97,0x99,0x23,0x3B,0x8D, |
||
9826 | 0x33,0x7B,0x0D,0xF1,0xD1,0xEE,0xF1,0xDB, |
||
9827 | 0x63,0x03,0x97,0x85,0xB1,0x01,0xA5,0x90, |
||
9828 | 0x63,0x43,0x1F,0x52,0x7C,0x0A,0xB0,0x71, |
||
9829 | 0x54,0x32,0x0F,0x1F,0xAF,0x7C,0x62,0x38, |
||
9830 | 0xBA,0x20,0x6F,0xE8,0xBE,0x5C,0xF8,0x48, |
||
9831 | 0x63,0x30,0x5F,0x5A,0x7C,0x06,0xE5,0x43, |
||
9832 | 0x04,0xD7,0x57,0xC5,0x43,0x04,0x3E,0xA1, |
||
9833 | 0x86,0x88,0x1E,0xCF,0xFF,0xFF,0x11,0xCC, |
||
9834 | 0x43,0x64,0x43,0x03,0xAF,0x87,0xA1,0x01, |
||
9835 | 0xA5,0x98,0xC0,0x5E,0x85,0x87,0x46,0x4F, |
||
9836 | 0x3F,0x3E,0x04,0x30,0x08,0xDF,0x06,0xD8, |
||
9837 | 0x55,0xC0,0x57,0x21,0x83,0x24,0x18,0xE7, |
||
9838 | 0x64,0x41,0x07,0x07,0x8E,0x21,0x79,0x70, |
||
9839 | 0xF0,0x07,0xE3,0x21,0x70,0x60,0xCF,0xE0, |
||
9840 | 0xB9,0xE8,0x31,0xD8,0xA7,0x1D,0x9F,0x4A, |
||
9841 | 0xC0,0x77,0xE6,0x04,0xC7,0xE9,0x1D,0x7B, |
||
9842 | 0x29,0xF0,0x08,0x1E,0xAD,0x3C,0x02,0x7E, |
||
9843 | 0xB4,0x02,0x66,0xFF,0xFF,0xA3,0x15,0x30, |
||
9844 | 0x09,0x7A,0xE6,0xA4,0x03,0x77,0x34,0x18, |
||
9845 | 0xD4,0xD1,0x0A,0x5C,0x11,0xC0,0x75,0xDC, |
||
9846 | 0xF0,0xD1,0x02,0xCE,0x50,0x0F,0xDA,0x07, |
||
9847 | 0x65,0xCF,0xDA,0x97,0x21,0x76,0xB4,0x00, |
||
9848 | 0x97,0x89,0x43,0x08,0xD0,0x04,0x3E,0x89, |
||
9849 | 0x67,0xEF,0x43,0x03,0xB3,0x8A,0xA1,0x01, |
||
9850 | 0xA5,0xA3,0x01,0xEE,0x44,0x81,0xFD,0xFF, |
||
9851 | 0x9F,0x28,0x60,0xDE,0x30,0x70,0x07,0x0A, |
||
9852 | 0xC0,0xCD,0xE9,0xDB,0xE3,0xE2,0xD0,0x38, |
||
9853 | 0xC4,0xE7,0xA7,0x73,0xF6,0xD1,0xE8,0x4C, |
||
9854 | 0x71,0x67,0x11,0x30,0x9C,0x7D,0x11,0x8F, |
||
9855 | 0x18,0x03,0xF9,0x81,0x21,0x59,0x30,0x28, |
||
9856 | 0x16,0x0F,0xC5,0x07,0x03,0x0E,0xEC,0x23, |
||
9857 | 0x02,0x3B,0x17,0xB0,0x73,0xAD,0xE1,0xF8, |
||
9858 | 0x59,0xC0,0xA7,0x84,0xB7,0xA6,0x17,0x7B, |
||
9859 | 0x9F,0xD7,0x7D,0xD6,0x08,0xC9,0xCE,0xF4, |
||
9860 | 0x3E,0x89,0xE2,0x0E,0xA2,0x70,0x4E,0x9F, |
||
9861 | 0xE0,0x22,0xF0,0x65,0xDF,0xA3,0xE0,0xA7, |
||
9862 | 0x07,0xCF,0xF1,0x8D,0xC1,0xA7,0x07,0xE6, |
||
9863 | 0x7E,0xF8,0x9A,0xF1,0x33,0xC3,0xE3,0x43, |
||
9864 | 0x88,0x27,0xE2,0xDA,0xA6,0x20,0x5B,0x18, |
||
9865 | 0x42,0x09,0xF4,0xFF,0x8F,0x10,0xE5,0x6D, |
||
9866 | 0x20,0xCA,0x29,0x44,0x88,0x12,0xA4,0xB1, |
||
9867 | 0xC9,0x0B,0x35,0xCA,0xD9,0x45,0x6E,0x6D, |
||
9868 | 0xF6,0x82,0x0B,0x14,0x2A,0x66,0x9C,0x28, |
||
9869 | 0xEF,0x10,0xB1,0xDA,0x1F,0x04,0x91,0xF4, |
||
9870 | 0x32,0xD0,0x71,0xC9,0x91,0x0E,0x7D,0xE8, |
||
9871 | 0x61,0xFB,0x04,0x8C,0x3F,0x48,0xE2,0xAE, |
||
9872 | 0x2A,0x3E,0x28,0xF8,0x00,0x80,0x77,0x09, |
||
9873 | 0xA8,0x5B,0x9D,0xC7,0xED,0xF3,0x06,0xF8, |
||
9874 | 0xAF,0x17,0x58,0x82,0xF2,0x07,0x81,0x1A, |
||
9875 | 0x99,0xA1,0x3D,0xCC,0xB7,0x19,0x43,0xBE, |
||
9876 | 0x07,0x1C,0x16,0x3B,0x27,0xF9,0xF0,0x08, |
||
9877 | 0x1C,0x8E,0x01,0x4F,0x1B,0xBE,0x51,0x7B, |
||
9878 | 0xBE,0x3E,0x62,0x01,0x8E,0xFE,0xFF,0x47, |
||
9879 | 0x2C,0x30,0x9D,0xDF,0x7D,0x82,0x01,0xC7, |
||
9880 | 0xCD,0x82,0x9F,0x61,0x00,0x67,0x40,0xCF, |
||
9881 | 0x30,0x60,0x1F,0x2A,0x6E,0x08,0x5C,0xEE, |
||
9882 | 0x8A,0x28,0x90,0x05,0xC2,0xA0,0x0E,0xFD, |
||
9883 | 0xE4,0x08,0x42,0xCF,0x9C,0x70,0x86,0x72, |
||
9884 | 0xB2,0xBD,0x5F,0x1D,0xC8,0x2D,0xC2,0x43, |
||
9885 | 0x3D,0x8B,0xC7,0x04,0x76,0xDA,0x02,0x36, |
||
9886 | 0xFF,0xFF,0xE3,0x29,0xB0,0x98,0xF7,0xD3, |
||
9887 | 0x69,0x84,0x63,0x03,0xFB,0x71,0x0B,0x38, |
||
9888 | 0x1D,0xCC,0xE0,0xDC,0x7F,0xD8,0x2D,0x1A, |
||
9889 | 0x37,0x34,0xB0,0x0D,0xCC,0x43,0x03,0x3E, |
||
9890 | 0x27,0x47,0x30,0x9E,0x98,0xF8,0x55,0xE2, |
||
9891 | 0xE1,0x89,0x1F,0x43,0xC0,0xFA,0xFF,0x3F, |
||
9892 | 0x99,0x01,0xF6,0x84,0x1E,0xCB,0x50,0xD2, |
||
9893 | 0x4E,0x66,0x80,0xC0,0xFB,0xD8,0x3B,0xC3, |
||
9894 | 0x4B,0x83,0xE7,0x74,0xD2,0xCF,0x62,0x3E, |
||
9895 | 0x99,0x19,0x21,0x0A,0xBB,0x8F,0x19,0xAD, |
||
9896 | 0x37,0x14,0xCD,0x3C,0xE8,0x3B,0x99,0x51, |
||
9897 | 0x62,0x46,0x6A,0x0E,0x4C,0x48,0x11,0x0F, |
||
9898 | 0x27,0x4A,0x88,0x60,0xAF,0x13,0x6F,0x67, |
||
9899 | 0x4F,0x66,0x4C,0xD6,0xC9,0x0C,0x24,0xFF, |
||
9900 | 0xFF,0x93,0x19,0x98,0x5C,0x9F,0xCC,0x80, |
||
9901 | 0xCA,0x39,0x0A,0x7F,0x32,0x03,0x78,0x74, |
||
9902 | 0xC0,0xC2,0x9D,0xCC,0xC0,0xF2,0xFF,0x3F, |
||
9903 | 0xC4,0x00,0xCE,0xC7,0x0A,0x63,0x0C,0x3C, |
||
9904 | 0xDA,0xC1,0x0C,0x15,0xE6,0x6C,0x86,0x0E, |
||
9905 | 0x72,0x08,0xA1,0xC1,0x0E,0x21,0x50,0xE6, |
||
9906 | 0x72,0xA0,0xA7,0xF0,0x9A,0xE0,0x73,0x14, |
||
9907 | 0xD8,0x0F,0x67,0xC0,0xE1,0xD4,0x80,0x0F, |
||
9908 | 0x74,0xE2,0x42,0x8F,0xC2,0x23,0x0E,0x58, |
||
9909 | 0xFD,0xC0,0xC8,0xFF,0xFF,0x64,0x06,0x18, |
||
9910 | 0x78,0x6A,0xF8,0x40,0x82,0x63,0x31,0xEA, |
||
9911 | 0x1B,0xC4,0x21,0xBE,0x8D,0xF8,0xE8,0xFE, |
||
9912 | 0x6A,0xE2,0x4B,0x00,0xE6,0x42,0xE2,0xD3, |
||
9913 | 0x09,0xB3,0x70,0x38,0x03,0x5A,0x43,0x60, |
||
9914 | 0x57,0x26,0xCF,0x9C,0x0F,0xE1,0x6C,0x3C, |
||
9915 | 0x7A,0xDC,0xE9,0x04,0xDE,0x38,0x7C,0x3A, |
||
9916 | 0x01,0x5E,0x07,0x0C,0xCC,0x0C,0xC2,0x3F, |
||
9917 | 0x84,0xB0,0x21,0x9C,0xAA,0xC7,0x70,0xEE, |
||
9918 | 0xAF,0x38,0x3E,0x9D,0x80,0xF3,0xFF,0x7F, |
||
9919 | 0x62,0x03,0x0C,0x0A,0x7E,0x32,0xF8,0xB8, |
||
9920 | 0x46,0x25,0xC2,0xA0,0x8E,0xE6,0x80,0x7B, |
||
9921 | 0x98,0x27,0x36,0x26,0x6F,0xC5,0x1A,0x8B, |
||
9922 | 0x4F,0x6C,0x30,0xFF,0xFF,0x27,0x36,0x80, |
||
9923 | 0xD1,0x87,0x20,0xB0,0xFD,0xFF,0x0F,0x41, |
||
9924 | 0x60,0x1C,0xA0,0x0F,0x41,0x80,0x9B,0xD3, |
||
9925 | 0x09,0xEE,0xC4,0x07,0xB6,0x63,0x10,0x60, |
||
9926 | 0x6D,0xE8,0x3E,0x06,0x81,0xF9,0xFF,0x3F, |
||
9927 | 0x5A,0x98,0xA3,0xE0,0xC2,0x8E,0x7C,0x28, |
||
9928 | 0x29,0xA7,0x3E,0xB4,0x0C,0x20,0x69,0x38, |
||
9929 | 0xC9,0x01,0x9D,0xD3,0x3D,0x70,0x92,0x75, |
||
9930 | 0xEA,0x40,0x8F,0xC7,0xA0,0xAF,0x1C,0xBE, |
||
9931 | 0x12,0xF0,0x23,0x07,0x93,0x00,0xAA,0x41, |
||
9932 | 0xFA,0xCC,0x07,0x9C,0x8E,0x1C,0xE0,0x38, |
||
9933 | 0x26,0x05,0xC6,0xDE,0x0E,0xDE,0x22,0x3D, |
||
9934 | 0x89,0xA7,0xA1,0xE3,0x0C,0x51,0x38,0x26, |
||
9935 | 0x39,0x18,0x44,0x7A,0x95,0x62,0x03,0x7C, |
||
9936 | 0xAB,0xF1,0xD9,0xC8,0x07,0x10,0x78,0xE3, |
||
9937 | 0xF6,0xD8,0x61,0xFF,0xFF,0x0F,0x75,0xC0, |
||
9938 | 0x01,0xE2,0xA4,0xF8,0x21,0xC3,0x98,0x67, |
||
9939 | 0xC5,0x0F,0x75,0x80,0xF5,0x18,0x27,0x3A, |
||
9940 | 0x94,0xF0,0x43,0x1D,0x20,0xE8,0xFF,0x7F, |
||
9941 | 0xA8,0x03,0x86,0x38,0x6F,0x24,0xD1,0x1E, |
||
9942 | 0xEA,0x98,0xE8,0x43,0x1D,0x40,0xC8,0xFF, |
||
9943 | 0xFF,0xA1,0x0E,0x18,0x9E,0x87,0x00,0xAE, |
||
9944 | 0x9C,0xEF,0xC0,0x7C,0x22,0x02,0xEF,0xFF, |
||
9945 | 0xFF,0x7C,0x07,0xB8,0x1B,0x2D,0xCC,0x51, |
||
9946 | 0x70,0x41,0xAF,0x0E,0x03,0x51,0x09,0x30, |
||
9947 | 0x28,0x02,0xC7,0x5F,0x9B,0x60,0x1C,0xEA, |
||
9948 | 0x7C,0x87,0x3E,0x2F,0x78,0xD8,0x4F,0x05, |
||
9949 | 0x9E,0xC4,0xA9,0xFA,0x5A,0x70,0x14,0x4F, |
||
9950 | 0x00,0x3E,0xE1,0x01,0xFF,0xA1,0xC1,0x9A, |
||
9951 | 0x44,0xF1,0x43,0x03,0xF5,0x11,0xE4,0xFF, |
||
9952 | 0x7F,0x68,0xC0,0x28,0xEA,0xF9,0x06,0x7D, |
||
9953 | 0xCC,0xF2,0xD9,0x20,0xE6,0x0B,0x48,0x84, |
||
9954 | 0x07,0x10,0x5F,0x1F,0xD8,0x71,0xD2,0x67, |
||
9955 | 0xA0,0x40,0x51,0xDE,0x37,0xF8,0x09,0x07, |
||
9956 | 0x5C,0x83,0xF3,0x09,0x07,0xBC,0x87,0x23, |
||
9957 | 0x1F,0x4B,0xC0,0x77,0xD0,0x84,0x73,0x81, |
||
9958 | 0xF1,0x8D,0x8D,0x9D,0x06,0xC0,0x76,0x00, |
||
9959 | 0x06,0xDF,0x69,0x00,0x1C,0xC7,0x24,0x7E, |
||
9960 | 0x3A,0x04,0x13,0xCC,0xC1,0xBC,0x34,0xFB, |
||
9961 | 0xFF,0xEF,0xFD,0x94,0x43,0xCF,0x86,0x80, |
||
9962 | 0x75,0x49,0x07,0x43,0x94,0x88,0xB3,0x21, |
||
9963 | 0x20,0xFD,0xFF,0x7F,0x36,0xC4,0x20,0xC4, |
||
9964 | 0x09,0xFC,0x12,0xD1,0xDC,0xD9,0x90,0xAE, |
||
9965 | 0xD8,0x67,0x43,0x80,0xE1,0xFF,0xFF,0x23, |
||
9966 | 0x00,0xF6,0x7C,0x04,0x38,0x3D,0x64,0x83, |
||
9967 | 0xE7,0x14,0x08,0xE3,0xE4,0x03,0x38,0xFE, |
||
9968 | 0xFF,0x8F,0x15,0xE6,0x18,0x78,0xEA,0x97, |
||
9969 | 0x9B,0x8F,0x03,0x54,0xD4,0x2B,0xC2,0x30, |
||
9970 | 0x94,0xC5,0x87,0x05,0x1F,0x11,0xF8,0x61, |
||
9971 | 0xC1,0x23,0xA8,0x78,0x9C,0xF4,0x74,0xE3, |
||
9972 | 0x33,0x21,0x3B,0x24,0x38,0xFC,0x20,0xE9, |
||
9973 | 0x41,0x13,0x3C,0xE7,0x23,0x78,0xB7,0x1E, |
||
9974 | 0x38,0xA7,0x02,0xC0,0x4D,0xAE,0x27,0xA3, |
||
9975 | 0x4E,0x17,0x0E,0x70,0x8E,0x92,0x8D,0x63, |
||
9976 | 0x08,0xE5,0x70,0xCC,0xB7,0x87,0xA6,0xC9, |
||
9977 | 0x4E,0x56,0x30,0x63,0x41,0xEA,0x24,0xE0, |
||
9978 | 0x01,0x38,0x10,0x8C,0xB4,0x93,0x68,0x34, |
||
9979 | 0x86,0xB3,0x5A,0x18,0xC1,0x19,0xC4,0xC7, |
||
9980 | 0x11,0xE7,0x3A,0x19,0xA1,0x3F,0x07,0x3E, |
||
9981 | 0x15,0x61,0x82,0xDC,0x4B,0xE8,0xBC,0x7D, |
||
9982 | 0x37,0xE0,0x57,0x61,0x8F,0xC5,0xFF,0x7F, |
||
9983 | 0x60,0xDF,0x4E,0xC0,0x31,0x17,0xAB,0x01, |
||
9984 | 0x45,0x0D,0xC0,0x68,0x98,0x53,0xC0,0x53, |
||
9985 | 0x09,0xB8,0x82,0xCD,0x0D,0x7D,0x61,0xB1, |
||
9986 | 0xD6,0xA9,0xE8,0x14,0xF4,0x3E,0x70,0x70, |
||
9987 | 0xC0,0x63,0xF6,0x1E,0x1C,0x2C,0x34,0x0F, |
||
9988 | 0x0E,0x6C,0xD9,0x06,0x87,0x56,0x72,0x17, |
||
9989 | 0x21,0x87,0x0F,0xFC,0xEC,0x80,0x03,0xA0, |
||
9990 | 0x67,0x07,0x0B,0xC9,0xB3,0x03,0x9B,0xBE, |
||
9991 | 0xB3,0x08,0x28,0x70,0xFE,0xFF,0x11,0xDE, |
||
9992 | 0x3B,0x7C,0x6E,0x79,0xF6,0x60,0x63,0x78, |
||
9993 | 0x74,0x31,0x9A,0xD1,0xB9,0xA6,0xDB,0x04, |
||
9994 | 0x4A,0xC5,0x6D,0x82,0x82,0xF8,0x06,0xE0, |
||
9995 | 0x84,0x34,0xBA,0x75,0xE2,0x66,0x62,0xFC, |
||
9996 | 0x47,0x0C,0x1F,0x11,0x0E,0xE9,0x6C,0x4D, |
||
9997 | 0x30,0x0F,0xA4,0x9E,0x81,0xBE,0xB3,0xE1, |
||
9998 | 0x67,0x1F,0xF2,0xC1,0xC5,0xD3,0xF0,0xF5, |
||
9999 | 0x86,0xDC,0x3B,0xE8,0xB4,0x7D,0x66,0xC0, |
||
10000 | 0x1C,0x74,0x7D,0x9D,0x7A,0x83,0x27,0x57, |
||
10001 | 0x09,0xEA,0xE1,0x02,0x42,0x2F,0x34,0xBE, |
||
10002 | 0xDC,0x25,0x78,0xE0,0xF4,0xE9,0xEE,0xBD, |
||
10003 | 0x84,0x9D,0xF1,0x12,0xBC,0xE0,0x25,0x98, |
||
10004 | 0x77,0x10,0xA8,0x51,0x79,0x10,0x98,0xAB, |
||
10005 | 0x3C,0xCB,0x37,0x06,0x54,0xB2,0x8B,0x16, |
||
10006 | 0x3D,0xC3,0xBC,0xC3,0xF8,0x92,0xE0,0xEB, |
||
10007 | 0x87,0xCF,0x2D,0x5E,0xC0,0xEB,0x16,0x0C, |
||
10008 | 0x82,0x67,0xA0,0x57,0x17,0xDF,0xD9,0x0D, |
||
10009 | 0xFC,0x2A,0xF0,0x46,0x13,0x22,0x98,0x61, |
||
10010 | 0x0F,0xFF,0xDD,0xDD,0xA8,0xBE,0xE9,0x18, |
||
10011 | 0xEB,0x75,0xC4,0x23,0xE5,0xC7,0x96,0x03, |
||
10012 | 0x8A,0xF4,0xF2,0xE6,0x09,0xF8,0x2C,0xE3, |
||
10013 | 0x53,0xDD,0x49,0xF9,0x7A,0x68,0xF4,0x57, |
||
10014 | 0x08,0x1F,0x7E,0x8C,0xEC,0x73,0x0E,0x3B, |
||
10015 | 0xDF,0xB1,0x41,0x71,0xC4,0x07,0x86,0x97, |
||
10016 | 0x1A,0x4F,0x85,0x9D,0xBB,0x60,0x1C,0x1C, |
||
10017 | 0xD8,0xB1,0x08,0x73,0x7C,0x05,0xD7,0xC9, |
||
10018 | 0xE6,0xFF,0xFF,0xE4,0x00,0x6E,0x78,0xCC, |
||
10019 | 0xC1,0xD7,0xE7,0x0D,0xDF,0x0C,0x3C,0x2E, |
||
10020 | 0x7E,0xE4,0xF0,0x49,0xE3,0xA5,0xD3,0xD8, |
||
10021 | 0xA7,0xE9,0xA3,0xD1,0xCB,0x9B,0x4F,0x2F, |
||
10022 | 0x18,0x58,0x5F,0x1A,0x38,0xAC,0xD1,0xC2, |
||
10023 | 0x3E,0x06,0x9C,0xB9,0x2F,0x44,0xB8,0xC3, |
||
10024 | 0x23,0x58,0x00,0xF1,0xB7,0x92,0x47,0x0E, |
||
10025 | 0x4F,0xC0,0x80,0x4C,0xD3,0xBA,0x74,0x20, |
||
10026 | 0xE2,0xA7,0x3C,0x2B,0x5F,0x99,0x2E,0x43, |
||
10027 | 0x0C,0xE3,0xA9,0xF2,0xF1,0xC3,0xB3,0xF1, |
||
10028 | 0x51,0xC0,0xC7,0x28,0xCF,0xFC,0x8C,0x22, |
||
10029 | 0xBD,0x32,0x10,0x50,0x9D,0x88,0xB8,0x42, |
||
10030 | 0x18,0x89,0xA1,0xD1,0x9D,0x83,0xC7,0x1F, |
||
10031 | 0x22,0x05,0x31,0xA0,0x6F,0x2E,0xC0,0xF4, |
||
10032 | 0x4C,0x04,0x5C,0xFE,0xFF,0x37,0x17,0x80, |
||
10033 | 0xFF,0xFF,0xFF,0x9B,0x0B,0xE0,0xE6,0xFE, |
||
10034 | 0xE0,0x9B,0x0B,0x70,0x8D,0xB4,0x2A,0x7A, |
||
10035 | 0x61,0x77,0x08,0x18,0xD4,0x9D,0x1D,0x70, |
||
10036 | 0x78,0x2B,0x78,0x67,0x87,0xF5,0xFF,0xBF, |
||
10037 | 0xB3,0xC3,0xC3,0x8C,0x13,0xE5,0x85,0x21, |
||
10038 | 0xC6,0x3B,0x3B,0x0B,0xF0,0x26,0xD0,0x51, |
||
10039 | 0xC6,0x77,0x76,0x80,0x1F,0x67,0xD8,0x77, |
||
10040 | 0x69,0xF0,0x5E,0x75,0x81,0xF5,0xFF,0xFF, |
||
10041 | 0xAA,0x0B,0x3C,0x04,0xDF,0xA7,0x41,0x3E, |
||
10042 | 0x5E,0x30,0x8C,0x83,0x2B,0x27,0xA1,0xC7, |
||
10043 | 0x02,0x6B,0x85,0x41,0xDD,0xA9,0xC1,0xA5, |
||
10044 | 0x09,0x5C,0x17,0x5F,0x1F,0x6A,0x7C,0xA4, |
||
10045 | 0xC5,0x9F,0x2F,0x70,0x01,0x86,0x4C,0x4F, |
||
10046 | 0x65,0x30,0xAE,0x29,0x3E,0x95,0x61,0xEE, |
||
10047 | 0x0E,0x1E,0x90,0x8F,0x18,0xC0,0x67,0x15, |
||
10048 | 0x1E,0x18,0xEE,0xB4,0xE0,0x9B,0x92,0x41, |
||
10049 | 0xCF,0x31,0xA8,0x8F,0x3C,0x27,0xEF,0x7B, |
||
10050 | 0xC2,0xE3,0x84,0xA3,0x9E,0x83,0xE8,0xD8, |
||
10051 | 0xC0,0x71,0xDC,0xC0,0xFD,0xFF,0xC7,0x06, |
||
10052 | 0xEF,0x70,0x83,0x3B,0xE8,0xF8,0x62,0x70, |
||
10053 | 0x5C,0x18,0xB8,0xE7,0x02,0x0F,0xC3,0x37, |
||
10054 | 0x1D,0x8F,0x08,0x33,0xFE,0xD7,0x3F,0x23, |
||
10055 | 0x04,0xC4,0x5F,0x8C,0xD8,0x80,0xC1,0x78, |
||
10056 | 0x6B,0xF3,0xF5,0x0D,0x37,0x60,0x5F,0x1D, |
||
10057 | 0x7C,0xC1,0xF0,0x09,0xCC,0xE8,0x2F,0x30, |
||
10058 | 0x4F,0x62,0x3E,0x36,0x90,0x0B,0x1C,0x1D, |
||
10059 | 0x30,0x38,0x00,0x3D,0x60,0xF8,0x87,0x8B, |
||
10060 | 0x77,0x39,0x30,0x5C,0x05,0x7D,0x5C,0xF0, |
||
10061 | 0xB1,0xC7,0x8A,0xEE,0x72,0xE8,0x9B,0x9C, |
||
10062 | 0x61,0xE2,0x18,0xE2,0x0D,0x8C,0xDD,0x25, |
||
10063 | 0xC8,0x61,0x0E,0xEA,0x5D,0xC2,0x73,0xE0, |
||
10064 | 0x67,0x0B,0x9F,0xE0,0x7C,0xF3,0x09,0x71, |
||
10065 | 0xAA,0x8F,0x56,0xEF,0x01,0x3E,0x7A,0xBC, |
||
10066 | 0x77,0xF9,0xEC,0xC4,0x2E,0x02,0x3E,0x72, |
||
10067 | 0x19,0xC7,0xD3,0xF4,0x15,0xD0,0x43,0x36, |
||
10068 | 0xD8,0xAB,0x86,0x4F,0x60,0x3E,0xBA,0xE1, |
||
10069 | 0x8E,0x51,0x9E,0x89,0xA7,0xEF,0x3B,0x08, |
||
10070 | 0x3B,0x92,0x1C,0x75,0xA8,0x6B,0x7A,0x44, |
||
10071 | 0xF9,0xFF,0x9F,0xD0,0x81,0xF8,0xD6,0x06, |
||
10072 | 0xCE,0x68,0xF7,0x0F,0xF4,0x36,0x3D,0x32, |
||
10073 | 0xCC,0xD1,0x00,0xD6,0x25,0x04,0x5C,0x77, |
||
10074 | 0x0C,0x5F,0x42,0x80,0x4F,0xD0,0x4B,0x04, |
||
10075 | 0xFA,0x9A,0xE1,0xD1,0x3D,0x02,0x60,0xAE, |
||
10076 | 0x18,0xEC,0x58,0xE0,0xC3,0x86,0xAF,0x01, |
||
10077 | 0xEC,0x5E,0xE0,0x30,0xF7,0x08,0x50,0x81, |
||
10078 | 0x7A,0x78,0xF0,0xD5,0xDE,0x23,0x40,0x71, |
||
10079 | 0xB2,0xF4,0xA1,0xC1,0x03,0xB5,0xAA,0x33, |
||
10080 | 0x26,0x94,0x23,0x26,0x3F,0x9B,0xF9,0x26, |
||
10081 | 0x81,0xB9,0x5D,0xFA,0x26,0x01,0x37,0xCF, |
||
10082 | 0x2C,0x50,0x49,0x20,0xF4,0xFF,0xBF,0x49, |
||
10083 | 0xC0,0x85,0xE9,0xF2,0x32,0x43,0xE7,0x7F, |
||
10084 | 0xE0,0xBE,0xD5,0x79,0x84,0x3E,0x44,0x30, |
||
10085 | 0x94,0xF7,0x3C,0x9F,0xC2,0xF8,0x19,0xC2, |
||
10086 | 0x07,0x4C,0x76,0xA6,0xE0,0x67,0x4D,0xDC, |
||
10087 | 0x1D,0xC0,0x28,0x6F,0x9E,0x9E,0x00,0x3B, |
||
10088 | 0x7F,0x1A,0xF9,0xDD,0xE0,0x5D,0xC0,0xD3, |
||
10089 | 0xF7,0xBD,0x88,0x9F,0x28,0xC0,0x17,0xEC, |
||
10090 | 0x4E,0x07,0x05,0xFA,0x84,0x3C,0x22,0xA3, |
||
10091 | 0xFA,0x88,0xC0,0x2F,0x49,0x60,0x3C,0x92, |
||
10092 | 0xF8,0x40,0x01,0x84,0xEE,0x05,0xA8,0xD3, |
||
10093 | 0x07,0x47,0x3D,0xE3,0x17,0x54,0x63,0xBE, |
||
10094 | 0x5B,0x3D,0xC2,0x79,0x72,0x98,0xCB,0x01, |
||
10095 | 0x8B,0x73,0x4D,0x02,0xD5,0x71,0x97,0x8F, |
||
10096 | 0x0E,0xEE,0xB5,0x15,0xFB,0xFF,0x27,0x38, |
||
10097 | 0xB8,0x77,0x96,0x77,0x3E,0x43,0x79,0x90, |
||
10098 | 0xE0,0xBB,0xB6,0x82,0xE3,0xAA,0x06,0xE3, |
||
10099 | 0xD8,0xC2,0x2F,0x79,0x80,0x9D,0x61,0x71, |
||
10100 | 0xC1,0x7F,0x0F,0x03,0x51,0x89,0x30,0x28, |
||
10101 | 0x02,0xCB,0xBB,0xB7,0x52,0xF8,0x43,0x06, |
||
10102 | 0xE3,0x4D,0x81,0x4F,0x1A,0x3B,0x6A,0xE0, |
||
10103 | 0xFB,0xFF,0x1F,0x35,0xD8,0x86,0x8A,0xBB, |
||
10104 | 0x29,0x82,0x75,0xAA,0x98,0x21,0xF0,0x60, |
||
10105 | 0x0F,0x00,0x9F,0xAF,0x7C,0x06,0x50,0x14, |
||
10106 | 0x18,0xD4,0xA1,0x1D,0xCE,0x6D,0x18,0x70, |
||
10107 | 0x30,0x62,0xDC,0xA5,0x10,0xEE,0x94,0xDF, |
||
10108 | 0x51,0x62,0x3F,0x97,0xB3,0xE9,0xE2,0xAE, |
||
10109 | 0xE6,0x3E,0x9D,0xB0,0x0B,0x32,0x8C,0xB3, |
||
10110 | 0xC0,0x23,0xC0,0xAB,0x39,0xBF,0x20,0x3F, |
||
10111 | 0x17,0xBF,0x10,0x3C,0x26,0x85,0x78,0x53, |
||
10112 | 0x7A,0x25,0x36,0xC6,0x93,0x71,0x73,0xB7, |
||
10113 | 0x62,0x72,0xDE,0x79,0x41,0x36,0xC6,0xD1, |
||
10114 | 0x44,0x8C,0x72,0x6E,0x0F,0x03,0x91,0x5F, |
||
10115 | 0x90,0x7D,0x3F,0x79,0x21,0x88,0x18,0xCD, |
||
10116 | 0x10,0x41,0x9F,0x97,0x8D,0x15,0x28,0xDE, |
||
10117 | 0x0B,0x32,0x13,0xF8,0x56,0xD0,0xC1,0xC5, |
||
10118 | 0x17,0x64,0xEC,0xFF,0xFF,0x82,0x0C,0x30, |
||
10119 | 0xE2,0x64,0x04,0xF8,0x3C,0x71,0xE0,0xCE, |
||
10120 | 0x35,0x30,0xFE,0xFF,0x97,0x6A,0xD8,0x27, |
||
10121 | 0x1B,0xC0,0xD9,0xD0,0x7D,0xB2,0x01,0xF7, |
||
10122 | 0x68,0xE1,0x1D,0x4D,0x10,0x27,0x1B,0x0A, |
||
10123 | 0xE4,0xE0,0xEB,0xA2,0x70,0x3C,0xF4,0x49, |
||
10124 | 0x84,0x1E,0x9D,0x7C,0x94,0xC4,0x9D,0x19, |
||
10125 | 0x3C,0x91,0x77,0x16,0x8F,0xE2,0x65,0xD0, |
||
10126 | 0xF7,0x82,0x13,0x79,0x7D,0xB0,0x9C,0x63, |
||
10127 | 0x24,0xA8,0x46,0xE2,0xE3,0x03,0xFC,0xEB, |
||
10128 | 0x8B,0x8F,0x91,0xF0,0xF9,0xFC,0xC3,0xF2, |
||
10129 | 0x60,0x0C,0xF9,0xFF,0x7F,0x8A,0xC4,0x80, |
||
10130 | 0x3C,0xBB,0x3C,0x86,0xF0,0x0B,0x24,0xDC, |
||
10131 | 0xD3,0xCC,0x01,0x60,0x64,0x5D,0x1E,0xD1, |
||
10132 | 0x67,0x47,0x8E,0x11,0xD7,0x17,0x45,0x5F, |
||
10133 | 0x81,0x7D,0x10,0x38,0x9F,0xE7,0x44,0xB0, |
||
10134 | 0x8E,0x9A,0x1F,0x6D,0xF8,0xF8,0x39,0xF8, |
||
10135 | 0x5B,0xC1,0x03,0xA5,0x8F,0x45,0x21,0x1E, |
||
10136 | 0x91,0xF8,0x39,0x11,0x5C,0x26,0xCE,0x89, |
||
10137 | 0x40,0xE2,0xD0,0x0B,0xE3,0xB4,0x80,0x1B, |
||
10138 | 0x88,0xCF,0x94,0xD8,0x29,0x9F,0x08,0x3B, |
||
10139 | 0x97,0x60,0x46,0x07,0xAE,0xCB,0xBD,0x47, |
||
10140 | 0x07,0xFE,0x93,0x00,0x1E,0xEB,0xFF,0xFF, |
||
10141 | 0x78,0x07,0xBE,0x93,0xBA,0xEF,0x26,0xBE, |
||
10142 | 0xC8,0xF8,0x50,0xF4,0x7C,0x07,0xF8,0x0F, |
||
10143 | 0x77,0xB8,0x43,0xC5,0x39,0xDF,0x01,0xD2, |
||
10144 | 0xFE,0xFF,0xE7,0x3B,0x60,0x79,0xB6,0x7E, |
||
10145 | 0xBE,0x03,0xBB,0xC8,0xF3,0x1D,0x40,0xAC, |
||
10146 | 0xFF,0xFF,0xF9,0x0E,0xB0,0x73,0x46,0xC3, |
||
10147 | 0x9D,0xEF,0xC0,0x76,0xB4,0x01,0xCC,0x4D, |
||
10148 | 0xE3,0xD1,0x06,0xDC,0xC3,0x85,0x3D,0x0C, |
||
10149 | 0xAE,0xD0,0xA6,0x4F,0x8D,0x46,0xAD,0x1A, |
||
10150 | 0x94,0xA9,0x51,0xE6,0xFF,0xDF,0xA0,0x56, |
||
10151 | 0x9F,0x4A,0x8D,0x19,0xCB,0x0E,0xA5,0x80, |
||
10152 | 0x8F,0x0A,0x8D,0xCD,0xF2,0x28,0x04,0x62, |
||
10153 | 0x31,0xAF,0x06,0x81,0x38,0x2C,0x08,0x8D, |
||
10154 | 0xF4,0xCA,0x11,0x88,0x25,0x3F,0xFB,0x05, |
||
10155 | 0x62,0xB9,0x6F,0x06,0x81,0x38,0xE0,0x1B, |
||
10156 | 0x4C,0xE0,0xE4,0x61,0x25,0x70,0xF2,0x6E, |
||
10157 | 0x10,0x88,0x23,0x83,0x50,0xA1,0x3A,0x40, |
||
10158 | 0x58,0x4C,0x10,0x1A,0xCA,0x07,0x08,0x93, |
||
10159 | 0xFE,0x48,0x10,0x20,0x31,0x02,0xC2,0xC2, |
||
10160 | 0xBD,0xBF,0x04,0x62,0x69,0xEF,0x09,0x81, |
||
10161 | 0x58,0x88,0x15,0x10,0x16,0x17,0x84,0x86, |
||
10162 | 0xD3,0x02,0xC2,0x24,0x99,0x01,0x61,0x81, |
||
10163 | 0x40,0xA8,0x7C,0x35,0x20,0x4C,0xA4,0x1B, |
||
10164 | 0x40,0xBA,0x7A,0x81,0x38,0x88,0x1E,0x10, |
||
10165 | 0x26,0xC3,0x0F,0x08,0x0B,0x0D,0x42,0xA3, |
||
10166 | 0x3D,0x30,0x04,0x48,0x0C,0x81,0xB0,0xF8, |
||
10167 | 0x8E,0x40,0x98,0xF8,0x57,0x91,0x40,0x9C, |
||
10168 | 0xDF,0x12,0xC4,0x4D,0x69,0x88,0x35,0x01, |
||
10169 | 0x31,0x0D,0x9E,0x80,0x98,0x22,0x10,0x01, |
||
10170 | 0x39,0xF6,0xD3,0x43,0x40,0xD6,0x60,0x0A, |
||
10171 | 0x88,0x45,0x07,0x11,0x90,0x85,0xA8,0x02, |
||
10172 | 0x62,0x79,0x5D,0x01,0xB1,0xF0,0x20,0x02, |
||
10173 | 0x72,0xE6,0x97,0x9F,0x80,0xAC,0xE0,0xA5, |
||
10174 | 0xF3,0x10,0xC0,0xDE,0x10,0x81,0x48,0x72, |
||
10175 | 0x10,0x01,0x39,0xB0,0x2F,0x20,0x16,0x1F, |
||
10176 | 0x44,0x40,0xCE,0xFA,0x28,0x14,0x90,0x83, |
||
10177 | 0x83,0x68,0x10,0xE4,0x6B,0x26,0x20,0xA7, |
||
10178 | 0x07,0x11,0x10,0xF9,0x04,0x05,0x21,0x6A, |
||
10179 | 0xBD,0x81,0x30,0x3D,0x8F,0x42,0x0D,0x85, |
||
10180 | 0x80,0x50,0xE5,0xEA,0xCE,0x31,0x2C,0x07, |
||
10181 | 0x08,0xCD,0x05,0x22,0x30,0xAB,0x70,0x07, |
||
10182 | 0xC4,0x54,0x81,0x08,0xC8,0x09,0x80,0xC8, |
||
10183 | 0xFF,0x9F,0x60,0x2A,0x10,0x9A,0x12,0x8C, |
||
10184 | 0xEA,0x92,0x07,0xC4,0x12,0x80,0xD0,0x54, |
||
10185 | 0x20,0x34,0x25,0x88,0x00,0xAD,0xCA,0x1E, |
||
10186 | 0x10,0x53,0x0A,0x42,0x95,0x83,0xD0,0x74, |
||
10187 | 0x20,0x54,0xB6,0xBE,0xC3,0x02,0x05,0x11, |
||
10188 | 0x90,0xA3,0x83,0x50,0xE1,0xFE,0x40,0x98, |
||
10189 | 0xDE,0x97,0x86,0x00,0x9D,0x0E,0x44,0x40, |
||
10190 | 0x4E,0x0C,0x42,0x15,0x7C,0x32,0x82,0x10, |
||
10191 | 0xB1,0x20,0x54,0xC1,0x27,0x23,0x28,0xD1, |
||
10192 | 0xF2,0xB2,0x13,0x90,0xF5,0x81,0x50,0xBD, |
||
10193 | 0x20,0x02,0x73,0x36,0x20,0x9A,0x17,0x84, |
||
10194 | 0xE6,0x07,0xA3,0x5A,0x8D,0x02,0x31,0xFD, |
||
10195 | 0x20,0x34,0x0F,0x88,0xC0,0xAC,0xE0,0xF9, |
||
10196 | 0x71,0xC0,0x0C,0x84,0xAA,0x04,0x11,0x98, |
||
10197 | 0x73,0x01,0xD1,0xAC,0x20,0x34,0x3B,0x18, |
||
10198 | 0xD5,0xFE,0x0F,0xD1,0x00,0x08,0x08,0xCD, |
||
10199 | 0x07,0xA2,0xC3,0x00,0x79,0x96,0x09,0xC8, |
||
10200 | 0x1A,0x41,0xA8,0x66,0x10,0x81,0x39,0x27, |
||
10201 | 0x10,0xCD,0x0E,0x42,0x95,0xFD,0x4D,0x82, |
||
10202 | 0x91,0x8C,0x0F,0xD0,0x40,0x24,0x37,0x08, |
||
10203 | 0xD5,0xF1,0x0C,0x0A,0x46,0x74,0x83,0x08, |
||
10204 | 0xC8,0x59,0x40,0x68,0x36,0x30,0x9A,0x4C, |
||
10205 | 0xED,0x91,0x80,0xBA,0x05,0x61,0xE9,0x41, |
||
10206 | 0x68,0x3A,0xBB,0x83,0xA7,0x20,0x54,0x81, |
||
10207 | 0x5E,0x30,0xA6,0x19,0x44,0x87,0x05,0x02, |
||
10208 | 0x42,0x73,0x81,0x51,0x1D,0xAF,0x96,0x40, |
||
10209 | 0x44,0x1B,0x08,0xD5,0x0A,0xA2,0x81,0x93, |
||
10210 | 0x1F,0x53,0x10,0x92,0x14,0x84,0xFC,0xFF, |
||
10211 | 0x07,0xAA,0xC7,0x9C,0x40,0xAC,0xFA,0x5B, |
||
10212 | 0x25,0x50,0x27,0x01,0xA1,0xC9,0x40,0x74, |
||
10213 | 0x7C,0x20,0x0F,0xB8,0x83,0x64,0x20,0x54, |
||
10214 | 0x29,0x88,0xC0,0xAC,0xF4,0x63,0xA4,0x23, |
||
10215 | 0x05,0x51,0x7D,0xBC,0xA0,0x20,0x34,0xD1, |
||
10216 | 0x3B,0x2C,0x08,0x7B,0xB8,0x69,0xA8,0xE4, |
||
10217 | 0x59,0xA5,0xA1,0x12,0x10,0x9A,0x0D,0x44, |
||
10218 | 0xC7,0x04,0xF2,0xAA,0x79,0x4C,0x60,0x20, |
||
10219 | 0x54,0x2F,0x08,0xCD,0x01,0x42,0x13,0x83, |
||
10220 | 0x08,0xD4,0xA9,0xBF,0x37,0x1A,0x2A,0xF9, |
||
10221 | 0x5B,0x09,0xC4,0xCA,0x5E,0x69,0x02,0xB1, |
||
10222 | 0xDE,0xA7,0x4E,0x20,0xE6,0x1D,0x98,0xA9, |
||
10223 | 0x05,0xA1,0xEA,0x41,0x04,0xE6,0xB4,0x40, |
||
10224 | 0x54,0x81,0x78,0x10,0xA6,0x08,0x44,0x60, |
||
10225 | 0x4E,0x02,0x44,0xD3,0x81,0xD0,0xEC,0x60, |
||
10226 | 0x54,0xE7,0xA3,0x4D,0x40,0xD6,0x0E,0x42, |
||
10227 | 0xB3,0x80,0x08,0xCC,0x59,0x1E,0x69,0x02, |
||
10228 | 0xB1,0x92,0x2F,0x9D,0x0E,0x24,0x04,0x84, |
||
10229 | 0x26,0xD3,0x7F,0x68,0xA1,0x05,0x80,0x99, |
||
10230 | 0x84,0x04,0x20,0x4C,0x16,0x88,0x0E,0x27, |
||
10231 | 0xD6,0x08,0x22,0x40,0xC7,0x01,0xA3,0xD1, |
||
10232 | 0x40,0x68,0x5C,0x40,0x9A,0x1D,0x90,0x2A, |
||
10233 | 0x6D,0x00,0xC6,0x54,0x83,0xD0,0x24,0x20, |
||
10234 | 0x02,0x74,0x2C,0x10,0x01,0x5A,0x74,0x04, |
||
10235 | 0x30,0x16,0x01,0x84,0x46,0x05,0xA1,0xC9, |
||
10236 | 0x2A,0x80,0xB2,0x9C,0x20,0x1A,0x20,0xC9, |
||
10237 | 0x30,0x60,0x0A,0x42,0x33,0x81,0xD0,0x8C, |
||
10238 | 0x20,0x54,0x7C,0x07,0x10,0x16,0x04,0x84, |
||
10239 | 0x86,0x03,0xD1,0x00,0xFE,0xFF,0x8F,0x0C, |
||
10240 | 0x02,0xD1,0x00,0x9C,0x23,0xC4,0x61,0x85, |
||
10241 | 0x82,0xD0,0xF4,0x20,0x34,0x6C,0x09,0x50, |
||
10242 | 0x16,0x1D,0x44,0xC7,0x23,0x92,0x02,0x8C, |
||
10243 | 0x05,0x02,0xA1,0x31,0x41,0x68,0x6C,0x10, |
||
10244 | 0x1A,0x29,0x06,0x28,0x13,0x54,0xE3,0x50, |
||
10245 | 0x44,0x7B,0x80,0x31,0x99,0x20,0x54,0x36, |
||
10246 | 0x88,0xC0,0x1C,0x14,0x88,0x86,0x07,0xA1, |
||
10247 | 0x62,0x82,0x00,0x52,0x10,0x01,0x12,0x20, |
||
10248 | 0x1A,0x1E,0x84,0x8A,0x29,0x32,0x74,0x0A, |
||
10249 | 0x42,0x55,0x24,0x39,0x9A,0x50,0x10,0x1D, |
||
10250 | 0x4D,0x08,0x08,0xCD,0x07,0x46,0x75,0x35, |
||
10251 | 0x39,0x6E,0x50,0x10,0xAA,0x1D,0x84,0x06, |
||
10252 | 0x05,0xA1,0x39,0xA2,0x80,0xB2,0xEC,0x20, |
||
10253 | 0x02,0xB2,0x9E,0x2A,0x87,0x0A,0x0A,0x22, |
||
10254 | 0x30,0xA7,0x02,0xA2,0x49,0x41,0xA8,0x8E, |
||
10255 | 0x2C,0x47,0x0A,0x9A,0x06,0x84,0x25,0x06, |
||
10256 | 0xA1,0xC9,0xDA,0x80,0xB0,0x0C,0x75,0x0E, |
||
10257 | 0x24,0x14,0x84,0xE6,0x04,0xA1,0x4A,0xF2, |
||
10258 | 0x0C,0x8F,0x82,0xE8,0x38,0x42,0x80,0x68, |
||
10259 | 0x7A,0x10,0xAA,0xA6,0xCF,0x00,0x28,0x88, |
||
10260 | 0x06,0x40,0x40,0x68,0x4E,0x30,0xAA,0xA8, |
||
10261 | 0xD1,0xD1,0x84,0x82,0x50,0xDD,0x2F,0x4E, |
||
10262 | 0x81,0xF8,0xFF,0x0F, |
||
10263 | }) // END MBUF |
||
10264 | |||
10265 | } //end DefinitionBlock>>>> |
||
10266 |