1/******************************************************************************
2 *
3 * Module Name: nsconvert - Object conversions for objects returned by
4 *                          predefined methods
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2016, 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#include <contrib/dev/acpica/include/acpi.h>
46#include <contrib/dev/acpica/include/accommon.h>
47#include <contrib/dev/acpica/include/acnamesp.h>
48#include <contrib/dev/acpica/include/acinterp.h>
49#include <contrib/dev/acpica/include/acpredef.h>
50#include <contrib/dev/acpica/include/amlresrc.h>
51
52#define _COMPONENT          ACPI_NAMESPACE
53        ACPI_MODULE_NAME    ("nsconvert")
54
55
56/*******************************************************************************
57 *
58 * FUNCTION:    AcpiNsConvertToInteger
59 *
60 * PARAMETERS:  OriginalObject      - Object to be converted
61 *              ReturnObject        - Where the new converted object is returned
62 *
63 * RETURN:      Status. AE_OK if conversion was successful.
64 *
65 * DESCRIPTION: Attempt to convert a String/Buffer object to an Integer.
66 *
67 ******************************************************************************/
68
69ACPI_STATUS
70AcpiNsConvertToInteger (
71    ACPI_OPERAND_OBJECT     *OriginalObject,
72    ACPI_OPERAND_OBJECT     **ReturnObject)
73{
74    ACPI_OPERAND_OBJECT     *NewObject;
75    ACPI_STATUS             Status;
76    UINT64                  Value = 0;
77    UINT32                  i;
78
79
80    switch (OriginalObject->Common.Type)
81    {
82    case ACPI_TYPE_STRING:
83
84        /* String-to-Integer conversion */
85
86        Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer,
87            ACPI_ANY_BASE, AcpiGbl_IntegerByteWidth, &Value);
88        if (ACPI_FAILURE (Status))
89        {
90            return (Status);
91        }
92        break;
93
94    case ACPI_TYPE_BUFFER:
95
96        /* Buffer-to-Integer conversion. Max buffer size is 64 bits. */
97
98        if (OriginalObject->Buffer.Length > 8)
99        {
100            return (AE_AML_OPERAND_TYPE);
101        }
102
103        /* Extract each buffer byte to create the integer */
104
105        for (i = 0; i < OriginalObject->Buffer.Length; i++)
106        {
107            Value |= ((UINT64)
108                OriginalObject->Buffer.Pointer[i] << (i * 8));
109        }
110        break;
111
112    default:
113
114        return (AE_AML_OPERAND_TYPE);
115    }
116
117    NewObject = AcpiUtCreateIntegerObject (Value);
118    if (!NewObject)
119    {
120        return (AE_NO_MEMORY);
121    }
122
123    *ReturnObject = NewObject;
124    return (AE_OK);
125}
126
127
128/*******************************************************************************
129 *
130 * FUNCTION:    AcpiNsConvertToString
131 *
132 * PARAMETERS:  OriginalObject      - Object to be converted
133 *              ReturnObject        - Where the new converted object is returned
134 *
135 * RETURN:      Status. AE_OK if conversion was successful.
136 *
137 * DESCRIPTION: Attempt to convert a Integer/Buffer object to a String.
138 *
139 ******************************************************************************/
140
141ACPI_STATUS
142AcpiNsConvertToString (
143    ACPI_OPERAND_OBJECT     *OriginalObject,
144    ACPI_OPERAND_OBJECT     **ReturnObject)
145{
146    ACPI_OPERAND_OBJECT     *NewObject;
147    ACPI_SIZE               Length;
148    ACPI_STATUS             Status;
149
150
151    switch (OriginalObject->Common.Type)
152    {
153    case ACPI_TYPE_INTEGER:
154        /*
155         * Integer-to-String conversion. Commonly, convert
156         * an integer of value 0 to a NULL string. The last element of
157         * _BIF and _BIX packages occasionally need this fix.
158         */
159        if (OriginalObject->Integer.Value == 0)
160        {
161            /* Allocate a new NULL string object */
162
163            NewObject = AcpiUtCreateStringObject (0);
164            if (!NewObject)
165            {
166                return (AE_NO_MEMORY);
167            }
168        }
169        else
170        {
171            Status = AcpiExConvertToString (OriginalObject,
172                &NewObject, ACPI_IMPLICIT_CONVERT_HEX);
173            if (ACPI_FAILURE (Status))
174            {
175                return (Status);
176            }
177        }
178        break;
179
180    case ACPI_TYPE_BUFFER:
181        /*
182         * Buffer-to-String conversion. Use a ToString
183         * conversion, no transform performed on the buffer data. The best
184         * example of this is the _BIF method, where the string data from
185         * the battery is often (incorrectly) returned as buffer object(s).
186         */
187        Length = 0;
188        while ((Length < OriginalObject->Buffer.Length) &&
189                (OriginalObject->Buffer.Pointer[Length]))
190        {
191            Length++;
192        }
193
194        /* Allocate a new string object */
195
196        NewObject = AcpiUtCreateStringObject (Length);
197        if (!NewObject)
198        {
199            return (AE_NO_MEMORY);
200        }
201
202        /*
203         * Copy the raw buffer data with no transform. String is already NULL
204         * terminated at Length+1.
205         */
206        memcpy (NewObject->String.Pointer,
207            OriginalObject->Buffer.Pointer, Length);
208        break;
209
210    default:
211
212        return (AE_AML_OPERAND_TYPE);
213    }
214
215    *ReturnObject = NewObject;
216    return (AE_OK);
217}
218
219
220/*******************************************************************************
221 *
222 * FUNCTION:    AcpiNsConvertToBuffer
223 *
224 * PARAMETERS:  OriginalObject      - Object to be converted
225 *              ReturnObject        - Where the new converted object is returned
226 *
227 * RETURN:      Status. AE_OK if conversion was successful.
228 *
229 * DESCRIPTION: Attempt to convert a Integer/String/Package object to a Buffer.
230 *
231 ******************************************************************************/
232
233ACPI_STATUS
234AcpiNsConvertToBuffer (
235    ACPI_OPERAND_OBJECT     *OriginalObject,
236    ACPI_OPERAND_OBJECT     **ReturnObject)
237{
238    ACPI_OPERAND_OBJECT     *NewObject;
239    ACPI_STATUS             Status;
240    ACPI_OPERAND_OBJECT     **Elements;
241    UINT32                  *DwordBuffer;
242    UINT32                  Count;
243    UINT32                  i;
244
245
246    switch (OriginalObject->Common.Type)
247    {
248    case ACPI_TYPE_INTEGER:
249        /*
250         * Integer-to-Buffer conversion.
251         * Convert the Integer to a packed-byte buffer. _MAT and other
252         * objects need this sometimes, if a read has been performed on a
253         * Field object that is less than or equal to the global integer
254         * size (32 or 64 bits).
255         */
256        Status = AcpiExConvertToBuffer (OriginalObject, &NewObject);
257        if (ACPI_FAILURE (Status))
258        {
259            return (Status);
260        }
261        break;
262
263    case ACPI_TYPE_STRING:
264
265        /* String-to-Buffer conversion. Simple data copy */
266
267        NewObject = AcpiUtCreateBufferObject
268            (OriginalObject->String.Length);
269        if (!NewObject)
270        {
271            return (AE_NO_MEMORY);
272        }
273
274        memcpy (NewObject->Buffer.Pointer,
275            OriginalObject->String.Pointer, OriginalObject->String.Length);
276        break;
277
278    case ACPI_TYPE_PACKAGE:
279        /*
280         * This case is often seen for predefined names that must return a
281         * Buffer object with multiple DWORD integers within. For example,
282         * _FDE and _GTM. The Package can be converted to a Buffer.
283         */
284
285        /* All elements of the Package must be integers */
286
287        Elements = OriginalObject->Package.Elements;
288        Count = OriginalObject->Package.Count;
289
290        for (i = 0; i < Count; i++)
291        {
292            if ((!*Elements) ||
293                ((*Elements)->Common.Type != ACPI_TYPE_INTEGER))
294            {
295                return (AE_AML_OPERAND_TYPE);
296            }
297            Elements++;
298        }
299
300        /* Create the new buffer object to replace the Package */
301
302        NewObject = AcpiUtCreateBufferObject (ACPI_MUL_4 (Count));
303        if (!NewObject)
304        {
305            return (AE_NO_MEMORY);
306        }
307
308        /* Copy the package elements (integers) to the buffer as DWORDs */
309
310        Elements = OriginalObject->Package.Elements;
311        DwordBuffer = ACPI_CAST_PTR (UINT32, NewObject->Buffer.Pointer);
312
313        for (i = 0; i < Count; i++)
314        {
315            *DwordBuffer = (UINT32) (*Elements)->Integer.Value;
316            DwordBuffer++;
317            Elements++;
318        }
319        break;
320
321    default:
322
323        return (AE_AML_OPERAND_TYPE);
324    }
325
326    *ReturnObject = NewObject;
327    return (AE_OK);
328}
329
330
331/*******************************************************************************
332 *
333 * FUNCTION:    AcpiNsConvertToUnicode
334 *
335 * PARAMETERS:  Scope               - Namespace node for the method/object
336 *              OriginalObject      - ASCII String Object to be converted
337 *              ReturnObject        - Where the new converted object is returned
338 *
339 * RETURN:      Status. AE_OK if conversion was successful.
340 *
341 * DESCRIPTION: Attempt to convert a String object to a Unicode string Buffer.
342 *
343 ******************************************************************************/
344
345ACPI_STATUS
346AcpiNsConvertToUnicode (
347    ACPI_NAMESPACE_NODE     *Scope,
348    ACPI_OPERAND_OBJECT     *OriginalObject,
349    ACPI_OPERAND_OBJECT     **ReturnObject)
350{
351    ACPI_OPERAND_OBJECT     *NewObject;
352    char                    *AsciiString;
353    UINT16                  *UnicodeBuffer;
354    UINT32                  UnicodeLength;
355    UINT32                  i;
356
357
358    if (!OriginalObject)
359    {
360        return (AE_OK);
361    }
362
363    /* If a Buffer was returned, it must be at least two bytes long */
364
365    if (OriginalObject->Common.Type == ACPI_TYPE_BUFFER)
366    {
367        if (OriginalObject->Buffer.Length < 2)
368        {
369            return (AE_AML_OPERAND_VALUE);
370        }
371
372        *ReturnObject = NULL;
373        return (AE_OK);
374    }
375
376    /*
377     * The original object is an ASCII string. Convert this string to
378     * a unicode buffer.
379     */
380    AsciiString = OriginalObject->String.Pointer;
381    UnicodeLength = (OriginalObject->String.Length * 2) + 2;
382
383    /* Create a new buffer object for the Unicode data */
384
385    NewObject = AcpiUtCreateBufferObject (UnicodeLength);
386    if (!NewObject)
387    {
388        return (AE_NO_MEMORY);
389    }
390
391    UnicodeBuffer = ACPI_CAST_PTR (UINT16, NewObject->Buffer.Pointer);
392
393    /* Convert ASCII to Unicode */
394
395    for (i = 0; i < OriginalObject->String.Length; i++)
396    {
397        UnicodeBuffer[i] = (UINT16) AsciiString[i];
398    }
399
400    *ReturnObject = NewObject;
401    return (AE_OK);
402}
403
404
405/*******************************************************************************
406 *
407 * FUNCTION:    AcpiNsConvertToResource
408 *
409 * PARAMETERS:  Scope               - Namespace node for the method/object
410 *              OriginalObject      - Object to be converted
411 *              ReturnObject        - Where the new converted object is returned
412 *
413 * RETURN:      Status. AE_OK if conversion was successful
414 *
415 * DESCRIPTION: Attempt to convert a Integer object to a ResourceTemplate
416 *              Buffer.
417 *
418 ******************************************************************************/
419
420ACPI_STATUS
421AcpiNsConvertToResource (
422    ACPI_NAMESPACE_NODE     *Scope,
423    ACPI_OPERAND_OBJECT     *OriginalObject,
424    ACPI_OPERAND_OBJECT     **ReturnObject)
425{
426    ACPI_OPERAND_OBJECT     *NewObject;
427    UINT8                   *Buffer;
428
429
430    /*
431     * We can fix the following cases for an expected resource template:
432     * 1. No return value (interpreter slack mode is disabled)
433     * 2. A "Return (Zero)" statement
434     * 3. A "Return empty buffer" statement
435     *
436     * We will return a buffer containing a single EndTag
437     * resource descriptor.
438     */
439    if (OriginalObject)
440    {
441        switch (OriginalObject->Common.Type)
442        {
443        case ACPI_TYPE_INTEGER:
444
445            /* We can only repair an Integer==0 */
446
447            if (OriginalObject->Integer.Value)
448            {
449                return (AE_AML_OPERAND_TYPE);
450            }
451            break;
452
453        case ACPI_TYPE_BUFFER:
454
455            if (OriginalObject->Buffer.Length)
456            {
457                /* Additional checks can be added in the future */
458
459                *ReturnObject = NULL;
460                return (AE_OK);
461            }
462            break;
463
464        case ACPI_TYPE_STRING:
465        default:
466
467            return (AE_AML_OPERAND_TYPE);
468        }
469    }
470
471    /* Create the new buffer object for the resource descriptor */
472
473    NewObject = AcpiUtCreateBufferObject (2);
474    if (!NewObject)
475    {
476        return (AE_NO_MEMORY);
477    }
478
479    Buffer = ACPI_CAST_PTR (UINT8, NewObject->Buffer.Pointer);
480
481    /* Initialize the Buffer with a single EndTag descriptor */
482
483    Buffer[0] = (ACPI_RESOURCE_NAME_END_TAG | ASL_RDESC_END_TAG_SIZE);
484    Buffer[1] = 0x00;
485
486    *ReturnObject = NewObject;
487    return (AE_OK);
488}
489
490
491/*******************************************************************************
492 *
493 * FUNCTION:    AcpiNsConvertToReference
494 *
495 * PARAMETERS:  Scope               - Namespace node for the method/object
496 *              OriginalObject      - Object to be converted
497 *              ReturnObject        - Where the new converted object is returned
498 *
499 * RETURN:      Status. AE_OK if conversion was successful
500 *
501 * DESCRIPTION: Attempt to convert a Integer object to a ObjectReference.
502 *              Buffer.
503 *
504 ******************************************************************************/
505
506ACPI_STATUS
507AcpiNsConvertToReference (
508    ACPI_NAMESPACE_NODE     *Scope,
509    ACPI_OPERAND_OBJECT     *OriginalObject,
510    ACPI_OPERAND_OBJECT     **ReturnObject)
511{
512    ACPI_OPERAND_OBJECT     *NewObject = NULL;
513    ACPI_STATUS             Status;
514    ACPI_NAMESPACE_NODE     *Node;
515    ACPI_GENERIC_STATE      ScopeInfo;
516    char                    *Name;
517
518
519    ACPI_FUNCTION_NAME (NsConvertToReference);
520
521
522    /* Convert path into internal presentation */
523
524    Status = AcpiNsInternalizeName (OriginalObject->String.Pointer, &Name);
525    if (ACPI_FAILURE (Status))
526    {
527        return_ACPI_STATUS (Status);
528    }
529
530    /* Find the namespace node */
531
532    ScopeInfo.Scope.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Scope);
533    Status = AcpiNsLookup (&ScopeInfo, Name,
534        ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
535        ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL, &Node);
536    if (ACPI_FAILURE (Status))
537    {
538        /* Check if we are resolving a named reference within a package */
539
540        ACPI_ERROR_NAMESPACE (OriginalObject->String.Pointer, Status);
541        goto ErrorExit;
542    }
543
544    /* Create and init a new internal ACPI object */
545
546    NewObject = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_REFERENCE);
547    if (!NewObject)
548    {
549        Status = AE_NO_MEMORY;
550        goto ErrorExit;
551    }
552    NewObject->Reference.Node = Node;
553    NewObject->Reference.Object = Node->Object;
554    NewObject->Reference.Class = ACPI_REFCLASS_NAME;
555
556    /*
557     * Increase reference of the object if needed (the object is likely a
558     * null for device nodes).
559     */
560    AcpiUtAddReference (Node->Object);
561
562ErrorExit:
563    ACPI_FREE (Name);
564    *ReturnObject = NewObject;
565    return (AE_OK);
566}
567