aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/acpi/acpica/nsxfeval.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/acpi/acpica/nsxfeval.c')
-rw-r--r--drivers/acpi/acpica/nsxfeval.c812
1 files changed, 812 insertions, 0 deletions
diff --git a/drivers/acpi/acpica/nsxfeval.c b/drivers/acpi/acpica/nsxfeval.c
new file mode 100644
index 00000000000..598393a04e5
--- /dev/null
+++ b/drivers/acpi/acpica/nsxfeval.c
@@ -0,0 +1,812 @@
1/*******************************************************************************
2 *
3 * Module Name: nsxfeval - Public interfaces to the ACPI subsystem
4 * ACPI Object evaluation interfaces
5 *
6 ******************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2008, 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 <acpi/acpi.h>
46#include <acpi/accommon.h>
47#include <acpi/acnamesp.h>
48#include <acpi/acinterp.h>
49
50#define _COMPONENT ACPI_NAMESPACE
51ACPI_MODULE_NAME("nsxfeval")
52
53/* Local prototypes */
54static void acpi_ns_resolve_references(struct acpi_evaluate_info *info);
55
56#ifdef ACPI_FUTURE_USAGE
57/*******************************************************************************
58 *
59 * FUNCTION: acpi_evaluate_object_typed
60 *
61 * PARAMETERS: Handle - Object handle (optional)
62 * Pathname - Object pathname (optional)
63 * external_params - List of parameters to pass to method,
64 * terminated by NULL. May be NULL
65 * if no parameters are being passed.
66 * return_buffer - Where to put method's return value (if
67 * any). If NULL, no value is returned.
68 * return_type - Expected type of return object
69 *
70 * RETURN: Status
71 *
72 * DESCRIPTION: Find and evaluate the given object, passing the given
73 * parameters if necessary. One of "Handle" or "Pathname" must
74 * be valid (non-null)
75 *
76 ******************************************************************************/
77
78acpi_status
79acpi_evaluate_object_typed(acpi_handle handle,
80 acpi_string pathname,
81 struct acpi_object_list *external_params,
82 struct acpi_buffer *return_buffer,
83 acpi_object_type return_type)
84{
85 acpi_status status;
86 u8 must_free = FALSE;
87
88 ACPI_FUNCTION_TRACE(acpi_evaluate_object_typed);
89
90 /* Return buffer must be valid */
91
92 if (!return_buffer) {
93 return_ACPI_STATUS(AE_BAD_PARAMETER);
94 }
95
96 if (return_buffer->length == ACPI_ALLOCATE_BUFFER) {
97 must_free = TRUE;
98 }
99
100 /* Evaluate the object */
101
102 status =
103 acpi_evaluate_object(handle, pathname, external_params,
104 return_buffer);
105 if (ACPI_FAILURE(status)) {
106 return_ACPI_STATUS(status);
107 }
108
109 /* Type ANY means "don't care" */
110
111 if (return_type == ACPI_TYPE_ANY) {
112 return_ACPI_STATUS(AE_OK);
113 }
114
115 if (return_buffer->length == 0) {
116
117 /* Error because caller specifically asked for a return value */
118
119 ACPI_ERROR((AE_INFO, "No return value"));
120 return_ACPI_STATUS(AE_NULL_OBJECT);
121 }
122
123 /* Examine the object type returned from evaluate_object */
124
125 if (((union acpi_object *)return_buffer->pointer)->type == return_type) {
126 return_ACPI_STATUS(AE_OK);
127 }
128
129 /* Return object type does not match requested type */
130
131 ACPI_ERROR((AE_INFO,
132 "Incorrect return type [%s] requested [%s]",
133 acpi_ut_get_type_name(((union acpi_object *)return_buffer->
134 pointer)->type),
135 acpi_ut_get_type_name(return_type)));
136
137 if (must_free) {
138
139 /* Caller used ACPI_ALLOCATE_BUFFER, free the return buffer */
140
141 ACPI_FREE(return_buffer->pointer);
142 return_buffer->pointer = NULL;
143 }
144
145 return_buffer->length = 0;
146 return_ACPI_STATUS(AE_TYPE);
147}
148
149ACPI_EXPORT_SYMBOL(acpi_evaluate_object_typed)
150#endif /* ACPI_FUTURE_USAGE */
151/*******************************************************************************
152 *
153 * FUNCTION: acpi_evaluate_object
154 *
155 * PARAMETERS: Handle - Object handle (optional)
156 * Pathname - Object pathname (optional)
157 * external_params - List of parameters to pass to method,
158 * terminated by NULL. May be NULL
159 * if no parameters are being passed.
160 * return_buffer - Where to put method's return value (if
161 * any). If NULL, no value is returned.
162 *
163 * RETURN: Status
164 *
165 * DESCRIPTION: Find and evaluate the given object, passing the given
166 * parameters if necessary. One of "Handle" or "Pathname" must
167 * be valid (non-null)
168 *
169 ******************************************************************************/
170acpi_status
171acpi_evaluate_object(acpi_handle handle,
172 acpi_string pathname,
173 struct acpi_object_list *external_params,
174 struct acpi_buffer *return_buffer)
175{
176 acpi_status status;
177 struct acpi_evaluate_info *info;
178 acpi_size buffer_space_needed;
179 u32 i;
180
181 ACPI_FUNCTION_TRACE(acpi_evaluate_object);
182
183 /* Allocate and initialize the evaluation information block */
184
185 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
186 if (!info) {
187 return_ACPI_STATUS(AE_NO_MEMORY);
188 }
189
190 info->pathname = pathname;
191
192 /* Convert and validate the device handle */
193
194 info->prefix_node = acpi_ns_map_handle_to_node(handle);
195 if (!info->prefix_node) {
196 status = AE_BAD_PARAMETER;
197 goto cleanup;
198 }
199
200 /*
201 * If there are parameters to be passed to a control method, the external
202 * objects must all be converted to internal objects
203 */
204 if (external_params && external_params->count) {
205 /*
206 * Allocate a new parameter block for the internal objects
207 * Add 1 to count to allow for null terminated internal list
208 */
209 info->parameters = ACPI_ALLOCATE_ZEROED(((acpi_size)
210 external_params->
211 count +
212 1) * sizeof(void *));
213 if (!info->parameters) {
214 status = AE_NO_MEMORY;
215 goto cleanup;
216 }
217
218 /* Convert each external object in the list to an internal object */
219
220 for (i = 0; i < external_params->count; i++) {
221 status =
222 acpi_ut_copy_eobject_to_iobject(&external_params->
223 pointer[i],
224 &info->
225 parameters[i]);
226 if (ACPI_FAILURE(status)) {
227 goto cleanup;
228 }
229 }
230 info->parameters[external_params->count] = NULL;
231 }
232
233 /*
234 * Three major cases:
235 * 1) Fully qualified pathname
236 * 2) No handle, not fully qualified pathname (error)
237 * 3) Valid handle
238 */
239 if ((pathname) && (acpi_ns_valid_root_prefix(pathname[0]))) {
240
241 /* The path is fully qualified, just evaluate by name */
242
243 info->prefix_node = NULL;
244 status = acpi_ns_evaluate(info);
245 } else if (!handle) {
246 /*
247 * A handle is optional iff a fully qualified pathname is specified.
248 * Since we've already handled fully qualified names above, this is
249 * an error
250 */
251 if (!pathname) {
252 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
253 "Both Handle and Pathname are NULL"));
254 } else {
255 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
256 "Null Handle with relative pathname [%s]",
257 pathname));
258 }
259
260 status = AE_BAD_PARAMETER;
261 } else {
262 /* We have a namespace a node and a possible relative path */
263
264 status = acpi_ns_evaluate(info);
265 }
266
267 /*
268 * If we are expecting a return value, and all went well above,
269 * copy the return value to an external object.
270 */
271 if (return_buffer) {
272 if (!info->return_object) {
273 return_buffer->length = 0;
274 } else {
275 if (ACPI_GET_DESCRIPTOR_TYPE(info->return_object) ==
276 ACPI_DESC_TYPE_NAMED) {
277 /*
278 * If we received a NS Node as a return object, this means that
279 * the object we are evaluating has nothing interesting to
280 * return (such as a mutex, etc.) We return an error because
281 * these types are essentially unsupported by this interface.
282 * We don't check up front because this makes it easier to add
283 * support for various types at a later date if necessary.
284 */
285 status = AE_TYPE;
286 info->return_object = NULL; /* No need to delete a NS Node */
287 return_buffer->length = 0;
288 }
289
290 if (ACPI_SUCCESS(status)) {
291
292 /* Dereference Index and ref_of references */
293
294 acpi_ns_resolve_references(info);
295
296 /* Get the size of the returned object */
297
298 status =
299 acpi_ut_get_object_size(info->return_object,
300 &buffer_space_needed);
301 if (ACPI_SUCCESS(status)) {
302
303 /* Validate/Allocate/Clear caller buffer */
304
305 status =
306 acpi_ut_initialize_buffer
307 (return_buffer,
308 buffer_space_needed);
309 if (ACPI_FAILURE(status)) {
310 /*
311 * Caller's buffer is too small or a new one can't
312 * be allocated
313 */
314 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
315 "Needed buffer size %X, %s\n",
316 (u32)
317 buffer_space_needed,
318 acpi_format_exception
319 (status)));
320 } else {
321 /* We have enough space for the object, build it */
322
323 status =
324 acpi_ut_copy_iobject_to_eobject
325 (info->return_object,
326 return_buffer);
327 }
328 }
329 }
330 }
331 }
332
333 if (info->return_object) {
334 /*
335 * Delete the internal return object. NOTE: Interpreter must be
336 * locked to avoid race condition.
337 */
338 acpi_ex_enter_interpreter();
339
340 /* Remove one reference on the return object (should delete it) */
341
342 acpi_ut_remove_reference(info->return_object);
343 acpi_ex_exit_interpreter();
344 }
345
346 cleanup:
347
348 /* Free the input parameter list (if we created one) */
349
350 if (info->parameters) {
351
352 /* Free the allocated parameter block */
353
354 acpi_ut_delete_internal_object_list(info->parameters);
355 }
356
357 ACPI_FREE(info);
358 return_ACPI_STATUS(status);
359}
360
361ACPI_EXPORT_SYMBOL(acpi_evaluate_object)
362
363/*******************************************************************************
364 *
365 * FUNCTION: acpi_ns_resolve_references
366 *
367 * PARAMETERS: Info - Evaluation info block
368 *
369 * RETURN: Info->return_object is replaced with the dereferenced object
370 *
371 * DESCRIPTION: Dereference certain reference objects. Called before an
372 * internal return object is converted to an external union acpi_object.
373 *
374 * Performs an automatic dereference of Index and ref_of reference objects.
375 * These reference objects are not supported by the union acpi_object, so this is a
376 * last resort effort to return something useful. Also, provides compatibility
377 * with other ACPI implementations.
378 *
379 * NOTE: does not handle references within returned package objects or nested
380 * references, but this support could be added later if found to be necessary.
381 *
382 ******************************************************************************/
383static void acpi_ns_resolve_references(struct acpi_evaluate_info *info)
384{
385 union acpi_operand_object *obj_desc = NULL;
386 struct acpi_namespace_node *node;
387
388 /* We are interested in reference objects only */
389
390 if (ACPI_GET_OBJECT_TYPE(info->return_object) !=
391 ACPI_TYPE_LOCAL_REFERENCE) {
392 return;
393 }
394
395 /*
396 * Two types of references are supported - those created by Index and
397 * ref_of operators. A name reference (AML_NAMEPATH_OP) can be converted
398 * to an union acpi_object, so it is not dereferenced here. A ddb_handle
399 * (AML_LOAD_OP) cannot be dereferenced, nor can it be converted to
400 * an union acpi_object.
401 */
402 switch (info->return_object->reference.class) {
403 case ACPI_REFCLASS_INDEX:
404
405 obj_desc = *(info->return_object->reference.where);
406 break;
407
408 case ACPI_REFCLASS_REFOF:
409
410 node = info->return_object->reference.object;
411 if (node) {
412 obj_desc = node->object;
413 }
414 break;
415
416 default:
417 return;
418 }
419
420 /* Replace the existing reference object */
421
422 if (obj_desc) {
423 acpi_ut_add_reference(obj_desc);
424 acpi_ut_remove_reference(info->return_object);
425 info->return_object = obj_desc;
426 }
427
428 return;
429}
430
431/*******************************************************************************
432 *
433 * FUNCTION: acpi_walk_namespace
434 *
435 * PARAMETERS: Type - acpi_object_type to search for
436 * start_object - Handle in namespace where search begins
437 * max_depth - Depth to which search is to reach
438 * user_function - Called when an object of "Type" is found
439 * Context - Passed to user function
440 * return_value - Location where return value of
441 * user_function is put if terminated early
442 *
443 * RETURNS Return value from the user_function if terminated early.
444 * Otherwise, returns NULL.
445 *
446 * DESCRIPTION: Performs a modified depth-first walk of the namespace tree,
447 * starting (and ending) at the object specified by start_handle.
448 * The user_function is called whenever an object that matches
449 * the type parameter is found. If the user function returns
450 * a non-zero value, the search is terminated immediately and this
451 * value is returned to the caller.
452 *
453 * The point of this procedure is to provide a generic namespace
454 * walk routine that can be called from multiple places to
455 * provide multiple services; the User Function can be tailored
456 * to each task, whether it is a print function, a compare
457 * function, etc.
458 *
459 ******************************************************************************/
460
461acpi_status
462acpi_walk_namespace(acpi_object_type type,
463 acpi_handle start_object,
464 u32 max_depth,
465 acpi_walk_callback user_function,
466 void *context, void **return_value)
467{
468 acpi_status status;
469
470 ACPI_FUNCTION_TRACE(acpi_walk_namespace);
471
472 /* Parameter validation */
473
474 if ((type > ACPI_TYPE_LOCAL_MAX) || (!max_depth) || (!user_function)) {
475 return_ACPI_STATUS(AE_BAD_PARAMETER);
476 }
477
478 /*
479 * Lock the namespace around the walk.
480 * The namespace will be unlocked/locked around each call
481 * to the user function - since this function
482 * must be allowed to make Acpi calls itself.
483 */
484 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
485 if (ACPI_FAILURE(status)) {
486 return_ACPI_STATUS(status);
487 }
488
489 status = acpi_ns_walk_namespace(type, start_object, max_depth,
490 ACPI_NS_WALK_UNLOCK,
491 user_function, context, return_value);
492
493 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
494 return_ACPI_STATUS(status);
495}
496
497ACPI_EXPORT_SYMBOL(acpi_walk_namespace)
498
499/*******************************************************************************
500 *
501 * FUNCTION: acpi_ns_get_device_callback
502 *
503 * PARAMETERS: Callback from acpi_get_device
504 *
505 * RETURN: Status
506 *
507 * DESCRIPTION: Takes callbacks from walk_namespace and filters out all non-
508 * present devices, or if they specified a HID, it filters based
509 * on that.
510 *
511 ******************************************************************************/
512static acpi_status
513acpi_ns_get_device_callback(acpi_handle obj_handle,
514 u32 nesting_level,
515 void *context, void **return_value)
516{
517 struct acpi_get_devices_info *info = context;
518 acpi_status status;
519 struct acpi_namespace_node *node;
520 u32 flags;
521 struct acpica_device_id hid;
522 struct acpi_compatible_id_list *cid;
523 u32 i;
524 int found;
525
526 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
527 if (ACPI_FAILURE(status)) {
528 return (status);
529 }
530
531 node = acpi_ns_map_handle_to_node(obj_handle);
532 status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
533 if (ACPI_FAILURE(status)) {
534 return (status);
535 }
536
537 if (!node) {
538 return (AE_BAD_PARAMETER);
539 }
540
541 /* Run _STA to determine if device is present */
542
543 status = acpi_ut_execute_STA(node, &flags);
544 if (ACPI_FAILURE(status)) {
545 return (AE_CTRL_DEPTH);
546 }
547
548 if (!(flags & ACPI_STA_DEVICE_PRESENT) &&
549 !(flags & ACPI_STA_DEVICE_FUNCTIONING)) {
550 /*
551 * Don't examine the children of the device only when the
552 * device is neither present nor functional. See ACPI spec,
553 * description of _STA for more information.
554 */
555 return (AE_CTRL_DEPTH);
556 }
557
558 /* Filter based on device HID & CID */
559
560 if (info->hid != NULL) {
561 status = acpi_ut_execute_HID(node, &hid);
562 if (status == AE_NOT_FOUND) {
563 return (AE_OK);
564 } else if (ACPI_FAILURE(status)) {
565 return (AE_CTRL_DEPTH);
566 }
567
568 if (ACPI_STRNCMP(hid.value, info->hid, sizeof(hid.value)) != 0) {
569
570 /* Get the list of Compatible IDs */
571
572 status = acpi_ut_execute_CID(node, &cid);
573 if (status == AE_NOT_FOUND) {
574 return (AE_OK);
575 } else if (ACPI_FAILURE(status)) {
576 return (AE_CTRL_DEPTH);
577 }
578
579 /* Walk the CID list */
580
581 found = 0;
582 for (i = 0; i < cid->count; i++) {
583 if (ACPI_STRNCMP(cid->id[i].value, info->hid,
584 sizeof(struct
585 acpi_compatible_id)) ==
586 0) {
587 found = 1;
588 break;
589 }
590 }
591 ACPI_FREE(cid);
592 if (!found)
593 return (AE_OK);
594 }
595 }
596
597 status = info->user_function(obj_handle, nesting_level, info->context,
598 return_value);
599 return (status);
600}
601
602/*******************************************************************************
603 *
604 * FUNCTION: acpi_get_devices
605 *
606 * PARAMETERS: HID - HID to search for. Can be NULL.
607 * user_function - Called when a matching object is found
608 * Context - Passed to user function
609 * return_value - Location where return value of
610 * user_function is put if terminated early
611 *
612 * RETURNS Return value from the user_function if terminated early.
613 * Otherwise, returns NULL.
614 *
615 * DESCRIPTION: Performs a modified depth-first walk of the namespace tree,
616 * starting (and ending) at the object specified by start_handle.
617 * The user_function is called whenever an object of type
618 * Device is found. If the user function returns
619 * a non-zero value, the search is terminated immediately and this
620 * value is returned to the caller.
621 *
622 * This is a wrapper for walk_namespace, but the callback performs
623 * additional filtering. Please see acpi_ns_get_device_callback.
624 *
625 ******************************************************************************/
626
627acpi_status
628acpi_get_devices(const char *HID,
629 acpi_walk_callback user_function,
630 void *context, void **return_value)
631{
632 acpi_status status;
633 struct acpi_get_devices_info info;
634
635 ACPI_FUNCTION_TRACE(acpi_get_devices);
636
637 /* Parameter validation */
638
639 if (!user_function) {
640 return_ACPI_STATUS(AE_BAD_PARAMETER);
641 }
642
643 /*
644 * We're going to call their callback from OUR callback, so we need
645 * to know what it is, and their context parameter.
646 */
647 info.hid = HID;
648 info.context = context;
649 info.user_function = user_function;
650
651 /*
652 * Lock the namespace around the walk.
653 * The namespace will be unlocked/locked around each call
654 * to the user function - since this function
655 * must be allowed to make Acpi calls itself.
656 */
657 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
658 if (ACPI_FAILURE(status)) {
659 return_ACPI_STATUS(status);
660 }
661
662 status = acpi_ns_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
663 ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
664 acpi_ns_get_device_callback, &info,
665 return_value);
666
667 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
668 return_ACPI_STATUS(status);
669}
670
671ACPI_EXPORT_SYMBOL(acpi_get_devices)
672
673/*******************************************************************************
674 *
675 * FUNCTION: acpi_attach_data
676 *
677 * PARAMETERS: obj_handle - Namespace node
678 * Handler - Handler for this attachment
679 * Data - Pointer to data to be attached
680 *
681 * RETURN: Status
682 *
683 * DESCRIPTION: Attach arbitrary data and handler to a namespace node.
684 *
685 ******************************************************************************/
686acpi_status
687acpi_attach_data(acpi_handle obj_handle,
688 acpi_object_handler handler, void *data)
689{
690 struct acpi_namespace_node *node;
691 acpi_status status;
692
693 /* Parameter validation */
694
695 if (!obj_handle || !handler || !data) {
696 return (AE_BAD_PARAMETER);
697 }
698
699 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
700 if (ACPI_FAILURE(status)) {
701 return (status);
702 }
703
704 /* Convert and validate the handle */
705
706 node = acpi_ns_map_handle_to_node(obj_handle);
707 if (!node) {
708 status = AE_BAD_PARAMETER;
709 goto unlock_and_exit;
710 }
711
712 status = acpi_ns_attach_data(node, handler, data);
713
714 unlock_and_exit:
715 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
716 return (status);
717}
718
719ACPI_EXPORT_SYMBOL(acpi_attach_data)
720
721/*******************************************************************************
722 *
723 * FUNCTION: acpi_detach_data
724 *
725 * PARAMETERS: obj_handle - Namespace node handle
726 * Handler - Handler used in call to acpi_attach_data
727 *
728 * RETURN: Status
729 *
730 * DESCRIPTION: Remove data that was previously attached to a node.
731 *
732 ******************************************************************************/
733acpi_status
734acpi_detach_data(acpi_handle obj_handle, acpi_object_handler handler)
735{
736 struct acpi_namespace_node *node;
737 acpi_status status;
738
739 /* Parameter validation */
740
741 if (!obj_handle || !handler) {
742 return (AE_BAD_PARAMETER);
743 }
744
745 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
746 if (ACPI_FAILURE(status)) {
747 return (status);
748 }
749
750 /* Convert and validate the handle */
751
752 node = acpi_ns_map_handle_to_node(obj_handle);
753 if (!node) {
754 status = AE_BAD_PARAMETER;
755 goto unlock_and_exit;
756 }
757
758 status = acpi_ns_detach_data(node, handler);
759
760 unlock_and_exit:
761 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
762 return (status);
763}
764
765ACPI_EXPORT_SYMBOL(acpi_detach_data)
766
767/*******************************************************************************
768 *
769 * FUNCTION: acpi_get_data
770 *
771 * PARAMETERS: obj_handle - Namespace node
772 * Handler - Handler used in call to attach_data
773 * Data - Where the data is returned
774 *
775 * RETURN: Status
776 *
777 * DESCRIPTION: Retrieve data that was previously attached to a namespace node.
778 *
779 ******************************************************************************/
780acpi_status
781acpi_get_data(acpi_handle obj_handle, acpi_object_handler handler, void **data)
782{
783 struct acpi_namespace_node *node;
784 acpi_status status;
785
786 /* Parameter validation */
787
788 if (!obj_handle || !handler || !data) {
789 return (AE_BAD_PARAMETER);
790 }
791
792 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
793 if (ACPI_FAILURE(status)) {
794 return (status);
795 }
796
797 /* Convert and validate the handle */
798
799 node = acpi_ns_map_handle_to_node(obj_handle);
800 if (!node) {
801 status = AE_BAD_PARAMETER;
802 goto unlock_and_exit;
803 }
804
805 status = acpi_ns_get_attached_data(node, handler, data);
806
807 unlock_and_exit:
808 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
809 return (status);
810}
811
812ACPI_EXPORT_SYMBOL(acpi_get_data)
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-16 23:08:20 -0500