xref: /linux/drivers/acpi/acpica/nsinit.c (revision 7c66e12136c2fa421ae75497e02728f252108a1b)
1 /******************************************************************************
2  *
3  * Module Name: nsinit - namespace initialization
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acnamesp.h"
47 #include "acdispat.h"
48 #include "acinterp.h"
49 #include "acevents.h"
50 
51 #define _COMPONENT          ACPI_NAMESPACE
52 ACPI_MODULE_NAME("nsinit")
53 
54 /* Local prototypes */
55 static acpi_status
56 acpi_ns_init_one_object(acpi_handle obj_handle,
57 			u32 level, void *context, void **return_value);
58 
59 static acpi_status
60 acpi_ns_init_one_device(acpi_handle obj_handle,
61 			u32 nesting_level, void *context, void **return_value);
62 
63 static acpi_status
64 acpi_ns_find_ini_methods(acpi_handle obj_handle,
65 			 u32 nesting_level, void *context, void **return_value);
66 
67 /*******************************************************************************
68  *
69  * FUNCTION:    acpi_ns_initialize_objects
70  *
71  * PARAMETERS:  None
72  *
73  * RETURN:      Status
74  *
75  * DESCRIPTION: Walk the entire namespace and perform any necessary
76  *              initialization on the objects found therein
77  *
78  ******************************************************************************/
79 
80 acpi_status acpi_ns_initialize_objects(void)
81 {
82 	acpi_status status;
83 	struct acpi_init_walk_info info;
84 
85 	ACPI_FUNCTION_TRACE(ns_initialize_objects);
86 
87 	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
88 			  "[Init] Completing Initialization of ACPI Objects\n"));
89 	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
90 			  "**** Starting initialization of namespace objects ****\n"));
91 	ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
92 			      "Completing Region/Field/Buffer/Package initialization:\n"));
93 
94 	/* Set all init info to zero */
95 
96 	memset(&info, 0, sizeof(struct acpi_init_walk_info));
97 
98 	/* Walk entire namespace from the supplied root */
99 
100 	status = acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
101 				     ACPI_UINT32_MAX, acpi_ns_init_one_object,
102 				     NULL, &info, NULL);
103 	if (ACPI_FAILURE(status)) {
104 		ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace"));
105 	}
106 
107 	ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
108 			      "    Initialized %u/%u Regions %u/%u Fields %u/%u "
109 			      "Buffers %u/%u Packages (%u nodes)\n",
110 			      info.op_region_init, info.op_region_count,
111 			      info.field_init, info.field_count,
112 			      info.buffer_init, info.buffer_count,
113 			      info.package_init, info.package_count,
114 			      info.object_count));
115 
116 	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
117 			  "%u Control Methods found\n%u Op Regions found\n",
118 			  info.method_count, info.op_region_count));
119 
120 	return_ACPI_STATUS(AE_OK);
121 }
122 
123 /*******************************************************************************
124  *
125  * FUNCTION:    acpi_ns_initialize_devices
126  *
127  * PARAMETERS:  None
128  *
129  * RETURN:      acpi_status
130  *
131  * DESCRIPTION: Walk the entire namespace and initialize all ACPI devices.
132  *              This means running _INI on all present devices.
133  *
134  *              Note: We install PCI config space handler on region access,
135  *              not here.
136  *
137  ******************************************************************************/
138 
139 acpi_status acpi_ns_initialize_devices(u32 flags)
140 {
141 	acpi_status status = AE_OK;
142 	struct acpi_device_walk_info info;
143 	acpi_handle handle;
144 
145 	ACPI_FUNCTION_TRACE(ns_initialize_devices);
146 
147 	if (!(flags & ACPI_NO_DEVICE_INIT)) {
148 		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
149 				  "[Init] Initializing ACPI Devices\n"));
150 
151 		/* Init counters */
152 
153 		info.device_count = 0;
154 		info.num_STA = 0;
155 		info.num_INI = 0;
156 
157 		ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
158 				      "Initializing Device/Processor/Thermal objects "
159 				      "and executing _INI/_STA methods:\n"));
160 
161 		/* Tree analysis: find all subtrees that contain _INI methods */
162 
163 		status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
164 						ACPI_UINT32_MAX, FALSE,
165 						acpi_ns_find_ini_methods, NULL,
166 						&info, NULL);
167 		if (ACPI_FAILURE(status)) {
168 			goto error_exit;
169 		}
170 
171 		/* Allocate the evaluation information block */
172 
173 		info.evaluate_info =
174 		    ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
175 		if (!info.evaluate_info) {
176 			status = AE_NO_MEMORY;
177 			goto error_exit;
178 		}
179 
180 		/*
181 		 * Execute the "global" _INI method that may appear at the root.
182 		 * This support is provided for Windows compatibility (Vista+) and
183 		 * is not part of the ACPI specification.
184 		 */
185 		info.evaluate_info->prefix_node = acpi_gbl_root_node;
186 		info.evaluate_info->relative_pathname = METHOD_NAME__INI;
187 		info.evaluate_info->parameters = NULL;
188 		info.evaluate_info->flags = ACPI_IGNORE_RETURN_VALUE;
189 
190 		status = acpi_ns_evaluate(info.evaluate_info);
191 		if (ACPI_SUCCESS(status)) {
192 			info.num_INI++;
193 		}
194 
195 		/*
196 		 * Execute \_SB._INI.
197 		 * There appears to be a strict order requirement for \_SB._INI,
198 		 * which should be evaluated before any _REG evaluations.
199 		 */
200 		status = acpi_get_handle(NULL, "\\_SB", &handle);
201 		if (ACPI_SUCCESS(status)) {
202 			memset(info.evaluate_info, 0,
203 			       sizeof(struct acpi_evaluate_info));
204 			info.evaluate_info->prefix_node = handle;
205 			info.evaluate_info->relative_pathname =
206 			    METHOD_NAME__INI;
207 			info.evaluate_info->parameters = NULL;
208 			info.evaluate_info->flags = ACPI_IGNORE_RETURN_VALUE;
209 
210 			status = acpi_ns_evaluate(info.evaluate_info);
211 			if (ACPI_SUCCESS(status)) {
212 				info.num_INI++;
213 			}
214 		}
215 	}
216 
217 	/*
218 	 * Run all _REG methods
219 	 *
220 	 * Note: Any objects accessed by the _REG methods will be automatically
221 	 * initialized, even if they contain executable AML (see the call to
222 	 * acpi_ns_initialize_objects below).
223 	 *
224 	 * Note: According to the ACPI specification, we actually needn't execute
225 	 * _REG for system_memory/system_io operation regions, but for PCI_Config
226 	 * operation regions, it is required to evaluate _REG for those on a PCI
227 	 * root bus that doesn't contain _BBN object. So this code is kept here
228 	 * in order not to break things.
229 	 */
230 	if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
231 		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
232 				  "[Init] Executing _REG OpRegion methods\n"));
233 
234 		status = acpi_ev_initialize_op_regions();
235 		if (ACPI_FAILURE(status)) {
236 			goto error_exit;
237 		}
238 	}
239 
240 	if (!(flags & ACPI_NO_DEVICE_INIT)) {
241 
242 		/* Walk namespace to execute all _INIs on present devices */
243 
244 		status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
245 						ACPI_UINT32_MAX, FALSE,
246 						acpi_ns_init_one_device, NULL,
247 						&info, NULL);
248 
249 		/*
250 		 * Any _OSI requests should be completed by now. If the BIOS has
251 		 * requested any Windows OSI strings, we will always truncate
252 		 * I/O addresses to 16 bits -- for Windows compatibility.
253 		 */
254 		if (acpi_gbl_osi_data >= ACPI_OSI_WIN_2000) {
255 			acpi_gbl_truncate_io_addresses = TRUE;
256 		}
257 
258 		ACPI_FREE(info.evaluate_info);
259 		if (ACPI_FAILURE(status)) {
260 			goto error_exit;
261 		}
262 
263 		ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
264 				      "    Executed %u _INI methods requiring %u _STA executions "
265 				      "(examined %u objects)\n",
266 				      info.num_INI, info.num_STA,
267 				      info.device_count));
268 	}
269 
270 	return_ACPI_STATUS(status);
271 
272 error_exit:
273 	ACPI_EXCEPTION((AE_INFO, status, "During device initialization"));
274 	return_ACPI_STATUS(status);
275 }
276 
277 /*******************************************************************************
278  *
279  * FUNCTION:    acpi_ns_init_one_object
280  *
281  * PARAMETERS:  obj_handle      - Node
282  *              level           - Current nesting level
283  *              context         - Points to a init info struct
284  *              return_value    - Not used
285  *
286  * RETURN:      Status
287  *
288  * DESCRIPTION: Callback from acpi_walk_namespace. Invoked for every object
289  *              within the  namespace.
290  *
291  *              Currently, the only objects that require initialization are:
292  *              1) Methods
293  *              2) Op Regions
294  *
295  ******************************************************************************/
296 
297 static acpi_status
298 acpi_ns_init_one_object(acpi_handle obj_handle,
299 			u32 level, void *context, void **return_value)
300 {
301 	acpi_object_type type;
302 	acpi_status status = AE_OK;
303 	struct acpi_init_walk_info *info =
304 	    (struct acpi_init_walk_info *)context;
305 	struct acpi_namespace_node *node =
306 	    (struct acpi_namespace_node *)obj_handle;
307 	union acpi_operand_object *obj_desc;
308 
309 	ACPI_FUNCTION_NAME(ns_init_one_object);
310 
311 	info->object_count++;
312 
313 	/* And even then, we are only interested in a few object types */
314 
315 	type = acpi_ns_get_type(obj_handle);
316 	obj_desc = acpi_ns_get_attached_object(node);
317 	if (!obj_desc) {
318 		return (AE_OK);
319 	}
320 
321 	/* Increment counters for object types we are looking for */
322 
323 	switch (type) {
324 	case ACPI_TYPE_REGION:
325 
326 		info->op_region_count++;
327 		break;
328 
329 	case ACPI_TYPE_BUFFER_FIELD:
330 
331 		info->field_count++;
332 		break;
333 
334 	case ACPI_TYPE_LOCAL_BANK_FIELD:
335 
336 		info->field_count++;
337 		break;
338 
339 	case ACPI_TYPE_BUFFER:
340 
341 		info->buffer_count++;
342 		break;
343 
344 	case ACPI_TYPE_PACKAGE:
345 
346 		info->package_count++;
347 		break;
348 
349 	default:
350 
351 		/* No init required, just exit now */
352 
353 		return (AE_OK);
354 	}
355 
356 	/* If the object is already initialized, nothing else to do */
357 
358 	if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
359 		return (AE_OK);
360 	}
361 
362 	/* Must lock the interpreter before executing AML code */
363 
364 	acpi_ex_enter_interpreter();
365 
366 	/*
367 	 * Each of these types can contain executable AML code within the
368 	 * declaration.
369 	 */
370 	switch (type) {
371 	case ACPI_TYPE_REGION:
372 
373 		info->op_region_init++;
374 		status = acpi_ds_get_region_arguments(obj_desc);
375 		break;
376 
377 	case ACPI_TYPE_BUFFER_FIELD:
378 
379 		info->field_init++;
380 		status = acpi_ds_get_buffer_field_arguments(obj_desc);
381 		break;
382 
383 	case ACPI_TYPE_LOCAL_BANK_FIELD:
384 
385 		info->field_init++;
386 		status = acpi_ds_get_bank_field_arguments(obj_desc);
387 		break;
388 
389 	case ACPI_TYPE_BUFFER:
390 
391 		info->buffer_init++;
392 		status = acpi_ds_get_buffer_arguments(obj_desc);
393 		break;
394 
395 	case ACPI_TYPE_PACKAGE:
396 
397 		info->package_init++;
398 		status = acpi_ds_get_package_arguments(obj_desc);
399 		break;
400 
401 	default:
402 
403 		/* No other types can get here */
404 
405 		break;
406 	}
407 
408 	if (ACPI_FAILURE(status)) {
409 		ACPI_EXCEPTION((AE_INFO, status,
410 				"Could not execute arguments for [%4.4s] (%s)",
411 				acpi_ut_get_node_name(node),
412 				acpi_ut_get_type_name(type)));
413 	}
414 
415 	/*
416 	 * We ignore errors from above, and always return OK, since we don't want
417 	 * to abort the walk on any single error.
418 	 */
419 	acpi_ex_exit_interpreter();
420 	return (AE_OK);
421 }
422 
423 /*******************************************************************************
424  *
425  * FUNCTION:    acpi_ns_find_ini_methods
426  *
427  * PARAMETERS:  acpi_walk_callback
428  *
429  * RETURN:      acpi_status
430  *
431  * DESCRIPTION: Called during namespace walk. Finds objects named _INI under
432  *              device/processor/thermal objects, and marks the entire subtree
433  *              with a SUBTREE_HAS_INI flag. This flag is used during the
434  *              subsequent device initialization walk to avoid entire subtrees
435  *              that do not contain an _INI.
436  *
437  ******************************************************************************/
438 
439 static acpi_status
440 acpi_ns_find_ini_methods(acpi_handle obj_handle,
441 			 u32 nesting_level, void *context, void **return_value)
442 {
443 	struct acpi_device_walk_info *info =
444 	    ACPI_CAST_PTR(struct acpi_device_walk_info, context);
445 	struct acpi_namespace_node *node;
446 	struct acpi_namespace_node *parent_node;
447 
448 	/* Keep count of device/processor/thermal objects */
449 
450 	node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
451 	if ((node->type == ACPI_TYPE_DEVICE) ||
452 	    (node->type == ACPI_TYPE_PROCESSOR) ||
453 	    (node->type == ACPI_TYPE_THERMAL)) {
454 		info->device_count++;
455 		return (AE_OK);
456 	}
457 
458 	/* We are only looking for methods named _INI */
459 
460 	if (!ACPI_COMPARE_NAME(node->name.ascii, METHOD_NAME__INI)) {
461 		return (AE_OK);
462 	}
463 
464 	/*
465 	 * The only _INI methods that we care about are those that are
466 	 * present under Device, Processor, and Thermal objects.
467 	 */
468 	parent_node = node->parent;
469 	switch (parent_node->type) {
470 	case ACPI_TYPE_DEVICE:
471 	case ACPI_TYPE_PROCESSOR:
472 	case ACPI_TYPE_THERMAL:
473 
474 		/* Mark parent and bubble up the INI present flag to the root */
475 
476 		while (parent_node) {
477 			parent_node->flags |= ANOBJ_SUBTREE_HAS_INI;
478 			parent_node = parent_node->parent;
479 		}
480 		break;
481 
482 	default:
483 
484 		break;
485 	}
486 
487 	return (AE_OK);
488 }
489 
490 /*******************************************************************************
491  *
492  * FUNCTION:    acpi_ns_init_one_device
493  *
494  * PARAMETERS:  acpi_walk_callback
495  *
496  * RETURN:      acpi_status
497  *
498  * DESCRIPTION: This is called once per device soon after ACPI is enabled
499  *              to initialize each device. It determines if the device is
500  *              present, and if so, calls _INI.
501  *
502  ******************************************************************************/
503 
504 static acpi_status
505 acpi_ns_init_one_device(acpi_handle obj_handle,
506 			u32 nesting_level, void *context, void **return_value)
507 {
508 	struct acpi_device_walk_info *walk_info =
509 	    ACPI_CAST_PTR(struct acpi_device_walk_info, context);
510 	struct acpi_evaluate_info *info = walk_info->evaluate_info;
511 	u32 flags;
512 	acpi_status status;
513 	struct acpi_namespace_node *device_node;
514 
515 	ACPI_FUNCTION_TRACE(ns_init_one_device);
516 
517 	/* We are interested in Devices, Processors and thermal_zones only */
518 
519 	device_node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
520 	if ((device_node->type != ACPI_TYPE_DEVICE) &&
521 	    (device_node->type != ACPI_TYPE_PROCESSOR) &&
522 	    (device_node->type != ACPI_TYPE_THERMAL)) {
523 		return_ACPI_STATUS(AE_OK);
524 	}
525 
526 	/*
527 	 * Because of an earlier namespace analysis, all subtrees that contain an
528 	 * _INI method are tagged.
529 	 *
530 	 * If this device subtree does not contain any _INI methods, we
531 	 * can exit now and stop traversing this entire subtree.
532 	 */
533 	if (!(device_node->flags & ANOBJ_SUBTREE_HAS_INI)) {
534 		return_ACPI_STATUS(AE_CTRL_DEPTH);
535 	}
536 
537 	/*
538 	 * Run _STA to determine if this device is present and functioning. We
539 	 * must know this information for two important reasons (from ACPI spec):
540 	 *
541 	 * 1) We can only run _INI if the device is present.
542 	 * 2) We must abort the device tree walk on this subtree if the device is
543 	 *    not present and is not functional (we will not examine the children)
544 	 *
545 	 * The _STA method is not required to be present under the device, we
546 	 * assume the device is present if _STA does not exist.
547 	 */
548 	ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
549 			(ACPI_TYPE_METHOD, device_node, METHOD_NAME__STA));
550 
551 	status = acpi_ut_execute_STA(device_node, &flags);
552 	if (ACPI_FAILURE(status)) {
553 
554 		/* Ignore error and move on to next device */
555 
556 		return_ACPI_STATUS(AE_OK);
557 	}
558 
559 	/*
560 	 * Flags == -1 means that _STA was not found. In this case, we assume that
561 	 * the device is both present and functional.
562 	 *
563 	 * From the ACPI spec, description of _STA:
564 	 *
565 	 * "If a device object (including the processor object) does not have an
566 	 * _STA object, then OSPM assumes that all of the above bits are set (in
567 	 * other words, the device is present, ..., and functioning)"
568 	 */
569 	if (flags != ACPI_UINT32_MAX) {
570 		walk_info->num_STA++;
571 	}
572 
573 	/*
574 	 * Examine the PRESENT and FUNCTIONING status bits
575 	 *
576 	 * Note: ACPI spec does not seem to specify behavior for the present but
577 	 * not functioning case, so we assume functioning if present.
578 	 */
579 	if (!(flags & ACPI_STA_DEVICE_PRESENT)) {
580 
581 		/* Device is not present, we must examine the Functioning bit */
582 
583 		if (flags & ACPI_STA_DEVICE_FUNCTIONING) {
584 			/*
585 			 * Device is not present but is "functioning". In this case,
586 			 * we will not run _INI, but we continue to examine the children
587 			 * of this device.
588 			 *
589 			 * From the ACPI spec, description of _STA: (note - no mention
590 			 * of whether to run _INI or not on the device in question)
591 			 *
592 			 * "_STA may return bit 0 clear (not present) with bit 3 set
593 			 * (device is functional). This case is used to indicate a valid
594 			 * device for which no device driver should be loaded (for example,
595 			 * a bridge device.) Children of this device may be present and
596 			 * valid. OSPM should continue enumeration below a device whose
597 			 * _STA returns this bit combination"
598 			 */
599 			return_ACPI_STATUS(AE_OK);
600 		} else {
601 			/*
602 			 * Device is not present and is not functioning. We must abort the
603 			 * walk of this subtree immediately -- don't look at the children
604 			 * of such a device.
605 			 *
606 			 * From the ACPI spec, description of _INI:
607 			 *
608 			 * "If the _STA method indicates that the device is not present,
609 			 * OSPM will not run the _INI and will not examine the children
610 			 * of the device for _INI methods"
611 			 */
612 			return_ACPI_STATUS(AE_CTRL_DEPTH);
613 		}
614 	}
615 
616 	/*
617 	 * The device is present or is assumed present if no _STA exists.
618 	 * Run the _INI if it exists (not required to exist)
619 	 *
620 	 * Note: We know there is an _INI within this subtree, but it may not be
621 	 * under this particular device, it may be lower in the branch.
622 	 */
623 	if (!ACPI_COMPARE_NAME(device_node->name.ascii, "_SB_") ||
624 	    device_node->parent != acpi_gbl_root_node) {
625 		ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
626 				(ACPI_TYPE_METHOD, device_node,
627 				 METHOD_NAME__INI));
628 
629 		memset(info, 0, sizeof(struct acpi_evaluate_info));
630 		info->prefix_node = device_node;
631 		info->relative_pathname = METHOD_NAME__INI;
632 		info->parameters = NULL;
633 		info->flags = ACPI_IGNORE_RETURN_VALUE;
634 
635 		status = acpi_ns_evaluate(info);
636 		if (ACPI_SUCCESS(status)) {
637 			walk_info->num_INI++;
638 		}
639 #ifdef ACPI_DEBUG_OUTPUT
640 		else if (status != AE_NOT_FOUND) {
641 
642 			/* Ignore error and move on to next device */
643 
644 			char *scope_name =
645 			    acpi_ns_get_normalized_pathname(device_node, TRUE);
646 
647 			ACPI_EXCEPTION((AE_INFO, status,
648 					"during %s._INI execution",
649 					scope_name));
650 			ACPI_FREE(scope_name);
651 		}
652 #endif
653 	}
654 
655 	/* Ignore errors from above */
656 
657 	status = AE_OK;
658 
659 	/*
660 	 * The _INI method has been run if present; call the Global Initialization
661 	 * Handler for this device.
662 	 */
663 	if (acpi_gbl_init_handler) {
664 		status =
665 		    acpi_gbl_init_handler(device_node, ACPI_INIT_DEVICE_INI);
666 	}
667 
668 	return_ACPI_STATUS(status);
669 }
670