1 /******************************************************************************
3 * Module Name: nsxfname - Public interfaces to the ACPI subsystem
4 * ACPI Namespace oriented interfaces
6 *****************************************************************************/
9 * Copyright (C) 2000 - 2004, R. Byron Moore
10 * All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
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.
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.
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.
46 #include <acpi/acpi.h>
47 #include <acpi/acnamesp.h>
50 #define _COMPONENT ACPI_NAMESPACE
51 ACPI_MODULE_NAME ("nsxfname")
54 /******************************************************************************
56 * FUNCTION: acpi_get_handle
58 * PARAMETERS: Parent - Object to search under (search scope).
59 * path_name - Pointer to an asciiz string containing the
61 * ret_handle - Where the return handle is placed
65 * DESCRIPTION: This routine will search for a caller specified name in the
66 * name space. The caller can restrict the search region by
67 * specifying a non NULL parent. The parent value is itself a
70 ******************************************************************************/
76 acpi_handle
*ret_handle
)
79 struct acpi_namespace_node
*node
= NULL
;
80 struct acpi_namespace_node
*prefix_node
= NULL
;
83 ACPI_FUNCTION_ENTRY ();
86 /* Parameter Validation */
88 if (!ret_handle
|| !pathname
) {
89 return (AE_BAD_PARAMETER
);
92 /* Convert a parent handle to a prefix node */
95 status
= acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE
);
96 if (ACPI_FAILURE (status
)) {
100 prefix_node
= acpi_ns_map_handle_to_node (parent
);
102 (void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE
);
103 return (AE_BAD_PARAMETER
);
106 status
= acpi_ut_release_mutex (ACPI_MTX_NAMESPACE
);
107 if (ACPI_FAILURE (status
)) {
112 /* Special case for root, since we can't search for it */
114 if (ACPI_STRCMP (pathname
, ACPI_NS_ROOT_PATH
) == 0) {
115 *ret_handle
= acpi_ns_convert_entry_to_handle (acpi_gbl_root_node
);
120 * Find the Node and convert to a handle
122 status
= acpi_ns_get_node_by_path (pathname
, prefix_node
, ACPI_NS_NO_UPSEARCH
,
126 if (ACPI_SUCCESS (status
)) {
127 *ret_handle
= acpi_ns_convert_entry_to_handle (node
);
134 /******************************************************************************
136 * FUNCTION: acpi_get_name
138 * PARAMETERS: Handle - Handle to be converted to a pathname
139 * name_type - Full pathname or single segment
140 * Buffer - Buffer for returned path
142 * RETURN: Pointer to a string containing the fully qualified Name.
144 * DESCRIPTION: This routine returns the fully qualified name associated with
145 * the Handle parameter. This and the acpi_pathname_to_handle are
146 * complementary functions.
148 ******************************************************************************/
154 struct acpi_buffer
*buffer
)
157 struct acpi_namespace_node
*node
;
160 /* Parameter validation */
162 if (name_type
> ACPI_NAME_TYPE_MAX
) {
163 return (AE_BAD_PARAMETER
);
166 status
= acpi_ut_validate_buffer (buffer
);
167 if (ACPI_FAILURE (status
)) {
171 if (name_type
== ACPI_FULL_PATHNAME
) {
172 /* Get the full pathname (From the namespace root) */
174 status
= acpi_ns_handle_to_pathname (handle
, buffer
);
179 * Wants the single segment ACPI name.
180 * Validate handle and convert to a namespace Node
182 status
= acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE
);
183 if (ACPI_FAILURE (status
)) {
187 node
= acpi_ns_map_handle_to_node (handle
);
189 status
= AE_BAD_PARAMETER
;
190 goto unlock_and_exit
;
193 /* Validate/Allocate/Clear caller buffer */
195 status
= acpi_ut_initialize_buffer (buffer
, ACPI_PATH_SEGMENT_LENGTH
);
196 if (ACPI_FAILURE (status
)) {
197 goto unlock_and_exit
;
200 /* Just copy the ACPI name from the Node and zero terminate it */
202 ACPI_STRNCPY (buffer
->pointer
, acpi_ut_get_node_name (node
),
204 ((char *) buffer
->pointer
) [ACPI_NAME_SIZE
] = 0;
210 (void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE
);
215 /******************************************************************************
217 * FUNCTION: acpi_get_object_info
219 * PARAMETERS: Handle - Object Handle
220 * Info - Where the info is returned
224 * DESCRIPTION: Returns information about an object as gleaned from the
225 * namespace node and possibly by running several standard
226 * control methods (Such as in the case of a device.)
228 ******************************************************************************/
231 acpi_get_object_info (
233 struct acpi_buffer
*buffer
)
236 struct acpi_namespace_node
*node
;
237 struct acpi_device_info info
;
238 struct acpi_device_info
*return_info
;
239 struct acpi_compatible_id_list
*cid_list
= NULL
;
243 /* Parameter validation */
245 if (!handle
|| !buffer
) {
246 return (AE_BAD_PARAMETER
);
249 status
= acpi_ut_validate_buffer (buffer
);
250 if (ACPI_FAILURE (status
)) {
254 status
= acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE
);
255 if (ACPI_FAILURE (status
)) {
259 node
= acpi_ns_map_handle_to_node (handle
);
261 (void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE
);
262 return (AE_BAD_PARAMETER
);
265 /* Init return structure */
267 size
= sizeof (struct acpi_device_info
);
268 ACPI_MEMSET (&info
, 0, size
);
270 info
.type
= node
->type
;
271 info
.name
= node
->name
.integer
;
274 status
= acpi_ut_release_mutex (ACPI_MTX_NAMESPACE
);
275 if (ACPI_FAILURE (status
)) {
279 /* If not a device, we are all done */
281 if (info
.type
== ACPI_TYPE_DEVICE
) {
283 * Get extra info for ACPI Devices objects only:
284 * Run the Device _HID, _UID, _CID, _STA, _ADR and _sx_d methods.
286 * Note: none of these methods are required, so they may or may
287 * not be present for this device. The Info.Valid bitfield is used
288 * to indicate which methods were found and ran successfully.
291 /* Execute the Device._HID method */
293 status
= acpi_ut_execute_HID (node
, &info
.hardware_id
);
294 if (ACPI_SUCCESS (status
)) {
295 info
.valid
|= ACPI_VALID_HID
;
298 /* Execute the Device._UID method */
300 status
= acpi_ut_execute_UID (node
, &info
.unique_id
);
301 if (ACPI_SUCCESS (status
)) {
302 info
.valid
|= ACPI_VALID_UID
;
305 /* Execute the Device._CID method */
307 status
= acpi_ut_execute_CID (node
, &cid_list
);
308 if (ACPI_SUCCESS (status
)) {
309 size
+= ((acpi_size
) cid_list
->count
- 1) *
310 sizeof (struct acpi_compatible_id
);
311 info
.valid
|= ACPI_VALID_CID
;
314 /* Execute the Device._STA method */
316 status
= acpi_ut_execute_STA (node
, &info
.current_status
);
317 if (ACPI_SUCCESS (status
)) {
318 info
.valid
|= ACPI_VALID_STA
;
321 /* Execute the Device._ADR method */
323 status
= acpi_ut_evaluate_numeric_object (METHOD_NAME__ADR
, node
,
325 if (ACPI_SUCCESS (status
)) {
326 info
.valid
|= ACPI_VALID_ADR
;
329 /* Execute the Device._sx_d methods */
331 status
= acpi_ut_execute_sxds (node
, info
.highest_dstates
);
332 if (ACPI_SUCCESS (status
)) {
333 info
.valid
|= ACPI_VALID_SXDS
;
339 /* Validate/Allocate/Clear caller buffer */
341 status
= acpi_ut_initialize_buffer (buffer
, size
);
342 if (ACPI_FAILURE (status
)) {
346 /* Populate the return buffer */
348 return_info
= buffer
->pointer
;
349 ACPI_MEMCPY (return_info
, &info
, sizeof (struct acpi_device_info
));
352 ACPI_MEMCPY (&return_info
->compatibility_id
, cid_list
, cid_list
->size
);
358 ACPI_MEM_FREE (cid_list
);