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 - 2015, 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 EXPORT_ACPI_INTERFACES 46 47 #include "acpi.h" 48 #include "accommon.h" 49 #include "acnamesp.h" 50 #include "acparser.h" 51 #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_PNP_DEVICE_ID *Dest, 62 ACPI_PNP_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 (ACPI_IS_ROOT_PREFIX (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 (!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 char *NodeName; 181 182 183 /* Parameter validation */ 184 185 if (NameType > ACPI_NAME_TYPE_MAX) 186 { 187 return (AE_BAD_PARAMETER); 188 } 189 190 Status = AcpiUtValidateBuffer (Buffer); 191 if (ACPI_FAILURE (Status)) 192 { 193 return (Status); 194 } 195 196 if (NameType == ACPI_FULL_PATHNAME) 197 { 198 /* Get the full pathname (From the namespace root) */ 199 200 Status = AcpiNsHandleToPathname (Handle, Buffer); 201 return (Status); 202 } 203 204 /* 205 * Wants the single segment ACPI name. 206 * Validate handle and convert to a namespace Node 207 */ 208 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 209 if (ACPI_FAILURE (Status)) 210 { 211 return (Status); 212 } 213 214 Node = AcpiNsValidateHandle (Handle); 215 if (!Node) 216 { 217 Status = AE_BAD_PARAMETER; 218 goto UnlockAndExit; 219 } 220 221 /* Validate/Allocate/Clear caller buffer */ 222 223 Status = AcpiUtInitializeBuffer (Buffer, ACPI_PATH_SEGMENT_LENGTH); 224 if (ACPI_FAILURE (Status)) 225 { 226 goto UnlockAndExit; 227 } 228 229 /* Just copy the ACPI name from the Node and zero terminate it */ 230 231 NodeName = AcpiUtGetNodeName (Node); 232 ACPI_MOVE_NAME (Buffer->Pointer, NodeName); 233 ((char *) Buffer->Pointer) [ACPI_NAME_SIZE] = 0; 234 Status = AE_OK; 235 236 237 UnlockAndExit: 238 239 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 240 return (Status); 241 } 242 243 ACPI_EXPORT_SYMBOL (AcpiGetName) 244 245 246 /****************************************************************************** 247 * 248 * FUNCTION: AcpiNsCopyDeviceId 249 * 250 * PARAMETERS: Dest - Pointer to the destination PNP_DEVICE_ID 251 * Source - Pointer to the source PNP_DEVICE_ID 252 * StringArea - Pointer to where to copy the dest string 253 * 254 * RETURN: Pointer to the next string area 255 * 256 * DESCRIPTION: Copy a single PNP_DEVICE_ID, including the string data. 257 * 258 ******************************************************************************/ 259 260 static char * 261 AcpiNsCopyDeviceId ( 262 ACPI_PNP_DEVICE_ID *Dest, 263 ACPI_PNP_DEVICE_ID *Source, 264 char *StringArea) 265 { 266 267 /* Create the destination PNP_DEVICE_ID */ 268 269 Dest->String = StringArea; 270 Dest->Length = Source->Length; 271 272 /* Copy actual string and return a pointer to the next string area */ 273 274 memcpy (StringArea, Source->String, Source->Length); 275 return (StringArea + Source->Length); 276 } 277 278 279 /****************************************************************************** 280 * 281 * FUNCTION: AcpiGetObjectInfo 282 * 283 * PARAMETERS: Handle - Object Handle 284 * ReturnBuffer - Where the info is returned 285 * 286 * RETURN: Status 287 * 288 * DESCRIPTION: Returns information about an object as gleaned from the 289 * namespace node and possibly by running several standard 290 * control methods (Such as in the case of a device.) 291 * 292 * For Device and Processor objects, run the Device _HID, _UID, _CID, _SUB, 293 * _CLS, _STA, _ADR, _SxW, and _SxD methods. 294 * 295 * Note: Allocates the return buffer, must be freed by the caller. 296 * 297 ******************************************************************************/ 298 299 ACPI_STATUS 300 AcpiGetObjectInfo ( 301 ACPI_HANDLE Handle, 302 ACPI_DEVICE_INFO **ReturnBuffer) 303 { 304 ACPI_NAMESPACE_NODE *Node; 305 ACPI_DEVICE_INFO *Info; 306 ACPI_PNP_DEVICE_ID_LIST *CidList = NULL; 307 ACPI_PNP_DEVICE_ID *Hid = NULL; 308 ACPI_PNP_DEVICE_ID *Uid = NULL; 309 ACPI_PNP_DEVICE_ID *Sub = NULL; 310 ACPI_PNP_DEVICE_ID *Cls = NULL; 311 char *NextIdString; 312 ACPI_OBJECT_TYPE Type; 313 ACPI_NAME Name; 314 UINT8 ParamCount= 0; 315 UINT16 Valid = 0; 316 UINT32 InfoSize; 317 UINT32 i; 318 ACPI_STATUS Status; 319 320 321 /* Parameter validation */ 322 323 if (!Handle || !ReturnBuffer) 324 { 325 return (AE_BAD_PARAMETER); 326 } 327 328 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 329 if (ACPI_FAILURE (Status)) 330 { 331 return (Status); 332 } 333 334 Node = AcpiNsValidateHandle (Handle); 335 if (!Node) 336 { 337 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 338 return (AE_BAD_PARAMETER); 339 } 340 341 /* Get the namespace node data while the namespace is locked */ 342 343 InfoSize = sizeof (ACPI_DEVICE_INFO); 344 Type = Node->Type; 345 Name = Node->Name.Integer; 346 347 if (Node->Type == ACPI_TYPE_METHOD) 348 { 349 ParamCount = Node->Object->Method.ParamCount; 350 } 351 352 Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 353 if (ACPI_FAILURE (Status)) 354 { 355 return (Status); 356 } 357 358 if ((Type == ACPI_TYPE_DEVICE) || 359 (Type == ACPI_TYPE_PROCESSOR)) 360 { 361 /* 362 * Get extra info for ACPI Device/Processor objects only: 363 * Run the Device _HID, _UID, _SUB, _CID, and _CLS methods. 364 * 365 * Note: none of these methods are required, so they may or may 366 * not be present for this device. The Info->Valid bitfield is used 367 * to indicate which methods were found and run successfully. 368 */ 369 370 /* Execute the Device._HID method */ 371 372 Status = AcpiUtExecute_HID (Node, &Hid); 373 if (ACPI_SUCCESS (Status)) 374 { 375 InfoSize += Hid->Length; 376 Valid |= ACPI_VALID_HID; 377 } 378 379 /* Execute the Device._UID method */ 380 381 Status = AcpiUtExecute_UID (Node, &Uid); 382 if (ACPI_SUCCESS (Status)) 383 { 384 InfoSize += Uid->Length; 385 Valid |= ACPI_VALID_UID; 386 } 387 388 /* Execute the Device._SUB method */ 389 390 Status = AcpiUtExecute_SUB (Node, &Sub); 391 if (ACPI_SUCCESS (Status)) 392 { 393 InfoSize += Sub->Length; 394 Valid |= ACPI_VALID_SUB; 395 } 396 397 /* Execute the Device._CID method */ 398 399 Status = AcpiUtExecute_CID (Node, &CidList); 400 if (ACPI_SUCCESS (Status)) 401 { 402 /* Add size of CID strings and CID pointer array */ 403 404 InfoSize += (CidList->ListSize - sizeof (ACPI_PNP_DEVICE_ID_LIST)); 405 Valid |= ACPI_VALID_CID; 406 } 407 408 /* Execute the Device._CLS method */ 409 410 Status = AcpiUtExecute_CLS (Node, &Cls); 411 if (ACPI_SUCCESS (Status)) 412 { 413 InfoSize += Cls->Length; 414 Valid |= ACPI_VALID_CLS; 415 } 416 } 417 418 /* 419 * Now that we have the variable-length data, we can allocate the 420 * return buffer 421 */ 422 Info = ACPI_ALLOCATE_ZEROED (InfoSize); 423 if (!Info) 424 { 425 Status = AE_NO_MEMORY; 426 goto Cleanup; 427 } 428 429 /* Get the fixed-length data */ 430 431 if ((Type == ACPI_TYPE_DEVICE) || 432 (Type == ACPI_TYPE_PROCESSOR)) 433 { 434 /* 435 * Get extra info for ACPI Device/Processor objects only: 436 * Run the _STA, _ADR and, SxW, and _SxD methods. 437 * 438 * Notes: none of these methods are required, so they may or may 439 * not be present for this device. The Info->Valid bitfield is used 440 * to indicate which methods were found and run successfully. 441 * 442 * For _STA, if the method does not exist, then (as per the ACPI 443 * specification), the returned CurrentStatus flags will indicate 444 * that the device is present/functional/enabled. Otherwise, the 445 * CurrentStatus flags reflect the value returned from _STA. 446 */ 447 448 /* Execute the Device._STA method */ 449 450 Status = AcpiUtExecute_STA (Node, &Info->CurrentStatus); 451 if (ACPI_SUCCESS (Status)) 452 { 453 Valid |= ACPI_VALID_STA; 454 } 455 456 /* Execute the Device._ADR method */ 457 458 Status = AcpiUtEvaluateNumericObject (METHOD_NAME__ADR, Node, 459 &Info->Address); 460 if (ACPI_SUCCESS (Status)) 461 { 462 Valid |= ACPI_VALID_ADR; 463 } 464 465 /* Execute the Device._SxW methods */ 466 467 Status = AcpiUtExecutePowerMethods (Node, 468 AcpiGbl_LowestDstateNames, ACPI_NUM_SxW_METHODS, 469 Info->LowestDstates); 470 if (ACPI_SUCCESS (Status)) 471 { 472 Valid |= ACPI_VALID_SXWS; 473 } 474 475 /* Execute the Device._SxD methods */ 476 477 Status = AcpiUtExecutePowerMethods (Node, 478 AcpiGbl_HighestDstateNames, ACPI_NUM_SxD_METHODS, 479 Info->HighestDstates); 480 if (ACPI_SUCCESS (Status)) 481 { 482 Valid |= ACPI_VALID_SXDS; 483 } 484 } 485 486 /* 487 * Create a pointer to the string area of the return buffer. 488 * Point to the end of the base ACPI_DEVICE_INFO structure. 489 */ 490 NextIdString = ACPI_CAST_PTR (char, Info->CompatibleIdList.Ids); 491 if (CidList) 492 { 493 /* Point past the CID PNP_DEVICE_ID array */ 494 495 NextIdString += ((ACPI_SIZE) CidList->Count * sizeof (ACPI_PNP_DEVICE_ID)); 496 } 497 498 /* 499 * Copy the HID, UID, SUB, and CIDs to the return buffer. 500 * The variable-length strings are copied to the reserved area 501 * at the end of the buffer. 502 * 503 * For HID and CID, check if the ID is a PCI Root Bridge. 504 */ 505 if (Hid) 506 { 507 NextIdString = AcpiNsCopyDeviceId (&Info->HardwareId, 508 Hid, NextIdString); 509 510 if (AcpiUtIsPciRootBridge (Hid->String)) 511 { 512 Info->Flags |= ACPI_PCI_ROOT_BRIDGE; 513 } 514 } 515 516 if (Uid) 517 { 518 NextIdString = AcpiNsCopyDeviceId (&Info->UniqueId, 519 Uid, NextIdString); 520 } 521 522 if (Sub) 523 { 524 NextIdString = AcpiNsCopyDeviceId (&Info->SubsystemId, 525 Sub, NextIdString); 526 } 527 528 if (CidList) 529 { 530 Info->CompatibleIdList.Count = CidList->Count; 531 Info->CompatibleIdList.ListSize = CidList->ListSize; 532 533 /* Copy each CID */ 534 535 for (i = 0; i < CidList->Count; i++) 536 { 537 NextIdString = AcpiNsCopyDeviceId (&Info->CompatibleIdList.Ids[i], 538 &CidList->Ids[i], NextIdString); 539 540 if (AcpiUtIsPciRootBridge (CidList->Ids[i].String)) 541 { 542 Info->Flags |= ACPI_PCI_ROOT_BRIDGE; 543 } 544 } 545 } 546 547 if (Cls) 548 { 549 NextIdString = AcpiNsCopyDeviceId (&Info->ClassCode, 550 Cls, NextIdString); 551 } 552 553 /* Copy the fixed-length data */ 554 555 Info->InfoSize = InfoSize; 556 Info->Type = Type; 557 Info->Name = Name; 558 Info->ParamCount = ParamCount; 559 Info->Valid = Valid; 560 561 *ReturnBuffer = Info; 562 Status = AE_OK; 563 564 565 Cleanup: 566 if (Hid) 567 { 568 ACPI_FREE (Hid); 569 } 570 if (Uid) 571 { 572 ACPI_FREE (Uid); 573 } 574 if (Sub) 575 { 576 ACPI_FREE (Sub); 577 } 578 if (CidList) 579 { 580 ACPI_FREE (CidList); 581 } 582 if (Cls) 583 { 584 ACPI_FREE (Cls); 585 } 586 return (Status); 587 } 588 589 ACPI_EXPORT_SYMBOL (AcpiGetObjectInfo) 590 591 592 /****************************************************************************** 593 * 594 * FUNCTION: AcpiInstallMethod 595 * 596 * PARAMETERS: Buffer - An ACPI table containing one control method 597 * 598 * RETURN: Status 599 * 600 * DESCRIPTION: Install a control method into the namespace. If the method 601 * name already exists in the namespace, it is overwritten. The 602 * input buffer must contain a valid DSDT or SSDT containing a 603 * single control method. 604 * 605 ******************************************************************************/ 606 607 ACPI_STATUS 608 AcpiInstallMethod ( 609 UINT8 *Buffer) 610 { 611 ACPI_TABLE_HEADER *Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, Buffer); 612 UINT8 *AmlBuffer; 613 UINT8 *AmlStart; 614 char *Path; 615 ACPI_NAMESPACE_NODE *Node; 616 ACPI_OPERAND_OBJECT *MethodObj; 617 ACPI_PARSE_STATE ParserState; 618 UINT32 AmlLength; 619 UINT16 Opcode; 620 UINT8 MethodFlags; 621 ACPI_STATUS Status; 622 623 624 /* Parameter validation */ 625 626 if (!Buffer) 627 { 628 return (AE_BAD_PARAMETER); 629 } 630 631 /* Table must be a DSDT or SSDT */ 632 633 if (!ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_DSDT) && 634 !ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_SSDT)) 635 { 636 return (AE_BAD_HEADER); 637 } 638 639 /* First AML opcode in the table must be a control method */ 640 641 ParserState.Aml = Buffer + sizeof (ACPI_TABLE_HEADER); 642 Opcode = AcpiPsPeekOpcode (&ParserState); 643 if (Opcode != AML_METHOD_OP) 644 { 645 return (AE_BAD_PARAMETER); 646 } 647 648 /* Extract method information from the raw AML */ 649 650 ParserState.Aml += AcpiPsGetOpcodeSize (Opcode); 651 ParserState.PkgEnd = AcpiPsGetNextPackageEnd (&ParserState); 652 Path = AcpiPsGetNextNamestring (&ParserState); 653 MethodFlags = *ParserState.Aml++; 654 AmlStart = ParserState.Aml; 655 AmlLength = ACPI_PTR_DIFF (ParserState.PkgEnd, AmlStart); 656 657 /* 658 * Allocate resources up-front. We don't want to have to delete a new 659 * node from the namespace if we cannot allocate memory. 660 */ 661 AmlBuffer = ACPI_ALLOCATE (AmlLength); 662 if (!AmlBuffer) 663 { 664 return (AE_NO_MEMORY); 665 } 666 667 MethodObj = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD); 668 if (!MethodObj) 669 { 670 ACPI_FREE (AmlBuffer); 671 return (AE_NO_MEMORY); 672 } 673 674 /* Lock namespace for AcpiNsLookup, we may be creating a new node */ 675 676 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 677 if (ACPI_FAILURE (Status)) 678 { 679 goto ErrorExit; 680 } 681 682 /* The lookup either returns an existing node or creates a new one */ 683 684 Status = AcpiNsLookup (NULL, Path, ACPI_TYPE_METHOD, ACPI_IMODE_LOAD_PASS1, 685 ACPI_NS_DONT_OPEN_SCOPE | ACPI_NS_ERROR_IF_FOUND, NULL, &Node); 686 687 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 688 689 if (ACPI_FAILURE (Status)) /* NsLookup */ 690 { 691 if (Status != AE_ALREADY_EXISTS) 692 { 693 goto ErrorExit; 694 } 695 696 /* Node existed previously, make sure it is a method node */ 697 698 if (Node->Type != ACPI_TYPE_METHOD) 699 { 700 Status = AE_TYPE; 701 goto ErrorExit; 702 } 703 } 704 705 /* Copy the method AML to the local buffer */ 706 707 memcpy (AmlBuffer, AmlStart, AmlLength); 708 709 /* Initialize the method object with the new method's information */ 710 711 MethodObj->Method.AmlStart = AmlBuffer; 712 MethodObj->Method.AmlLength = AmlLength; 713 714 MethodObj->Method.ParamCount = (UINT8) 715 (MethodFlags & AML_METHOD_ARG_COUNT); 716 717 if (MethodFlags & AML_METHOD_SERIALIZED) 718 { 719 MethodObj->Method.InfoFlags = ACPI_METHOD_SERIALIZED; 720 721 MethodObj->Method.SyncLevel = (UINT8) 722 ((MethodFlags & AML_METHOD_SYNC_LEVEL) >> 4); 723 } 724 725 /* 726 * Now that it is complete, we can attach the new method object to 727 * the method Node (detaches/deletes any existing object) 728 */ 729 Status = AcpiNsAttachObject (Node, MethodObj, ACPI_TYPE_METHOD); 730 731 /* 732 * Flag indicates AML buffer is dynamic, must be deleted later. 733 * Must be set only after attach above. 734 */ 735 Node->Flags |= ANOBJ_ALLOCATED_BUFFER; 736 737 /* Remove local reference to the method object */ 738 739 AcpiUtRemoveReference (MethodObj); 740 return (Status); 741 742 743 ErrorExit: 744 745 ACPI_FREE (AmlBuffer); 746 ACPI_FREE (MethodObj); 747 return (Status); 748 } 749 750 ACPI_EXPORT_SYMBOL (AcpiInstallMethod) 751