sys/contrib/dev/acpica/excreate.c

   1 /******************************************************************************
   2  *
   3  * Module Name: excreate - Named object creation
   4  *              $Revision: 101 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2004, 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
  88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90  * PARTICULAR PURPOSE.
  91  *
  92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99  * LIMITED REMEDY.
 100  *
 101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 102  * software or system incorporating such software without first obtaining any
 103  * required license or other approval from the U. S. Department of Commerce or
 104  * any other agency or department of the United States Government.  In the
 105  * event Licensee exports any such software from the United States or
 106  * re-exports any such software from a foreign destination, Licensee shall
 107  * ensure that the distribution and export/re-export of the software is in
 108  * compliance with all laws, regulations, orders, or other restrictions of the
 109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 110  * any of its subsidiaries will export/re-export any technical data, process,
 111  * software, or service, directly or indirectly, to any country for which the
 112  * United States government or any agency thereof requires an export license,
 113  * other governmental approval, or letter of assurance, without first obtaining
 114  * such license, approval or letter.
 115  *
 116  *****************************************************************************/
 117
 118 #define __EXCREATE_C__
 119
 120 #include "acpi.h"
 121 #include "acinterp.h"
 122 #include "amlcode.h"
 123 #include "acnamesp.h"
 124 #include "acevents.h"
 125 #include "actables.h"
 126
 127
 128 #define _COMPONENT          ACPI_EXECUTER
 129         ACPI_MODULE_NAME    ("excreate")
 130
 131
 132 #ifndef ACPI_NO_METHOD_EXECUTION
 133 /*****************************************************************************
 134  *
 135  * FUNCTION:    AcpiExCreateAlias
 136  *
 137  * PARAMETERS:  WalkState            - Current state, contains operands
 138  *
 139  * RETURN:      Status
 140  *
 141  * DESCRIPTION: Create a new named alias
 142  *
 143  ****************************************************************************/
 144
 145 ACPI_STATUS
 146 AcpiExCreateAlias (
 147     ACPI_WALK_STATE         *WalkState)
 148 {
 149     ACPI_NAMESPACE_NODE     *TargetNode;
 150     ACPI_NAMESPACE_NODE     *AliasNode;
 151     ACPI_STATUS             Status = AE_OK;
 152
 153
 154     ACPI_FUNCTION_TRACE ("ExCreateAlias");
 155
 156
 157     /* Get the source/alias operands (both namespace nodes) */
 158
 159     AliasNode =  (ACPI_NAMESPACE_NODE *) WalkState->Operands[0];
 160     TargetNode = (ACPI_NAMESPACE_NODE *) WalkState->Operands[1];
 161
 162     if (TargetNode->Type == ACPI_TYPE_LOCAL_ALIAS)
 163     {
 164         /*
 165          * Dereference an existing alias so that we don't create a chain
 166          * of aliases.  With this code, we guarantee that an alias is
 167          * always exactly one level of indirection away from the
 168          * actual aliased name.
 169          */
 170         TargetNode = (ACPI_NAMESPACE_NODE *) TargetNode->Object;
 171     }
 172
 173     /*
 174      * For objects that can never change (i.e., the NS node will
 175      * permanently point to the same object), we can simply attach
 176      * the object to the new NS node.  For other objects (such as
 177      * Integers, buffers, etc.), we have to point the Alias node
 178      * to the original Node.
 179      */
 180     switch (TargetNode->Type)
 181     {
 182     case ACPI_TYPE_INTEGER:
 183     case ACPI_TYPE_STRING:
 184     case ACPI_TYPE_BUFFER:
 185     case ACPI_TYPE_PACKAGE:
 186     case ACPI_TYPE_BUFFER_FIELD:
 187
 188         /*
 189          * The new alias has the type ALIAS and points to the original
 190          * NS node, not the object itself.  This is because for these
 191          * types, the object can change dynamically via a Store.
 192          */
 193         AliasNode->Type = ACPI_TYPE_LOCAL_ALIAS;
 194         AliasNode->Object = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, TargetNode);
 195         break;
 196
 197     default:
 198
 199         /* Attach the original source object to the new Alias Node */
 200
 201         /*
 202          * The new alias assumes the type of the target, and it points
 203          * to the same object.  The reference count of the object has an
 204          * additional reference to prevent deletion out from under either the
 205          * target node or the alias Node
 206          */
 207         Status = AcpiNsAttachObject (AliasNode,
 208                                 AcpiNsGetAttachedObject (TargetNode),
 209                                 TargetNode->Type);
 210         break;
 211     }
 212
 213     /* Since both operands are Nodes, we don't need to delete them */
 214
 215     return_ACPI_STATUS (Status);
 216 }
 217
 218
 219 /*****************************************************************************
 220  *
 221  * FUNCTION:    AcpiExCreateEvent
 222  *
 223  * PARAMETERS:  WalkState           - Current state
 224  *
 225  * RETURN:      Status
 226  *
 227  * DESCRIPTION: Create a new event object
 228  *
 229  ****************************************************************************/
 230
 231 ACPI_STATUS
 232 AcpiExCreateEvent (
 233     ACPI_WALK_STATE         *WalkState)
 234 {
 235     ACPI_STATUS             Status;
 236     ACPI_OPERAND_OBJECT     *ObjDesc;
 237
 238
 239     ACPI_FUNCTION_TRACE ("ExCreateEvent");
 240
 241
 242     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_EVENT);
 243     if (!ObjDesc)
 244     {
 245         Status = AE_NO_MEMORY;
 246         goto Cleanup;
 247     }
 248
 249     /*
 250      * Create the actual OS semaphore, with zero initial units -- meaning
 251      * that the event is created in an unsignalled state
 252      */
 253     Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0,
 254                                     &ObjDesc->Event.Semaphore);
 255     if (ACPI_FAILURE (Status))
 256     {
 257         goto Cleanup;
 258     }
 259
 260     /* Attach object to the Node */
 261
 262     Status = AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) WalkState->Operands[0],
 263                                     ObjDesc, ACPI_TYPE_EVENT);
 264
 265 Cleanup:
 266     /*
 267      * Remove local reference to the object (on error, will cause deletion
 268      * of both object and semaphore if present.)
 269      */
 270     AcpiUtRemoveReference (ObjDesc);
 271     return_ACPI_STATUS (Status);
 272 }
 273
 274
 275 /*****************************************************************************
 276  *
 277  * FUNCTION:    AcpiExCreateMutex
 278  *
 279  * PARAMETERS:  WalkState           - Current state
 280  *
 281  * RETURN:      Status
 282  *
 283  * DESCRIPTION: Create a new mutex object
 284  *
 285  *              Mutex (Name[0], SyncLevel[1])
 286  *
 287  ****************************************************************************/
 288
 289 ACPI_STATUS
 290 AcpiExCreateMutex (
 291     ACPI_WALK_STATE         *WalkState)
 292 {
 293     ACPI_STATUS             Status = AE_OK;
 294     ACPI_OPERAND_OBJECT     *ObjDesc;
 295
 296
 297     ACPI_FUNCTION_TRACE_PTR ("ExCreateMutex", ACPI_WALK_OPERANDS);
 298
 299
 300     /* Create the new mutex object */
 301
 302     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_MUTEX);
 303     if (!ObjDesc)
 304     {
 305         Status = AE_NO_MEMORY;
 306         goto Cleanup;
 307     }
 308
 309     /*
 310      * Create the actual OS semaphore.
 311      * One unit max to make it a mutex, with one initial unit to allow
 312      * the mutex to be acquired.
 313      */
 314     Status = AcpiOsCreateSemaphore (1, 1, &ObjDesc->Mutex.Semaphore);
 315     if (ACPI_FAILURE (Status))
 316     {
 317         goto Cleanup;
 318     }
 319
 320     /* Init object and attach to NS node */
 321
 322     ObjDesc->Mutex.SyncLevel = (UINT8) WalkState->Operands[1]->Integer.Value;
 323     ObjDesc->Mutex.Node = (ACPI_NAMESPACE_NODE *) WalkState->Operands[0];
 324
 325     Status = AcpiNsAttachObject (ObjDesc->Mutex.Node,
 326                 ObjDesc, ACPI_TYPE_MUTEX);
 327
 328
 329 Cleanup:
 330     /*
 331      * Remove local reference to the object (on error, will cause deletion
 332      * of both object and semaphore if present.)
 333      */
 334     AcpiUtRemoveReference (ObjDesc);
 335     return_ACPI_STATUS (Status);
 336 }
 337
 338
 339 /*****************************************************************************
 340  *
 341  * FUNCTION:    AcpiExCreateRegion
 342  *
 343  * PARAMETERS:  AmlStart            - Pointer to the region declaration AML
 344  *              AmlLength           - Max length of the declaration AML
 345  *              Operands            - List of operands for the opcode
 346  *              WalkState           - Current state
 347  *
 348  * RETURN:      Status
 349  *
 350  * DESCRIPTION: Create a new operation region object
 351  *
 352  ****************************************************************************/
 353
 354 ACPI_STATUS
 355 AcpiExCreateRegion (
 356     UINT8                   *AmlStart,
 357     UINT32                  AmlLength,
 358     UINT8                   RegionSpace,
 359     ACPI_WALK_STATE         *WalkState)
 360 {
 361     ACPI_STATUS             Status;
 362     ACPI_OPERAND_OBJECT     *ObjDesc;
 363     ACPI_NAMESPACE_NODE     *Node;
 364     ACPI_OPERAND_OBJECT     *RegionObj2;
 365
 366
 367     ACPI_FUNCTION_TRACE ("ExCreateRegion");
 368
 369
 370     /* Get the Namespace Node */
 371
 372     Node = WalkState->Op->Common.Node;
 373
 374     /*
 375      * If the region object is already attached to this node,
 376      * just return
 377      */
 378     if (AcpiNsGetAttachedObject (Node))
 379     {
 380         return_ACPI_STATUS (AE_OK);
 381     }
 382
 383     /*
 384      * Space ID must be one of the predefined IDs, or in the user-defined
 385      * range
 386      */
 387     if ((RegionSpace >= ACPI_NUM_PREDEFINED_REGIONS) &&
 388         (RegionSpace < ACPI_USER_REGION_BEGIN))
 389     {
 390         ACPI_REPORT_ERROR (("Invalid AddressSpace type %X\n", RegionSpace));
 391         return_ACPI_STATUS (AE_AML_INVALID_SPACE_ID);
 392     }
 393
 394     ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Region Type - %s (%X)\n",
 395                     AcpiUtGetRegionName (RegionSpace), RegionSpace));
 396
 397     /* Create the region descriptor */
 398
 399     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_REGION);
 400     if (!ObjDesc)
 401     {
 402         Status = AE_NO_MEMORY;
 403         goto Cleanup;
 404     }
 405
 406     /*
 407      * Remember location in AML stream of address & length
 408      * operands since they need to be evaluated at run time.
 409      */
 410     RegionObj2                  = ObjDesc->Common.NextObject;
 411     RegionObj2->Extra.AmlStart  = AmlStart;
 412     RegionObj2->Extra.AmlLength = AmlLength;
 413
 414     /* Init the region from the operands */
 415
 416     ObjDesc->Region.SpaceId = RegionSpace;
 417     ObjDesc->Region.Address = 0;
 418     ObjDesc->Region.Length  = 0;
 419     ObjDesc->Region.Node    = Node;
 420
 421     /* Install the new region object in the parent Node */
 422
 423     Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_REGION);
 424
 425
 426 Cleanup:
 427
 428     /* Remove local reference to the object */
 429
 430     AcpiUtRemoveReference (ObjDesc);
 431     return_ACPI_STATUS (Status);
 432 }
 433
 434
 435 /*****************************************************************************
 436  *
 437  * FUNCTION:    AcpiExCreateTableRegion
 438  *
 439  * PARAMETERS:  WalkState           - Current state
 440  *
 441  * RETURN:      Status
 442  *
 443  * DESCRIPTION: Create a new DataTableRegion object
 444  *
 445  ****************************************************************************/
 446
 447 ACPI_STATUS
 448 AcpiExCreateTableRegion (
 449     ACPI_WALK_STATE         *WalkState)
 450 {
 451     ACPI_STATUS             Status;
 452     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
 453     ACPI_OPERAND_OBJECT     *ObjDesc;
 454     ACPI_NAMESPACE_NODE     *Node;
 455     ACPI_TABLE_HEADER       *Table;
 456     ACPI_OPERAND_OBJECT     *RegionObj2;
 457
 458
 459     ACPI_FUNCTION_TRACE ("ExCreateTableRegion");
 460
 461
 462     /* Get the Node from the object stack  */
 463
 464     Node = WalkState->Op->Common.Node;
 465
 466     /*
 467      * If the region object is already attached to this node,
 468      * just return
 469      */
 470     if (AcpiNsGetAttachedObject (Node))
 471     {
 472         return_ACPI_STATUS (AE_OK);
 473     }
 474
 475     /* Find the ACPI table */
 476
 477     Status = AcpiTbFindTable (Operand[1]->String.Pointer,
 478                               Operand[2]->String.Pointer,
 479                               Operand[3]->String.Pointer, &Table);
 480     if (ACPI_FAILURE (Status))
 481     {
 482         return_ACPI_STATUS (Status);
 483     }
 484
 485     /* Create the region descriptor */
 486
 487     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_REGION);
 488     if (!ObjDesc)
 489     {
 490         return_ACPI_STATUS (AE_NO_MEMORY);
 491     }
 492
 493     RegionObj2                      = ObjDesc->Common.NextObject;
 494     RegionObj2->Extra.RegionContext = NULL;
 495
 496     /* Init the region from the operands */
 497
 498     ObjDesc->Region.SpaceId = REGION_DATA_TABLE;
 499     ObjDesc->Region.Address = (ACPI_PHYSICAL_ADDRESS) ACPI_TO_INTEGER (Table);
 500     ObjDesc->Region.Length  = Table->Length;
 501     ObjDesc->Region.Node    = Node;
 502     ObjDesc->Region.Flags   = AOPOBJ_DATA_VALID;
 503
 504     /* Install the new region object in the parent Node */
 505
 506     Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_REGION);
 507     if (ACPI_FAILURE (Status))
 508     {
 509         goto Cleanup;
 510     }
 511
 512     Status = AcpiEvInitializeRegion (ObjDesc, FALSE);
 513     if (ACPI_FAILURE (Status))
 514     {
 515         if (Status == AE_NOT_EXIST)
 516         {
 517             Status = AE_OK;
 518         }
 519         else
 520         {
 521             goto Cleanup;
 522         }
 523     }
 524
 525     ObjDesc->Region.Flags |= AOPOBJ_SETUP_COMPLETE;
 526
 527
 528 Cleanup:
 529
 530     /* Remove local reference to the object */
 531
 532     AcpiUtRemoveReference (ObjDesc);
 533     return_ACPI_STATUS (Status);
 534 }
 535
 536
 537 /*****************************************************************************
 538  *
 539  * FUNCTION:    AcpiExCreateProcessor
 540  *
 541  * PARAMETERS:  WalkState           - Current state
 542  *
 543  * RETURN:      Status
 544  *
 545  * DESCRIPTION: Create a new processor object and populate the fields
 546  *
 547  *              Processor (Name[0], CpuID[1], PblockAddr[2], PblockLength[3])
 548  *
 549  ****************************************************************************/
 550
 551 ACPI_STATUS
 552 AcpiExCreateProcessor (
 553     ACPI_WALK_STATE         *WalkState)
 554 {
 555     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
 556     ACPI_OPERAND_OBJECT     *ObjDesc;
 557     ACPI_STATUS             Status;
 558
 559
 560     ACPI_FUNCTION_TRACE_PTR ("ExCreateProcessor", WalkState);
 561
 562
 563     /* Create the processor object */
 564
 565     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PROCESSOR);
 566     if (!ObjDesc)
 567     {
 568         return_ACPI_STATUS (AE_NO_MEMORY);
 569     }
 570
 571     /*
 572      * Initialize the processor object from the operands
 573      */
 574     ObjDesc->Processor.ProcId  = (UINT8)           Operand[1]->Integer.Value;
 575     ObjDesc->Processor.Address = (ACPI_IO_ADDRESS) Operand[2]->Integer.Value;
 576     ObjDesc->Processor.Length  = (UINT8)           Operand[3]->Integer.Value;
 577
 578     /* Install the processor object in the parent Node */
 579
 580     Status = AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) Operand[0],
 581                     ObjDesc, ACPI_TYPE_PROCESSOR);
 582
 583     /* Remove local reference to the object */
 584
 585     AcpiUtRemoveReference (ObjDesc);
 586     return_ACPI_STATUS (Status);
 587 }
 588
 589
 590 /*****************************************************************************
 591  *
 592  * FUNCTION:    AcpiExCreatePowerResource
 593  *
 594  * PARAMETERS:  WalkState           - Current state
 595  *
 596  * RETURN:      Status
 597  *
 598  * DESCRIPTION: Create a new PowerResource object and populate the fields
 599  *
 600  *              PowerResource (Name[0], SystemLevel[1], ResourceOrder[2])
 601  *
 602  ****************************************************************************/
 603
 604 ACPI_STATUS
 605 AcpiExCreatePowerResource (
 606     ACPI_WALK_STATE         *WalkState)
 607 {
 608     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
 609     ACPI_STATUS             Status;
 610     ACPI_OPERAND_OBJECT     *ObjDesc;
 611
 612
 613     ACPI_FUNCTION_TRACE_PTR ("ExCreatePowerResource", WalkState);
 614
 615
 616     /* Create the power resource object */
 617
 618     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_POWER);
 619     if (!ObjDesc)
 620     {
 621         return_ACPI_STATUS (AE_NO_MEMORY);
 622     }
 623
 624     /* Initialize the power object from the operands */
 625
 626     ObjDesc->PowerResource.SystemLevel   = (UINT8)  Operand[1]->Integer.Value;
 627     ObjDesc->PowerResource.ResourceOrder = (UINT16) Operand[2]->Integer.Value;
 628
 629     /* Install the  power resource object in the parent Node */
 630
 631     Status = AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) Operand[0],
 632                     ObjDesc, ACPI_TYPE_POWER);
 633
 634     /* Remove local reference to the object */
 635
 636     AcpiUtRemoveReference (ObjDesc);
 637     return_ACPI_STATUS (Status);
 638 }
 639
 640 #endif
 641
 642 /*****************************************************************************
 643  *
 644  * FUNCTION:    AcpiExCreateMethod
 645  *
 646  * PARAMETERS:  AmlStart        - First byte of the method's AML
 647  *              AmlLength       - AML byte count for this method
 648  *              WalkState       - Current state
 649  *
 650  * RETURN:      Status
 651  *
 652  * DESCRIPTION: Create a new method object
 653  *
 654  ****************************************************************************/
 655
 656 ACPI_STATUS
 657 AcpiExCreateMethod (
 658     UINT8                   *AmlStart,
 659     UINT32                  AmlLength,
 660     ACPI_WALK_STATE         *WalkState)
 661 {
 662     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
 663     ACPI_OPERAND_OBJECT     *ObjDesc;
 664     ACPI_STATUS             Status;
 665     UINT8                   MethodFlags;
 666
 667
 668     ACPI_FUNCTION_TRACE_PTR ("ExCreateMethod", WalkState);
 669
 670
 671     /* Create a new method object */
 672
 673     ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);
 674     if (!ObjDesc)
 675     {
 676        return_ACPI_STATUS (AE_NO_MEMORY);
 677     }
 678
 679     /* Save the method's AML pointer and length  */
 680
 681     ObjDesc->Method.AmlStart  = AmlStart;
 682     ObjDesc->Method.AmlLength = AmlLength;
 683
 684     /* disassemble the method flags */
 685
 686     MethodFlags = (UINT8) Operand[1]->Integer.Value;
 687
 688     ObjDesc->Method.MethodFlags = MethodFlags;
 689     ObjDesc->Method.ParamCount  = (UINT8) (MethodFlags & METHOD_FLAGS_ARG_COUNT);
 690
 691     /*
 692      * Get the concurrency count.  If required, a semaphore will be
 693      * created for this method when it is parsed.
 694      */
 695     if (MethodFlags & METHOD_FLAGS_SERIALIZED)
 696     {
 697         /*
 698          * ACPI 1.0: Concurrency = 1
 699          * ACPI 2.0: Concurrency = (SyncLevel (in method declaration) + 1)
 700          */
 701         ObjDesc->Method.Concurrency = (UINT8)
 702                         (((MethodFlags & METHOD_FLAGS_SYNCH_LEVEL) >> 4) + 1);
 703     }
 704     else
 705     {
 706         ObjDesc->Method.Concurrency = INFINITE_CONCURRENCY;
 707     }
 708
 709     /* Attach the new object to the method Node */
 710
 711     Status = AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) Operand[0],
 712                     ObjDesc, ACPI_TYPE_METHOD);
 713
 714     /* Remove local reference to the object */
 715
 716     AcpiUtRemoveReference (ObjDesc);
 717
 718     /* Remove a reference to the operand */
 719
 720     AcpiUtRemoveReference (Operand[1]);
 721     return_ACPI_STATUS (Status);
 722 }
 723
 724