sys/contrib/dev/acpica/namespace/nsxfname.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nsxfname - Public interfaces to the ACPI subsystem
   4  *                         ACPI Namespace oriented interfaces
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  * Copyright (C) 2000 - 2011, Intel Corp.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions, and the following disclaimer,
  17  *    without modification.
  18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  19  *    substantially similar to the "NO WARRANTY" disclaimer below
  20  *    ("Disclaimer") and any redistribution must be conditioned upon
  21  *    including a substantially similar Disclaimer requirement for further
  22  *    binary redistribution.
  23  * 3. Neither the names of the above-listed copyright holders nor the names
  24  *    of any contributors may be used to endorse or promote products derived
  25  *    from this software without specific prior written permission.
  26  *
  27  * Alternatively, this software may be distributed under the terms of the
  28  * GNU General Public License ("GPL") version 2 as published by the Free
  29  * Software Foundation.
  30  *
  31  * NO WARRANTY
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42  * POSSIBILITY OF SUCH DAMAGES.
  43  */
  44
  45 #define __NSXFNAME_C__
  46
  47 #include <contrib/dev/acpica/include/acpi.h>
  48 #include <contrib/dev/acpica/include/accommon.h>
  49 #include <contrib/dev/acpica/include/acnamesp.h>
  50 #include <contrib/dev/acpica/include/acparser.h>
  51 #include <contrib/dev/acpica/include/amlcode.h>
  52
  53
  54 #define _COMPONENT          ACPI_NAMESPACE
  55         ACPI_MODULE_NAME    ("nsxfname")
  56
  57 /* Local prototypes */
  58
  59 static char *
  60 AcpiNsCopyDeviceId (
  61     ACPI_DEVICE_ID          *Dest,
  62     ACPI_DEVICE_ID          *Source,
  63     char                    *StringArea);
  64
  65
  66 /******************************************************************************
  67  *
  68  * FUNCTION:    AcpiGetHandle
  69  *
  70  * PARAMETERS:  Parent          - Object to search under (search scope).
  71  *              Pathname        - Pointer to an asciiz string containing the
  72  *                                name
  73  *              RetHandle       - Where the return handle is returned
  74  *
  75  * RETURN:      Status
  76  *
  77  * DESCRIPTION: This routine will search for a caller specified name in the
  78  *              name space.  The caller can restrict the search region by
  79  *              specifying a non NULL parent.  The parent value is itself a
  80  *              namespace handle.
  81  *
  82  ******************************************************************************/
  83
  84 ACPI_STATUS
  85 AcpiGetHandle (
  86     ACPI_HANDLE             Parent,
  87     ACPI_STRING             Pathname,
  88     ACPI_HANDLE             *RetHandle)
  89 {
  90     ACPI_STATUS             Status;
  91     ACPI_NAMESPACE_NODE     *Node = NULL;
  92     ACPI_NAMESPACE_NODE     *PrefixNode = NULL;
  93
  94
  95     ACPI_FUNCTION_ENTRY ();
  96
  97
  98     /* Parameter Validation */
  99
 100     if (!RetHandle || !Pathname)
 101     {
 102         return (AE_BAD_PARAMETER);
 103     }
 104
 105     /* Convert a parent handle to a prefix node */
 106
 107     if (Parent)
 108     {
 109         PrefixNode = AcpiNsValidateHandle (Parent);
 110         if (!PrefixNode)
 111         {
 112             return (AE_BAD_PARAMETER);
 113         }
 114     }
 115
 116     /*
 117      * Valid cases are:
 118      * 1) Fully qualified pathname
 119      * 2) Parent + Relative pathname
 120      *
 121      * Error for <null Parent + relative path>
 122      */
 123     if (AcpiNsValidRootPrefix (Pathname[0]))
 124     {
 125         /* Pathname is fully qualified (starts with '\') */
 126
 127         /* Special case for root-only, since we can't search for it */
 128
 129         if (!ACPI_STRCMP (Pathname, ACPI_NS_ROOT_PATH))
 130         {
 131             *RetHandle = ACPI_CAST_PTR (ACPI_HANDLE, AcpiGbl_RootNode);
 132             return (AE_OK);
 133         }
 134     }
 135     else if (!PrefixNode)
 136     {
 137         /* Relative path with null prefix is disallowed */
 138
 139         return (AE_BAD_PARAMETER);
 140     }
 141
 142     /* Find the Node and convert to a handle */
 143
 144     Status = AcpiNsGetNode (PrefixNode, Pathname, ACPI_NS_NO_UPSEARCH, &Node);
 145     if (ACPI_SUCCESS (Status))
 146     {
 147         *RetHandle = ACPI_CAST_PTR (ACPI_HANDLE, Node);
 148     }
 149
 150     return (Status);
 151 }
 152
 153 ACPI_EXPORT_SYMBOL (AcpiGetHandle)
 154
 155
 156 /******************************************************************************
 157  *
 158  * FUNCTION:    AcpiGetName
 159  *
 160  * PARAMETERS:  Handle          - Handle to be converted to a pathname
 161  *              NameType        - Full pathname or single segment
 162  *              Buffer          - Buffer for returned path
 163  *
 164  * RETURN:      Pointer to a string containing the fully qualified Name.
 165  *
 166  * DESCRIPTION: This routine returns the fully qualified name associated with
 167  *              the Handle parameter.  This and the AcpiPathnameToHandle are
 168  *              complementary functions.
 169  *
 170  ******************************************************************************/
 171
 172 ACPI_STATUS
 173 AcpiGetName (
 174     ACPI_HANDLE             Handle,
 175     UINT32                  NameType,
 176     ACPI_BUFFER             *Buffer)
 177 {
 178     ACPI_STATUS             Status;
 179     ACPI_NAMESPACE_NODE     *Node;
 180
 181
 182     /* Parameter validation */
 183
 184     if (NameType > ACPI_NAME_TYPE_MAX)
 185     {
 186         return (AE_BAD_PARAMETER);
 187     }
 188
 189     Status = AcpiUtValidateBuffer (Buffer);
 190     if (ACPI_FAILURE (Status))
 191     {
 192         return (Status);
 193     }
 194
 195     if (NameType == ACPI_FULL_PATHNAME)
 196     {
 197         /* Get the full pathname (From the namespace root) */
 198
 199         Status = AcpiNsHandleToPathname (Handle, Buffer);
 200         return (Status);
 201     }
 202
 203     /*
 204      * Wants the single segment ACPI name.
 205      * Validate handle and convert to a namespace Node
 206      */
 207     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 208     if (ACPI_FAILURE (Status))
 209     {
 210         return (Status);
 211     }
 212
 213     Node = AcpiNsValidateHandle (Handle);
 214     if (!Node)
 215     {
 216         Status = AE_BAD_PARAMETER;
 217         goto UnlockAndExit;
 218     }
 219
 220     /* Validate/Allocate/Clear caller buffer */
 221
 222     Status = AcpiUtInitializeBuffer (Buffer, ACPI_PATH_SEGMENT_LENGTH);
 223     if (ACPI_FAILURE (Status))
 224     {
 225         goto UnlockAndExit;
 226     }
 227
 228     /* Just copy the ACPI name from the Node and zero terminate it */
 229
 230     ACPI_STRNCPY (Buffer->Pointer, AcpiUtGetNodeName (Node),
 231                 ACPI_NAME_SIZE);
 232     ((char *) Buffer->Pointer) [ACPI_NAME_SIZE] = 0;
 233     Status = AE_OK;
 234
 235
 236 UnlockAndExit:
 237
 238     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 239     return (Status);
 240 }
 241
 242 ACPI_EXPORT_SYMBOL (AcpiGetName)
 243
 244
 245 /******************************************************************************
 246  *
 247  * FUNCTION:    AcpiNsCopyDeviceId
 248  *
 249  * PARAMETERS:  Dest                - Pointer to the destination DEVICE_ID
 250  *              Source              - Pointer to the source DEVICE_ID
 251  *              StringArea          - Pointer to where to copy the dest string
 252  *
 253  * RETURN:      Pointer to the next string area
 254  *
 255  * DESCRIPTION: Copy a single DEVICE_ID, including the string data.
 256  *
 257  ******************************************************************************/
 258
 259 static char *
 260 AcpiNsCopyDeviceId (
 261     ACPI_DEVICE_ID          *Dest,
 262     ACPI_DEVICE_ID          *Source,
 263     char                    *StringArea)
 264 {
 265     /* Create the destination DEVICE_ID */
 266
 267     Dest->String = StringArea;
 268     Dest->Length = Source->Length;
 269
 270     /* Copy actual string and return a pointer to the next string area */
 271
 272     ACPI_MEMCPY (StringArea, Source->String, Source->Length);
 273     return (StringArea + Source->Length);
 274 }
 275
 276
 277 /******************************************************************************
 278  *
 279  * FUNCTION:    AcpiGetObjectInfo
 280  *
 281  * PARAMETERS:  Handle              - Object Handle
 282  *              ReturnBuffer        - Where the info is returned
 283  *
 284  * RETURN:      Status
 285  *
 286  * DESCRIPTION: Returns information about an object as gleaned from the
 287  *              namespace node and possibly by running several standard
 288  *              control methods (Such as in the case of a device.)
 289  *
 290  * For Device and Processor objects, run the Device _HID, _UID, _CID, _STA,
 291  * _ADR, _SxW, and _SxD methods.
 292  *
 293  * Note: Allocates the return buffer, must be freed by the caller.
 294  *
 295  ******************************************************************************/
 296
 297 ACPI_STATUS
 298 AcpiGetObjectInfo (
 299     ACPI_HANDLE             Handle,
 300     ACPI_DEVICE_INFO        **ReturnBuffer)
 301 {
 302     ACPI_NAMESPACE_NODE     *Node;
 303     ACPI_DEVICE_INFO        *Info;
 304     ACPI_DEVICE_ID_LIST     *CidList = NULL;
 305     ACPI_DEVICE_ID          *Hid = NULL;
 306     ACPI_DEVICE_ID          *Uid = NULL;
 307     char                    *NextIdString;
 308     ACPI_OBJECT_TYPE        Type;
 309     ACPI_NAME               Name;
 310     UINT8                   ParamCount= 0;
 311     UINT8                   Valid = 0;
 312     UINT32                  InfoSize;
 313     UINT32                  i;
 314     ACPI_STATUS             Status;
 315
 316
 317     /* Parameter validation */
 318
 319     if (!Handle || !ReturnBuffer)
 320     {
 321         return (AE_BAD_PARAMETER);
 322     }
 323
 324     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 325     if (ACPI_FAILURE (Status))
 326     {
 327         goto Cleanup;
 328     }
 329
 330     Node = AcpiNsValidateHandle (Handle);
 331     if (!Node)
 332     {
 333         (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 334         return (AE_BAD_PARAMETER);
 335     }
 336
 337     /* Get the namespace node data while the namespace is locked */
 338
 339     InfoSize = sizeof (ACPI_DEVICE_INFO);
 340     Type = Node->Type;
 341     Name = Node->Name.Integer;
 342
 343     if (Node->Type == ACPI_TYPE_METHOD)
 344     {
 345         ParamCount = Node->Object->Method.ParamCount;
 346     }
 347
 348     Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 349     if (ACPI_FAILURE (Status))
 350     {
 351         return (Status);
 352     }
 353
 354     if ((Type == ACPI_TYPE_DEVICE) ||
 355         (Type == ACPI_TYPE_PROCESSOR))
 356     {
 357         /*
 358          * Get extra info for ACPI Device/Processor objects only:
 359          * Run the Device _HID, _UID, and _CID methods.
 360          *
 361          * Note: none of these methods are required, so they may or may
 362          * not be present for this device. The Info->Valid bitfield is used
 363          * to indicate which methods were found and run successfully.
 364          */
 365
 366         /* Execute the Device._HID method */
 367
 368         Status = AcpiUtExecute_HID (Node, &Hid);
 369         if (ACPI_SUCCESS (Status))
 370         {
 371             InfoSize += Hid->Length;
 372             Valid |= ACPI_VALID_HID;
 373         }
 374
 375         /* Execute the Device._UID method */
 376
 377         Status = AcpiUtExecute_UID (Node, &Uid);
 378         if (ACPI_SUCCESS (Status))
 379         {
 380             InfoSize += Uid->Length;
 381             Valid |= ACPI_VALID_UID;
 382         }
 383
 384         /* Execute the Device._CID method */
 385
 386         Status = AcpiUtExecute_CID (Node, &CidList);
 387         if (ACPI_SUCCESS (Status))
 388         {
 389             /* Add size of CID strings and CID pointer array */
 390
 391             InfoSize += (CidList->ListSize - sizeof (ACPI_DEVICE_ID_LIST));
 392             Valid |= ACPI_VALID_CID;
 393         }
 394     }
 395
 396     /*
 397      * Now that we have the variable-length data, we can allocate the
 398      * return buffer
 399      */
 400     Info = ACPI_ALLOCATE_ZEROED (InfoSize);
 401     if (!Info)
 402     {
 403         Status = AE_NO_MEMORY;
 404         goto Cleanup;
 405     }
 406
 407     /* Get the fixed-length data */
 408
 409     if ((Type == ACPI_TYPE_DEVICE) ||
 410         (Type == ACPI_TYPE_PROCESSOR))
 411     {
 412         /*
 413          * Get extra info for ACPI Device/Processor objects only:
 414          * Run the _STA, _ADR and, SxW, and _SxD methods.
 415          *
 416          * Note: none of these methods are required, so they may or may
 417          * not be present for this device. The Info->Valid bitfield is used
 418          * to indicate which methods were found and run successfully.
 419          */
 420
 421         /* Execute the Device._STA method */
 422
 423         Status = AcpiUtExecute_STA (Node, &Info->CurrentStatus);
 424         if (ACPI_SUCCESS (Status))
 425         {
 426             Valid |= ACPI_VALID_STA;
 427         }
 428
 429         /* Execute the Device._ADR method */
 430
 431         Status = AcpiUtEvaluateNumericObject (METHOD_NAME__ADR, Node,
 432                     &Info->Address);
 433         if (ACPI_SUCCESS (Status))
 434         {
 435             Valid |= ACPI_VALID_ADR;
 436         }
 437
 438         /* Execute the Device._SxW methods */
 439
 440         Status = AcpiUtExecutePowerMethods (Node,
 441                     AcpiGbl_LowestDstateNames, ACPI_NUM_SxW_METHODS,
 442                     Info->LowestDstates);
 443         if (ACPI_SUCCESS (Status))
 444         {
 445             Valid |= ACPI_VALID_SXWS;
 446         }
 447
 448         /* Execute the Device._SxD methods */
 449
 450         Status = AcpiUtExecutePowerMethods (Node,
 451                     AcpiGbl_HighestDstateNames, ACPI_NUM_SxD_METHODS,
 452                     Info->HighestDstates);
 453         if (ACPI_SUCCESS (Status))
 454         {
 455             Valid |= ACPI_VALID_SXDS;
 456         }
 457     }
 458
 459     /*
 460      * Create a pointer to the string area of the return buffer.
 461      * Point to the end of the base ACPI_DEVICE_INFO structure.
 462      */
 463     NextIdString = ACPI_CAST_PTR (char, Info->CompatibleIdList.Ids);
 464     if (CidList)
 465     {
 466         /* Point past the CID DEVICE_ID array */
 467
 468         NextIdString += ((ACPI_SIZE) CidList->Count * sizeof (ACPI_DEVICE_ID));
 469     }
 470
 471     /*
 472      * Copy the HID, UID, and CIDs to the return buffer. The variable-length
 473      * strings are copied to the reserved area at the end of the buffer.
 474      *
 475      * For HID and CID, check if the ID is a PCI Root Bridge.
 476      */
 477     if (Hid)
 478     {
 479         NextIdString = AcpiNsCopyDeviceId (&Info->HardwareId,
 480             Hid, NextIdString);
 481
 482         if (AcpiUtIsPciRootBridge (Hid->String))
 483         {
 484             Info->Flags |= ACPI_PCI_ROOT_BRIDGE;
 485         }
 486     }
 487
 488     if (Uid)
 489     {
 490         NextIdString = AcpiNsCopyDeviceId (&Info->UniqueId,
 491             Uid, NextIdString);
 492     }
 493
 494     if (CidList)
 495     {
 496         Info->CompatibleIdList.Count = CidList->Count;
 497         Info->CompatibleIdList.ListSize = CidList->ListSize;
 498
 499         /* Copy each CID */
 500
 501         for (i = 0; i < CidList->Count; i++)
 502         {
 503             NextIdString = AcpiNsCopyDeviceId (&Info->CompatibleIdList.Ids[i],
 504                 &CidList->Ids[i], NextIdString);
 505
 506             if (AcpiUtIsPciRootBridge (CidList->Ids[i].String))
 507             {
 508                 Info->Flags |= ACPI_PCI_ROOT_BRIDGE;
 509             }
 510         }
 511     }
 512
 513     /* Copy the fixed-length data */
 514
 515     Info->InfoSize = InfoSize;
 516     Info->Type = Type;
 517     Info->Name = Name;
 518     Info->ParamCount = ParamCount;
 519     Info->Valid = Valid;
 520
 521     *ReturnBuffer = Info;
 522     Status = AE_OK;
 523
 524
 525 Cleanup:
 526     if (Hid)
 527     {
 528         ACPI_FREE (Hid);
 529     }
 530     if (Uid)
 531     {
 532         ACPI_FREE (Uid);
 533     }
 534     if (CidList)
 535     {
 536         ACPI_FREE (CidList);
 537     }
 538     return (Status);
 539 }
 540
 541 ACPI_EXPORT_SYMBOL (AcpiGetObjectInfo)
 542
 543
 544 /******************************************************************************
 545  *
 546  * FUNCTION:    AcpiInstallMethod
 547  *
 548  * PARAMETERS:  Buffer         - An ACPI table containing one control method
 549  *
 550  * RETURN:      Status
 551  *
 552  * DESCRIPTION: Install a control method into the namespace. If the method
 553  *              name already exists in the namespace, it is overwritten. The
 554  *              input buffer must contain a valid DSDT or SSDT containing a
 555  *              single control method.
 556  *
 557  ******************************************************************************/
 558
 559 ACPI_STATUS
 560 AcpiInstallMethod (
 561     UINT8                   *Buffer)
 562 {
 563     ACPI_TABLE_HEADER       *Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, Buffer);
 564     UINT8                   *AmlBuffer;
 565     UINT8                   *AmlStart;
 566     char                    *Path;
 567     ACPI_NAMESPACE_NODE     *Node;
 568     ACPI_OPERAND_OBJECT     *MethodObj;
 569     ACPI_PARSE_STATE        ParserState;
 570     UINT32                  AmlLength;
 571     UINT16                  Opcode;
 572     UINT8                   MethodFlags;
 573     ACPI_STATUS             Status;
 574
 575
 576     /* Parameter validation */
 577
 578     if (!Buffer)
 579     {
 580         return (AE_BAD_PARAMETER);
 581     }
 582
 583     /* Table must be a DSDT or SSDT */
 584
 585     if (!ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_DSDT) &&
 586         !ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_SSDT))
 587     {
 588         return (AE_BAD_HEADER);
 589     }
 590
 591     /* First AML opcode in the table must be a control method */
 592
 593     ParserState.Aml = Buffer + sizeof (ACPI_TABLE_HEADER);
 594     Opcode = AcpiPsPeekOpcode (&ParserState);
 595     if (Opcode != AML_METHOD_OP)
 596     {
 597         return (AE_BAD_PARAMETER);
 598     }
 599
 600     /* Extract method information from the raw AML */
 601
 602     ParserState.Aml += AcpiPsGetOpcodeSize (Opcode);
 603     ParserState.PkgEnd = AcpiPsGetNextPackageEnd (&ParserState);
 604     Path = AcpiPsGetNextNamestring (&ParserState);
 605     MethodFlags = *ParserState.Aml++;
 606     AmlStart = ParserState.Aml;
 607     AmlLength = ACPI_PTR_DIFF (ParserState.PkgEnd, AmlStart);
 608
 609     /*
 610      * Allocate resources up-front. We don't want to have to delete a new
 611      * node from the namespace if we cannot allocate memory.
 612      */
 613     AmlBuffer = ACPI_ALLOCATE (AmlLength);
 614     if (!AmlBuffer)
 615     {
 616         return (AE_NO_MEMORY);
 617     }
 618
 619     MethodObj = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);
 620     if (!MethodObj)
 621     {
 622         ACPI_FREE (AmlBuffer);
 623         return (AE_NO_MEMORY);
 624     }
 625
 626     /* Lock namespace for AcpiNsLookup, we may be creating a new node */
 627
 628     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 629     if (ACPI_FAILURE (Status))
 630     {
 631         goto ErrorExit;
 632     }
 633
 634     /* The lookup either returns an existing node or creates a new one */
 635
 636     Status = AcpiNsLookup (NULL, Path, ACPI_TYPE_METHOD, ACPI_IMODE_LOAD_PASS1,
 637                 ACPI_NS_DONT_OPEN_SCOPE | ACPI_NS_ERROR_IF_FOUND, NULL, &Node);
 638
 639     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 640
 641     if (ACPI_FAILURE (Status)) /* NsLookup */
 642     {
 643         if (Status != AE_ALREADY_EXISTS)
 644         {
 645             goto ErrorExit;
 646         }
 647
 648         /* Node existed previously, make sure it is a method node */
 649
 650         if (Node->Type != ACPI_TYPE_METHOD)
 651         {
 652             Status = AE_TYPE;
 653             goto ErrorExit;
 654         }
 655     }
 656
 657     /* Copy the method AML to the local buffer */
 658
 659     ACPI_MEMCPY (AmlBuffer, AmlStart, AmlLength);
 660
 661     /* Initialize the method object with the new method's information */
 662
 663     MethodObj->Method.AmlStart = AmlBuffer;
 664     MethodObj->Method.AmlLength = AmlLength;
 665
 666     MethodObj->Method.ParamCount = (UINT8)
 667         (MethodFlags & AML_METHOD_ARG_COUNT);
 668
 669     if (MethodFlags & AML_METHOD_SERIALIZED)
 670     {
 671         MethodObj->Method.InfoFlags = ACPI_METHOD_SERIALIZED;
 672
 673         MethodObj->Method.SyncLevel = (UINT8)
 674             ((MethodFlags & AML_METHOD_SYNC_LEVEL) >> 4);
 675     }
 676
 677     /*
 678      * Now that it is complete, we can attach the new method object to
 679      * the method Node (detaches/deletes any existing object)
 680      */
 681     Status = AcpiNsAttachObject (Node, MethodObj, ACPI_TYPE_METHOD);
 682
 683     /*
 684      * Flag indicates AML buffer is dynamic, must be deleted later.
 685      * Must be set only after attach above.
 686      */
 687     Node->Flags |= ANOBJ_ALLOCATED_BUFFER;
 688
 689     /* Remove local reference to the method object */
 690
 691     AcpiUtRemoveReference (MethodObj);
 692     return (Status);
 693
 694
 695 ErrorExit:
 696
 697     ACPI_FREE (AmlBuffer);
 698     ACPI_FREE (MethodObj);
 699     return (Status);
 700 }
 701
 702 ACPI_EXPORT_SYMBOL (AcpiInstallMethod)