1/*******************************************************************************
2 *
3 * Module Name: dbcmds - Miscellaneous debug commands and output routines
4 *
5 ******************************************************************************/
6
7/******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2023, Intel Corp.
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 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 *    notice, this list of conditions, and the following disclaimer,
124 *    without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 *    substantially similar to the "NO WARRANTY" disclaimer below
127 *    ("Disclaimer") and any redistribution must be conditioned upon
128 *    including a substantially similar Disclaimer requirement for further
129 *    binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 *    of any contributors may be used to endorse or promote products derived
132 *    from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152#include <contrib/dev/acpica/include/acpi.h>
153#include <contrib/dev/acpica/include/accommon.h>
154#include <contrib/dev/acpica/include/acevents.h>
155#include <contrib/dev/acpica/include/acdebug.h>
156#include <contrib/dev/acpica/include/acnamesp.h>
157#include <contrib/dev/acpica/include/acresrc.h>
158#include <contrib/dev/acpica/include/actables.h>
159
160#define _COMPONENT          ACPI_CA_DEBUGGER
161        ACPI_MODULE_NAME    ("dbcmds")
162
163
164/* Local prototypes */
165
166static void
167AcpiDmCompareAmlResources (
168    UINT8                   *Aml1Buffer,
169    ACPI_RSDESC_SIZE        Aml1BufferLength,
170    UINT8                   *Aml2Buffer,
171    ACPI_RSDESC_SIZE        Aml2BufferLength);
172
173static ACPI_STATUS
174AcpiDmTestResourceConversion (
175    ACPI_NAMESPACE_NODE     *Node,
176    char                    *Name);
177
178static ACPI_STATUS
179AcpiDbResourceCallback (
180    ACPI_RESOURCE           *Resource,
181    void                    *Context);
182
183static ACPI_STATUS
184AcpiDbDeviceResources (
185    ACPI_HANDLE             ObjHandle,
186    UINT32                  NestingLevel,
187    void                    *Context,
188    void                    **ReturnValue);
189
190static void
191AcpiDbDoOneSleepState (
192    UINT8                   SleepState);
193
194
195static char                 *AcpiDbTraceMethodName = NULL;
196
197
198/*******************************************************************************
199 *
200 * FUNCTION:    AcpiDbConvertToNode
201 *
202 * PARAMETERS:  InString            - String to convert
203 *
204 * RETURN:      Pointer to a NS node
205 *
206 * DESCRIPTION: Convert a string to a valid NS pointer. Handles numeric or
207 *              alphanumeric strings.
208 *
209 ******************************************************************************/
210
211ACPI_NAMESPACE_NODE *
212AcpiDbConvertToNode (
213    char                    *InString)
214{
215    ACPI_NAMESPACE_NODE     *Node;
216    ACPI_SIZE               Address;
217
218
219    if ((*InString >= 0x30) && (*InString <= 0x39))
220    {
221        /* Numeric argument, convert */
222
223        Address = strtoul (InString, NULL, 16);
224        Node = ACPI_TO_POINTER (Address);
225        if (!AcpiOsReadable (Node, sizeof (ACPI_NAMESPACE_NODE)))
226        {
227            AcpiOsPrintf ("Address %p is invalid", Node);
228            return (NULL);
229        }
230
231        /* Make sure pointer is valid NS node */
232
233        if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
234        {
235            AcpiOsPrintf ("Address %p is not a valid namespace node [%s]\n",
236                Node, AcpiUtGetDescriptorName (Node));
237            return (NULL);
238        }
239    }
240    else
241    {
242        /*
243         * Alpha argument: The parameter is a name string that must be
244         * resolved to a Namespace object.
245         */
246        Node = AcpiDbLocalNsLookup (InString);
247        if (!Node)
248        {
249            AcpiOsPrintf (
250                "Could not find [%s] in namespace, defaulting to root node\n",
251                InString);
252            Node = AcpiGbl_RootNode;
253        }
254    }
255
256    return (Node);
257}
258
259
260/*******************************************************************************
261 *
262 * FUNCTION:    AcpiDbSleep
263 *
264 * PARAMETERS:  ObjectArg           - Desired sleep state (0-5). NULL means
265 *                                    invoke all possible sleep states.
266 *
267 * RETURN:      Status
268 *
269 * DESCRIPTION: Simulate sleep/wake sequences
270 *
271 ******************************************************************************/
272
273ACPI_STATUS
274AcpiDbSleep (
275    char                    *ObjectArg)
276{
277    UINT8                   SleepState;
278    UINT32                  i;
279
280
281    ACPI_FUNCTION_TRACE (AcpiDbSleep);
282
283
284    /* Null input (no arguments) means to invoke all sleep states */
285
286    if (!ObjectArg)
287    {
288        AcpiOsPrintf ("Invoking all possible sleep states, 0-%d\n",
289            ACPI_S_STATES_MAX);
290
291        for (i = 0; i <= ACPI_S_STATES_MAX; i++)
292        {
293            AcpiDbDoOneSleepState ((UINT8) i);
294        }
295
296        return_ACPI_STATUS (AE_OK);
297    }
298
299    /* Convert argument to binary and invoke the sleep state */
300
301    SleepState = (UINT8) strtoul (ObjectArg, NULL, 0);
302    AcpiDbDoOneSleepState (SleepState);
303    return_ACPI_STATUS (AE_OK);
304}
305
306
307/*******************************************************************************
308 *
309 * FUNCTION:    AcpiDbDoOneSleepState
310 *
311 * PARAMETERS:  SleepState          - Desired sleep state (0-5)
312 *
313 * RETURN:      None
314 *
315 * DESCRIPTION: Simulate a sleep/wake sequence
316 *
317 ******************************************************************************/
318
319static void
320AcpiDbDoOneSleepState (
321    UINT8                   SleepState)
322{
323    ACPI_STATUS             Status;
324    UINT8                   SleepTypeA;
325    UINT8                   SleepTypeB;
326
327
328    /* Validate parameter */
329
330    if (SleepState > ACPI_S_STATES_MAX)
331    {
332        AcpiOsPrintf ("Sleep state %d out of range (%d max)\n",
333            SleepState, ACPI_S_STATES_MAX);
334        return;
335    }
336
337    AcpiOsPrintf ("\n---- Invoking sleep state S%d (%s):\n",
338        SleepState, AcpiGbl_SleepStateNames[SleepState]);
339
340    /* Get the values for the sleep type registers (for display only) */
341
342    Status = AcpiGetSleepTypeData (SleepState, &SleepTypeA, &SleepTypeB);
343    if (ACPI_FAILURE (Status))
344    {
345        AcpiOsPrintf ("Could not evaluate [%s] method, %s\n",
346            AcpiGbl_SleepStateNames[SleepState],
347            AcpiFormatException (Status));
348        return;
349    }
350
351    AcpiOsPrintf (
352        "Register values for sleep state S%d: Sleep-A: %.2X, Sleep-B: %.2X\n",
353        SleepState, SleepTypeA, SleepTypeB);
354
355    /* Invoke the various sleep/wake interfaces */
356
357    AcpiOsPrintf ("**** Sleep: Prepare to sleep (S%d) ****\n",
358        SleepState);
359    Status = AcpiEnterSleepStatePrep (SleepState);
360    if (ACPI_FAILURE (Status))
361    {
362        goto ErrorExit;
363    }
364
365    AcpiOsPrintf ("**** Sleep: Going to sleep (S%d) ****\n",
366        SleepState);
367    Status = AcpiEnterSleepState (SleepState);
368    if (ACPI_FAILURE (Status))
369    {
370        goto ErrorExit;
371    }
372
373    AcpiOsPrintf ("**** Wake: Prepare to return from sleep (S%d) ****\n",
374        SleepState);
375    Status = AcpiLeaveSleepStatePrep (SleepState);
376    if (ACPI_FAILURE (Status))
377    {
378        goto ErrorExit;
379    }
380
381    AcpiOsPrintf ("**** Wake: Return from sleep (S%d) ****\n",
382        SleepState);
383    Status = AcpiLeaveSleepState (SleepState);
384    if (ACPI_FAILURE (Status))
385    {
386        goto ErrorExit;
387    }
388
389    return;
390
391
392ErrorExit:
393    ACPI_EXCEPTION ((AE_INFO, Status, "During invocation of sleep state S%d",
394        SleepState));
395}
396
397
398/*******************************************************************************
399 *
400 * FUNCTION:    AcpiDbDisplayLocks
401 *
402 * PARAMETERS:  None
403 *
404 * RETURN:      None
405 *
406 * DESCRIPTION: Display information about internal mutexes.
407 *
408 ******************************************************************************/
409
410void
411AcpiDbDisplayLocks (
412    void)
413{
414    UINT32                  i;
415
416
417    for (i = 0; i < ACPI_MAX_MUTEX; i++)
418    {
419        AcpiOsPrintf ("%26s : %s\n", AcpiUtGetMutexName (i),
420            AcpiGbl_MutexInfo[i].ThreadId == ACPI_MUTEX_NOT_ACQUIRED
421                ? "Locked" : "Unlocked");
422    }
423}
424
425
426/*******************************************************************************
427 *
428 * FUNCTION:    AcpiDbDisplayTableInfo
429 *
430 * PARAMETERS:  TableArg            - Name of table to be displayed
431 *
432 * RETURN:      None
433 *
434 * DESCRIPTION: Display information about loaded tables. Current
435 *              implementation displays all loaded tables.
436 *
437 ******************************************************************************/
438
439void
440AcpiDbDisplayTableInfo (
441    char                    *TableArg)
442{
443    UINT32                  i;
444    ACPI_TABLE_DESC         *TableDesc;
445    ACPI_STATUS             Status;
446
447
448    /* Header */
449
450    AcpiOsPrintf ("Idx ID    Status Type                    "
451        "TableHeader (Sig, Address, Length, Misc)\n");
452
453    /* Walk the entire root table list */
454
455    for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
456    {
457        TableDesc = &AcpiGbl_RootTableList.Tables[i];
458
459        /* Index and Table ID */
460
461        AcpiOsPrintf ("%3u %.2u ", i, TableDesc->OwnerId);
462
463        /* Decode the table flags */
464
465        if (!(TableDesc->Flags & ACPI_TABLE_IS_LOADED))
466        {
467            AcpiOsPrintf ("NotLoaded ");
468        }
469        else
470        {
471            AcpiOsPrintf ("   Loaded ");
472        }
473
474        switch (TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK)
475        {
476        case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
477
478            AcpiOsPrintf ("External/virtual  ");
479            break;
480
481        case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
482
483            AcpiOsPrintf ("Internal/physical ");
484            break;
485
486        case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
487
488            AcpiOsPrintf ("Internal/virtual  ");
489            break;
490
491        default:
492
493            AcpiOsPrintf ("INVALID TYPE      ");
494            break;
495        }
496
497        /* Make sure that the table is mapped */
498
499        Status = AcpiTbValidateTable (TableDesc);
500        if (ACPI_FAILURE (Status))
501        {
502            return;
503        }
504
505        /* Dump the table header */
506
507        if (TableDesc->Pointer)
508        {
509            AcpiTbPrintTableHeader (TableDesc->Address, TableDesc->Pointer);
510        }
511        else
512        {
513            /* If the pointer is null, the table has been unloaded */
514
515            ACPI_INFO (("%4.4s - Table has been unloaded",
516                TableDesc->Signature.Ascii));
517        }
518    }
519}
520
521
522/*******************************************************************************
523 *
524 * FUNCTION:    AcpiDbUnloadAcpiTable
525 *
526 * PARAMETERS:  ObjectName          - Namespace pathname for an object that
527 *                                    is owned by the table to be unloaded
528 *
529 * RETURN:      None
530 *
531 * DESCRIPTION: Unload an ACPI table, via any namespace node that is owned
532 *              by the table.
533 *
534 ******************************************************************************/
535
536void
537AcpiDbUnloadAcpiTable (
538    char                    *ObjectName)
539{
540    ACPI_NAMESPACE_NODE     *Node;
541    ACPI_STATUS             Status;
542
543
544    /* Translate name to an Named object */
545
546    Node = AcpiDbConvertToNode (ObjectName);
547    if (!Node)
548    {
549        return;
550    }
551
552    Status = AcpiUnloadParentTable (ACPI_CAST_PTR (ACPI_HANDLE, Node));
553    if (ACPI_SUCCESS (Status))
554    {
555        AcpiOsPrintf ("Parent of [%s] (%p) unloaded and uninstalled\n",
556            ObjectName, Node);
557    }
558    else
559    {
560        AcpiOsPrintf ("%s, while unloading parent table of [%s]\n",
561            AcpiFormatException (Status), ObjectName);
562    }
563}
564
565
566/*******************************************************************************
567 *
568 * FUNCTION:    AcpiDbSendNotify
569 *
570 * PARAMETERS:  Name                - Name of ACPI object where to send notify
571 *              Value               - Value of the notify to send.
572 *
573 * RETURN:      None
574 *
575 * DESCRIPTION: Send an ACPI notification. The value specified is sent to the
576 *              named object as an ACPI notify.
577 *
578 ******************************************************************************/
579
580void
581AcpiDbSendNotify (
582    char                    *Name,
583    UINT32                  Value)
584{
585    ACPI_NAMESPACE_NODE     *Node;
586    ACPI_STATUS             Status;
587
588
589    /* Translate name to an Named object */
590
591    Node = AcpiDbConvertToNode (Name);
592    if (!Node)
593    {
594        return;
595    }
596
597    /* Dispatch the notify if legal */
598
599    if (AcpiEvIsNotifyObject (Node))
600    {
601        Status = AcpiEvQueueNotifyRequest (Node, Value);
602        if (ACPI_FAILURE (Status))
603        {
604            AcpiOsPrintf ("Could not queue notify\n");
605        }
606    }
607    else
608    {
609        AcpiOsPrintf (
610            "Named object [%4.4s] Type %s, "
611            "must be Device/Thermal/Processor type\n",
612            AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type));
613    }
614}
615
616
617/*******************************************************************************
618 *
619 * FUNCTION:    AcpiDbDisplayInterfaces
620 *
621 * PARAMETERS:  ActionArg           - Null, "install", or "remove"
622 *              InterfaceNameArg    - Name for install/remove options
623 *
624 * RETURN:      None
625 *
626 * DESCRIPTION: Display or modify the global _OSI interface list
627 *
628 ******************************************************************************/
629
630void
631AcpiDbDisplayInterfaces (
632    char                    *ActionArg,
633    char                    *InterfaceNameArg)
634{
635    ACPI_INTERFACE_INFO     *NextInterface;
636    char                    *SubString;
637    ACPI_STATUS             Status;
638
639
640    /* If no arguments, just display current interface list */
641
642    if (!ActionArg)
643    {
644        (void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
645
646        NextInterface = AcpiGbl_SupportedInterfaces;
647        while (NextInterface)
648        {
649            if (!(NextInterface->Flags & ACPI_OSI_INVALID))
650            {
651                AcpiOsPrintf ("%s\n", NextInterface->Name);
652            }
653
654            NextInterface = NextInterface->Next;
655        }
656
657        AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
658        return;
659    }
660
661    /* If ActionArg exists, so must InterfaceNameArg */
662
663    if (!InterfaceNameArg)
664    {
665        AcpiOsPrintf ("Missing Interface Name argument\n");
666        return;
667    }
668
669    /* Uppercase the action for match below */
670
671    AcpiUtStrupr (ActionArg);
672
673    /* Install - install an interface */
674
675    SubString = strstr ("INSTALL", ActionArg);
676    if (SubString)
677    {
678        Status = AcpiInstallInterface (InterfaceNameArg);
679        if (ACPI_FAILURE (Status))
680        {
681            AcpiOsPrintf ("%s, while installing \"%s\"\n",
682                AcpiFormatException (Status), InterfaceNameArg);
683        }
684        return;
685    }
686
687    /* Remove - remove an interface */
688
689    SubString = strstr ("REMOVE", ActionArg);
690    if (SubString)
691    {
692        Status = AcpiRemoveInterface (InterfaceNameArg);
693        if (ACPI_FAILURE (Status))
694        {
695            AcpiOsPrintf ("%s, while removing \"%s\"\n",
696                AcpiFormatException (Status), InterfaceNameArg);
697        }
698        return;
699    }
700
701    /* Invalid ActionArg */
702
703    AcpiOsPrintf ("Invalid action argument: %s\n", ActionArg);
704    return;
705}
706
707
708/*******************************************************************************
709 *
710 * FUNCTION:    AcpiDbDisplayTemplate
711 *
712 * PARAMETERS:  BufferArg           - Buffer name or address
713 *
714 * RETURN:      None
715 *
716 * DESCRIPTION: Dump a buffer that contains a resource template
717 *
718 ******************************************************************************/
719
720void
721AcpiDbDisplayTemplate (
722    char                    *BufferArg)
723{
724    ACPI_NAMESPACE_NODE     *Node;
725    ACPI_STATUS             Status;
726    ACPI_BUFFER             ReturnBuffer;
727
728
729    /* Translate BufferArg to an Named object */
730
731    Node = AcpiDbConvertToNode (BufferArg);
732    if (!Node || (Node == AcpiGbl_RootNode))
733    {
734        AcpiOsPrintf ("Invalid argument: %s\n", BufferArg);
735        return;
736    }
737
738    /* We must have a buffer object */
739
740    if (Node->Type != ACPI_TYPE_BUFFER)
741    {
742        AcpiOsPrintf ("Not a Buffer object, cannot be a template: %s\n",
743            BufferArg);
744        return;
745    }
746
747    ReturnBuffer.Length = ACPI_DEBUG_BUFFER_SIZE;
748    ReturnBuffer.Pointer = AcpiGbl_DbBuffer;
749
750    /* Attempt to convert the raw buffer to a resource list */
751
752    Status = AcpiRsCreateResourceList (Node->Object, &ReturnBuffer);
753
754    AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
755    AcpiDbgLevel |= ACPI_LV_RESOURCES;
756
757    if (ACPI_FAILURE (Status))
758    {
759        AcpiOsPrintf (
760            "Could not convert Buffer to a resource list: %s, %s\n",
761            BufferArg, AcpiFormatException (Status));
762        goto DumpBuffer;
763    }
764
765    /* Now we can dump the resource list */
766
767    AcpiRsDumpResourceList (ACPI_CAST_PTR (ACPI_RESOURCE,
768        ReturnBuffer.Pointer));
769
770DumpBuffer:
771    AcpiOsPrintf ("\nRaw data buffer:\n");
772    AcpiUtDebugDumpBuffer ((UINT8 *) Node->Object->Buffer.Pointer,
773        Node->Object->Buffer.Length,
774        DB_BYTE_DISPLAY, ACPI_UINT32_MAX);
775
776    AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
777    return;
778}
779
780
781/*******************************************************************************
782 *
783 * FUNCTION:    AcpiDmCompareAmlResources
784 *
785 * PARAMETERS:  Aml1Buffer          - Contains first resource list
786 *              Aml1BufferLength    - Length of first resource list
787 *              Aml2Buffer          - Contains second resource list
788 *              Aml2BufferLength    - Length of second resource list
789 *
790 * RETURN:      None
791 *
792 * DESCRIPTION: Compare two AML resource lists, descriptor by descriptor (in
793 *              order to isolate a miscompare to an individual resource)
794 *
795 ******************************************************************************/
796
797static void
798AcpiDmCompareAmlResources (
799    UINT8                   *Aml1Buffer,
800    ACPI_RSDESC_SIZE        Aml1BufferLength,
801    UINT8                   *Aml2Buffer,
802    ACPI_RSDESC_SIZE        Aml2BufferLength)
803{
804    UINT8                   *Aml1;
805    UINT8                   *Aml2;
806    UINT8                   *Aml1End;
807    UINT8                   *Aml2End;
808    ACPI_RSDESC_SIZE        Aml1Length;
809    ACPI_RSDESC_SIZE        Aml2Length;
810    ACPI_RSDESC_SIZE        Offset = 0;
811    UINT8                   ResourceType;
812    UINT32                  Count = 0;
813    UINT32                  i;
814
815
816    /* Compare overall buffer sizes (may be different due to size rounding) */
817
818    if (Aml1BufferLength != Aml2BufferLength)
819    {
820        AcpiOsPrintf (
821            "**** Buffer length mismatch in converted "
822            "AML: Original %X, New %X ****\n",
823            Aml1BufferLength, Aml2BufferLength);
824    }
825
826    Aml1 = Aml1Buffer;
827    Aml2 = Aml2Buffer;
828    Aml1End = Aml1Buffer + Aml1BufferLength;
829    Aml2End = Aml2Buffer + Aml2BufferLength;
830
831    /* Walk the descriptor lists, comparing each descriptor */
832
833    while ((Aml1 < Aml1End) && (Aml2 < Aml2End))
834    {
835        /* Get the lengths of each descriptor */
836
837        Aml1Length = AcpiUtGetDescriptorLength (Aml1);
838        Aml2Length = AcpiUtGetDescriptorLength (Aml2);
839        ResourceType = AcpiUtGetResourceType (Aml1);
840
841        /* Check for descriptor length match */
842
843        if (Aml1Length != Aml2Length)
844        {
845            AcpiOsPrintf (
846                "**** Length mismatch in descriptor [%.2X] type %2.2X, "
847                "Offset %8.8X Len1 %X, Len2 %X ****\n",
848                Count, ResourceType, Offset, Aml1Length, Aml2Length);
849        }
850
851        /* Check for descriptor byte match */
852
853        else if (memcmp (Aml1, Aml2, Aml1Length))
854        {
855            AcpiOsPrintf (
856                "**** Data mismatch in descriptor [%.2X] type %2.2X, "
857                "Offset %8.8X ****\n",
858                Count, ResourceType, Offset);
859
860            for (i = 0; i < Aml1Length; i++)
861            {
862                if (Aml1[i] != Aml2[i])
863                {
864                    AcpiOsPrintf (
865                        "Mismatch at byte offset %.2X: is %2.2X, "
866                        "should be %2.2X\n",
867                        i, Aml2[i], Aml1[i]);
868                }
869            }
870        }
871
872        /* Exit on EndTag descriptor */
873
874        if (ResourceType == ACPI_RESOURCE_NAME_END_TAG)
875        {
876            return;
877        }
878
879        /* Point to next descriptor in each buffer */
880
881        Count++;
882        Offset += Aml1Length;
883        Aml1 += Aml1Length;
884        Aml2 += Aml2Length;
885    }
886}
887
888
889/*******************************************************************************
890 *
891 * FUNCTION:    AcpiDmTestResourceConversion
892 *
893 * PARAMETERS:  Node                - Parent device node
894 *              Name                - resource method name (_CRS)
895 *
896 * RETURN:      Status
897 *
898 * DESCRIPTION: Compare the original AML with a conversion of the AML to
899 *              internal resource list, then back to AML.
900 *
901 ******************************************************************************/
902
903static ACPI_STATUS
904AcpiDmTestResourceConversion (
905    ACPI_NAMESPACE_NODE     *Node,
906    char                    *Name)
907{
908    ACPI_STATUS             Status;
909    ACPI_BUFFER             ReturnBuffer;
910    ACPI_BUFFER             ResourceBuffer;
911    ACPI_BUFFER             NewAml;
912    ACPI_OBJECT             *OriginalAml;
913
914
915    AcpiOsPrintf ("Resource Conversion Comparison:\n");
916
917    NewAml.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
918    ReturnBuffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
919    ResourceBuffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
920
921    /* Get the original _CRS AML resource template */
922
923    Status = AcpiEvaluateObject (Node, Name, NULL, &ReturnBuffer);
924    if (ACPI_FAILURE (Status))
925    {
926        AcpiOsPrintf ("Could not obtain %s: %s\n",
927            Name, AcpiFormatException (Status));
928        return (Status);
929    }
930
931    /* Get the AML resource template, converted to internal resource structs */
932
933    Status = AcpiGetCurrentResources (Node, &ResourceBuffer);
934    if (ACPI_FAILURE (Status))
935    {
936        AcpiOsPrintf ("AcpiGetCurrentResources failed: %s\n",
937            AcpiFormatException (Status));
938        goto Exit1;
939    }
940
941    /* Convert internal resource list to external AML resource template */
942
943    Status = AcpiRsCreateAmlResources (&ResourceBuffer, &NewAml);
944    if (ACPI_FAILURE (Status))
945    {
946        AcpiOsPrintf ("AcpiRsCreateAmlResources failed: %s\n",
947            AcpiFormatException (Status));
948        goto Exit2;
949    }
950
951    /* Compare original AML to the newly created AML resource list */
952
953    OriginalAml = ReturnBuffer.Pointer;
954
955    AcpiDmCompareAmlResources (OriginalAml->Buffer.Pointer,
956        (ACPI_RSDESC_SIZE) OriginalAml->Buffer.Length,
957        NewAml.Pointer, (ACPI_RSDESC_SIZE) NewAml.Length);
958
959    /* Cleanup and exit */
960
961    ACPI_FREE (NewAml.Pointer);
962Exit2:
963    ACPI_FREE (ResourceBuffer.Pointer);
964Exit1:
965    ACPI_FREE (ReturnBuffer.Pointer);
966    return (Status);
967}
968
969
970/*******************************************************************************
971 *
972 * FUNCTION:    AcpiDbResourceCallback
973 *
974 * PARAMETERS:  ACPI_WALK_RESOURCE_CALLBACK
975 *
976 * RETURN:      Status
977 *
978 * DESCRIPTION: Simple callback to exercise AcpiWalkResources and
979 *              AcpiWalkResourceBuffer.
980 *
981 ******************************************************************************/
982
983static ACPI_STATUS
984AcpiDbResourceCallback (
985    ACPI_RESOURCE           *Resource,
986    void                    *Context)
987{
988
989    return (AE_OK);
990}
991
992
993/*******************************************************************************
994 *
995 * FUNCTION:    AcpiDbDeviceResources
996 *
997 * PARAMETERS:  ACPI_WALK_CALLBACK
998 *
999 * RETURN:      Status
1000 *
1001 * DESCRIPTION: Display the _PRT/_CRS/_PRS resources for a device object.
1002 *
1003 ******************************************************************************/
1004
1005static ACPI_STATUS
1006AcpiDbDeviceResources (
1007    ACPI_HANDLE             ObjHandle,
1008    UINT32                  NestingLevel,
1009    void                    *Context,
1010    void                    **ReturnValue)
1011{
1012    ACPI_NAMESPACE_NODE     *Node;
1013    ACPI_NAMESPACE_NODE     *PrtNode = NULL;
1014    ACPI_NAMESPACE_NODE     *CrsNode = NULL;
1015    ACPI_NAMESPACE_NODE     *PrsNode = NULL;
1016    ACPI_NAMESPACE_NODE     *AeiNode = NULL;
1017    char                    *ParentPath;
1018    ACPI_BUFFER             ReturnBuffer;
1019    ACPI_STATUS             Status;
1020
1021
1022    Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);
1023    ParentPath = AcpiNsGetNormalizedPathname (Node, TRUE);
1024    if (!ParentPath)
1025    {
1026        return (AE_NO_MEMORY);
1027    }
1028
1029    /* Get handles to the resource methods for this device */
1030
1031    (void) AcpiGetHandle (Node, METHOD_NAME__PRT,
1032        ACPI_CAST_PTR (ACPI_HANDLE, &PrtNode));
1033    (void) AcpiGetHandle (Node, METHOD_NAME__CRS,
1034        ACPI_CAST_PTR (ACPI_HANDLE, &CrsNode));
1035    (void) AcpiGetHandle (Node, METHOD_NAME__PRS,
1036        ACPI_CAST_PTR (ACPI_HANDLE, &PrsNode));
1037    (void) AcpiGetHandle (Node, METHOD_NAME__AEI,
1038        ACPI_CAST_PTR (ACPI_HANDLE, &AeiNode));
1039
1040    if (!PrtNode && !CrsNode && !PrsNode && !AeiNode)
1041    {
1042        goto Cleanup;   /* Nothing to do */
1043    }
1044
1045    AcpiOsPrintf ("\nDevice: %s\n", ParentPath);
1046
1047    /* Prepare for a return object of arbitrary size */
1048
1049    ReturnBuffer.Pointer = AcpiGbl_DbBuffer;
1050    ReturnBuffer.Length  = ACPI_DEBUG_BUFFER_SIZE;
1051
1052
1053    /* _PRT */
1054
1055    if (PrtNode)
1056    {
1057        AcpiOsPrintf ("Evaluating _PRT\n");
1058
1059        Status = AcpiEvaluateObject (PrtNode, NULL, NULL, &ReturnBuffer);
1060        if (ACPI_FAILURE (Status))
1061        {
1062            AcpiOsPrintf ("Could not evaluate _PRT: %s\n",
1063                AcpiFormatException (Status));
1064            goto GetCrs;
1065        }
1066
1067        ReturnBuffer.Pointer = AcpiGbl_DbBuffer;
1068        ReturnBuffer.Length  = ACPI_DEBUG_BUFFER_SIZE;
1069
1070        Status = AcpiGetIrqRoutingTable (Node, &ReturnBuffer);
1071        if (ACPI_FAILURE (Status))
1072        {
1073            AcpiOsPrintf ("GetIrqRoutingTable failed: %s\n",
1074                AcpiFormatException (Status));
1075            goto GetCrs;
1076        }
1077
1078        AcpiRsDumpIrqList (ACPI_CAST_PTR (UINT8, AcpiGbl_DbBuffer));
1079    }
1080
1081
1082    /* _CRS */
1083
1084GetCrs:
1085    if (CrsNode)
1086    {
1087        AcpiOsPrintf ("Evaluating _CRS\n");
1088
1089        ReturnBuffer.Pointer = AcpiGbl_DbBuffer;
1090        ReturnBuffer.Length  = ACPI_DEBUG_BUFFER_SIZE;
1091
1092        Status = AcpiEvaluateObject (CrsNode, NULL, NULL, &ReturnBuffer);
1093        if (ACPI_FAILURE (Status))
1094        {
1095            AcpiOsPrintf ("Could not evaluate _CRS: %s\n",
1096                AcpiFormatException (Status));
1097            goto GetPrs;
1098        }
1099
1100        /* This code exercises the AcpiWalkResources interface */
1101
1102        Status = AcpiWalkResources (Node, METHOD_NAME__CRS,
1103            AcpiDbResourceCallback, NULL);
1104        if (ACPI_FAILURE (Status))
1105        {
1106            AcpiOsPrintf ("AcpiWalkResources failed: %s\n",
1107                AcpiFormatException (Status));
1108            goto GetPrs;
1109        }
1110
1111        /* Get the _CRS resource list (test ALLOCATE buffer) */
1112
1113        ReturnBuffer.Pointer = NULL;
1114        ReturnBuffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
1115
1116        Status = AcpiGetCurrentResources (Node, &ReturnBuffer);
1117        if (ACPI_FAILURE (Status))
1118        {
1119            AcpiOsPrintf ("AcpiGetCurrentResources failed: %s\n",
1120                AcpiFormatException (Status));
1121            goto GetPrs;
1122        }
1123
1124        /* This code exercises the AcpiWalkResourceBuffer interface */
1125
1126        Status = AcpiWalkResourceBuffer (&ReturnBuffer,
1127            AcpiDbResourceCallback, NULL);
1128        if (ACPI_FAILURE (Status))
1129        {
1130            AcpiOsPrintf ("AcpiWalkResourceBuffer failed: %s\n",
1131                AcpiFormatException (Status));
1132            goto EndCrs;
1133        }
1134
1135        /* Dump the _CRS resource list */
1136
1137        AcpiRsDumpResourceList (ACPI_CAST_PTR (ACPI_RESOURCE,
1138            ReturnBuffer.Pointer));
1139
1140        /*
1141         * Perform comparison of original AML to newly created AML. This
1142         * tests both the AML->Resource conversion and the Resource->AML
1143         * conversion.
1144         */
1145        (void) AcpiDmTestResourceConversion (Node, METHOD_NAME__CRS);
1146
1147        /* Execute _SRS with the resource list */
1148
1149        AcpiOsPrintf ("Evaluating _SRS\n");
1150
1151        Status = AcpiSetCurrentResources (Node, &ReturnBuffer);
1152        if (ACPI_FAILURE (Status))
1153        {
1154            AcpiOsPrintf ("AcpiSetCurrentResources failed: %s\n",
1155                AcpiFormatException (Status));
1156            goto EndCrs;
1157        }
1158
1159EndCrs:
1160        ACPI_FREE (ReturnBuffer.Pointer);
1161    }
1162
1163
1164    /* _PRS */
1165
1166GetPrs:
1167    if (PrsNode)
1168    {
1169        AcpiOsPrintf ("Evaluating _PRS\n");
1170
1171        ReturnBuffer.Pointer = AcpiGbl_DbBuffer;
1172        ReturnBuffer.Length  = ACPI_DEBUG_BUFFER_SIZE;
1173
1174        Status = AcpiEvaluateObject (PrsNode, NULL, NULL, &ReturnBuffer);
1175        if (ACPI_FAILURE (Status))
1176        {
1177            AcpiOsPrintf ("Could not evaluate _PRS: %s\n",
1178                AcpiFormatException (Status));
1179            goto GetAei;
1180        }
1181
1182        ReturnBuffer.Pointer = AcpiGbl_DbBuffer;
1183        ReturnBuffer.Length = ACPI_DEBUG_BUFFER_SIZE;
1184
1185        Status = AcpiGetPossibleResources (Node, &ReturnBuffer);
1186        if (ACPI_FAILURE (Status))
1187        {
1188            AcpiOsPrintf ("AcpiGetPossibleResources failed: %s\n",
1189                AcpiFormatException (Status));
1190            goto GetAei;
1191        }
1192
1193        AcpiRsDumpResourceList (ACPI_CAST_PTR (
1194            ACPI_RESOURCE, AcpiGbl_DbBuffer));
1195    }
1196
1197
1198    /* _AEI */
1199
1200GetAei:
1201    if (AeiNode)
1202    {
1203        AcpiOsPrintf ("Evaluating _AEI\n");
1204
1205        ReturnBuffer.Pointer = AcpiGbl_DbBuffer;
1206        ReturnBuffer.Length = ACPI_DEBUG_BUFFER_SIZE;
1207
1208        Status = AcpiEvaluateObject (AeiNode, NULL, NULL, &ReturnBuffer);
1209        if (ACPI_FAILURE (Status))
1210        {
1211            AcpiOsPrintf ("Could not evaluate _AEI: %s\n",
1212                AcpiFormatException (Status));
1213            goto Cleanup;
1214        }
1215
1216        ReturnBuffer.Pointer = AcpiGbl_DbBuffer;
1217        ReturnBuffer.Length = ACPI_DEBUG_BUFFER_SIZE;
1218
1219        Status = AcpiGetEventResources (Node, &ReturnBuffer);
1220        if (ACPI_FAILURE (Status))
1221        {
1222            AcpiOsPrintf ("AcpiGetEventResources failed: %s\n",
1223                AcpiFormatException (Status));
1224            goto Cleanup;
1225        }
1226
1227        AcpiRsDumpResourceList (ACPI_CAST_PTR (
1228            ACPI_RESOURCE, AcpiGbl_DbBuffer));
1229    }
1230
1231
1232Cleanup:
1233    ACPI_FREE (ParentPath);
1234    return (AE_OK);
1235}
1236
1237
1238/*******************************************************************************
1239 *
1240 * FUNCTION:    AcpiDbDisplayResources
1241 *
1242 * PARAMETERS:  ObjectArg           - String object name or object pointer.
1243 *                                    NULL or "*" means "display resources for
1244 *                                    all devices"
1245 *
1246 * RETURN:      None
1247 *
1248 * DESCRIPTION: Display the resource objects associated with a device.
1249 *
1250 ******************************************************************************/
1251
1252void
1253AcpiDbDisplayResources (
1254    char                    *ObjectArg)
1255{
1256    ACPI_NAMESPACE_NODE     *Node;
1257
1258
1259    AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
1260    AcpiDbgLevel |= ACPI_LV_RESOURCES;
1261
1262    /* Asterisk means "display resources for all devices" */
1263
1264    if (!ObjectArg || (!strcmp (ObjectArg, "*")))
1265    {
1266        (void) AcpiWalkNamespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1267            ACPI_UINT32_MAX, AcpiDbDeviceResources, NULL, NULL, NULL);
1268    }
1269    else
1270    {
1271        /* Convert string to object pointer */
1272
1273        Node = AcpiDbConvertToNode (ObjectArg);
1274        if (Node)
1275        {
1276            if (Node->Type != ACPI_TYPE_DEVICE)
1277            {
1278                AcpiOsPrintf (
1279                    "%4.4s: Name is not a device object (%s)\n",
1280                    Node->Name.Ascii, AcpiUtGetTypeName (Node->Type));
1281            }
1282            else
1283            {
1284                (void) AcpiDbDeviceResources (Node, 0, NULL, NULL);
1285            }
1286        }
1287    }
1288
1289    AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
1290}
1291
1292
1293/*******************************************************************************
1294 *
1295 * FUNCTION:    AcpiDbGenerateGed
1296 *
1297 * PARAMETERS:  GedArg              - Raw GED number, ascii string
1298 *
1299 * RETURN:      None
1300 *
1301 * DESCRIPTION: Simulate firing of a GED
1302 *
1303 ******************************************************************************/
1304
1305void
1306AcpiDbGenerateInterrupt (
1307    char *GsivArg)
1308{
1309    UINT32      GsivNumber;
1310    ACPI_GED_HANDLER_INFO *GedInfo = AcpiGbl_GedHandlerList;
1311
1312	if (!GedInfo) {
1313		AcpiOsPrintf ("No GED handling present\n");
1314	}
1315
1316    GsivNumber = strtoul (GsivArg, NULL, 0);
1317
1318	while (GedInfo) {
1319
1320		if (GedInfo->IntId == GsivNumber) {
1321			ACPI_OBJECT_LIST ArgList;
1322			ACPI_OBJECT Arg0;
1323			ACPI_HANDLE EvtHandle = GedInfo->EvtMethod;
1324			ACPI_STATUS Status;
1325
1326			AcpiOsPrintf ("Evaluate GED _EVT (GSIV=%d)\n", GsivNumber);
1327
1328			if (!EvtHandle) {
1329				AcpiOsPrintf ("Undefined _EVT method\n");
1330				return;
1331			}
1332
1333			Arg0.Integer.Type = ACPI_TYPE_INTEGER;
1334			Arg0.Integer.Value = GsivNumber;
1335
1336			ArgList.Count = 1;
1337			ArgList.Pointer = &Arg0;
1338
1339			Status = AcpiEvaluateObject (EvtHandle, NULL, &ArgList, NULL);
1340			if (ACPI_FAILURE (Status))
1341			{
1342				AcpiOsPrintf ("Could not evaluate _EVT\n");
1343				return;
1344			}
1345
1346		}
1347		GedInfo = GedInfo->Next;
1348	}
1349}
1350
1351#if (!ACPI_REDUCED_HARDWARE)
1352/*******************************************************************************
1353 *
1354 * FUNCTION:    AcpiDbGenerateGpe
1355 *
1356 * PARAMETERS:  GpeArg              - Raw GPE number, ascii string
1357 *              BlockArg            - GPE block number, ascii string
1358 *                                    0 or 1 for FADT GPE blocks
1359 *
1360 * RETURN:      None
1361 *
1362 * DESCRIPTION: Simulate firing of a GPE
1363 *
1364 ******************************************************************************/
1365
1366void
1367AcpiDbGenerateGpe (
1368    char                    *GpeArg,
1369    char                    *BlockArg)
1370{
1371    UINT32                  BlockNumber = 0;
1372    UINT32                  GpeNumber;
1373    ACPI_GPE_EVENT_INFO     *GpeEventInfo;
1374
1375
1376    GpeNumber = strtoul (GpeArg, NULL, 0);
1377
1378    /*
1379     * If no block arg, or block arg == 0 or 1, use the FADT-defined
1380     * GPE blocks.
1381     */
1382    if (BlockArg)
1383    {
1384        BlockNumber = strtoul (BlockArg, NULL, 0);
1385        if (BlockNumber == 1)
1386        {
1387            BlockNumber = 0;
1388        }
1389    }
1390
1391    GpeEventInfo = AcpiEvGetGpeEventInfo (
1392        ACPI_TO_POINTER (BlockNumber), GpeNumber);
1393    if (!GpeEventInfo)
1394    {
1395        AcpiOsPrintf ("Invalid GPE\n");
1396        return;
1397    }
1398
1399    (void) AcpiEvGpeDispatch (NULL, GpeEventInfo, GpeNumber);
1400}
1401
1402
1403/*******************************************************************************
1404 *
1405 * FUNCTION:    AcpiDbGenerateSci
1406 *
1407 * PARAMETERS:  None
1408 *
1409 * RETURN:      None
1410 *
1411 * DESCRIPTION: Simulate an SCI -- just call the SCI dispatch.
1412 *
1413 ******************************************************************************/
1414
1415void
1416AcpiDbGenerateSci (
1417    void)
1418{
1419    AcpiEvSciDispatch ();
1420}
1421
1422#endif /* !ACPI_REDUCED_HARDWARE */
1423
1424
1425/*******************************************************************************
1426 *
1427 * FUNCTION:    AcpiDbTrace
1428 *
1429 * PARAMETERS:  EnableArg           - ENABLE/AML to enable tracer
1430 *                                    DISABLE to disable tracer
1431 *              MethodArg           - Method to trace
1432 *              OnceArg             - Whether trace once
1433 *
1434 * RETURN:      None
1435 *
1436 * DESCRIPTION: Control method tracing facility
1437 *
1438 ******************************************************************************/
1439
1440void
1441AcpiDbTrace (
1442    char                    *EnableArg,
1443    char                    *MethodArg,
1444    char                    *OnceArg)
1445{
1446    UINT32                  DebugLevel = 0;
1447    UINT32                  DebugLayer = 0;
1448    UINT32                  Flags = 0;
1449
1450
1451    AcpiUtStrupr (EnableArg);
1452    AcpiUtStrupr (OnceArg);
1453
1454    if (MethodArg)
1455    {
1456        if (AcpiDbTraceMethodName)
1457        {
1458            ACPI_FREE (AcpiDbTraceMethodName);
1459            AcpiDbTraceMethodName = NULL;
1460        }
1461
1462        AcpiDbTraceMethodName = ACPI_ALLOCATE (strlen (MethodArg) + 1);
1463        if (!AcpiDbTraceMethodName)
1464        {
1465            AcpiOsPrintf ("Failed to allocate method name (%s)\n",
1466                MethodArg);
1467            return;
1468        }
1469
1470        strcpy (AcpiDbTraceMethodName, MethodArg);
1471    }
1472
1473    if (!strcmp (EnableArg, "ENABLE") ||
1474        !strcmp (EnableArg, "METHOD") ||
1475        !strcmp (EnableArg, "OPCODE"))
1476    {
1477        if (!strcmp (EnableArg, "ENABLE"))
1478        {
1479            /* Inherit current console settings */
1480
1481            DebugLevel = AcpiGbl_DbConsoleDebugLevel;
1482            DebugLayer = AcpiDbgLayer;
1483        }
1484        else
1485        {
1486            /* Restrict console output to trace points only */
1487
1488            DebugLevel = ACPI_LV_TRACE_POINT;
1489            DebugLayer = ACPI_EXECUTER;
1490        }
1491
1492        Flags = ACPI_TRACE_ENABLED;
1493
1494        if (!strcmp (EnableArg, "OPCODE"))
1495        {
1496            Flags |= ACPI_TRACE_OPCODE;
1497        }
1498
1499        if (OnceArg && !strcmp (OnceArg, "ONCE"))
1500        {
1501            Flags |= ACPI_TRACE_ONESHOT;
1502        }
1503    }
1504
1505    (void) AcpiDebugTrace (AcpiDbTraceMethodName,
1506        DebugLevel, DebugLayer, Flags);
1507}
1508