1/******************************************************************************
2 *
3 * Module Name: dswstate - Dispatcher parse tree walk management routines
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2013, 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
45#define __DSWSTATE_C__
46
47#include <contrib/dev/acpica/include/acpi.h>
48#include <contrib/dev/acpica/include/accommon.h>
49#include <contrib/dev/acpica/include/acparser.h>
50#include <contrib/dev/acpica/include/acdispat.h>
51#include <contrib/dev/acpica/include/acnamesp.h>
52
53#define _COMPONENT          ACPI_DISPATCHER
54        ACPI_MODULE_NAME    ("dswstate")
55
56/* Local prototypes */
57
58static ACPI_STATUS
59AcpiDsResultStackPush (
60    ACPI_WALK_STATE         *WalkState);
61
62static ACPI_STATUS
63AcpiDsResultStackPop (
64    ACPI_WALK_STATE         *WalkState);
65
66
67/*******************************************************************************
68 *
69 * FUNCTION:    AcpiDsResultPop
70 *
71 * PARAMETERS:  Object              - Where to return the popped object
72 *              WalkState           - Current Walk state
73 *
74 * RETURN:      Status
75 *
76 * DESCRIPTION: Pop an object off the top of this walk's result stack
77 *
78 ******************************************************************************/
79
80ACPI_STATUS
81AcpiDsResultPop (
82    ACPI_OPERAND_OBJECT     **Object,
83    ACPI_WALK_STATE         *WalkState)
84{
85    UINT32                  Index;
86    ACPI_GENERIC_STATE      *State;
87    ACPI_STATUS             Status;
88
89
90    ACPI_FUNCTION_NAME (DsResultPop);
91
92
93    State = WalkState->Results;
94
95    /* Incorrect state of result stack */
96
97    if (State && !WalkState->ResultCount)
98    {
99        ACPI_ERROR ((AE_INFO, "No results on result stack"));
100        return (AE_AML_INTERNAL);
101    }
102
103    if (!State && WalkState->ResultCount)
104    {
105        ACPI_ERROR ((AE_INFO, "No result state for result stack"));
106        return (AE_AML_INTERNAL);
107    }
108
109    /* Empty result stack */
110
111    if (!State)
112    {
113        ACPI_ERROR ((AE_INFO, "Result stack is empty! State=%p", WalkState));
114        return (AE_AML_NO_RETURN_VALUE);
115    }
116
117    /* Return object of the top element and clean that top element result stack */
118
119    WalkState->ResultCount--;
120    Index = (UINT32) WalkState->ResultCount % ACPI_RESULTS_FRAME_OBJ_NUM;
121
122    *Object = State->Results.ObjDesc [Index];
123    if (!*Object)
124    {
125        ACPI_ERROR ((AE_INFO, "No result objects on result stack, State=%p",
126            WalkState));
127        return (AE_AML_NO_RETURN_VALUE);
128    }
129
130    State->Results.ObjDesc [Index] = NULL;
131    if (Index == 0)
132    {
133        Status = AcpiDsResultStackPop (WalkState);
134        if (ACPI_FAILURE (Status))
135        {
136            return (Status);
137        }
138    }
139
140    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
141        "Obj=%p [%s] Index=%X State=%p Num=%X\n", *Object,
142        AcpiUtGetObjectTypeName (*Object),
143        Index, WalkState, WalkState->ResultCount));
144
145    return (AE_OK);
146}
147
148
149/*******************************************************************************
150 *
151 * FUNCTION:    AcpiDsResultPush
152 *
153 * PARAMETERS:  Object              - Where to return the popped object
154 *              WalkState           - Current Walk state
155 *
156 * RETURN:      Status
157 *
158 * DESCRIPTION: Push an object onto the current result stack
159 *
160 ******************************************************************************/
161
162ACPI_STATUS
163AcpiDsResultPush (
164    ACPI_OPERAND_OBJECT     *Object,
165    ACPI_WALK_STATE         *WalkState)
166{
167    ACPI_GENERIC_STATE      *State;
168    ACPI_STATUS             Status;
169    UINT32                  Index;
170
171
172    ACPI_FUNCTION_NAME (DsResultPush);
173
174
175    if (WalkState->ResultCount > WalkState->ResultSize)
176    {
177        ACPI_ERROR ((AE_INFO, "Result stack is full"));
178        return (AE_AML_INTERNAL);
179    }
180    else if (WalkState->ResultCount == WalkState->ResultSize)
181    {
182        /* Extend the result stack */
183
184        Status = AcpiDsResultStackPush (WalkState);
185        if (ACPI_FAILURE (Status))
186        {
187            ACPI_ERROR ((AE_INFO, "Failed to extend the result stack"));
188            return (Status);
189        }
190    }
191
192    if (!(WalkState->ResultCount < WalkState->ResultSize))
193    {
194        ACPI_ERROR ((AE_INFO, "No free elements in result stack"));
195        return (AE_AML_INTERNAL);
196    }
197
198    State = WalkState->Results;
199    if (!State)
200    {
201        ACPI_ERROR ((AE_INFO, "No result stack frame during push"));
202        return (AE_AML_INTERNAL);
203    }
204
205    if (!Object)
206    {
207        ACPI_ERROR ((AE_INFO,
208            "Null Object! Obj=%p State=%p Num=%u",
209            Object, WalkState, WalkState->ResultCount));
210        return (AE_BAD_PARAMETER);
211    }
212
213    /* Assign the address of object to the top free element of result stack */
214
215    Index = (UINT32) WalkState->ResultCount % ACPI_RESULTS_FRAME_OBJ_NUM;
216    State->Results.ObjDesc [Index] = Object;
217    WalkState->ResultCount++;
218
219    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p [%s] State=%p Num=%X Cur=%X\n",
220        Object, AcpiUtGetObjectTypeName ((ACPI_OPERAND_OBJECT *) Object),
221        WalkState, WalkState->ResultCount, WalkState->CurrentResult));
222
223    return (AE_OK);
224}
225
226
227/*******************************************************************************
228 *
229 * FUNCTION:    AcpiDsResultStackPush
230 *
231 * PARAMETERS:  WalkState           - Current Walk state
232 *
233 * RETURN:      Status
234 *
235 * DESCRIPTION: Push an object onto the WalkState result stack
236 *
237 ******************************************************************************/
238
239static ACPI_STATUS
240AcpiDsResultStackPush (
241    ACPI_WALK_STATE         *WalkState)
242{
243    ACPI_GENERIC_STATE      *State;
244
245
246    ACPI_FUNCTION_NAME (DsResultStackPush);
247
248
249    /* Check for stack overflow */
250
251    if (((UINT32) WalkState->ResultSize + ACPI_RESULTS_FRAME_OBJ_NUM) >
252        ACPI_RESULTS_OBJ_NUM_MAX)
253    {
254        ACPI_ERROR ((AE_INFO, "Result stack overflow: State=%p Num=%u",
255            WalkState, WalkState->ResultSize));
256        return (AE_STACK_OVERFLOW);
257    }
258
259    State = AcpiUtCreateGenericState ();
260    if (!State)
261    {
262        return (AE_NO_MEMORY);
263    }
264
265    State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_RESULT;
266    AcpiUtPushGenericState (&WalkState->Results, State);
267
268    /* Increase the length of the result stack by the length of frame */
269
270    WalkState->ResultSize += ACPI_RESULTS_FRAME_OBJ_NUM;
271
272    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Results=%p State=%p\n",
273        State, WalkState));
274
275    return (AE_OK);
276}
277
278
279/*******************************************************************************
280 *
281 * FUNCTION:    AcpiDsResultStackPop
282 *
283 * PARAMETERS:  WalkState           - Current Walk state
284 *
285 * RETURN:      Status
286 *
287 * DESCRIPTION: Pop an object off of the WalkState result stack
288 *
289 ******************************************************************************/
290
291static ACPI_STATUS
292AcpiDsResultStackPop (
293    ACPI_WALK_STATE         *WalkState)
294{
295    ACPI_GENERIC_STATE      *State;
296
297
298    ACPI_FUNCTION_NAME (DsResultStackPop);
299
300
301    /* Check for stack underflow */
302
303    if (WalkState->Results == NULL)
304    {
305        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Result stack underflow - State=%p\n",
306            WalkState));
307        return (AE_AML_NO_OPERAND);
308    }
309
310    if (WalkState->ResultSize < ACPI_RESULTS_FRAME_OBJ_NUM)
311    {
312        ACPI_ERROR ((AE_INFO, "Insufficient result stack size"));
313        return (AE_AML_INTERNAL);
314    }
315
316    State = AcpiUtPopGenericState (&WalkState->Results);
317    AcpiUtDeleteGenericState (State);
318
319    /* Decrease the length of result stack by the length of frame */
320
321    WalkState->ResultSize -= ACPI_RESULTS_FRAME_OBJ_NUM;
322
323    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
324        "Result=%p RemainingResults=%X State=%p\n",
325        State, WalkState->ResultCount, WalkState));
326
327    return (AE_OK);
328}
329
330
331/*******************************************************************************
332 *
333 * FUNCTION:    AcpiDsObjStackPush
334 *
335 * PARAMETERS:  Object              - Object to push
336 *              WalkState           - Current Walk state
337 *
338 * RETURN:      Status
339 *
340 * DESCRIPTION: Push an object onto this walk's object/operand stack
341 *
342 ******************************************************************************/
343
344ACPI_STATUS
345AcpiDsObjStackPush (
346    void                    *Object,
347    ACPI_WALK_STATE         *WalkState)
348{
349    ACPI_FUNCTION_NAME (DsObjStackPush);
350
351
352    /* Check for stack overflow */
353
354    if (WalkState->NumOperands >= ACPI_OBJ_NUM_OPERANDS)
355    {
356        ACPI_ERROR ((AE_INFO,
357            "Object stack overflow! Obj=%p State=%p #Ops=%u",
358            Object, WalkState, WalkState->NumOperands));
359        return (AE_STACK_OVERFLOW);
360    }
361
362    /* Put the object onto the stack */
363
364    WalkState->Operands [WalkState->OperandIndex] = Object;
365    WalkState->NumOperands++;
366
367    /* For the usual order of filling the operand stack */
368
369    WalkState->OperandIndex++;
370
371    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p [%s] State=%p #Ops=%X\n",
372        Object, AcpiUtGetObjectTypeName ((ACPI_OPERAND_OBJECT *) Object),
373        WalkState, WalkState->NumOperands));
374
375    return (AE_OK);
376}
377
378
379/*******************************************************************************
380 *
381 * FUNCTION:    AcpiDsObjStackPop
382 *
383 * PARAMETERS:  PopCount            - Number of objects/entries to pop
384 *              WalkState           - Current Walk state
385 *
386 * RETURN:      Status
387 *
388 * DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT
389 *              deleted by this routine.
390 *
391 ******************************************************************************/
392
393ACPI_STATUS
394AcpiDsObjStackPop (
395    UINT32                  PopCount,
396    ACPI_WALK_STATE         *WalkState)
397{
398    UINT32                  i;
399
400
401    ACPI_FUNCTION_NAME (DsObjStackPop);
402
403
404    for (i = 0; i < PopCount; i++)
405    {
406        /* Check for stack underflow */
407
408        if (WalkState->NumOperands == 0)
409        {
410            ACPI_ERROR ((AE_INFO,
411                "Object stack underflow! Count=%X State=%p #Ops=%u",
412                PopCount, WalkState, WalkState->NumOperands));
413            return (AE_STACK_UNDERFLOW);
414        }
415
416        /* Just set the stack entry to null */
417
418        WalkState->NumOperands--;
419        WalkState->Operands [WalkState->NumOperands] = NULL;
420    }
421
422    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%u\n",
423        PopCount, WalkState, WalkState->NumOperands));
424
425    return (AE_OK);
426}
427
428
429/*******************************************************************************
430 *
431 * FUNCTION:    AcpiDsObjStackPopAndDelete
432 *
433 * PARAMETERS:  PopCount            - Number of objects/entries to pop
434 *              WalkState           - Current Walk state
435 *
436 * RETURN:      Status
437 *
438 * DESCRIPTION: Pop this walk's object stack and delete each object that is
439 *              popped off.
440 *
441 ******************************************************************************/
442
443void
444AcpiDsObjStackPopAndDelete (
445    UINT32                  PopCount,
446    ACPI_WALK_STATE         *WalkState)
447{
448    INT32                   i;
449    ACPI_OPERAND_OBJECT     *ObjDesc;
450
451
452    ACPI_FUNCTION_NAME (DsObjStackPopAndDelete);
453
454
455    if (PopCount == 0)
456    {
457        return;
458    }
459
460    for (i = (INT32) PopCount - 1; i >= 0; i--)
461    {
462        if (WalkState->NumOperands == 0)
463        {
464            return;
465        }
466
467        /* Pop the stack and delete an object if present in this stack entry */
468
469        WalkState->NumOperands--;
470        ObjDesc = WalkState->Operands [i];
471        if (ObjDesc)
472        {
473            AcpiUtRemoveReference (WalkState->Operands [i]);
474            WalkState->Operands [i] = NULL;
475        }
476    }
477
478    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%X\n",
479        PopCount, WalkState, WalkState->NumOperands));
480}
481
482
483/*******************************************************************************
484 *
485 * FUNCTION:    AcpiDsGetCurrentWalkState
486 *
487 * PARAMETERS:  Thread          - Get current active state for this Thread
488 *
489 * RETURN:      Pointer to the current walk state
490 *
491 * DESCRIPTION: Get the walk state that is at the head of the list (the "current"
492 *              walk state.)
493 *
494 ******************************************************************************/
495
496ACPI_WALK_STATE *
497AcpiDsGetCurrentWalkState (
498    ACPI_THREAD_STATE       *Thread)
499{
500    ACPI_FUNCTION_NAME (DsGetCurrentWalkState);
501
502
503    if (!Thread)
504    {
505        return (NULL);
506    }
507
508    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Current WalkState %p\n",
509        Thread->WalkStateList));
510
511    return (Thread->WalkStateList);
512}
513
514
515/*******************************************************************************
516 *
517 * FUNCTION:    AcpiDsPushWalkState
518 *
519 * PARAMETERS:  WalkState       - State to push
520 *              Thread          - Thread state object
521 *
522 * RETURN:      None
523 *
524 * DESCRIPTION: Place the Thread state at the head of the state list
525 *
526 ******************************************************************************/
527
528void
529AcpiDsPushWalkState (
530    ACPI_WALK_STATE         *WalkState,
531    ACPI_THREAD_STATE       *Thread)
532{
533    ACPI_FUNCTION_TRACE (DsPushWalkState);
534
535
536    WalkState->Next = Thread->WalkStateList;
537    Thread->WalkStateList = WalkState;
538
539    return_VOID;
540}
541
542
543/*******************************************************************************
544 *
545 * FUNCTION:    AcpiDsPopWalkState
546 *
547 * PARAMETERS:  Thread      - Current thread state
548 *
549 * RETURN:      A WalkState object popped from the thread's stack
550 *
551 * DESCRIPTION: Remove and return the walkstate object that is at the head of
552 *              the walk stack for the given walk list. NULL indicates that
553 *              the list is empty.
554 *
555 ******************************************************************************/
556
557ACPI_WALK_STATE *
558AcpiDsPopWalkState (
559    ACPI_THREAD_STATE       *Thread)
560{
561    ACPI_WALK_STATE         *WalkState;
562
563
564    ACPI_FUNCTION_TRACE (DsPopWalkState);
565
566
567    WalkState = Thread->WalkStateList;
568
569    if (WalkState)
570    {
571        /* Next walk state becomes the current walk state */
572
573        Thread->WalkStateList = WalkState->Next;
574
575        /*
576         * Don't clear the NEXT field, this serves as an indicator
577         * that there is a parent WALK STATE
578         * Do Not: WalkState->Next = NULL;
579         */
580    }
581
582    return_PTR (WalkState);
583}
584
585
586/*******************************************************************************
587 *
588 * FUNCTION:    AcpiDsCreateWalkState
589 *
590 * PARAMETERS:  OwnerId         - ID for object creation
591 *              Origin          - Starting point for this walk
592 *              MethodDesc      - Method object
593 *              Thread          - Current thread state
594 *
595 * RETURN:      Pointer to the new walk state.
596 *
597 * DESCRIPTION: Allocate and initialize a new walk state. The current walk
598 *              state is set to this new state.
599 *
600 ******************************************************************************/
601
602ACPI_WALK_STATE *
603AcpiDsCreateWalkState (
604    ACPI_OWNER_ID           OwnerId,
605    ACPI_PARSE_OBJECT       *Origin,
606    ACPI_OPERAND_OBJECT     *MethodDesc,
607    ACPI_THREAD_STATE       *Thread)
608{
609    ACPI_WALK_STATE         *WalkState;
610
611
612    ACPI_FUNCTION_TRACE (DsCreateWalkState);
613
614
615    WalkState = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_WALK_STATE));
616    if (!WalkState)
617    {
618        return_PTR (NULL);
619    }
620
621    WalkState->DescriptorType = ACPI_DESC_TYPE_WALK;
622    WalkState->MethodDesc = MethodDesc;
623    WalkState->OwnerId = OwnerId;
624    WalkState->Origin = Origin;
625    WalkState->Thread = Thread;
626
627    WalkState->ParserState.StartOp = Origin;
628
629    /* Init the method args/local */
630
631#if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY))
632    AcpiDsMethodDataInit (WalkState);
633#endif
634
635    /* Put the new state at the head of the walk list */
636
637    if (Thread)
638    {
639        AcpiDsPushWalkState (WalkState, Thread);
640    }
641
642    return_PTR (WalkState);
643}
644
645
646/*******************************************************************************
647 *
648 * FUNCTION:    AcpiDsInitAmlWalk
649 *
650 * PARAMETERS:  WalkState       - New state to be initialized
651 *              Op              - Current parse op
652 *              MethodNode      - Control method NS node, if any
653 *              AmlStart        - Start of AML
654 *              AmlLength       - Length of AML
655 *              Info            - Method info block (params, etc.)
656 *              PassNumber      - 1, 2, or 3
657 *
658 * RETURN:      Status
659 *
660 * DESCRIPTION: Initialize a walk state for a pass 1 or 2 parse tree walk
661 *
662 ******************************************************************************/
663
664ACPI_STATUS
665AcpiDsInitAmlWalk (
666    ACPI_WALK_STATE         *WalkState,
667    ACPI_PARSE_OBJECT       *Op,
668    ACPI_NAMESPACE_NODE     *MethodNode,
669    UINT8                   *AmlStart,
670    UINT32                  AmlLength,
671    ACPI_EVALUATE_INFO      *Info,
672    UINT8                   PassNumber)
673{
674    ACPI_STATUS             Status;
675    ACPI_PARSE_STATE        *ParserState = &WalkState->ParserState;
676    ACPI_PARSE_OBJECT       *ExtraOp;
677
678
679    ACPI_FUNCTION_TRACE (DsInitAmlWalk);
680
681
682    WalkState->ParserState.Aml =
683    WalkState->ParserState.AmlStart = AmlStart;
684    WalkState->ParserState.AmlEnd =
685    WalkState->ParserState.PkgEnd = AmlStart + AmlLength;
686
687    /* The NextOp of the NextWalk will be the beginning of the method */
688
689    WalkState->NextOp = NULL;
690    WalkState->PassNumber = PassNumber;
691
692    if (Info)
693    {
694        WalkState->Params = Info->Parameters;
695        WalkState->CallerReturnDesc = &Info->ReturnObject;
696    }
697
698    Status = AcpiPsInitScope (&WalkState->ParserState, Op);
699    if (ACPI_FAILURE (Status))
700    {
701        return_ACPI_STATUS (Status);
702    }
703
704    if (MethodNode)
705    {
706        WalkState->ParserState.StartNode = MethodNode;
707        WalkState->WalkType = ACPI_WALK_METHOD;
708        WalkState->MethodNode = MethodNode;
709        WalkState->MethodDesc = AcpiNsGetAttachedObject (MethodNode);
710
711        /* Push start scope on scope stack and make it current  */
712
713        Status = AcpiDsScopeStackPush (MethodNode, ACPI_TYPE_METHOD, WalkState);
714        if (ACPI_FAILURE (Status))
715        {
716            return_ACPI_STATUS (Status);
717        }
718
719        /* Init the method arguments */
720
721        Status = AcpiDsMethodDataInitArgs (WalkState->Params,
722                    ACPI_METHOD_NUM_ARGS, WalkState);
723        if (ACPI_FAILURE (Status))
724        {
725            return_ACPI_STATUS (Status);
726        }
727    }
728    else
729    {
730        /*
731         * Setup the current scope.
732         * Find a Named Op that has a namespace node associated with it.
733         * search upwards from this Op. Current scope is the first
734         * Op with a namespace node.
735         */
736        ExtraOp = ParserState->StartOp;
737        while (ExtraOp && !ExtraOp->Common.Node)
738        {
739            ExtraOp = ExtraOp->Common.Parent;
740        }
741
742        if (!ExtraOp)
743        {
744            ParserState->StartNode = NULL;
745        }
746        else
747        {
748            ParserState->StartNode = ExtraOp->Common.Node;
749        }
750
751        if (ParserState->StartNode)
752        {
753            /* Push start scope on scope stack and make it current  */
754
755            Status = AcpiDsScopeStackPush (ParserState->StartNode,
756                            ParserState->StartNode->Type, WalkState);
757            if (ACPI_FAILURE (Status))
758            {
759                return_ACPI_STATUS (Status);
760            }
761        }
762    }
763
764    Status = AcpiDsInitCallbacks (WalkState, PassNumber);
765    return_ACPI_STATUS (Status);
766}
767
768
769/*******************************************************************************
770 *
771 * FUNCTION:    AcpiDsDeleteWalkState
772 *
773 * PARAMETERS:  WalkState       - State to delete
774 *
775 * RETURN:      Status
776 *
777 * DESCRIPTION: Delete a walk state including all internal data structures
778 *
779 ******************************************************************************/
780
781void
782AcpiDsDeleteWalkState (
783    ACPI_WALK_STATE         *WalkState)
784{
785    ACPI_GENERIC_STATE      *State;
786
787
788    ACPI_FUNCTION_TRACE_PTR (DsDeleteWalkState, WalkState);
789
790
791    if (!WalkState)
792    {
793        return_VOID;
794    }
795
796    if (WalkState->DescriptorType != ACPI_DESC_TYPE_WALK)
797    {
798        ACPI_ERROR ((AE_INFO, "%p is not a valid walk state",
799            WalkState));
800        return_VOID;
801    }
802
803    /* There should not be any open scopes */
804
805    if (WalkState->ParserState.Scope)
806    {
807        ACPI_ERROR ((AE_INFO, "%p walk still has a scope list",
808            WalkState));
809        AcpiPsCleanupScope (&WalkState->ParserState);
810    }
811
812    /* Always must free any linked control states */
813
814    while (WalkState->ControlState)
815    {
816        State = WalkState->ControlState;
817        WalkState->ControlState = State->Common.Next;
818
819        AcpiUtDeleteGenericState (State);
820    }
821
822    /* Always must free any linked parse states */
823
824    while (WalkState->ScopeInfo)
825    {
826        State = WalkState->ScopeInfo;
827        WalkState->ScopeInfo = State->Common.Next;
828
829        AcpiUtDeleteGenericState (State);
830    }
831
832    /* Always must free any stacked result states */
833
834    while (WalkState->Results)
835    {
836        State = WalkState->Results;
837        WalkState->Results = State->Common.Next;
838
839        AcpiUtDeleteGenericState (State);
840    }
841
842    ACPI_FREE (WalkState);
843    return_VOID;
844}
845