sys/contrib/dev/acpica-unix/tools/acpiexec/aemain.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aemain - Main routine for the AcpiExec utility
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2011, 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 #include "aecommon.h"
 117
 118 #ifdef _DEBUG
 119 #include <crtdbg.h>
 120 #endif
 121
 122 #define _COMPONENT          PARSER
 123         ACPI_MODULE_NAME    ("aemain")
 124
 125
 126 UINT8                   AcpiGbl_RegionFillValue = 0;
 127 BOOLEAN                 AcpiGbl_IgnoreErrors = FALSE;
 128 BOOLEAN                 AcpiGbl_DbOpt_NoRegionSupport = FALSE;
 129 BOOLEAN                 AcpiGbl_DebugTimeout = FALSE;
 130
 131 static UINT8            AcpiGbl_BatchMode = 0;
 132 static char             BatchBuffer[128];
 133 static AE_TABLE_DESC    *AeTableListHead = NULL;
 134
 135 #define ASL_MAX_FILES   256
 136 static char             *FileList[ASL_MAX_FILES];
 137
 138
 139 #define AE_SUPPORTED_OPTIONS    "?b:d:e:f:gm^ovx:"
 140
 141
 142 /******************************************************************************
 143  *
 144  * FUNCTION:    usage
 145  *
 146  * PARAMETERS:  None
 147  *
 148  * RETURN:      None
 149  *
 150  * DESCRIPTION: Print a usage message
 151  *
 152  *****************************************************************************/
 153
 154 static void
 155 usage (void)
 156 {
 157     printf ("Usage: acpiexec [options] AMLfile1 AMLfile2 ...\n\n");
 158
 159     printf ("Where:\n");
 160     printf ("   -?                  Display this message\n");
 161     printf ("   -b <CommandLine>    Batch mode command execution\n");
 162     printf ("   -m [Method]         Batch mode method execution. Default=MAIN\n");
 163     printf ("\n");
 164
 165     printf ("   -da                 Disable method abort on error\n");
 166     printf ("   -di                 Disable execution of STA/INI methods during init\n");
 167     printf ("   -do                 Disable Operation Region address simulation\n");
 168     printf ("   -dt                 Disable allocation tracking (performance)\n");
 169     printf ("\n");
 170
 171     printf ("   -ef                 Enable display of final memory statistics\n");
 172     printf ("   -em                 Enable Interpreter Serialized Mode\n");
 173     printf ("   -es                 Enable Interpreter Slack Mode\n");
 174     printf ("   -et                 Enable debug semaphore timeout\n");
 175     printf ("\n");
 176
 177     printf ("   -f <Value>          Operation Region initialization fill value\n");
 178     printf ("   -v                  Verbose initialization output\n");
 179     printf ("   -x <DebugLevel>     Debug output level\n");
 180 }
 181
 182
 183 /******************************************************************************
 184  *
 185  * FUNCTION:    AcpiDbRunBatchMode
 186  *
 187  * PARAMETERS:  BatchCommandLine    - A semicolon separated list of commands
 188  *                                    to be executed.
 189  *                                    Use only commas to separate elements of
 190  *                                    particular command.
 191  * RETURN:      Status
 192  *
 193  * DESCRIPTION: For each command of list separated by ';' prepare the command
 194  *              buffer and pass it to AcpiDbCommandDispatch.
 195  *
 196  *****************************************************************************/
 197
 198 static ACPI_STATUS
 199 AcpiDbRunBatchMode (
 200     void)
 201 {
 202     ACPI_STATUS             Status;
 203     char                    *Ptr = BatchBuffer;
 204     char                    *Cmd = Ptr;
 205     UINT8                   Run = 0;
 206
 207
 208     AcpiGbl_MethodExecuting = FALSE;
 209     AcpiGbl_StepToNextCall = FALSE;
 210
 211     while (*Ptr)
 212     {
 213         if (*Ptr == ',')
 214         {
 215             /* Convert commas to spaces */
 216             *Ptr = ' ';
 217         }
 218         else if (*Ptr == ';')
 219         {
 220             *Ptr = '\0';
 221             Run = 1;
 222         }
 223
 224         Ptr++;
 225
 226         if (Run || (*Ptr == '\0'))
 227         {
 228             (void) AcpiDbCommandDispatch (Cmd, NULL, NULL);
 229             Run = 0;
 230             Cmd = Ptr;
 231         }
 232     }
 233
 234     Status = AcpiTerminate ();
 235     return (Status);
 236 }
 237
 238
 239 /*******************************************************************************
 240  *
 241  * FUNCTION:    FlStrdup
 242  *
 243  * DESCRIPTION: Local strdup function
 244  *
 245  ******************************************************************************/
 246
 247 static char *
 248 FlStrdup (
 249     char                *String)
 250 {
 251     char                *NewString;
 252
 253
 254     NewString = AcpiOsAllocate (strlen (String) + 1);
 255     if (!NewString)
 256     {
 257         return (NULL);
 258     }
 259
 260     strcpy (NewString, String);
 261     return (NewString);
 262 }
 263
 264
 265 /*******************************************************************************
 266  *
 267  * FUNCTION:    FlSplitInputPathname
 268  *
 269  * PARAMETERS:  InputFilename       - The user-specified ASL source file to be
 270  *                                    compiled
 271  *              OutDirectoryPath    - Where the directory path prefix is
 272  *                                    returned
 273  *              OutFilename         - Where the filename part is returned
 274  *
 275  * RETURN:      Status
 276  *
 277  * DESCRIPTION: Split the input path into a directory and filename part
 278  *              1) Directory part used to open include files
 279  *              2) Filename part used to generate output filenames
 280  *
 281  ******************************************************************************/
 282
 283 ACPI_STATUS
 284 FlSplitInputPathname (
 285     char                    *InputPath,
 286     char                    **OutDirectoryPath,
 287     char                    **OutFilename)
 288 {
 289     char                    *Substring;
 290     char                    *DirectoryPath;
 291     char                    *Filename;
 292
 293
 294     *OutDirectoryPath = NULL;
 295     *OutFilename = NULL;
 296
 297     if (!InputPath)
 298     {
 299         return (AE_OK);
 300     }
 301
 302     /* Get the path to the input filename's directory */
 303
 304     DirectoryPath = FlStrdup (InputPath);
 305     if (!DirectoryPath)
 306     {
 307         return (AE_NO_MEMORY);
 308     }
 309
 310     Substring = strrchr (DirectoryPath, '\\');
 311     if (!Substring)
 312     {
 313         Substring = strrchr (DirectoryPath, '/');
 314         if (!Substring)
 315         {
 316             Substring = strrchr (DirectoryPath, ':');
 317         }
 318     }
 319
 320     if (!Substring)
 321     {
 322         DirectoryPath[0] = 0;
 323         Filename = FlStrdup (InputPath);
 324     }
 325     else
 326     {
 327         Filename = FlStrdup (Substring + 1);
 328         *(Substring+1) = 0;
 329     }
 330
 331     if (!Filename)
 332     {
 333         return (AE_NO_MEMORY);
 334     }
 335
 336     *OutDirectoryPath = DirectoryPath;
 337     *OutFilename = Filename;
 338
 339     return (AE_OK);
 340 }
 341
 342
 343 /******************************************************************************
 344  *
 345  * FUNCTION:    AsDoWildcard
 346  *
 347  * PARAMETERS:  DirectoryPathname   - Path to parent directory
 348  *              FileSpecifier       - the wildcard specification (*.c, etc.)
 349  *
 350  * RETURN:      Pointer to a list of filenames
 351  *
 352  * DESCRIPTION: Process files via wildcards. This function is for the Windows
 353  *              case only.
 354  *
 355  ******************************************************************************/
 356
 357 static char **
 358 AsDoWildcard (
 359     char                    *DirectoryPathname,
 360     char                    *FileSpecifier)
 361 {
 362 #ifdef WIN32
 363     void                    *DirInfo;
 364     char                    *Filename;
 365     int                     FileCount;
 366
 367
 368     FileCount = 0;
 369
 370     /* Open parent directory */
 371
 372     DirInfo = AcpiOsOpenDirectory (DirectoryPathname, FileSpecifier, REQUEST_FILE_ONLY);
 373     if (!DirInfo)
 374     {
 375         /* Either the directory or file does not exist */
 376
 377         printf ("File or directory %s%s does not exist\n", DirectoryPathname, FileSpecifier);
 378         return (NULL);
 379     }
 380
 381     /* Process each file that matches the wildcard specification */
 382
 383     while ((Filename = AcpiOsGetNextFilename (DirInfo)))
 384     {
 385         /* Add the filename to the file list */
 386
 387         FileList[FileCount] = AcpiOsAllocate (strlen (Filename) + 1);
 388         strcpy (FileList[FileCount], Filename);
 389         FileCount++;
 390
 391         if (FileCount >= ASL_MAX_FILES)
 392         {
 393             printf ("Max files reached\n");
 394             FileList[0] = NULL;
 395             return (FileList);
 396         }
 397     }
 398
 399     /* Cleanup */
 400
 401     AcpiOsCloseDirectory (DirInfo);
 402     FileList[FileCount] = NULL;
 403     return (FileList);
 404
 405 #else
 406     if (!FileSpecifier)
 407     {
 408         return (NULL);
 409     }
 410
 411     /*
 412      * Linux/Unix cases - Wildcards are expanded by the shell automatically.
 413      * Just return the filename in a null terminated list
 414      */
 415     FileList[0] = AcpiOsAllocate (strlen (FileSpecifier) + 1);
 416     strcpy (FileList[0], FileSpecifier);
 417     FileList[1] = NULL;
 418
 419     return (FileList);
 420 #endif
 421 }
 422
 423
 424 /******************************************************************************
 425  *
 426  * FUNCTION:    main
 427  *
 428  * PARAMETERS:  argc, argv
 429  *
 430  * RETURN:      Status
 431  *
 432  * DESCRIPTION: Main routine for AcpiDump utility
 433  *
 434  *****************************************************************************/
 435
 436 int ACPI_SYSTEM_XFACE
 437 main (
 438     int                     argc,
 439     char                    **argv)
 440 {
 441     int                     j;
 442     ACPI_STATUS             Status;
 443     UINT32                  InitFlags;
 444     ACPI_TABLE_HEADER       *Table = NULL;
 445     UINT32                  TableCount;
 446     AE_TABLE_DESC           *TableDesc;
 447     char                    **WildcardList;
 448     char                    *Filename;
 449     char                    *Directory;
 450     char                    *FullPathname;
 451
 452
 453 #ifdef _DEBUG
 454     _CrtSetDbgFlag (_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF |
 455                     _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
 456 #endif
 457
 458     printf (ACPI_COMMON_SIGNON ("AML Execution/Debug Utility"));
 459
 460     if (argc < 2)
 461     {
 462         usage ();
 463         return (0);
 464     }
 465
 466     signal (SIGINT, AeCtrlCHandler);
 467
 468     /* Init globals */
 469
 470     AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
 471     AcpiDbgLayer = 0xFFFFFFFF;
 472
 473     /* Init ACPI and start debugger thread */
 474
 475     Status = AcpiInitializeSubsystem ();
 476     AE_CHECK_OK (AcpiInitializeSubsystem, Status);
 477
 478     /* Get the command line options */
 479
 480     while ((j = AcpiGetopt (argc, argv, AE_SUPPORTED_OPTIONS)) != EOF) switch(j)
 481     {
 482     case 'b':
 483         if (strlen (AcpiGbl_Optarg) > 127)
 484         {
 485             printf ("**** The length of command line (%u) exceeded maximum (127)\n",
 486                 (UINT32) strlen (AcpiGbl_Optarg));
 487             return (-1);
 488         }
 489         AcpiGbl_BatchMode = 1;
 490         strcpy (BatchBuffer, AcpiGbl_Optarg);
 491         break;
 492
 493     case 'd':
 494         switch (AcpiGbl_Optarg[0])
 495         {
 496         case 'a':
 497             AcpiGbl_IgnoreErrors = TRUE;
 498             break;
 499
 500         case 'i':
 501             AcpiGbl_DbOpt_ini_methods = FALSE;
 502             break;
 503
 504         case 'o':
 505             AcpiGbl_DbOpt_NoRegionSupport = TRUE;
 506             break;
 507
 508         case 't':
 509             #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 510                 AcpiGbl_DisableMemTracking = TRUE;
 511             #endif
 512             break;
 513
 514         default:
 515             printf ("Unknown option: -d%s\n", AcpiGbl_Optarg);
 516             return (-1);
 517         }
 518         break;
 519
 520     case 'e':
 521         switch (AcpiGbl_Optarg[0])
 522         {
 523         case 'f':
 524             #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 525                 AcpiGbl_DisplayFinalMemStats = TRUE;
 526             #endif
 527             break;
 528
 529         case 'm':
 530             AcpiGbl_AllMethodsSerialized = TRUE;
 531             printf ("Enabling AML Interpreter serialized mode\n");
 532             break;
 533
 534         case 's':
 535             AcpiGbl_EnableInterpreterSlack = TRUE;
 536             printf ("Enabling AML Interpreter slack mode\n");
 537             break;
 538
 539         case 't':
 540             AcpiGbl_DebugTimeout = TRUE;
 541             break;
 542
 543         default:
 544             printf ("Unknown option: -e%s\n", AcpiGbl_Optarg);
 545             return (-1);
 546         }
 547         break;
 548
 549     case 'f':
 550         AcpiGbl_RegionFillValue = (UINT8) strtoul (AcpiGbl_Optarg, NULL, 0);
 551         break;
 552
 553     case 'g':
 554         AcpiGbl_DbOpt_tables = TRUE;
 555         AcpiGbl_DbFilename = NULL;
 556         break;
 557
 558     case 'm':
 559         AcpiGbl_BatchMode = 2;
 560         switch (AcpiGbl_Optarg[0])
 561         {
 562         case '^':
 563             strcpy (BatchBuffer, "MAIN");
 564             break;
 565
 566         default:
 567             strcpy (BatchBuffer, AcpiGbl_Optarg);
 568             break;
 569         }
 570         break;
 571
 572     case 'o':
 573         AcpiGbl_DbOpt_disasm = TRUE;
 574         AcpiGbl_DbOpt_stats = TRUE;
 575         break;
 576
 577     case 'v':
 578         AcpiDbgLevel |= ACPI_LV_INIT_NAMES;
 579         break;
 580
 581     case 'x':
 582         AcpiDbgLevel = strtoul (AcpiGbl_Optarg, NULL, 0);
 583         AcpiGbl_DbConsoleDebugLevel = AcpiDbgLevel;
 584         printf ("Debug Level: 0x%8.8X\n", AcpiDbgLevel);
 585         break;
 586
 587     case '?':
 588     case 'h':
 589     default:
 590         usage();
 591         return (-1);
 592     }
 593
 594
 595     InitFlags = (ACPI_NO_HANDLER_INIT | ACPI_NO_ACPI_ENABLE);
 596     if (!AcpiGbl_DbOpt_ini_methods)
 597     {
 598         InitFlags |= (ACPI_NO_DEVICE_INIT | ACPI_NO_OBJECT_INIT);
 599     }
 600
 601     /* The remaining arguments are filenames for ACPI tables */
 602
 603     if (argv[AcpiGbl_Optind])
 604     {
 605         AcpiGbl_DbOpt_tables = TRUE;
 606         TableCount = 0;
 607
 608         /* Get each of the ACPI table files on the command line */
 609
 610         while (argv[AcpiGbl_Optind])
 611         {
 612             /* Split incoming path into a directory/filename combo */
 613
 614             Status = FlSplitInputPathname (argv[AcpiGbl_Optind], &Directory, &Filename);
 615             if (ACPI_FAILURE (Status))
 616             {
 617                 return (Status);
 618             }
 619
 620             /* Expand wildcards (Windows only) */
 621
 622             WildcardList = AsDoWildcard (Directory, Filename);
 623             if (!WildcardList)
 624             {
 625                 return (-1);
 626             }
 627
 628             while (*WildcardList)
 629             {
 630                 FullPathname = AcpiOsAllocate (
 631                     strlen (Directory) + strlen (*WildcardList) + 1);
 632
 633                 /* Construct a full path to the file */
 634
 635                 strcpy (FullPathname, Directory);
 636                 strcat (FullPathname, *WildcardList);
 637
 638                 /* Get one table */
 639
 640                 Status = AcpiDbReadTableFromFile (FullPathname, &Table);
 641                 if (ACPI_FAILURE (Status))
 642                 {
 643                     printf ("**** Could not get input table %s, %s\n", FullPathname,
 644                         AcpiFormatException (Status));
 645                     goto enterloop;
 646                 }
 647
 648                 AcpiOsFree (FullPathname);
 649                 AcpiOsFree (*WildcardList);
 650                 *WildcardList = NULL;
 651                 WildcardList++;
 652
 653                 /*
 654                  * Ignore an FACS or RSDT, we can't use them.
 655                  */
 656                 if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FACS) ||
 657                     ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_RSDT))
 658                 {
 659                     AcpiOsFree (Table);
 660                     continue;
 661                 }
 662
 663                 /* Allocate and link a table descriptor */
 664
 665                 TableDesc = AcpiOsAllocate (sizeof (AE_TABLE_DESC));
 666                 TableDesc->Table = Table;
 667                 TableDesc->Next = AeTableListHead;
 668                 AeTableListHead = TableDesc;
 669
 670                 TableCount++;
 671             }
 672
 673             AcpiGbl_Optind++;
 674         }
 675
 676         /* Build a local RSDT with all tables and let ACPICA process the RSDT */
 677
 678         Status = AeBuildLocalTables (TableCount, AeTableListHead);
 679         if (ACPI_FAILURE (Status))
 680         {
 681             return (-1);
 682         }
 683
 684         Status = AeInstallTables ();
 685         if (ACPI_FAILURE (Status))
 686         {
 687             printf ("**** Could not load ACPI tables, %s\n", AcpiFormatException (Status));
 688             goto enterloop;
 689         }
 690
 691          /*
 692           * Install most of the handlers.
 693           * Override some default region handlers, especially SystemMemory
 694           */
 695         Status = AeInstallEarlyHandlers ();
 696         if (ACPI_FAILURE (Status))
 697         {
 698             goto enterloop;
 699         }
 700
 701         /*
 702          * TBD: Need a way to call this after the "LOAD" command
 703          */
 704         Status = AcpiEnableSubsystem (InitFlags);
 705         if (ACPI_FAILURE (Status))
 706         {
 707             printf ("**** Could not EnableSubsystem, %s\n", AcpiFormatException (Status));
 708             goto enterloop;
 709         }
 710
 711         Status = AcpiInitializeObjects (InitFlags);
 712         if (ACPI_FAILURE (Status))
 713         {
 714             printf ("**** Could not InitializeObjects, %s\n", AcpiFormatException (Status));
 715             goto enterloop;
 716         }
 717
 718         /*
 719          * Install handlers for "device driver" space IDs (EC,SMBus, etc.)
 720          * and fixed event handlers
 721          */
 722         AeInstallLateHandlers ();
 723         AeMiscellaneousTests ();
 724     }
 725
 726 enterloop:
 727
 728     if (AcpiGbl_BatchMode == 1)
 729     {
 730         AcpiDbRunBatchMode ();
 731     }
 732     else if (AcpiGbl_BatchMode == 2)
 733     {
 734         AcpiDbExecute (BatchBuffer, NULL, EX_NO_SINGLE_STEP);
 735     }
 736     else
 737     {
 738         /* Enter the debugger command loop */
 739
 740         AcpiDbUserCommands (ACPI_DEBUGGER_COMMAND_PROMPT, NULL);
 741     }
 742
 743     return (0);
 744 }
 745