Subversion Repositories Kolibri OS

Rev

Rev 1498 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1498 serge 1
/*******************************************************************************
2
 *
3
 * Module Name: dmopcode - AML disassembler, specific AML opcodes
4
 *
5
 ******************************************************************************/
6
 
7
/******************************************************************************
8
 *
9
 * 1. Copyright Notice
10
 *
2216 Serge 11
 * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
1498 serge 12
 * All rights reserved.
13
 *
14
 * 2. License
15
 *
16
 * 2.1. This is your license from Intel Corp. under its intellectual property
17
 * rights.  You may have additional license terms from the party that provided
18
 * you this software, covering your right to use that party's intellectual
19
 * property rights.
20
 *
21
 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22
 * copy of the source code appearing in this file ("Covered Code") an
23
 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24
 * base code distributed originally by Intel ("Original Intel Code") to copy,
25
 * make derivatives, distribute, use and display any portion of the Covered
26
 * Code in any form, with the right to sublicense such rights; and
27
 *
28
 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29
 * license (with the right to sublicense), under only those claims of Intel
30
 * patents that are infringed by the Original Intel Code, to make, use, sell,
31
 * offer to sell, and import the Covered Code and derivative works thereof
32
 * solely to the minimum extent necessary to exercise the above copyright
33
 * license, and in no event shall the patent license extend to any additions
34
 * to or modifications of the Original Intel Code.  No other license or right
35
 * is granted directly or by implication, estoppel or otherwise;
36
 *
37
 * The above copyright and patent license is granted only if the following
38
 * conditions are met:
39
 *
40
 * 3. Conditions
41
 *
42
 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43
 * Redistribution of source code of any substantial portion of the Covered
44
 * Code or modification with rights to further distribute source must include
45
 * the above Copyright Notice, the above License, this list of Conditions,
46
 * and the following Disclaimer and Export Compliance provision.  In addition,
47
 * Licensee must cause all Covered Code to which Licensee contributes to
48
 * contain a file documenting the changes Licensee made to create that Covered
49
 * Code and the date of any change.  Licensee must include in that file the
50
 * documentation of any changes made by any predecessor Licensee.  Licensee
51
 * must include a prominent statement that the modification is derived,
52
 * directly or indirectly, from Original Intel Code.
53
 *
54
 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55
 * Redistribution of source code of any substantial portion of the Covered
56
 * Code or modification without rights to further distribute source must
57
 * include the following Disclaimer and Export Compliance provision in the
58
 * documentation and/or other materials provided with distribution.  In
59
 * addition, Licensee may not authorize further sublicense of source of any
60
 * portion of the Covered Code, and must include terms to the effect that the
61
 * license from Licensee to its licensee is limited to the intellectual
62
 * property embodied in the software Licensee provides to its licensee, and
63
 * not to intellectual property embodied in modifications its licensee may
64
 * make.
65
 *
66
 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67
 * substantial portion of the Covered Code or modification must reproduce the
68
 * above Copyright Notice, and the following Disclaimer and Export Compliance
69
 * provision in the documentation and/or other materials provided with the
70
 * distribution.
71
 *
72
 * 3.4. Intel retains all right, title, and interest in and to the Original
73
 * Intel Code.
74
 *
75
 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76
 * Intel shall be used in advertising or otherwise to promote the sale, use or
77
 * other dealings in products derived from or relating to the Covered Code
78
 * without prior written authorization from Intel.
79
 *
80
 * 4. Disclaimer and Export Compliance
81
 *
82
 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83
 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84
 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
85
 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
86
 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
87
 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88
 * PARTICULAR PURPOSE.
89
 *
90
 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91
 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92
 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93
 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94
 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95
 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
96
 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97
 * LIMITED REMEDY.
98
 *
99
 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100
 * software or system incorporating such software without first obtaining any
101
 * required license or other approval from the U. S. Department of Commerce or
102
 * any other agency or department of the United States Government.  In the
103
 * event Licensee exports any such software from the United States or
104
 * re-exports any such software from a foreign destination, Licensee shall
105
 * ensure that the distribution and export/re-export of the software is in
106
 * compliance with all laws, regulations, orders, or other restrictions of the
107
 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108
 * any of its subsidiaries will export/re-export any technical data, process,
109
 * software, or service, directly or indirectly, to any country for which the
110
 * United States government or any agency thereof requires an export license,
111
 * other governmental approval, or letter of assurance, without first obtaining
112
 * such license, approval or letter.
113
 *
114
 *****************************************************************************/
