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
166 static void
167 AcpiDmCompareAmlResources (
168 UINT8 *Aml1Buffer,
169 ACPI_RSDESC_SIZE Aml1BufferLength,
170 UINT8 *Aml2Buffer,
171 ACPI_RSDESC_SIZE Aml2BufferLength);
172
173 static ACPI_STATUS
174 AcpiDmTestResourceConversion (
175 ACPI_NAMESPACE_NODE *Node,
176 char *Name);
177
178 static ACPI_STATUS
179 AcpiDbResourceCallback (
180 ACPI_RESOURCE *Resource,
181 void *Context);
182
183 static ACPI_STATUS
184 AcpiDbDeviceResources (
185 ACPI_HANDLE ObjHandle,
186 UINT32 NestingLevel,
187 void *Context,
188 void **ReturnValue);
189
190 static void
191 AcpiDbDoOneSleepState (
192 UINT8 SleepState);
193
194
195 static 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
211 ACPI_NAMESPACE_NODE *
AcpiDbConvertToNode(char * InString)212 AcpiDbConvertToNode (
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
273 ACPI_STATUS
AcpiDbSleep(char * ObjectArg)274 AcpiDbSleep (
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
319 static void
AcpiDbDoOneSleepState(UINT8 SleepState)320 AcpiDbDoOneSleepState (
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
392 ErrorExit:
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
410 void
AcpiDbDisplayLocks(void)411 AcpiDbDisplayLocks (
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
439 void
AcpiDbDisplayTableInfo(char * TableArg)440 AcpiDbDisplayTableInfo (
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
536 void
AcpiDbUnloadAcpiTable(char * ObjectName)537 AcpiDbUnloadAcpiTable (
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
580 void
AcpiDbSendNotify(char * Name,UINT32 Value)581 AcpiDbSendNotify (
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
630 void
AcpiDbDisplayInterfaces(char * ActionArg,char * InterfaceNameArg)631 AcpiDbDisplayInterfaces (
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
720 void
AcpiDbDisplayTemplate(char * BufferArg)721 AcpiDbDisplayTemplate (
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
770 DumpBuffer:
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
797 static void
AcpiDmCompareAmlResources(UINT8 * Aml1Buffer,ACPI_RSDESC_SIZE Aml1BufferLength,UINT8 * Aml2Buffer,ACPI_RSDESC_SIZE Aml2BufferLength)798 AcpiDmCompareAmlResources (
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
903 static ACPI_STATUS
AcpiDmTestResourceConversion(ACPI_NAMESPACE_NODE * Node,char * Name)904 AcpiDmTestResourceConversion (
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);
962 Exit2:
963 ACPI_FREE (ResourceBuffer.Pointer);
964 Exit1:
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
983 static ACPI_STATUS
AcpiDbResourceCallback(ACPI_RESOURCE * Resource,void * Context)984 AcpiDbResourceCallback (
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
1005 static ACPI_STATUS
AcpiDbDeviceResources(ACPI_HANDLE ObjHandle,UINT32 NestingLevel,void * Context,void ** ReturnValue)1006 AcpiDbDeviceResources (
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
1084 GetCrs:
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
1159 EndCrs:
1160 ACPI_FREE (ReturnBuffer.Pointer);
1161 }
1162
1163
1164 /* _PRS */
1165
1166 GetPrs:
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
1200 GetAei:
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
1232 Cleanup:
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
1252 void
AcpiDbDisplayResources(char * ObjectArg)1253 AcpiDbDisplayResources (
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
1305 void
AcpiDbGenerateInterrupt(char * GsivArg)1306 AcpiDbGenerateInterrupt (
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
1366 void
AcpiDbGenerateGpe(char * GpeArg,char * BlockArg)1367 AcpiDbGenerateGpe (
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
1415 void
AcpiDbGenerateSci(void)1416 AcpiDbGenerateSci (
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
1440 void
AcpiDbTrace(char * EnableArg,char * MethodArg,char * OnceArg)1441 AcpiDbTrace (
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