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