115
 
116
#include "acpi.h"
117
#include "accommon.h"
118
#include "acparser.h"
119
#include "amlcode.h"
120
#include "acdisasm.h"
121
 
122
#ifdef ACPI_DISASSEMBLER
123
 
124
#define _COMPONENT          ACPI_CA_DEBUGGER
125
        ACPI_MODULE_NAME    ("dmopcode")
126
 
127
/* Local prototypes */
128
 
129
static void
130
AcpiDmMatchKeyword (
131
    ACPI_PARSE_OBJECT       *Op);
132
 
133
 
134
/*******************************************************************************
135
 *
136
 * FUNCTION:    AcpiDmMethodFlags
137
 *
138
 * PARAMETERS:  Op              - Method Object to be examined
139
 *
140
 * RETURN:      None
141
 *
142
 * DESCRIPTION: Decode control method flags
143
 *
144
 ******************************************************************************/
145
 
146
void
147
AcpiDmMethodFlags (
148
    ACPI_PARSE_OBJECT       *Op)
149
{
150
    UINT32                  Flags;
151
    UINT32                  Args;
152
 
153
 
154
    /* The next Op contains the flags */
155
 
156
    Op = AcpiPsGetDepthNext (NULL, Op);
157
    Flags = (UINT8) Op->Common.Value.Integer;
158
    Args = Flags & 0x07;
159
 
160
    /* Mark the Op as completed */
161
 
162
    Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
163
 
164
    /* 1) Method argument count */
165
 
166
    AcpiOsPrintf (", %u, ", Args);
167
 
168
    /* 2) Serialize rule */
169
 
170
    if (!(Flags & 0x08))
171
    {
172
        AcpiOsPrintf ("Not");
173
    }
174
 
175
    AcpiOsPrintf ("Serialized");
176
 
177
    /* 3) SyncLevel */
178
 
179
    if (Flags & 0xF0)
180
    {
181
        AcpiOsPrintf (", %u", Flags >> 4);
182
    }
183
}
184
 
185
 
186
/*******************************************************************************
187
 *
188
 * FUNCTION:    AcpiDmFieldFlags
189
 *
190
 * PARAMETERS:  Op              - Field Object to be examined
191
 *
192
 * RETURN:      None
193
 *
194
 * DESCRIPTION: Decode Field definition flags
195
 *
196
 ******************************************************************************/
197
 
198
void
199
AcpiDmFieldFlags (
200
    ACPI_PARSE_OBJECT       *Op)
201
{
202
    UINT32                  Flags;
203
 
204
 
205
    Op = Op->Common.Next;
206
    Flags = (UINT8) Op->Common.Value.Integer;
207
 
208
    /* Mark the Op as completed */
209
 
210
    Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
211
 
212
    AcpiOsPrintf ("%s, ", AcpiGbl_AccessTypes [Flags & 0x07]);
213
    AcpiOsPrintf ("%s, ", AcpiGbl_LockRule [(Flags & 0x10) >> 4]);
214
    AcpiOsPrintf ("%s)",  AcpiGbl_UpdateRules [(Flags & 0x60) >> 5]);
215
}
216
 
217
 
218
/*******************************************************************************
219
 *
220
 * FUNCTION:    AcpiDmAddressSpace
221
 *
222
 * PARAMETERS:  SpaceId         - ID to be translated
223
 *
224
 * RETURN:      None
225
 *
226
 * DESCRIPTION: Decode a SpaceId to an AddressSpaceKeyword
227
 *
228
 ******************************************************************************/
229
 
230
void
231
AcpiDmAddressSpace (
232
    UINT8                   SpaceId)
233
{
234
 
235
    if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS)
236
    {
237
        if (SpaceId == 0x7F)
238
        {
239
            AcpiOsPrintf ("FFixedHW, ");
240
        }
241
        else
242
        {
243
            AcpiOsPrintf ("0x%.2X, ", SpaceId);
244
        }
245
    }
246
    else
