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 <linux/nmi.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_DISPATCH,
88 "**** Starting initialization of namespace objects ****\n"));
89 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
90 "Completing Region/Field/Buffer/Package initialization:"));
91
92
93
94 ACPI_MEMSET(&info, 0, sizeof(struct acpi_init_walk_info));
95
96
97
98 status = acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
99 ACPI_UINT32_MAX, acpi_ns_init_one_object,
100 &info, NULL);
101 if (ACPI_FAILURE(status)) {
102 ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace"));
103 }
104
105 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
106 "\nInitialized %hd/%hd Regions %hd/%hd Fields %hd/%hd "
107 "Buffers %hd/%hd Packages (%hd nodes)\n",
108 info.op_region_init, info.op_region_count,
109 info.field_init, info.field_count,
110 info.buffer_init, info.buffer_count,
111 info.package_init, info.package_count,
112 info.object_count));
113
114 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
115 "%hd Control Methods found\n", info.method_count));
116 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
117 "%hd Op Regions found\n", info.op_region_count));
118
119 return_ACPI_STATUS(AE_OK);
120}
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138acpi_status acpi_ns_initialize_devices(void)
139{
140 acpi_status status;
141 struct acpi_device_walk_info info;
142
143 ACPI_FUNCTION_TRACE(ns_initialize_devices);
144
145
146
147 info.device_count = 0;
148 info.num_STA = 0;
149 info.num_INI = 0;
150
151 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
152 "Initializing Device/Processor/Thermal objects "
153 "by executing _INI methods:"));
154
155
156
157 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
158 ACPI_UINT32_MAX, FALSE,
159 acpi_ns_find_ini_methods, &info, NULL);
160 if (ACPI_FAILURE(status)) {
161 goto error_exit;
162 }
163
164
165
166 info.evaluate_info =
167 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
168 if (!info.evaluate_info) {
169 status = AE_NO_MEMORY;
170 goto error_exit;
171 }
172
173
174
175
176
177
178 info.evaluate_info->prefix_node = acpi_gbl_root_node;
179 info.evaluate_info->pathname = METHOD_NAME__INI;
180 info.evaluate_info->parameters = NULL;
181 info.evaluate_info->flags = ACPI_IGNORE_RETURN_VALUE;
182
183 status = acpi_ns_evaluate(info.evaluate_info);
184 if (ACPI_SUCCESS(status)) {
185 info.num_INI++;
186 }
187
188
189
190 status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
191 ACPI_UINT32_MAX, FALSE,
192 acpi_ns_init_one_device, &info, NULL);
193
194 ACPI_FREE(info.evaluate_info);
195 if (ACPI_FAILURE(status)) {
196 goto error_exit;
197 }
198
199 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
200 "\nExecuted %hd _INI methods requiring %hd _STA executions "
201 "(examined %hd objects)\n",
202 info.num_INI, info.num_STA, info.device_count));
203
204 return_ACPI_STATUS(status);
205
206 error_exit:
207 ACPI_EXCEPTION((AE_INFO, status, "During device initialization"));
208 return_ACPI_STATUS(status);
209}
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231static acpi_status
232acpi_ns_init_one_object(acpi_handle obj_handle,
233 u32 level, void *context, void **return_value)
234{
235 acpi_object_type type;
236 acpi_status status = AE_OK;
237 struct acpi_init_walk_info *info =
238 (struct acpi_init_walk_info *)context;
239 struct acpi_namespace_node *node =
240 (struct acpi_namespace_node *)obj_handle;
241 union acpi_operand_object *obj_desc;
242
243 ACPI_FUNCTION_NAME(ns_init_one_object);
244
245 info->object_count++;
246
247
248
249 type = acpi_ns_get_type(obj_handle);
250 obj_desc = acpi_ns_get_attached_object(node);
251 if (!obj_desc) {
252 return (AE_OK);
253 }
254
255
256
257 switch (type) {
258 case ACPI_TYPE_REGION:
259 info->op_region_count++;
260 break;
261
262 case ACPI_TYPE_BUFFER_FIELD:
263 info->field_count++;
264 break;
265
266 case ACPI_TYPE_LOCAL_BANK_FIELD:
267 info->field_count++;
268 break;
269
270 case ACPI_TYPE_BUFFER:
271 info->buffer_count++;
272 break;
273
274 case ACPI_TYPE_PACKAGE:
275 info->package_count++;
276 break;
277
278 default:
279
280
281 return (AE_OK);
282 }
283
284
285
286 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
287 return (AE_OK);
288 }
289
290
291
292 acpi_ex_enter_interpreter();
293
294
295
296
297
298 switch (type) {
299 case ACPI_TYPE_REGION:
300
301 info->op_region_init++;
302 status = acpi_ds_get_region_arguments(obj_desc);
303 break;
304
305 case ACPI_TYPE_BUFFER_FIELD:
306
307 info->field_init++;
308 status = acpi_ds_get_buffer_field_arguments(obj_desc);
309 break;
310
311 case ACPI_TYPE_LOCAL_BANK_FIELD:
312
313 info->field_init++;
314 status = acpi_ds_get_bank_field_arguments(obj_desc);
315 break;
316
317 case ACPI_TYPE_BUFFER:
318
319 info->buffer_init++;
320 status = acpi_ds_get_buffer_arguments(obj_desc);
321 break;
322
323 case ACPI_TYPE_PACKAGE:
324
325 info->package_init++;
326 status = acpi_ds_get_package_arguments(obj_desc);
327 break;
328
329 default:
330
331 break;
332 }
333
334 if (ACPI_FAILURE(status)) {
335 ACPI_EXCEPTION((AE_INFO, status,
336 "Could not execute arguments for [%4.4s] (%s)",
337 acpi_ut_get_node_name(node),
338 acpi_ut_get_type_name(type)));
339 }
340
341
342
343
344
345 if (!(acpi_dbg_level & ACPI_LV_INIT_NAMES)) {
346 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, "."));
347 }
348
349
350
351
352
353 acpi_ex_exit_interpreter();
354 return (AE_OK);
355}
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373static acpi_status
374acpi_ns_find_ini_methods(acpi_handle obj_handle,
375 u32 nesting_level, void *context, void **return_value)
376{
377 struct acpi_device_walk_info *info =
378 ACPI_CAST_PTR(struct acpi_device_walk_info, context);
379 struct acpi_namespace_node *node;
380 struct acpi_namespace_node *parent_node;
381
382
383
384 node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
385 if ((node->type == ACPI_TYPE_DEVICE) ||
386 (node->type == ACPI_TYPE_PROCESSOR) ||
387 (node->type == ACPI_TYPE_THERMAL)) {
388 info->device_count++;
389 return (AE_OK);
390 }
391
392
393
394 if (!ACPI_COMPARE_NAME(node->name.ascii, METHOD_NAME__INI)) {
395 return (AE_OK);
396 }
397
398
399
400
401
402 parent_node = acpi_ns_get_parent_node(node);
403 switch (parent_node->type) {
404 case ACPI_TYPE_DEVICE:
405 case ACPI_TYPE_PROCESSOR:
406 case ACPI_TYPE_THERMAL:
407
408
409
410 while (parent_node) {
411 parent_node->flags |= ANOBJ_SUBTREE_HAS_INI;
412 parent_node = acpi_ns_get_parent_node(parent_node);
413 }
414 break;
415
416 default:
417 break;
418 }
419
420 return (AE_OK);
421}
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437static acpi_status
438acpi_ns_init_one_device(acpi_handle obj_handle,
439 u32 nesting_level, void *context, void **return_value)
440{
441 struct acpi_device_walk_info *walk_info =
442 ACPI_CAST_PTR(struct acpi_device_walk_info, context);
443 struct acpi_evaluate_info *info = walk_info->evaluate_info;
444 u32 flags;
445 acpi_status status;
446 struct acpi_namespace_node *device_node;
447
448 ACPI_FUNCTION_TRACE(ns_init_one_device);
449
450
451
452 device_node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
453 if ((device_node->type != ACPI_TYPE_DEVICE) &&
454 (device_node->type != ACPI_TYPE_PROCESSOR) &&
455 (device_node->type != ACPI_TYPE_THERMAL)) {
456 return_ACPI_STATUS(AE_OK);
457 }
458
459
460
461
462
463
464
465
466 if (!(device_node->flags & ANOBJ_SUBTREE_HAS_INI)) {
467 return_ACPI_STATUS(AE_CTRL_DEPTH);
468 }
469
470
471
472
473
474
475
476
477
478
479
480
481 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
482 (ACPI_TYPE_METHOD, device_node, METHOD_NAME__STA));
483
484 status = acpi_ut_execute_STA(device_node, &flags);
485 if (ACPI_FAILURE(status)) {
486
487
488
489 return_ACPI_STATUS(AE_OK);
490 }
491
492
493
494
495
496
497
498
499
500
501
502 if (flags != ACPI_UINT32_MAX) {
503 walk_info->num_STA++;
504 }
505
506
507
508
509
510
511
512 if (!(flags & ACPI_STA_DEVICE_PRESENT)) {
513
514
515
516 if (flags & ACPI_STA_DEVICE_FUNCTIONING) {
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532 return_ACPI_STATUS(AE_OK);
533 } else {
534
535
536
537
538
539
540
541
542
543
544
545 return_ACPI_STATUS(AE_CTRL_DEPTH);
546 }
547 }
548
549
550
551
552
553
554
555
556 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
557 (ACPI_TYPE_METHOD, device_node, METHOD_NAME__INI));
558
559 info->prefix_node = device_node;
560 info->pathname = METHOD_NAME__INI;
561 info->parameters = NULL;
562 info->flags = ACPI_IGNORE_RETURN_VALUE;
563
564
565
566
567
568
569 acpi_nmi_disable();
570 status = acpi_ns_evaluate(info);
571 acpi_nmi_enable();
572
573 if (ACPI_SUCCESS(status)) {
574 walk_info->num_INI++;
575
576 if ((acpi_dbg_level <= ACPI_LV_ALL_EXCEPTIONS) &&
577 (!(acpi_dbg_level & ACPI_LV_INFO))) {
578 ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, "."));
579 }
580 }
581#ifdef ACPI_DEBUG_OUTPUT
582 else if (status != AE_NOT_FOUND) {
583
584
585
586 char *scope_name =
587 acpi_ns_get_external_pathname(info->resolved_node);
588
589 ACPI_EXCEPTION((AE_INFO, status, "during %s._INI execution",
590 scope_name));
591 ACPI_FREE(scope_name);
592 }
593#endif
594
595
596
597 status = AE_OK;
598
599
600
601
602
603 if (acpi_gbl_init_handler) {
604 status =
605 acpi_gbl_init_handler(device_node, ACPI_INIT_DEVICE_INI);
606 }
607
608 return_ACPI_STATUS(status);
609}
610