sys/contrib/dev/acpica/Subsystem/Namespace/nsload.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nsload - namespace loading/expanding/contracting procedures
   4  *              $Revision: 35 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117 #define __NSLOAD_C__
 118
 119 #include "acpi.h"
 120 #include "acinterp.h"
 121 #include "acnamesp.h"
 122 #include "amlcode.h"
 123 #include "acparser.h"
 124 #include "acdispat.h"
 125 #include "acdebug.h"
 126
 127
 128 #define _COMPONENT          NAMESPACE
 129         MODULE_NAME         ("nsload")
 130
 131
 132 /******************************************************************************
 133  *
 134  * FUNCTION:    AcpiLoadNamespace
 135  *
 136  * PARAMETERS:  DisplayAmlDuringLoad
 137  *
 138  * RETURN:      Status
 139  *
 140  * DESCRIPTION: Load the name space from what ever is pointed to by DSDT.
 141  *              (DSDT points to either the BIOS or a buffer.)
 142  *
 143  ******************************************************************************/
 144
 145 ACPI_STATUS
 146 AcpiNsLoadNamespace (
 147     void)
 148 {
 149     ACPI_STATUS             Status;
 150
 151
 152     FUNCTION_TRACE ("AcpiLoadNameSpace");
 153
 154
 155     /* There must be at least a DSDT installed */
 156
 157     if (AcpiGbl_DSDT == NULL)
 158     {
 159         DEBUG_PRINT (ACPI_ERROR, ("DSDT is not in memory\n"));
 160         return_ACPI_STATUS (AE_NO_ACPI_TABLES);
 161     }
 162
 163
 164     /*
 165      * Load the namespace.  The DSDT is required,
 166      * but the SSDT and PSDT tables are optional.
 167      */
 168
 169     Status = AcpiNsLoadTableByType (ACPI_TABLE_DSDT);
 170     if (ACPI_FAILURE (Status))
 171     {
 172         return_ACPI_STATUS (Status);
 173     }
 174
 175     /* Ignore exceptions from these */
 176
 177     AcpiNsLoadTableByType (ACPI_TABLE_SSDT);
 178     AcpiNsLoadTableByType (ACPI_TABLE_PSDT);
 179
 180
 181     DEBUG_PRINT_RAW (ACPI_OK,
 182         ("ACPI Namespace successfully loaded at root %p\n",
 183         AcpiGbl_RootNode));
 184
 185
 186     return_ACPI_STATUS (Status);
 187 }
 188
 189
 190 /*******************************************************************************
 191  *
 192  * FUNCTION:    AcpiNsOneParsePass
 193  *
 194  * PARAMETERS:
 195  *
 196  * RETURN:      Status
 197  *
 198  * DESCRIPTION:
 199  *
 200  ******************************************************************************/
 201
 202 ACPI_STATUS
 203 AcpiNsOneCompleteParse (
 204     UINT32                  PassNumber,
 205     ACPI_TABLE_DESC         *TableDesc)
 206 {
 207     ACPI_PARSE_DOWNWARDS    DescendingCallback;
 208     ACPI_PARSE_UPWARDS      AscendingCallback;
 209     ACPI_PARSE_OBJECT       *ParseRoot;
 210     ACPI_STATUS             Status;
 211
 212
 213     FUNCTION_TRACE ("NsOneCompleteParse");
 214
 215
 216     switch (PassNumber)
 217     {
 218     case 1:
 219         DescendingCallback = AcpiDsLoad1BeginOp;
 220         AscendingCallback  = AcpiDsLoad1EndOp;
 221         break;
 222
 223     case 2:
 224         DescendingCallback = AcpiDsLoad2BeginOp;
 225         AscendingCallback  = AcpiDsLoad2EndOp;
 226         break;
 227
 228     case 3:
 229         DescendingCallback = AcpiDsExecBeginOp;
 230         AscendingCallback  = AcpiDsExecEndOp;
 231         break;
 232
 233     default:
 234         return (AE_BAD_PARAMETER);
 235     }
 236
 237     /* Create and init a Root Node */
 238
 239     ParseRoot = AcpiPsAllocOp (AML_SCOPE_OP);
 240     if (!ParseRoot)
 241     {
 242         return_ACPI_STATUS (AE_NO_MEMORY);
 243     }
 244
 245     ((ACPI_PARSE2_OBJECT *) ParseRoot)->Name = ACPI_ROOT_NAME;
 246
 247
 248     /* Pass 1:  Parse everything except control method bodies */
 249
 250     DEBUG_PRINT (TRACE_PARSE,
 251         ("NsParseTable: *PARSE* pass %d parse\n", PassNumber));
 252
 253     Status = AcpiPsParseAml (ParseRoot,
 254                             TableDesc->AmlPointer,
 255                             TableDesc->AmlLength,
 256                             ACPI_PARSE_LOAD_PASS1 | ACPI_PARSE_DELETE_TREE,
 257                             NULL, NULL, NULL,
 258                             DescendingCallback,
 259                             AscendingCallback);
 260
 261     AcpiPsDeleteParseTree (ParseRoot);
 262
 263     return_ACPI_STATUS (Status);
 264 }
 265
 266
 267 /*******************************************************************************
 268  *
 269  * FUNCTION:    AcpiNsParseTable
 270  *
 271  * PARAMETERS:  TableDesc       - An ACPI table descriptor for table to parse
 272  *              StartNode       - Where to enter the table into the namespace
 273  *
 274  * RETURN:      Status
 275  *
 276  * DESCRIPTION: Parse AML within an ACPI table and return a tree of ops
 277  *
 278  ******************************************************************************/
 279
 280 ACPI_STATUS
 281 AcpiNsParseTable (
 282     ACPI_TABLE_DESC         *TableDesc,
 283     ACPI_NAMESPACE_NODE     *StartNode)
 284 {
 285     ACPI_STATUS             Status;
 286
 287
 288     FUNCTION_TRACE ("NsParseTable");
 289
 290
 291     /*
 292      * AML Parse, pass 1
 293      *
 294      * In this pass, we load most of the namespace.  Control methods
 295      * are not parsed until later.  A parse tree is not created.  Instead,
 296      * each Parser Op subtree is deleted when it is finished.  This saves
 297      * a great deal of memory, and allows a small cache of parse objects
 298      * to service the entire parse.  The second pass of the parse then
 299      * performs another complete parse of the AML..
 300      */
 301
 302     Status = AcpiNsOneCompleteParse (1, TableDesc);
 303     if (ACPI_FAILURE (Status))
 304     {
 305         return_ACPI_STATUS (Status);
 306     }
 307
 308
 309     /*
 310      * AML Parse, pass 2
 311      *
 312      * In this pass, we resolve forward references and other things
 313      * that could not be completed during the first pass.
 314      * Another complete parse of the AML is performed, but the
 315      * overhead of this is compensated for by the fact that the
 316      * parse objects are all cached.
 317      */
 318
 319     Status = AcpiNsOneCompleteParse (2, TableDesc);
 320     if (ACPI_FAILURE (Status))
 321     {
 322         return_ACPI_STATUS (Status);
 323     }
 324
 325     return_ACPI_STATUS (Status);
 326 }
 327
 328
 329 /*****************************************************************************
 330  *
 331  * FUNCTION:    AcpiNsLoadTable
 332  *
 333  * PARAMETERS:  *PcodeAddr          - Address of pcode block
 334  *              PcodeLength         - Length of pcode block
 335  *
 336  * RETURN:      Status
 337  *
 338  * DESCRIPTION: Load one ACPI table into the namespace
 339  *
 340  ****************************************************************************/
 341
 342 ACPI_STATUS
 343 AcpiNsLoadTable (
 344     ACPI_TABLE_DESC         *TableDesc,
 345     ACPI_NAMESPACE_NODE     *Node)
 346 {
 347     ACPI_STATUS             Status;
 348
 349
 350     FUNCTION_TRACE ("NsLoadTable");
 351
 352
 353     if (!TableDesc->AmlPointer)
 354     {
 355         DEBUG_PRINT (ACPI_ERROR, ("NsLoadTable: Null AML pointer\n"));
 356         return_ACPI_STATUS (AE_BAD_PARAMETER);
 357     }
 358
 359     DEBUG_PRINT (ACPI_INFO,
 360         ("NsLoadTable: AML block at %p\n", TableDesc->AmlPointer));
 361
 362
 363     if (!TableDesc->AmlLength)
 364     {
 365         DEBUG_PRINT (ACPI_ERROR,
 366             ("NsLoadTable: Zero-length AML block\n"));
 367         return_ACPI_STATUS (AE_BAD_PARAMETER);
 368     }
 369
 370
 371     /*
 372      * Parse the table and load the namespace with all named
 373      * objects found within.  Control methods are NOT parsed
 374      * at this time.  In fact, the control methods cannot be
 375      * parsed until the entire namespace is loaded, because
 376      * if a control method makes a forward reference (call)
 377      * to another control method, we can't continue parsing
 378      * because we don't know how many arguments to parse next!
 379      */
 380
 381     DEBUG_PRINT (ACPI_INFO,
 382         ("NsLoadTable: **** Loading table into namespace ****\n"));
 383
 384     AcpiCmAcquireMutex (ACPI_MTX_NAMESPACE);
 385     Status = AcpiNsParseTable (TableDesc, Node->Child);
 386     AcpiCmReleaseMutex (ACPI_MTX_NAMESPACE);
 387
 388     if (ACPI_FAILURE (Status))
 389     {
 390         return_ACPI_STATUS (Status);
 391     }
 392
 393     /*
 394      * Now we can parse the control methods.  We always parse
 395      * them here for a sanity check, and if configured for
 396      * just-in-time parsing, we delete the control method
 397      * parse trees.
 398      */
 399
 400     DEBUG_PRINT (ACPI_INFO,
 401         ("NsLoadTable: **** Begin Table Method Parsing and Object Initialization ****\n"));
 402
 403     Status = AcpiDsInitializeObjects (TableDesc, Node);
 404
 405     DEBUG_PRINT (ACPI_INFO,
 406         ("NsLoadTable: **** Completed Table Method Parsing and Object Initialization ****\n"));
 407
 408     return_ACPI_STATUS (Status);
 409 }
 410
 411
 412 /******************************************************************************
 413  *
 414  * FUNCTION:    AcpiNsLoadTableByType
 415  *
 416  * PARAMETERS:  TableType           - Id of the table type to load
 417  *
 418  * RETURN:      Status
 419  *
 420  * DESCRIPTION: Load an ACPI table or tables into the namespace.  All tables
 421  *              of the given type are loaded.  The mechanism allows this
 422  *              routine to be called repeatedly.
 423  *
 424  *****************************************************************************/
 425
 426 ACPI_STATUS
 427 AcpiNsLoadTableByType (
 428     ACPI_TABLE_TYPE         TableType)
 429 {
 430     UINT32                  i;
 431     ACPI_STATUS             Status = AE_OK;
 432     ACPI_TABLE_HEADER       *TablePtr;
 433     ACPI_TABLE_DESC         *TableDesc;
 434
 435
 436     FUNCTION_TRACE ("NsLoadTableByType");
 437
 438
 439     AcpiCmAcquireMutex (ACPI_MTX_TABLES);
 440
 441
 442     /*
 443      * Table types supported are:
 444      * DSDT (one), SSDT/PSDT (multiple)
 445      */
 446
 447     switch (TableType)
 448     {
 449
 450     case ACPI_TABLE_DSDT:
 451
 452         DEBUG_PRINT (ACPI_INFO, ("NsLoadTableByType: Loading DSDT\n"));
 453
 454         TableDesc = &AcpiGbl_AcpiTables[ACPI_TABLE_DSDT];
 455
 456         /* If table already loaded into namespace, just return */
 457
 458         if (TableDesc->LoadedIntoNamespace)
 459         {
 460             goto UnlockAndExit;
 461         }
 462
 463         TableDesc->TableId = TABLE_ID_DSDT;
 464
 465         /* Now load the single DSDT */
 466
 467         Status = AcpiNsLoadTable (TableDesc, AcpiGbl_RootNode);
 468         if (ACPI_SUCCESS (Status))
 469         {
 470             TableDesc->LoadedIntoNamespace = TRUE;
 471         }
 472
 473         break;
 474
 475
 476     case ACPI_TABLE_SSDT:
 477
 478         DEBUG_PRINT (ACPI_INFO,
 479             ("NsLoadTableByType: Loading %d SSDTs\n",
 480             AcpiGbl_AcpiTables[ACPI_TABLE_SSDT].Count));
 481
 482         /*
 483          * Traverse list of SSDT tables
 484          */
 485
 486         TableDesc = &AcpiGbl_AcpiTables[ACPI_TABLE_SSDT];
 487         for (i = 0; i < AcpiGbl_AcpiTables[ACPI_TABLE_SSDT].Count; i++)
 488         {
 489             TablePtr = TableDesc->Pointer;
 490
 491             /*
 492              * Only attempt to load table if it is not
 493              * already loaded!
 494              */
 495
 496             if (!TableDesc->LoadedIntoNamespace)
 497             {
 498                 Status = AcpiNsLoadTable (TableDesc,
 499                                             AcpiGbl_RootNode);
 500                 if (ACPI_FAILURE (Status))
 501                 {
 502                     break;
 503                 }
 504
 505                 TableDesc->LoadedIntoNamespace = TRUE;
 506             }
 507
 508             TableDesc = TableDesc->Next;
 509         }
 510
 511         break;
 512
 513
 514     case ACPI_TABLE_PSDT:
 515
 516         DEBUG_PRINT (ACPI_INFO,
 517             ("NsLoadTableByType: Loading %d PSDTs\n",
 518             AcpiGbl_AcpiTables[ACPI_TABLE_PSDT].Count));
 519
 520         /*
 521          * Traverse list of PSDT tables
 522          */
 523
 524         TableDesc = &AcpiGbl_AcpiTables[ACPI_TABLE_PSDT];
 525
 526         for (i = 0; i < AcpiGbl_AcpiTables[ACPI_TABLE_PSDT].Count; i++)
 527         {
 528             TablePtr = TableDesc->Pointer;
 529
 530             /* Only attempt to load table if it is not already loaded! */
 531
 532             if (!TableDesc->LoadedIntoNamespace)
 533             {
 534                 Status = AcpiNsLoadTable (TableDesc,
 535                                             AcpiGbl_RootNode);
 536                 if (ACPI_FAILURE (Status))
 537                 {
 538                     break;
 539                 }
 540
 541                 TableDesc->LoadedIntoNamespace = TRUE;
 542             }
 543
 544             TableDesc = TableDesc->Next;
 545         }
 546
 547         break;
 548
 549
 550     default:
 551         Status = AE_SUPPORT;
 552     }
 553
 554
 555 UnlockAndExit:
 556
 557     AcpiCmReleaseMutex (ACPI_MTX_TABLES);
 558
 559     return_ACPI_STATUS (Status);
 560
 561 }
 562
 563
 564 /******************************************************************************
 565  *
 566  * FUNCTION:    AcpiNsDeleteSubtree
 567  *
 568  * PARAMETERS:  StartHandle         - Handle in namespace where search begins
 569  *
 570  * RETURNS      Status
 571  *
 572  * DESCRIPTION: Walks the namespace starting at the given handle and deletes
 573  *              all objects, entries, and scopes in the entire subtree.
 574  *
 575  *              TBD: [Investigate] What if any part of this subtree is in use?
 576  *              (i.e. on one of the object stacks?)
 577  *
 578  ******************************************************************************/
 579
 580 ACPI_STATUS
 581 AcpiNsDeleteSubtree (
 582     ACPI_HANDLE             StartHandle)
 583 {
 584     ACPI_STATUS             Status;
 585     ACPI_HANDLE             ChildHandle;
 586     ACPI_HANDLE             ParentHandle;
 587     ACPI_HANDLE             NextChildHandle;
 588     ACPI_HANDLE             Dummy;
 589     UINT32                  Level;
 590
 591
 592     FUNCTION_TRACE ("NsDeleteSubtree");
 593
 594
 595     ParentHandle    = StartHandle;
 596     ChildHandle     = 0;
 597     Level           = 1;
 598
 599     /*
 600      * Traverse the tree of objects until we bubble back up
 601      * to where we started.
 602      */
 603
 604     while (Level > 0)
 605     {
 606         /* Attempt to get the next object in this scope */
 607
 608         Status = AcpiGetNextObject (ACPI_TYPE_ANY, ParentHandle,
 609                                     ChildHandle,
 610                                     &NextChildHandle);
 611
 612         ChildHandle = NextChildHandle;
 613
 614
 615         /* Did we get a new object? */
 616
 617         if (ACPI_SUCCESS (Status))
 618         {
 619             /* Check if this object has any children */
 620
 621             if (ACPI_SUCCESS (AcpiGetNextObject (ACPI_TYPE_ANY,
 622                                                 ChildHandle, 0,
 623                                                 &Dummy)))
 624             {
 625                 /*
 626                  * There is at least one child of this object,
 627                  * visit the object
 628                  */
 629
 630                 Level++;
 631                 ParentHandle    = ChildHandle;
 632                 ChildHandle     = 0;
 633             }
 634         }
 635
 636         else
 637         {
 638             /*
 639              * No more children in this object, go back up to
 640              * the object's parent
 641              */
 642             Level--;
 643
 644             /* Delete all children now */
 645
 646             AcpiNsDeleteChildren (ChildHandle);
 647
 648             ChildHandle = ParentHandle;
 649             AcpiGetParent (ParentHandle, &ParentHandle);
 650         }
 651     }
 652
 653     /* Now delete the starting object, and we are done */
 654
 655     AcpiNsDeleteNode (ChildHandle);
 656
 657
 658     return_ACPI_STATUS (AE_OK);
 659 }
 660
 661
 662 /****************************************************************************
 663  *
 664  *  FUNCTION:       AcpiNsUnloadNameSpace
 665  *
 666  *  PARAMETERS:     Handle          - Root of namespace subtree to be deleted
 667  *
 668  *  RETURN:         Status
 669  *
 670  *  DESCRIPTION:    Shrinks the namespace, typically in response to an undocking
 671  *                  event.  Deletes an entire subtree starting from (and
 672  *                  including) the given handle.
 673  *
 674  ****************************************************************************/
 675
 676 ACPI_STATUS
 677 AcpiNsUnloadNamespace (
 678     ACPI_HANDLE             Handle)
 679 {
 680     ACPI_STATUS             Status;
 681
 682
 683     FUNCTION_TRACE ("NsUnloadNameSpace");
 684
 685
 686     /* Parameter validation */
 687
 688     if (!AcpiGbl_RootNode)
 689     {
 690         return_ACPI_STATUS (AE_NO_NAMESPACE);
 691     }
 692
 693     if (!Handle)
 694     {
 695         return_ACPI_STATUS (AE_BAD_PARAMETER);
 696     }
 697
 698
 699     /* This function does the real work */
 700
 701     Status = AcpiNsDeleteSubtree (Handle);
 702
 703     return_ACPI_STATUS (Status);
 704 }
 705
 706