247
    {
248
        AcpiOsPrintf ("%s, ", AcpiGbl_RegionTypes [SpaceId]);
249
    }
250
}
251
 
252
 
253
/*******************************************************************************
254
 *
255
 * FUNCTION:    AcpiDmRegionFlags
256
 *
257
 * PARAMETERS:  Op              - Object to be examined
258
 *
259
 * RETURN:      None
260
 *
261
 * DESCRIPTION: Decode OperationRegion flags
262
 *
263
 ******************************************************************************/
264
 
265
void
266
AcpiDmRegionFlags (
267
    ACPI_PARSE_OBJECT       *Op)
268
{
269
 
270
 
271
    /* The next Op contains the SpaceId */
272
 
273
    Op = AcpiPsGetDepthNext (NULL, Op);
274
 
275
    /* Mark the Op as completed */
276
 
277
    Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
278
 
279
    AcpiOsPrintf (", ");
280
    AcpiDmAddressSpace ((UINT8) Op->Common.Value.Integer);
281
}
282
 
283
 
284
/*******************************************************************************
285
 *
286
 * FUNCTION:    AcpiDmMatchOp
287
 *
288
 * PARAMETERS:  Op              - Match Object to be examined
289
 *
290
 * RETURN:      None
291
 *
292
 * DESCRIPTION: Decode Match opcode operands
293
 *
294
 ******************************************************************************/
295
 
296
void
297
AcpiDmMatchOp (
298
    ACPI_PARSE_OBJECT       *Op)
299
{
300
    ACPI_PARSE_OBJECT       *NextOp;
301
 
302
 
303
    NextOp = AcpiPsGetDepthNext (NULL, Op);
304
    NextOp = NextOp->Common.Next;
305
 
306
    if (!NextOp)
307
    {
308
        /* Handle partial tree during single-step */
309
 
310
        return;
311
    }
312
 
313
    /* Mark the two nodes that contain the encoding for the match keywords */
314
 
315
    NextOp->Common.DisasmOpcode = ACPI_DASM_MATCHOP;
316
 
317
    NextOp = NextOp->Common.Next;
318
    NextOp = NextOp->Common.Next;
319
    NextOp->Common.DisasmOpcode = ACPI_DASM_MATCHOP;
320
}
321
 
322
 
323
/*******************************************************************************
324
 *
325
 * FUNCTION:    AcpiDmMatchKeyword
326
 *
327
 * PARAMETERS:  Op              - Match Object to be examined
328
 *
329
 * RETURN:      None
330
 *
331
 * DESCRIPTION: Decode Match opcode operands
332
 *
333
 ******************************************************************************/
334
 
335
static void
336
AcpiDmMatchKeyword (
337
    ACPI_PARSE_OBJECT       *Op)
338
{
339
 
340
 
341
    if (((UINT32) Op->Common.Value.Integer) > ACPI_MAX_MATCH_OPCODE)
342
    {
343
        AcpiOsPrintf ("/* Unknown Match Keyword encoding */");
344
    }
345
    else
346
    {
347
        AcpiOsPrintf ("%s", ACPI_CAST_PTR (char,
348
            AcpiGbl_MatchOps[(ACPI_SIZE) Op->Common.Value.Integer]));
349
    }
350
}
351
 
352
 
353
/*******************************************************************************
354
 *
355
 * FUNCTION:    AcpiDmDisassembleOneOp
356
 *
357
 * PARAMETERS:  WalkState           - Current walk info
358
 *              Info                - Parse tree walk info
359
 *              Op                  - Op that is to be printed
360
 *
361
 * RETURN:      None
362
 *
363
 * DESCRIPTION: Disassemble a single AML opcode
364
 *
365
 ******************************************************************************/
366
 
367
void
368
AcpiDmDisassembleOneOp (
369
    ACPI_WALK_STATE         *WalkState,
370
    ACPI_OP_WALK_INFO       *Info,
371
    ACPI_PARSE_OBJECT       *Op)
372
{
373
    const ACPI_OPCODE_INFO  *OpInfo = NULL;
374
    UINT32                  Offset;
375
    UINT32                  Length;
376
    ACPI_PARSE_OBJECT       *Child;
377
    ACPI_STATUS             Status;
378
 
379
 
380
    if (!Op)
381
    {
382
        AcpiOsPrintf ("");
383
        return;
384
    }
385
 
386
    switch (Op->Common.DisasmOpcode)
387
    {
388
    case ACPI_DASM_MATCHOP:
389
 
390
        AcpiDmMatchKeyword (Op);
391
        return;
392
 
393
    case ACPI_DASM_LNOT_SUFFIX:
394
        switch (Op->Common.AmlOpcode)
395
        {
396
        case AML_LEQUAL_OP:
397
            AcpiOsPrintf ("LNotEqual");
398
            break;
399
 
400
        case AML_LGREATER_OP:
401
            AcpiOsPrintf ("LLessEqual");
402
            break;
403
 
404
        case AML_LLESS_OP:
405
            AcpiOsPrintf ("LGreaterEqual");
406
            break;
407
 
408
        default:
409
            break;
410
        }
411
        Op->Common.DisasmOpcode = 0;
412
        Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
413
        return;
414
 
415
    default:
416
        break;
417
    }
418
 
419
 
420
    OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
421
 
422
    /* The op and arguments */
423
 
424
    switch (Op->Common.AmlOpcode)
425
    {
426
    case AML_LNOT_OP:
427
 
428
        Child = Op->Common.Value.Arg;
429
        if ((Child->Common.AmlOpcode == AML_LEQUAL_OP) ||
430
            (Child->Common.AmlOpcode == AML_LGREATER_OP) ||
431
            (Child->Common.AmlOpcode == AML_LLESS_OP))
432
        {
433
            Child->Common.DisasmOpcode = ACPI_DASM_LNOT_SUFFIX;
434
            Op->Common.DisasmOpcode = ACPI_DASM_LNOT_PREFIX;
435
        }
436
        else
437
        {
438
            AcpiOsPrintf ("%s", OpInfo->Name);
439
        }
440
        break;
441
 
442
    case AML_BYTE_OP:
443
 
444
        AcpiOsPrintf ("0x%2.2X", (UINT32) Op->Common.Value.Integer);
445
        break;
446
 
447
 
448
    case AML_WORD_OP:
449
 
450
        if (Op->Common.DisasmOpcode == ACPI_DASM_EISAID)
451
        {
452
            AcpiDmEisaId ((UINT32) Op->Common.Value.Integer);
453
        }
454
        else
455
        {
456
            AcpiOsPrintf ("0x%4.4X", (UINT32) Op->Common.Value.Integer);
457
        }
458
        break;
459
 
460
 
461
    case AML_DWORD_OP:
462
 
463
        if (Op->Common.DisasmOpcode == ACPI_DASM_EISAID)
464
        {
465
            AcpiDmEisaId ((UINT32) Op->Common.Value.Integer);
466
        }
467
        else
468
        {
469
            AcpiOsPrintf ("0x%8.8X", (UINT32) Op->Common.Value.Integer);
470
        }
471
        break;
472
 
473
 
474
    case AML_QWORD_OP:
475
 
476
        AcpiOsPrintf ("0x%8.8X%8.8X",
477
            ACPI_FORMAT_UINT64 (Op->Common.Value.Integer));
478
        break;
479
 
480
 
481
    case AML_STRING_OP:
482
 
483
        AcpiUtPrintString (Op->Common.Value.String, ACPI_UINT8_MAX);
484
        break;
485
 
486
 
487
    case AML_BUFFER_OP:
488
 
489
        /*
490
         * Determine the type of buffer.  We can have one of the following:
491
         *
492
         * 1) ResourceTemplate containing Resource Descriptors.
493
         * 2) Unicode String buffer
494
         * 3) ASCII String buffer
495
         * 4) Raw data buffer (if none of the above)
496
         *
497
         * Since there are no special AML opcodes to differentiate these
498
         * types of buffers, we have to closely look at the data in the
499
         * buffer to determine the type.
500
         */
501
        Status = AcpiDmIsResourceTemplate (Op);
502
        if (ACPI_SUCCESS (Status))
503
        {
504
            Op->Common.DisasmOpcode = ACPI_DASM_RESOURCE;
505
            AcpiOsPrintf ("ResourceTemplate");
506
            break;
507
        }
508
        else if (Status == AE_AML_NO_RESOURCE_END_TAG)
509
        {
510
            AcpiOsPrintf ("/**** Is ResourceTemplate, but EndTag not at buffer end ****/ ");
511
        }
512
 
513
        if (AcpiDmIsUnicodeBuffer (Op))
514
        {
515
            Op->Common.DisasmOpcode = ACPI_DASM_UNICODE;
516
            AcpiOsPrintf ("Unicode (");
517
        }
518
        else if (AcpiDmIsStringBuffer (Op))
519
        {
520
            Op->Common.DisasmOpcode = ACPI_DASM_STRING;
521
            AcpiOsPrintf ("Buffer");
522
        }
523
        else
524
        {
525
            Op->Common.DisasmOpcode = ACPI_DASM_BUFFER;
526
            AcpiOsPrintf ("Buffer");
527
        }
528
        break;
529
 
530
 
531
    case AML_INT_STATICSTRING_OP:
532
 
533
        if (Op->Common.Value.String)
534
        {
535
            AcpiOsPrintf ("%s", Op->Common.Value.String);
536
        }
537
        else
538
        {
539
            AcpiOsPrintf ("\"\"");
540
        }
541
        break;
542
 
543
 
544
    case AML_INT_NAMEPATH_OP:
545
 
546
        AcpiDmNamestring (Op->Common.Value.Name);
547
        break;
548
 
549
 
550
    case AML_INT_NAMEDFIELD_OP:
551
 
552
        Length = AcpiDmDumpName (Op->Named.Name);
553
        AcpiOsPrintf (",%*.s  %u", (unsigned) (5 - Length), " ",
554
            (UINT32) Op->Common.Value.Integer);
555
        AcpiDmCommaIfFieldMember (Op);
556
 
557
        Info->BitOffset += (UINT32) Op->Common.Value.Integer;
558
        break;
559
 
560
 
561
    case AML_INT_RESERVEDFIELD_OP:
562
 
563
        /* Offset() -- Must account for previous offsets */
564
 
565
        Offset = (UINT32) Op->Common.Value.Integer;
566
        Info->BitOffset += Offset;
567
 
568
        if (Info->BitOffset % 8 == 0)
569
        {
570
            AcpiOsPrintf ("        Offset (0x%.2X)", ACPI_DIV_8 (Info->BitOffset));
571
        }
572
        else
573
        {
574
            AcpiOsPrintf ("    ,   %u", Offset);
575
        }
576
 
577
        AcpiDmCommaIfFieldMember (Op);
578
        break;
579
 
580
 
581
    case AML_INT_ACCESSFIELD_OP:
582
 
583
        AcpiOsPrintf ("        AccessAs (%s, ",
584
            AcpiGbl_AccessTypes [(UINT32) (Op->Common.Value.Integer >> 8) & 0x7]);
585
 
586
        AcpiDmDecodeAttribute ((UINT8) Op->Common.Value.Integer);
587
        AcpiOsPrintf (")");
588
        AcpiDmCommaIfFieldMember (Op);
589
        break;
590
 
591
 
592
    case AML_INT_BYTELIST_OP:
593
 
594
        AcpiDmByteList (Info, Op);
595
        break;
596
 
597
 
598
    case AML_INT_METHODCALL_OP:
599
 
600
        Op = AcpiPsGetDepthNext (NULL, Op);
601
        Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
602
 
603
        AcpiDmNamestring (Op->Common.Value.Name);
604
        break;
605
 
606
 
607
    default:
608
 
609
        /* Just get the opcode name and print it */
610
 
611
        AcpiOsPrintf ("%s", OpInfo->Name);
612
 
613
 
614
#ifdef ACPI_DEBUGGER
615
 
616
        if ((Op->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP) &&
617
            (WalkState) &&
618
            (WalkState->Results) &&
619
            (WalkState->ResultCount))
620
        {
621
            AcpiDmDecodeInternalObject (
622
                WalkState->Results->Results.ObjDesc [
623
                    (WalkState->ResultCount - 1) %
624
                        ACPI_RESULTS_FRAME_OBJ_NUM]);
625
        }
626
#endif
627
 
628
        break;
629
    }
630
}
631
 
632
#endif  /* ACPI_DISASSEMBLER */