Print this page
acpica-unix2-20130823
PANKOVs restructure
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/intel/io/acpica/executer/exoparg2.c
+++ new/usr/src/common/acpica/components/executer/exoparg2.c
1 1 /******************************************************************************
2 2 *
3 3 * Module Name: exoparg2 - AML execution - opcodes with 2 arguments
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 __EXOPARG2_C__
46 46
47 47 #include "acpi.h"
48 48 #include "accommon.h"
49 49 #include "acparser.h"
50 50 #include "acinterp.h"
51 51 #include "acevents.h"
52 52 #include "amlcode.h"
53 53
54 54
55 55 #define _COMPONENT ACPI_EXECUTER
56 56 ACPI_MODULE_NAME ("exoparg2")
57 57
58 58
59 59 /*!
60 60 * Naming convention for AML interpreter execution routines.
61 61 *
62 62 * The routines that begin execution of AML opcodes are named with a common
63 63 * convention based upon the number of arguments, the number of target operands,
64 64 * and whether or not a value is returned:
65 65 *
66 66 * AcpiExOpcode_xA_yT_zR
67 67 *
68 68 * Where:
69 69 *
70 70 * xA - ARGUMENTS: The number of arguments (input operands) that are
71 71 * required for this opcode type (1 through 6 args).
72 72 * yT - TARGETS: The number of targets (output operands) that are required
73 73 * for this opcode type (0, 1, or 2 targets).
74 74 * zR - RETURN VALUE: Indicates whether this opcode type returns a value
75 75 * as the function return (0 or 1).
76 76 *
77 77 * The AcpiExOpcode* functions are called via the Dispatcher component with
78 78 * fully resolved operands.
79 79 !*/
80 80
81 81
82 82 /*******************************************************************************
83 83 *
84 84 * FUNCTION: AcpiExOpcode_2A_0T_0R
85 85 *
86 86 * PARAMETERS: WalkState - Current walk state
87 87 *
88 88 * RETURN: Status
89 89 *
90 90 * DESCRIPTION: Execute opcode with two arguments, no target, and no return
91 91 * value.
92 92 *
93 93 * ALLOCATION: Deletes both operands
94 94 *
95 95 ******************************************************************************/
96 96
97 97 ACPI_STATUS
98 98 AcpiExOpcode_2A_0T_0R (
99 99 ACPI_WALK_STATE *WalkState)
100 100 {
101 101 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
102 102 ACPI_NAMESPACE_NODE *Node;
103 103 UINT32 Value;
104 104 ACPI_STATUS Status = AE_OK;
105 105
106 106
107 107 ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_0R,
108 108 AcpiPsGetOpcodeName (WalkState->Opcode));
109 109
110 110
111 111 /* Examine the opcode */
112 112
113 113 switch (WalkState->Opcode)
114 114 {
115 115 case AML_NOTIFY_OP: /* Notify (NotifyObject, NotifyValue) */
116 116
117 117 /* The first operand is a namespace node */
118 118
119 119 Node = (ACPI_NAMESPACE_NODE *) Operand[0];
120 120
121 121 /* Second value is the notify value */
122 122
123 123 Value = (UINT32) Operand[1]->Integer.Value;
124 124
125 125 /* Are notifies allowed on this object? */
126 126
127 127 if (!AcpiEvIsNotifyObject (Node))
128 128 {
129 129 ACPI_ERROR ((AE_INFO,
|
↓ open down ↓ |
111 lines elided |
↑ open up ↑ |
130 130 "Unexpected notify object type [%s]",
131 131 AcpiUtGetTypeName (Node->Type)));
132 132
133 133 Status = AE_AML_OPERAND_TYPE;
134 134 break;
135 135 }
136 136
137 137 /*
138 138 * Dispatch the notify to the appropriate handler
139 139 * NOTE: the request is queued for execution after this method
140 - * completes. The notify handlers are NOT invoked synchronously
140 + * completes. The notify handlers are NOT invoked synchronously
141 141 * from this thread -- because handlers may in turn run other
142 142 * control methods.
143 143 */
144 144 Status = AcpiEvQueueNotifyRequest (Node, Value);
145 145 break;
146 146
147 -
148 147 default:
149 148
150 149 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
151 150 WalkState->Opcode));
152 151 Status = AE_AML_BAD_OPCODE;
153 152 }
154 153
155 154 return_ACPI_STATUS (Status);
156 155 }
157 156
158 157
159 158 /*******************************************************************************
160 159 *
161 160 * FUNCTION: AcpiExOpcode_2A_2T_1R
162 161 *
163 162 * PARAMETERS: WalkState - Current walk state
164 163 *
165 164 * RETURN: Status
166 165 *
167 166 * DESCRIPTION: Execute a dyadic operator (2 operands) with 2 output targets
168 167 * and one implicit return value.
169 168 *
170 169 ******************************************************************************/
171 170
172 171 ACPI_STATUS
173 172 AcpiExOpcode_2A_2T_1R (
174 173 ACPI_WALK_STATE *WalkState)
175 174 {
176 175 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
177 176 ACPI_OPERAND_OBJECT *ReturnDesc1 = NULL;
178 177 ACPI_OPERAND_OBJECT *ReturnDesc2 = NULL;
179 178 ACPI_STATUS Status;
180 179
181 180
182 181 ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_2T_1R,
183 182 AcpiPsGetOpcodeName (WalkState->Opcode));
184 183
185 184
186 185 /* Execute the opcode */
187 186
188 187 switch (WalkState->Opcode)
189 188 {
190 189 case AML_DIVIDE_OP:
191 190
192 191 /* Divide (Dividend, Divisor, RemainderResult QuotientResult) */
193 192
194 193 ReturnDesc1 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
195 194 if (!ReturnDesc1)
196 195 {
197 196 Status = AE_NO_MEMORY;
198 197 goto Cleanup;
199 198 }
200 199
201 200 ReturnDesc2 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
202 201 if (!ReturnDesc2)
203 202 {
204 203 Status = AE_NO_MEMORY;
205 204 goto Cleanup;
206 205 }
207 206
208 207 /* Quotient to ReturnDesc1, remainder to ReturnDesc2 */
209 208
|
↓ open down ↓ |
52 lines elided |
↑ open up ↑ |
210 209 Status = AcpiUtDivide (Operand[0]->Integer.Value,
211 210 Operand[1]->Integer.Value,
212 211 &ReturnDesc1->Integer.Value,
213 212 &ReturnDesc2->Integer.Value);
214 213 if (ACPI_FAILURE (Status))
215 214 {
216 215 goto Cleanup;
217 216 }
218 217 break;
219 218
220 -
221 219 default:
222 220
223 221 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
224 222 WalkState->Opcode));
225 223 Status = AE_AML_BAD_OPCODE;
226 224 goto Cleanup;
227 225 }
228 226
229 227 /* Store the results to the target reference operands */
230 228
231 229 Status = AcpiExStore (ReturnDesc2, Operand[2], WalkState);
232 230 if (ACPI_FAILURE (Status))
233 231 {
234 232 goto Cleanup;
235 233 }
236 234
237 235 Status = AcpiExStore (ReturnDesc1, Operand[3], WalkState);
238 236 if (ACPI_FAILURE (Status))
239 237 {
240 238 goto Cleanup;
241 239 }
242 240
243 241 Cleanup:
244 242 /*
245 243 * Since the remainder is not returned indirectly, remove a reference to
246 244 * it. Only the quotient is returned indirectly.
247 245 */
248 246 AcpiUtRemoveReference (ReturnDesc2);
249 247
250 248 if (ACPI_FAILURE (Status))
251 249 {
252 250 /* Delete the return object */
253 251
254 252 AcpiUtRemoveReference (ReturnDesc1);
255 253 }
256 254
257 255 /* Save return object (the remainder) on success */
258 256
259 257 else
260 258 {
261 259 WalkState->ResultObj = ReturnDesc1;
262 260 }
263 261
264 262 return_ACPI_STATUS (Status);
265 263 }
266 264
267 265
268 266 /*******************************************************************************
269 267 *
270 268 * FUNCTION: AcpiExOpcode_2A_1T_1R
271 269 *
272 270 * PARAMETERS: WalkState - Current walk state
273 271 *
274 272 * RETURN: Status
275 273 *
276 274 * DESCRIPTION: Execute opcode with two arguments, one target, and a return
277 275 * value.
278 276 *
|
↓ open down ↓ |
48 lines elided |
↑ open up ↑ |
279 277 ******************************************************************************/
280 278
281 279 ACPI_STATUS
282 280 AcpiExOpcode_2A_1T_1R (
283 281 ACPI_WALK_STATE *WalkState)
284 282 {
285 283 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
286 284 ACPI_OPERAND_OBJECT *ReturnDesc = NULL;
287 285 UINT64 Index;
288 286 ACPI_STATUS Status = AE_OK;
289 - ACPI_SIZE Length;
287 + ACPI_SIZE Length = 0;
290 288
291 289
292 290 ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_1T_1R,
293 291 AcpiPsGetOpcodeName (WalkState->Opcode));
294 292
295 293
296 294 /* Execute the opcode */
297 295
298 296 if (WalkState->OpInfo->Flags & AML_MATH)
299 297 {
300 298 /* All simple math opcodes (add, etc.) */
301 299
302 300 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
303 301 if (!ReturnDesc)
304 302 {
305 303 Status = AE_NO_MEMORY;
306 304 goto Cleanup;
307 305 }
308 306
309 307 ReturnDesc->Integer.Value = AcpiExDoMathOp (WalkState->Opcode,
310 308 Operand[0]->Integer.Value,
311 309 Operand[1]->Integer.Value);
312 310 goto StoreResultToTarget;
313 311 }
314 312
315 313 switch (WalkState->Opcode)
316 314 {
317 315 case AML_MOD_OP: /* Mod (Dividend, Divisor, RemainderResult (ACPI 2.0) */
318 316
319 317 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
320 318 if (!ReturnDesc)
321 319 {
322 320 Status = AE_NO_MEMORY;
323 321 goto Cleanup;
|
↓ open down ↓ |
24 lines elided |
↑ open up ↑ |
324 322 }
325 323
326 324 /* ReturnDesc will contain the remainder */
327 325
328 326 Status = AcpiUtDivide (Operand[0]->Integer.Value,
329 327 Operand[1]->Integer.Value,
330 328 NULL,
331 329 &ReturnDesc->Integer.Value);
332 330 break;
333 331
334 -
335 332 case AML_CONCAT_OP: /* Concatenate (Data1, Data2, Result) */
336 333
337 334 Status = AcpiExDoConcatenate (Operand[0], Operand[1],
338 335 &ReturnDesc, WalkState);
339 336 break;
340 337
341 -
342 338 case AML_TO_STRING_OP: /* ToString (Buffer, Length, Result) (ACPI 2.0) */
343 -
344 339 /*
345 340 * Input object is guaranteed to be a buffer at this point (it may have
346 341 * been converted.) Copy the raw buffer data to a new object of
347 342 * type String.
348 343 */
349 344
350 345 /*
351 346 * Get the length of the new string. It is the smallest of:
352 347 * 1) Length of the input buffer
353 348 * 2) Max length as specified in the ToString operator
354 349 * 3) Length of input buffer up to a zero byte (null terminator)
355 350 *
356 351 * NOTE: A length of zero is ok, and will create a zero-length, null
357 352 * terminated string.
358 353 */
359 - Length = 0;
360 354 while ((Length < Operand[0]->Buffer.Length) &&
361 355 (Length < Operand[1]->Integer.Value) &&
362 356 (Operand[0]->Buffer.Pointer[Length]))
363 357 {
364 358 Length++;
365 359 }
366 360
367 361 /* Allocate a new string object */
368 362
369 363 ReturnDesc = AcpiUtCreateStringObject (Length);
370 364 if (!ReturnDesc)
371 365 {
372 366 Status = AE_NO_MEMORY;
373 367 goto Cleanup;
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
374 368 }
375 369
376 370 /*
377 371 * Copy the raw buffer data with no transform.
378 372 * (NULL terminated already)
379 373 */
380 374 ACPI_MEMCPY (ReturnDesc->String.Pointer,
381 375 Operand[0]->Buffer.Pointer, Length);
382 376 break;
383 377
384 -
385 378 case AML_CONCAT_RES_OP:
386 379
387 380 /* ConcatenateResTemplate (Buffer, Buffer, Result) (ACPI 2.0) */
388 381
389 382 Status = AcpiExConcatTemplate (Operand[0], Operand[1],
390 383 &ReturnDesc, WalkState);
391 384 break;
392 385
393 -
394 386 case AML_INDEX_OP: /* Index (Source Index Result) */
395 387
396 388 /* Create the internal return object */
397 389
398 390 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_REFERENCE);
399 391 if (!ReturnDesc)
400 392 {
401 393 Status = AE_NO_MEMORY;
402 394 goto Cleanup;
403 395 }
404 396
405 397 /* Initialize the Index reference object */
406 398
407 399 Index = Operand[1]->Integer.Value;
408 400 ReturnDesc->Reference.Value = (UINT32) Index;
409 401 ReturnDesc->Reference.Class = ACPI_REFCLASS_INDEX;
410 402
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
411 403 /*
412 404 * At this point, the Source operand is a String, Buffer, or Package.
413 405 * Verify that the index is within range.
414 406 */
415 407 switch ((Operand[0])->Common.Type)
416 408 {
417 409 case ACPI_TYPE_STRING:
418 410
419 411 if (Index >= Operand[0]->String.Length)
420 412 {
413 + Length = Operand[0]->String.Length;
421 414 Status = AE_AML_STRING_LIMIT;
422 415 }
423 416
424 417 ReturnDesc->Reference.TargetType = ACPI_TYPE_BUFFER_FIELD;
425 418 break;
426 419
427 420 case ACPI_TYPE_BUFFER:
428 421
429 422 if (Index >= Operand[0]->Buffer.Length)
430 423 {
424 + Length = Operand[0]->Buffer.Length;
431 425 Status = AE_AML_BUFFER_LIMIT;
432 426 }
433 427
434 428 ReturnDesc->Reference.TargetType = ACPI_TYPE_BUFFER_FIELD;
435 429 break;
436 430
437 431 case ACPI_TYPE_PACKAGE:
438 432
439 433 if (Index >= Operand[0]->Package.Count)
440 434 {
435 + Length = Operand[0]->Package.Count;
441 436 Status = AE_AML_PACKAGE_LIMIT;
442 437 }
443 438
444 439 ReturnDesc->Reference.TargetType = ACPI_TYPE_PACKAGE;
445 440 ReturnDesc->Reference.Where = &Operand[0]->Package.Elements [Index];
446 441 break;
447 442
448 443 default:
449 444
450 445 Status = AE_AML_INTERNAL;
451 446 goto Cleanup;
452 447 }
453 448
454 449 /* Failure means that the Index was beyond the end of the object */
455 450
456 451 if (ACPI_FAILURE (Status))
457 452 {
458 453 ACPI_EXCEPTION ((AE_INFO, Status,
459 - "Index (0x%8.8X%8.8X) is beyond end of object",
460 - ACPI_FORMAT_UINT64 (Index)));
454 + "Index (0x%X%8.8X) is beyond end of object (length 0x%X)",
455 + ACPI_FORMAT_UINT64 (Index), (UINT32) Length));
461 456 goto Cleanup;
462 457 }
463 458
464 459 /*
465 460 * Save the target object and add a reference to it for the life
466 461 * of the index
467 462 */
468 463 ReturnDesc->Reference.Object = Operand[0];
469 464 AcpiUtAddReference (Operand[0]);
470 465
471 466 /* Store the reference to the Target */
472 467
473 468 Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
474 469
475 470 /* Return the reference */
476 471
477 472 WalkState->ResultObj = ReturnDesc;
478 473 goto Cleanup;
479 474
480 -
481 475 default:
482 476
483 477 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
484 478 WalkState->Opcode));
485 479 Status = AE_AML_BAD_OPCODE;
486 480 break;
487 481 }
488 482
489 483
490 484 StoreResultToTarget:
491 485
492 486 if (ACPI_SUCCESS (Status))
493 487 {
494 488 /*
495 489 * Store the result of the operation (which is now in ReturnDesc) into
496 490 * the Target descriptor.
497 491 */
498 492 Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
499 493 if (ACPI_FAILURE (Status))
500 494 {
501 495 goto Cleanup;
502 496 }
503 497
504 498 if (!WalkState->ResultObj)
505 499 {
506 500 WalkState->ResultObj = ReturnDesc;
507 501 }
508 502 }
509 503
510 504
511 505 Cleanup:
512 506
513 507 /* Delete return object on error */
514 508
515 509 if (ACPI_FAILURE (Status))
516 510 {
517 511 AcpiUtRemoveReference (ReturnDesc);
518 512 WalkState->ResultObj = NULL;
519 513 }
520 514
521 515 return_ACPI_STATUS (Status);
522 516 }
523 517
524 518
525 519 /*******************************************************************************
526 520 *
527 521 * FUNCTION: AcpiExOpcode_2A_0T_1R
528 522 *
529 523 * PARAMETERS: WalkState - Current walk state
530 524 *
531 525 * RETURN: Status
532 526 *
533 527 * DESCRIPTION: Execute opcode with 2 arguments, no target, and a return value
534 528 *
535 529 ******************************************************************************/
536 530
537 531 ACPI_STATUS
538 532 AcpiExOpcode_2A_0T_1R (
539 533 ACPI_WALK_STATE *WalkState)
540 534 {
541 535 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
542 536 ACPI_OPERAND_OBJECT *ReturnDesc = NULL;
543 537 ACPI_STATUS Status = AE_OK;
544 538 BOOLEAN LogicalResult = FALSE;
545 539
546 540
547 541 ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_1R,
548 542 AcpiPsGetOpcodeName (WalkState->Opcode));
549 543
550 544
551 545 /* Create the internal return object */
552 546
553 547 ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
554 548 if (!ReturnDesc)
555 549 {
556 550 Status = AE_NO_MEMORY;
557 551 goto Cleanup;
558 552 }
559 553
560 554 /* Execute the Opcode */
561 555
562 556 if (WalkState->OpInfo->Flags & AML_LOGICAL_NUMERIC)
563 557 {
564 558 /* LogicalOp (Operand0, Operand1) */
565 559
566 560 Status = AcpiExDoLogicalNumericOp (WalkState->Opcode,
567 561 Operand[0]->Integer.Value, Operand[1]->Integer.Value,
568 562 &LogicalResult);
569 563 goto StoreLogicalResult;
570 564 }
571 565 else if (WalkState->OpInfo->Flags & AML_LOGICAL)
572 566 {
573 567 /* LogicalOp (Operand0, Operand1) */
574 568
575 569 Status = AcpiExDoLogicalOp (WalkState->Opcode, Operand[0],
576 570 Operand[1], &LogicalResult);
577 571 goto StoreLogicalResult;
578 572 }
579 573
580 574 switch (WalkState->Opcode)
581 575 {
582 576 case AML_ACQUIRE_OP: /* Acquire (MutexObject, Timeout) */
583 577
584 578 Status = AcpiExAcquireMutex (Operand[1], Operand[0], WalkState);
585 579 if (Status == AE_TIME)
586 580 {
587 581 LogicalResult = TRUE; /* TRUE = Acquire timed out */
588 582 Status = AE_OK;
589 583 }
590 584 break;
591 585
592 586
|
↓ open down ↓ |
102 lines elided |
↑ open up ↑ |
593 587 case AML_WAIT_OP: /* Wait (EventObject, Timeout) */
594 588
595 589 Status = AcpiExSystemWaitEvent (Operand[1], Operand[0]);
596 590 if (Status == AE_TIME)
597 591 {
598 592 LogicalResult = TRUE; /* TRUE, Wait timed out */
599 593 Status = AE_OK;
600 594 }
601 595 break;
602 596
603 -
604 597 default:
605 598
606 599 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
607 600 WalkState->Opcode));
608 601 Status = AE_AML_BAD_OPCODE;
609 602 goto Cleanup;
610 603 }
611 604
612 605
613 606 StoreLogicalResult:
614 607 /*
615 608 * Set return value to according to LogicalResult. logical TRUE (all ones)
616 609 * Default is FALSE (zero)
617 610 */
618 611 if (LogicalResult)
619 612 {
620 613 ReturnDesc->Integer.Value = ACPI_UINT64_MAX;
621 614 }
622 615
623 616 Cleanup:
624 617
625 618 /* Delete return object on error */
626 619
627 620 if (ACPI_FAILURE (Status))
628 621 {
629 622 AcpiUtRemoveReference (ReturnDesc);
630 623 }
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
631 624
632 625 /* Save return object on success */
633 626
634 627 else
635 628 {
636 629 WalkState->ResultObj = ReturnDesc;
637 630 }
638 631
639 632 return_ACPI_STATUS (Status);
640 633 }
641 -
642 -
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX