1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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
52ACPI_MODULE_NAME("nsinit")
53
54
55static acpi_status
56acpi_ns_init_one_object(acpi_handle obj_handle,
57 u32 level, void *context, void **return_value);
58
59static acpi_status
60acpi_ns_init_one_device(acpi_handle obj_handle,
61 u32 nesting_level, void *context, void **return_value);
62
63static acpi_status
64acpi_ns_find_ini_methods(acpi_handle obj_handle,
65 u32 nesting_level, void *context, void **return_value);
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80acpi_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
95
96 memset(&info, 0, sizeof(struct acpi_init_walk_info));
97
98
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139acpi_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
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
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
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
182
183
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
197
198
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
219
220
221
222
223
224
225
226
227
228
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
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
251
252
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
272error_exit:
273 ACPI_EXCEPTION((AE_INFO, status, "During device initialization"));
274 return_ACPI_STATUS(status);
275}
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297static acpi_status
298acpi_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
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
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
352
353 return (AE_OK);
354 }
355
356
357
358 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
359 return (AE_OK);
360 }
361
362
363
364 acpi_ex_enter_interpreter();
365
366
367
368
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 if (ACPI_FAILURE(status)) {
400 break;
401 }
402
403
404
405
406
407
408
409 status = acpi_ut_walk_package_tree(obj_desc, NULL,
410 acpi_ds_init_package_element,
411 NULL);
412 obj_desc->package.flags |= AOPOBJ_DATA_VALID;
413 break;
414
415 default:
416
417
418
419 break;
420 }
421
422 if (ACPI_FAILURE(status)) {
423 ACPI_EXCEPTION((AE_INFO, status,
424 "Could not execute arguments for [%4.4s] (%s)",
425 acpi_ut_get_node_name(node),
426 acpi_ut_get_type_name(type)));
427 }
428
429
430
431
432
433 acpi_ex_exit_interpreter();
434 return (AE_OK);
435}
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453static acpi_status
454acpi_ns_find_ini_methods(acpi_handle obj_handle,
455 u32 nesting_level, void *context, void **return_value)
456{
457 struct acpi_device_walk_info *info =
458 ACPI_CAST_PTR(struct acpi_device_walk_info, context);
459 struct acpi_namespace_node *node;
460 struct acpi_namespace_node *parent_node;
461
462
463
464 node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
465 if ((node->type == ACPI_TYPE_DEVICE) ||
466 (node->type == ACPI_TYPE_PROCESSOR) ||
467 (node->type == ACPI_TYPE_THERMAL)) {
468 info->device_count++;
469 return (AE_OK);
470 }
471
472
473
474 if (!ACPI_COMPARE_NAME(node->name.ascii, METHOD_NAME__INI)) {
475 return (AE_OK);
476 }
477
478
479
480
481
482 parent_node = node->parent;
483 switch (parent_node->type) {
484 case ACPI_TYPE_DEVICE:
485 case ACPI_TYPE_PROCESSOR:
486 case ACPI_TYPE_THERMAL:
487
488
489
490 while (parent_node) {
491 parent_node->flags |= ANOBJ_SUBTREE_HAS_INI;
492 parent_node = parent_node->parent;
493 }
494 break;
495
496 default:
497
498 break;
499 }
500
501 return (AE_OK);
502}
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518static acpi_status
519acpi_ns_init_one_device(acpi_handle obj_handle,
520 u32 nesting_level, void *context, void **return_value)
521{
522 struct acpi_device_walk_info *walk_info =
523 ACPI_CAST_PTR(struct acpi_device_walk_info, context);
524 struct acpi_evaluate_info *info = walk_info->evaluate_info;
525 u32 flags;
526 acpi_status status;
527 struct acpi_namespace_node *device_node;
528
529 ACPI_FUNCTION_TRACE(ns_init_one_device);
530
531
532
533 device_node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
534 if ((device_node->type != ACPI_TYPE_DEVICE) &&
535 (device_node->type != ACPI_TYPE_PROCESSOR) &&
536 (device_node->type != ACPI_TYPE_THERMAL)) {
537 return_ACPI_STATUS(AE_OK);
538 }
539
540
541
542
543
544
545
546
547 if (!(device_node->flags & ANOBJ_SUBTREE_HAS_INI)) {
548 return_ACPI_STATUS(AE_CTRL_DEPTH);
549 }
550
551
552
553
554
555
556
557
558
559
560
561
562 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
563 (ACPI_TYPE_METHOD, device_node, METHOD_NAME__STA));
564
565 status = acpi_ut_execute_STA(device_node, &flags);
566 if (ACPI_FAILURE(status)) {
567
568
569
570 return_ACPI_STATUS(AE_OK);
571 }
572
573
574
575
576
577
578
579
580
581
582
583 if (flags != ACPI_UINT32_MAX) {
584 walk_info->num_STA++;
585 }
586
587
588
589
590
591
592
593 if (!(flags & ACPI_STA_DEVICE_PRESENT)) {
594
595
596
597 if (flags & ACPI_STA_DEVICE_FUNCTIONING) {
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613 return_ACPI_STATUS(AE_OK);
614 } else {
615
616
617
618
619
620
621
622
623
624
625
626 return_ACPI_STATUS(AE_CTRL_DEPTH);
627 }
628 }
629
630
631
632
633
634
635
636
637 if (!ACPI_COMPARE_NAME(device_node->name.ascii, "_SB_") ||
638 device_node->parent != acpi_gbl_root_node) {
639 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
640 (ACPI_TYPE_METHOD, device_node,
641 METHOD_NAME__INI));
642
643 memset(info, 0, sizeof(struct acpi_evaluate_info));
644 info->prefix_node = device_node;
645 info->relative_pathname = METHOD_NAME__INI;
646 info->parameters = NULL;
647 info->flags = ACPI_IGNORE_RETURN_VALUE;
648
649 status = acpi_ns_evaluate(info);
650 if (ACPI_SUCCESS(status)) {
651 walk_info->num_INI++;
652 }
653#ifdef ACPI_DEBUG_OUTPUT
654 else if (status != AE_NOT_FOUND) {
655
656
657
658 char *scope_name =
659 acpi_ns_get_normalized_pathname(device_node, TRUE);
660
661 ACPI_EXCEPTION((AE_INFO, status,
662 "during %s._INI execution",
663 scope_name));
664 ACPI_FREE(scope_name);
665 }
666#endif
667 }
668
669
670
671 status = AE_OK;
672
673
674
675
676
677 if (acpi_gbl_init_handler) {
678 status =
679 acpi_gbl_init_handler(device_node, ACPI_INIT_DEVICE_INI);
680 }
681
682 return_ACPI_STATUS(status);
683}
684