sys/contrib/dev/acpica/components/namespace/nsconvert.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nsconvert - Object conversions for objects returned by
   4  *                          predefined methods
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2017, 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  * Alternatively, you may choose to be licensed under the terms of the
 118  * following license:
 119  *
 120  * Redistribution and use in source and binary forms, with or without
 121  * modification, are permitted provided that the following conditions
 122  * are met:
 123  * 1. Redistributions of source code must retain the above copyright
 124  *    notice, this list of conditions, and the following disclaimer,
 125  *    without modification.
 126  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 127  *    substantially similar to the "NO WARRANTY" disclaimer below
 128  *    ("Disclaimer") and any redistribution must be conditioned upon
 129  *    including a substantially similar Disclaimer requirement for further
 130  *    binary redistribution.
 131  * 3. Neither the names of the above-listed copyright holders nor the names
 132  *    of any contributors may be used to endorse or promote products derived
 133  *    from this software without specific prior written permission.
 134  *
 135  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 136  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 137  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 138  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 139  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 140  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 141  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 142  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 143  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 144  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 145  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 146  *
 147  * Alternatively, you may choose to be licensed under the terms of the
 148  * GNU General Public License ("GPL") version 2 as published by the Free
 149  * Software Foundation.
 150  *
 151  *****************************************************************************/
 152
 153 #include <contrib/dev/acpica/include/acpi.h>
 154 #include <contrib/dev/acpica/include/accommon.h>
 155 #include <contrib/dev/acpica/include/acnamesp.h>
 156 #include <contrib/dev/acpica/include/acinterp.h>
 157 #include <contrib/dev/acpica/include/acpredef.h>
 158 #include <contrib/dev/acpica/include/amlresrc.h>
 159
 160 #define _COMPONENT          ACPI_NAMESPACE
 161         ACPI_MODULE_NAME    ("nsconvert")
 162
 163
 164 /*******************************************************************************
 165  *
 166  * FUNCTION:    AcpiNsConvertToInteger
 167  *
 168  * PARAMETERS:  OriginalObject      - Object to be converted
 169  *              ReturnObject        - Where the new converted object is returned
 170  *
 171  * RETURN:      Status. AE_OK if conversion was successful.
 172  *
 173  * DESCRIPTION: Attempt to convert a String/Buffer object to an Integer.
 174  *
 175  ******************************************************************************/
 176
 177 ACPI_STATUS
 178 AcpiNsConvertToInteger (
 179     ACPI_OPERAND_OBJECT     *OriginalObject,
 180     ACPI_OPERAND_OBJECT     **ReturnObject)
 181 {
 182     ACPI_OPERAND_OBJECT     *NewObject;
 183     ACPI_STATUS             Status;
 184     UINT64                  Value = 0;
 185     UINT32                  i;
 186
 187
 188     switch (OriginalObject->Common.Type)
 189     {
 190     case ACPI_TYPE_STRING:
 191
 192         /* String-to-Integer conversion */
 193
 194         Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer,
 195             AcpiGbl_IntegerByteWidth, &Value);
 196         if (ACPI_FAILURE (Status))
 197         {
 198             return (Status);
 199         }
 200         break;
 201
 202     case ACPI_TYPE_BUFFER:
 203
 204         /* Buffer-to-Integer conversion. Max buffer size is 64 bits. */
 205
 206         if (OriginalObject->Buffer.Length > 8)
 207         {
 208             return (AE_AML_OPERAND_TYPE);
 209         }
 210
 211         /* Extract each buffer byte to create the integer */
 212
 213         for (i = 0; i < OriginalObject->Buffer.Length; i++)
 214         {
 215             Value |= ((UINT64)
 216                 OriginalObject->Buffer.Pointer[i] << (i * 8));
 217         }
 218         break;
 219
 220     default:
 221
 222         return (AE_AML_OPERAND_TYPE);
 223     }
 224
 225     NewObject = AcpiUtCreateIntegerObject (Value);
 226     if (!NewObject)
 227     {
 228         return (AE_NO_MEMORY);
 229     }
 230
 231     *ReturnObject = NewObject;
 232     return (AE_OK);
 233 }
 234
 235
 236 /*******************************************************************************
 237  *
 238  * FUNCTION:    AcpiNsConvertToString
 239  *
 240  * PARAMETERS:  OriginalObject      - Object to be converted
 241  *              ReturnObject        - Where the new converted object is returned
 242  *
 243  * RETURN:      Status. AE_OK if conversion was successful.
 244  *
 245  * DESCRIPTION: Attempt to convert a Integer/Buffer object to a String.
 246  *
 247  ******************************************************************************/
 248
 249 ACPI_STATUS
 250 AcpiNsConvertToString (
 251     ACPI_OPERAND_OBJECT     *OriginalObject,
 252     ACPI_OPERAND_OBJECT     **ReturnObject)
 253 {
 254     ACPI_OPERAND_OBJECT     *NewObject;
 255     ACPI_SIZE               Length;
 256     ACPI_STATUS             Status;
 257
 258
 259     switch (OriginalObject->Common.Type)
 260     {
 261     case ACPI_TYPE_INTEGER:
 262         /*
 263          * Integer-to-String conversion. Commonly, convert
 264          * an integer of value 0 to a NULL string. The last element of
 265          * _BIF and _BIX packages occasionally need this fix.
 266          */
 267         if (OriginalObject->Integer.Value == 0)
 268         {
 269             /* Allocate a new NULL string object */
 270
 271             NewObject = AcpiUtCreateStringObject (0);
 272             if (!NewObject)
 273             {
 274                 return (AE_NO_MEMORY);
 275             }
 276         }
 277         else
 278         {
 279             Status = AcpiExConvertToString (OriginalObject,
 280                 &NewObject, ACPI_IMPLICIT_CONVERT_HEX);
 281             if (ACPI_FAILURE (Status))
 282             {
 283                 return (Status);
 284             }
 285         }
 286         break;
 287
 288     case ACPI_TYPE_BUFFER:
 289         /*
 290          * Buffer-to-String conversion. Use a ToString
 291          * conversion, no transform performed on the buffer data. The best
 292          * example of this is the _BIF method, where the string data from
 293          * the battery is often (incorrectly) returned as buffer object(s).
 294          */
 295         Length = 0;
 296         while ((Length < OriginalObject->Buffer.Length) &&
 297                 (OriginalObject->Buffer.Pointer[Length]))
 298         {
 299             Length++;
 300         }
 301
 302         /* Allocate a new string object */
 303
 304         NewObject = AcpiUtCreateStringObject (Length);
 305         if (!NewObject)
 306         {
 307             return (AE_NO_MEMORY);
 308         }
 309
 310         /*
 311          * Copy the raw buffer data with no transform. String is already NULL
 312          * terminated at Length+1.
 313          */
 314         memcpy (NewObject->String.Pointer,
 315             OriginalObject->Buffer.Pointer, Length);
 316         break;
 317
 318     default:
 319
 320         return (AE_AML_OPERAND_TYPE);
 321     }
 322
 323     *ReturnObject = NewObject;
 324     return (AE_OK);
 325 }
 326
 327
 328 /*******************************************************************************
 329  *
 330  * FUNCTION:    AcpiNsConvertToBuffer
 331  *
 332  * PARAMETERS:  OriginalObject      - Object to be converted
 333  *              ReturnObject        - Where the new converted object is returned
 334  *
 335  * RETURN:      Status. AE_OK if conversion was successful.
 336  *
 337  * DESCRIPTION: Attempt to convert a Integer/String/Package object to a Buffer.
 338  *
 339  ******************************************************************************/
 340
 341 ACPI_STATUS
 342 AcpiNsConvertToBuffer (
 343     ACPI_OPERAND_OBJECT     *OriginalObject,
 344     ACPI_OPERAND_OBJECT     **ReturnObject)
 345 {
 346     ACPI_OPERAND_OBJECT     *NewObject;
 347     ACPI_STATUS             Status;
 348     ACPI_OPERAND_OBJECT     **Elements;
 349     UINT32                  *DwordBuffer;
 350     UINT32                  Count;
 351     UINT32                  i;
 352
 353
 354     switch (OriginalObject->Common.Type)
 355     {
 356     case ACPI_TYPE_INTEGER:
 357         /*
 358          * Integer-to-Buffer conversion.
 359          * Convert the Integer to a packed-byte buffer. _MAT and other
 360          * objects need this sometimes, if a read has been performed on a
 361          * Field object that is less than or equal to the global integer
 362          * size (32 or 64 bits).
 363          */
 364         Status = AcpiExConvertToBuffer (OriginalObject, &NewObject);
 365         if (ACPI_FAILURE (Status))
 366         {
 367             return (Status);
 368         }
 369         break;
 370
 371     case ACPI_TYPE_STRING:
 372
 373         /* String-to-Buffer conversion. Simple data copy */
 374
 375         NewObject = AcpiUtCreateBufferObject
 376             (OriginalObject->String.Length);
 377         if (!NewObject)
 378         {
 379             return (AE_NO_MEMORY);
 380         }
 381
 382         memcpy (NewObject->Buffer.Pointer,
 383             OriginalObject->String.Pointer, OriginalObject->String.Length);
 384         break;
 385
 386     case ACPI_TYPE_PACKAGE:
 387         /*
 388          * This case is often seen for predefined names that must return a
 389          * Buffer object with multiple DWORD integers within. For example,
 390          * _FDE and _GTM. The Package can be converted to a Buffer.
 391          */
 392
 393         /* All elements of the Package must be integers */
 394
 395         Elements = OriginalObject->Package.Elements;
 396         Count = OriginalObject->Package.Count;
 397
 398         for (i = 0; i < Count; i++)
 399         {
 400             if ((!*Elements) ||
 401                 ((*Elements)->Common.Type != ACPI_TYPE_INTEGER))
 402             {
 403                 return (AE_AML_OPERAND_TYPE);
 404             }
 405             Elements++;
 406         }
 407
 408         /* Create the new buffer object to replace the Package */
 409
 410         NewObject = AcpiUtCreateBufferObject (ACPI_MUL_4 (Count));
 411         if (!NewObject)
 412         {
 413             return (AE_NO_MEMORY);
 414         }
 415
 416         /* Copy the package elements (integers) to the buffer as DWORDs */
 417
 418         Elements = OriginalObject->Package.Elements;
 419         DwordBuffer = ACPI_CAST_PTR (UINT32, NewObject->Buffer.Pointer);
 420
 421         for (i = 0; i < Count; i++)
 422         {
 423             *DwordBuffer = (UINT32) (*Elements)->Integer.Value;
 424             DwordBuffer++;
 425             Elements++;
 426         }
 427         break;
 428
 429     default:
 430
 431         return (AE_AML_OPERAND_TYPE);
 432     }
 433
 434     *ReturnObject = NewObject;
 435     return (AE_OK);
 436 }
 437
 438
 439 /*******************************************************************************
 440  *
 441  * FUNCTION:    AcpiNsConvertToUnicode
 442  *
 443  * PARAMETERS:  Scope               - Namespace node for the method/object
 444  *              OriginalObject      - ASCII String Object to be converted
 445  *              ReturnObject        - Where the new converted object is returned
 446  *
 447  * RETURN:      Status. AE_OK if conversion was successful.
 448  *
 449  * DESCRIPTION: Attempt to convert a String object to a Unicode string Buffer.
 450  *
 451  ******************************************************************************/
 452
 453 ACPI_STATUS
 454 AcpiNsConvertToUnicode (
 455     ACPI_NAMESPACE_NODE     *Scope,
 456     ACPI_OPERAND_OBJECT     *OriginalObject,
 457     ACPI_OPERAND_OBJECT     **ReturnObject)
 458 {
 459     ACPI_OPERAND_OBJECT     *NewObject;
 460     char                    *AsciiString;
 461     UINT16                  *UnicodeBuffer;
 462     UINT32                  UnicodeLength;
 463     UINT32                  i;
 464
 465
 466     if (!OriginalObject)
 467     {
 468         return (AE_OK);
 469     }
 470
 471     /* If a Buffer was returned, it must be at least two bytes long */
 472
 473     if (OriginalObject->Common.Type == ACPI_TYPE_BUFFER)
 474     {
 475         if (OriginalObject->Buffer.Length < 2)
 476         {
 477             return (AE_AML_OPERAND_VALUE);
 478         }
 479
 480         *ReturnObject = NULL;
 481         return (AE_OK);
 482     }
 483
 484     /*
 485      * The original object is an ASCII string. Convert this string to
 486      * a unicode buffer.
 487      */
 488     AsciiString = OriginalObject->String.Pointer;
 489     UnicodeLength = (OriginalObject->String.Length * 2) + 2;
 490
 491     /* Create a new buffer object for the Unicode data */
 492
 493     NewObject = AcpiUtCreateBufferObject (UnicodeLength);
 494     if (!NewObject)
 495     {
 496         return (AE_NO_MEMORY);
 497     }
 498
 499     UnicodeBuffer = ACPI_CAST_PTR (UINT16, NewObject->Buffer.Pointer);
 500
 501     /* Convert ASCII to Unicode */
 502
 503     for (i = 0; i < OriginalObject->String.Length; i++)
 504     {
 505         UnicodeBuffer[i] = (UINT16) AsciiString[i];
 506     }
 507
 508     *ReturnObject = NewObject;
 509     return (AE_OK);
 510 }
 511
 512
 513 /*******************************************************************************
 514  *
 515  * FUNCTION:    AcpiNsConvertToResource
 516  *
 517  * PARAMETERS:  Scope               - Namespace node for the method/object
 518  *              OriginalObject      - Object to be converted
 519  *              ReturnObject        - Where the new converted object is returned
 520  *
 521  * RETURN:      Status. AE_OK if conversion was successful
 522  *
 523  * DESCRIPTION: Attempt to convert a Integer object to a ResourceTemplate
 524  *              Buffer.
 525  *
 526  ******************************************************************************/
 527
 528 ACPI_STATUS
 529 AcpiNsConvertToResource (
 530     ACPI_NAMESPACE_NODE     *Scope,
 531     ACPI_OPERAND_OBJECT     *OriginalObject,
 532     ACPI_OPERAND_OBJECT     **ReturnObject)
 533 {
 534     ACPI_OPERAND_OBJECT     *NewObject;
 535     UINT8                   *Buffer;
 536
 537
 538     /*
 539      * We can fix the following cases for an expected resource template:
 540      * 1. No return value (interpreter slack mode is disabled)
 541      * 2. A "Return (Zero)" statement
 542      * 3. A "Return empty buffer" statement
 543      *
 544      * We will return a buffer containing a single EndTag
 545      * resource descriptor.
 546      */
 547     if (OriginalObject)
 548     {
 549         switch (OriginalObject->Common.Type)
 550         {
 551         case ACPI_TYPE_INTEGER:
 552
 553             /* We can only repair an Integer==0 */
 554
 555             if (OriginalObject->Integer.Value)
 556             {
 557                 return (AE_AML_OPERAND_TYPE);
 558             }
 559             break;
 560
 561         case ACPI_TYPE_BUFFER:
 562
 563             if (OriginalObject->Buffer.Length)
 564             {
 565                 /* Additional checks can be added in the future */
 566
 567                 *ReturnObject = NULL;
 568                 return (AE_OK);
 569             }
 570             break;
 571
 572         case ACPI_TYPE_STRING:
 573         default:
 574
 575             return (AE_AML_OPERAND_TYPE);
 576         }
 577     }
 578
 579     /* Create the new buffer object for the resource descriptor */
 580
 581     NewObject = AcpiUtCreateBufferObject (2);
 582     if (!NewObject)
 583     {
 584         return (AE_NO_MEMORY);
 585     }
 586
 587     Buffer = ACPI_CAST_PTR (UINT8, NewObject->Buffer.Pointer);
 588
 589     /* Initialize the Buffer with a single EndTag descriptor */
 590
 591     Buffer[0] = (ACPI_RESOURCE_NAME_END_TAG | ASL_RDESC_END_TAG_SIZE);
 592     Buffer[1] = 0x00;
 593
 594     *ReturnObject = NewObject;
 595     return (AE_OK);
 596 }
 597
 598
 599 /*******************************************************************************
 600  *
 601  * FUNCTION:    AcpiNsConvertToReference
 602  *
 603  * PARAMETERS:  Scope               - Namespace node for the method/object
 604  *              OriginalObject      - Object to be converted
 605  *              ReturnObject        - Where the new converted object is returned
 606  *
 607  * RETURN:      Status. AE_OK if conversion was successful
 608  *
 609  * DESCRIPTION: Attempt to convert a Integer object to a ObjectReference.
 610  *              Buffer.
 611  *
 612  ******************************************************************************/
 613
 614 ACPI_STATUS
 615 AcpiNsConvertToReference (
 616     ACPI_NAMESPACE_NODE     *Scope,
 617     ACPI_OPERAND_OBJECT     *OriginalObject,
 618     ACPI_OPERAND_OBJECT     **ReturnObject)
 619 {
 620     ACPI_OPERAND_OBJECT     *NewObject = NULL;
 621     ACPI_STATUS             Status;
 622     ACPI_NAMESPACE_NODE     *Node;
 623     ACPI_GENERIC_STATE      ScopeInfo;
 624     char                    *Name;
 625
 626
 627     ACPI_FUNCTION_NAME (NsConvertToReference);
 628
 629
 630     /* Convert path into internal presentation */
 631
 632     Status = AcpiNsInternalizeName (OriginalObject->String.Pointer, &Name);
 633     if (ACPI_FAILURE (Status))
 634     {
 635         return_ACPI_STATUS (Status);
 636     }
 637
 638     /* Find the namespace node */
 639
 640     ScopeInfo.Scope.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Scope);
 641     Status = AcpiNsLookup (&ScopeInfo, Name,
 642         ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 643         ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL, &Node);
 644     if (ACPI_FAILURE (Status))
 645     {
 646         /* Check if we are resolving a named reference within a package */
 647
 648         ACPI_ERROR_NAMESPACE (OriginalObject->String.Pointer, Status);
 649         goto ErrorExit;
 650     }
 651
 652     /* Create and init a new internal ACPI object */
 653
 654     NewObject = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_REFERENCE);
 655     if (!NewObject)
 656     {
 657         Status = AE_NO_MEMORY;
 658         goto ErrorExit;
 659     }
 660     NewObject->Reference.Node = Node;
 661     NewObject->Reference.Object = Node->Object;
 662     NewObject->Reference.Class = ACPI_REFCLASS_NAME;
 663
 664     /*
 665      * Increase reference of the object if needed (the object is likely a
 666      * null for device nodes).
 667      */
 668     AcpiUtAddReference (Node->Object);
 669
 670 ErrorExit:
 671     ACPI_FREE (Name);
 672     *ReturnObject = NewObject;
 673     return (AE_OK);
 674 }