1 /******************************************************************************
3 * Module Name: utids - support for device IDs - HID, UID, CID
5 *****************************************************************************/
7 /******************************************************************************
11 * Some or all of this work - Copyright (c) 1999 - 2015, Intel Corp.
12 * All rights reserved.
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
37 * The above copyright and patent license is granted only if the following
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
72 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
80 * 4. Disclaimer and Export Compliance
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
114 *****************************************************************************/
117 #include "accommon.h"
118 #include "acinterp.h"
121 #define _COMPONENT ACPI_UTILITIES
122 ACPI_MODULE_NAME ("utids")
125 /*******************************************************************************
127 * FUNCTION: AcpiUtExecute_HID
129 * PARAMETERS: DeviceNode - Node for the device
130 * ReturnId - Where the string HID is returned
134 * DESCRIPTION: Executes the _HID control method that returns the hardware
135 * ID of the device. The HID is either an 32-bit encoded EISAID
136 * Integer or a String. A string is always returned. An EISAID
137 * is converted to a string.
139 * NOTE: Internal function, no parameter validation
141 ******************************************************************************/
145 ACPI_NAMESPACE_NODE *DeviceNode,
146 ACPI_PNP_DEVICE_ID **ReturnId)
148 ACPI_OPERAND_OBJECT *ObjDesc;
149 ACPI_PNP_DEVICE_ID *Hid;
154 ACPI_FUNCTION_TRACE (UtExecute_HID);
157 Status = AcpiUtEvaluateObject (DeviceNode, METHOD_NAME__HID,
158 ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING, &ObjDesc);
159 if (ACPI_FAILURE (Status))
161 return_ACPI_STATUS (Status);
164 /* Get the size of the String to be returned, includes null terminator */
166 if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER)
168 Length = ACPI_EISAID_STRING_SIZE;
172 Length = ObjDesc->String.Length + 1;
175 /* Allocate a buffer for the HID */
177 Hid = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_PNP_DEVICE_ID) + (ACPI_SIZE) Length);
180 Status = AE_NO_MEMORY;
184 /* Area for the string starts after PNP_DEVICE_ID struct */
186 Hid->String = ACPI_ADD_PTR (char, Hid, sizeof (ACPI_PNP_DEVICE_ID));
188 /* Convert EISAID to a string or simply copy existing string */
190 if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER)
192 AcpiExEisaIdToString (Hid->String, ObjDesc->Integer.Value);
196 ACPI_STRCPY (Hid->String, ObjDesc->String.Pointer);
199 Hid->Length = Length;
205 /* On exit, we must delete the return object */
207 AcpiUtRemoveReference (ObjDesc);
208 return_ACPI_STATUS (Status);
212 /*******************************************************************************
214 * FUNCTION: AcpiUtExecute_SUB
216 * PARAMETERS: DeviceNode - Node for the device
217 * ReturnId - Where the _SUB is returned
221 * DESCRIPTION: Executes the _SUB control method that returns the subsystem
222 * ID of the device. The _SUB value is always a string containing
223 * either a valid PNP or ACPI ID.
225 * NOTE: Internal function, no parameter validation
227 ******************************************************************************/
231 ACPI_NAMESPACE_NODE *DeviceNode,
232 ACPI_PNP_DEVICE_ID **ReturnId)
234 ACPI_OPERAND_OBJECT *ObjDesc;
235 ACPI_PNP_DEVICE_ID *Sub;
240 ACPI_FUNCTION_TRACE (UtExecute_SUB);
243 Status = AcpiUtEvaluateObject (DeviceNode, METHOD_NAME__SUB,
244 ACPI_BTYPE_STRING, &ObjDesc);
245 if (ACPI_FAILURE (Status))
247 return_ACPI_STATUS (Status);
250 /* Get the size of the String to be returned, includes null terminator */
252 Length = ObjDesc->String.Length + 1;
254 /* Allocate a buffer for the SUB */
256 Sub = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_PNP_DEVICE_ID) + (ACPI_SIZE) Length);
259 Status = AE_NO_MEMORY;
263 /* Area for the string starts after PNP_DEVICE_ID struct */
265 Sub->String = ACPI_ADD_PTR (char, Sub, sizeof (ACPI_PNP_DEVICE_ID));
267 /* Simply copy existing string */
269 ACPI_STRCPY (Sub->String, ObjDesc->String.Pointer);
270 Sub->Length = Length;
276 /* On exit, we must delete the return object */
278 AcpiUtRemoveReference (ObjDesc);
279 return_ACPI_STATUS (Status);
283 /*******************************************************************************
285 * FUNCTION: AcpiUtExecute_UID
287 * PARAMETERS: DeviceNode - Node for the device
288 * ReturnId - Where the string UID is returned
292 * DESCRIPTION: Executes the _UID control method that returns the unique
293 * ID of the device. The UID is either a 64-bit Integer (NOT an
294 * EISAID) or a string. Always returns a string. A 64-bit integer
295 * is converted to a decimal string.
297 * NOTE: Internal function, no parameter validation
299 ******************************************************************************/
303 ACPI_NAMESPACE_NODE *DeviceNode,
304 ACPI_PNP_DEVICE_ID **ReturnId)
306 ACPI_OPERAND_OBJECT *ObjDesc;
307 ACPI_PNP_DEVICE_ID *Uid;
312 ACPI_FUNCTION_TRACE (UtExecute_UID);
315 Status = AcpiUtEvaluateObject (DeviceNode, METHOD_NAME__UID,
316 ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING, &ObjDesc);
317 if (ACPI_FAILURE (Status))
319 return_ACPI_STATUS (Status);
322 /* Get the size of the String to be returned, includes null terminator */
324 if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER)
326 Length = ACPI_MAX64_DECIMAL_DIGITS + 1;
330 Length = ObjDesc->String.Length + 1;
333 /* Allocate a buffer for the UID */
335 Uid = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_PNP_DEVICE_ID) + (ACPI_SIZE) Length);
338 Status = AE_NO_MEMORY;
342 /* Area for the string starts after PNP_DEVICE_ID struct */
344 Uid->String = ACPI_ADD_PTR (char, Uid, sizeof (ACPI_PNP_DEVICE_ID));
346 /* Convert an Integer to string, or just copy an existing string */
348 if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER)
350 AcpiExIntegerToString (Uid->String, ObjDesc->Integer.Value);
354 ACPI_STRCPY (Uid->String, ObjDesc->String.Pointer);
357 Uid->Length = Length;
363 /* On exit, we must delete the return object */
365 AcpiUtRemoveReference (ObjDesc);
366 return_ACPI_STATUS (Status);
370 /*******************************************************************************
372 * FUNCTION: AcpiUtExecute_CID
374 * PARAMETERS: DeviceNode - Node for the device
375 * ReturnCidList - Where the CID list is returned
377 * RETURN: Status, list of CID strings
379 * DESCRIPTION: Executes the _CID control method that returns one or more
380 * compatible hardware IDs for the device.
382 * NOTE: Internal function, no parameter validation
384 * A _CID method can return either a single compatible ID or a package of
385 * compatible IDs. Each compatible ID can be one of the following:
386 * 1) Integer (32 bit compressed EISA ID) or
387 * 2) String (PCI ID format, e.g. "PCI\VEN_vvvv&DEV_dddd&SUBSYS_ssssssss")
389 * The Integer CIDs are converted to string format by this function.
391 ******************************************************************************/
395 ACPI_NAMESPACE_NODE *DeviceNode,
396 ACPI_PNP_DEVICE_ID_LIST **ReturnCidList)
398 ACPI_OPERAND_OBJECT **CidObjects;
399 ACPI_OPERAND_OBJECT *ObjDesc;
400 ACPI_PNP_DEVICE_ID_LIST *CidList;
402 UINT32 StringAreaSize;
410 ACPI_FUNCTION_TRACE (UtExecute_CID);
413 /* Evaluate the _CID method for this device */
415 Status = AcpiUtEvaluateObject (DeviceNode, METHOD_NAME__CID,
416 ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING | ACPI_BTYPE_PACKAGE,
418 if (ACPI_FAILURE (Status))
420 return_ACPI_STATUS (Status);
424 * Get the count and size of the returned _CIDs. _CID can return either
425 * a Package of Integers/Strings or a single Integer or String.
426 * Note: This section also validates that all CID elements are of the
427 * correct type (Integer or String).
429 if (ObjDesc->Common.Type == ACPI_TYPE_PACKAGE)
431 Count = ObjDesc->Package.Count;
432 CidObjects = ObjDesc->Package.Elements;
434 else /* Single Integer or String CID */
437 CidObjects = &ObjDesc;
441 for (i = 0; i < Count; i++)
443 /* String lengths include null terminator */
445 switch (CidObjects[i]->Common.Type)
447 case ACPI_TYPE_INTEGER:
449 StringAreaSize += ACPI_EISAID_STRING_SIZE;
452 case ACPI_TYPE_STRING:
454 StringAreaSize += CidObjects[i]->String.Length + 1;
465 * Now that we know the length of the CIDs, allocate return buffer:
466 * 1) Size of the base structure +
467 * 2) Size of the CID PNP_DEVICE_ID array +
468 * 3) Size of the actual CID strings
470 CidListSize = sizeof (ACPI_PNP_DEVICE_ID_LIST) +
471 ((Count - 1) * sizeof (ACPI_PNP_DEVICE_ID)) +
474 CidList = ACPI_ALLOCATE_ZEROED (CidListSize);
477 Status = AE_NO_MEMORY;
481 /* Area for CID strings starts after the CID PNP_DEVICE_ID array */
483 NextIdString = ACPI_CAST_PTR (char, CidList->Ids) +
484 ((ACPI_SIZE) Count * sizeof (ACPI_PNP_DEVICE_ID));
486 /* Copy/convert the CIDs to the return buffer */
488 for (i = 0; i < Count; i++)
490 if (CidObjects[i]->Common.Type == ACPI_TYPE_INTEGER)
492 /* Convert the Integer (EISAID) CID to a string */
494 AcpiExEisaIdToString (NextIdString, CidObjects[i]->Integer.Value);
495 Length = ACPI_EISAID_STRING_SIZE;
497 else /* ACPI_TYPE_STRING */
499 /* Copy the String CID from the returned object */
501 ACPI_STRCPY (NextIdString, CidObjects[i]->String.Pointer);
502 Length = CidObjects[i]->String.Length + 1;
505 CidList->Ids[i].String = NextIdString;
506 CidList->Ids[i].Length = Length;
507 NextIdString += Length;
510 /* Finish the CID list */
512 CidList->Count = Count;
513 CidList->ListSize = CidListSize;
514 *ReturnCidList = CidList;
519 /* On exit, we must delete the _CID return object */
521 AcpiUtRemoveReference (ObjDesc);
522 return_ACPI_STATUS (Status);