]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: dswstate - Dispatcher parse tree walk management routines | |
4 | * | |
5 | *****************************************************************************/ | |
6 | ||
7 | /* | |
75a44ce0 | 8 | * Copyright (C) 2000 - 2008, Intel Corp. |
1da177e4 LT |
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 | ||
1da177e4 LT |
44 | #include <acpi/acpi.h> |
45 | #include <acpi/acparser.h> | |
46 | #include <acpi/acdispat.h> | |
47 | #include <acpi/acnamesp.h> | |
48 | ||
49 | #define _COMPONENT ACPI_DISPATCHER | |
4be44fcd | 50 | ACPI_MODULE_NAME("dswstate") |
1da177e4 | 51 | |
773069d4 BM |
52 | /* Local prototypes */ |
53 | static acpi_status acpi_ds_result_stack_push(struct acpi_walk_state *ws); | |
54 | static acpi_status acpi_ds_result_stack_pop(struct acpi_walk_state *ws); | |
1da177e4 | 55 | |
1da177e4 LT |
56 | /******************************************************************************* |
57 | * | |
58 | * FUNCTION: acpi_ds_result_pop | |
59 | * | |
60 | * PARAMETERS: Object - Where to return the popped object | |
61 | * walk_state - Current Walk state | |
62 | * | |
63 | * RETURN: Status | |
64 | * | |
773069d4 | 65 | * DESCRIPTION: Pop an object off the top of this walk's result stack |
1da177e4 LT |
66 | * |
67 | ******************************************************************************/ | |
68 | ||
69 | acpi_status | |
773069d4 BM |
70 | acpi_ds_result_pop(union acpi_operand_object **object, |
71 | struct acpi_walk_state *walk_state) | |
1da177e4 | 72 | { |
4be44fcd LB |
73 | acpi_native_uint index; |
74 | union acpi_generic_state *state; | |
773069d4 | 75 | acpi_status status; |
1da177e4 | 76 | |
b229cf92 | 77 | ACPI_FUNCTION_NAME(ds_result_pop); |
1da177e4 LT |
78 | |
79 | state = walk_state->results; | |
1da177e4 | 80 | |
773069d4 | 81 | /* Incorrect state of result stack */ |
1da177e4 | 82 | |
773069d4 BM |
83 | if (state && !walk_state->result_count) { |
84 | ACPI_ERROR((AE_INFO, "No results on result stack")); | |
85 | return (AE_AML_INTERNAL); | |
1da177e4 LT |
86 | } |
87 | ||
773069d4 BM |
88 | if (!state && walk_state->result_count) { |
89 | ACPI_ERROR((AE_INFO, "No result state for result stack")); | |
90 | return (AE_AML_INTERNAL); | |
91 | } | |
1da177e4 | 92 | |
773069d4 | 93 | /* Empty result stack */ |
1da177e4 | 94 | |
1da177e4 | 95 | if (!state) { |
773069d4 | 96 | ACPI_ERROR((AE_INFO, "Result stack is empty! State=%p", |
b8e4d893 | 97 | walk_state)); |
1da177e4 LT |
98 | return (AE_AML_NO_RETURN_VALUE); |
99 | } | |
100 | ||
773069d4 | 101 | /* Return object of the top element and clean that top element result stack */ |
1da177e4 | 102 | |
773069d4 BM |
103 | walk_state->result_count--; |
104 | index = walk_state->result_count % ACPI_RESULTS_FRAME_OBJ_NUM; | |
1da177e4 | 105 | |
773069d4 | 106 | *object = state->results.obj_desc[index]; |
1da177e4 | 107 | if (!*object) { |
b8e4d893 | 108 | ACPI_ERROR((AE_INFO, |
773069d4 BM |
109 | "No result objects on result stack, State=%p", |
110 | walk_state)); | |
1da177e4 LT |
111 | return (AE_AML_NO_RETURN_VALUE); |
112 | } | |
113 | ||
773069d4 BM |
114 | state->results.obj_desc[index] = NULL; |
115 | if (index == 0) { | |
116 | status = acpi_ds_result_stack_pop(walk_state); | |
117 | if (ACPI_FAILURE(status)) { | |
118 | return (status); | |
119 | } | |
120 | } | |
121 | ||
122 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, | |
123 | "Obj=%p [%s] Index=%X State=%p Num=%X\n", *object, | |
124 | acpi_ut_get_object_type_name(*object), | |
125 | (u32) index, walk_state, walk_state->result_count)); | |
1da177e4 LT |
126 | |
127 | return (AE_OK); | |
128 | } | |
129 | ||
1da177e4 LT |
130 | /******************************************************************************* |
131 | * | |
132 | * FUNCTION: acpi_ds_result_push | |
133 | * | |
134 | * PARAMETERS: Object - Where to return the popped object | |
135 | * walk_state - Current Walk state | |
136 | * | |
137 | * RETURN: Status | |
138 | * | |
139 | * DESCRIPTION: Push an object onto the current result stack | |
140 | * | |
141 | ******************************************************************************/ | |
142 | ||
143 | acpi_status | |
4be44fcd LB |
144 | acpi_ds_result_push(union acpi_operand_object * object, |
145 | struct acpi_walk_state * walk_state) | |
1da177e4 | 146 | { |
4be44fcd | 147 | union acpi_generic_state *state; |
773069d4 BM |
148 | acpi_status status; |
149 | acpi_native_uint index; | |
1da177e4 | 150 | |
b229cf92 | 151 | ACPI_FUNCTION_NAME(ds_result_push); |
1da177e4 | 152 | |
773069d4 BM |
153 | if (walk_state->result_count > walk_state->result_size) { |
154 | ACPI_ERROR((AE_INFO, "Result stack is full")); | |
155 | return (AE_AML_INTERNAL); | |
156 | } else if (walk_state->result_count == walk_state->result_size) { | |
157 | ||
158 | /* Extend the result stack */ | |
159 | ||
160 | status = acpi_ds_result_stack_push(walk_state); | |
161 | if (ACPI_FAILURE(status)) { | |
162 | ACPI_ERROR((AE_INFO, | |
163 | "Failed to extend the result stack")); | |
164 | return (status); | |
165 | } | |
166 | } | |
167 | ||
168 | if (!(walk_state->result_count < walk_state->result_size)) { | |
169 | ACPI_ERROR((AE_INFO, "No free elements in result stack")); | |
170 | return (AE_AML_INTERNAL); | |
171 | } | |
172 | ||
1da177e4 LT |
173 | state = walk_state->results; |
174 | if (!state) { | |
b8e4d893 | 175 | ACPI_ERROR((AE_INFO, "No result stack frame during push")); |
1da177e4 LT |
176 | return (AE_AML_INTERNAL); |
177 | } | |
178 | ||
1da177e4 | 179 | if (!object) { |
b8e4d893 BM |
180 | ACPI_ERROR((AE_INFO, |
181 | "Null Object! Obj=%p State=%p Num=%X", | |
773069d4 | 182 | object, walk_state, walk_state->result_count)); |
1da177e4 LT |
183 | return (AE_BAD_PARAMETER); |
184 | } | |
185 | ||
773069d4 BM |
186 | /* Assign the address of object to the top free element of result stack */ |
187 | ||
188 | index = walk_state->result_count % ACPI_RESULTS_FRAME_OBJ_NUM; | |
189 | state->results.obj_desc[index] = object; | |
190 | walk_state->result_count++; | |
1da177e4 | 191 | |
4be44fcd LB |
192 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Obj=%p [%s] State=%p Num=%X Cur=%X\n", |
193 | object, | |
4be44fcd LB |
194 | acpi_ut_get_object_type_name((union |
195 | acpi_operand_object *) | |
773069d4 BM |
196 | object), walk_state, |
197 | walk_state->result_count, | |
4be44fcd | 198 | walk_state->current_result)); |
1da177e4 LT |
199 | |
200 | return (AE_OK); | |
201 | } | |
202 | ||
1da177e4 LT |
203 | /******************************************************************************* |
204 | * | |
205 | * FUNCTION: acpi_ds_result_stack_push | |
206 | * | |
207 | * PARAMETERS: walk_state - Current Walk state | |
208 | * | |
209 | * RETURN: Status | |
210 | * | |
773069d4 | 211 | * DESCRIPTION: Push an object onto the walk_state result stack |
1da177e4 LT |
212 | * |
213 | ******************************************************************************/ | |
214 | ||
773069d4 | 215 | static acpi_status acpi_ds_result_stack_push(struct acpi_walk_state *walk_state) |
1da177e4 | 216 | { |
4be44fcd | 217 | union acpi_generic_state *state; |
1da177e4 | 218 | |
b229cf92 | 219 | ACPI_FUNCTION_NAME(ds_result_stack_push); |
1da177e4 | 220 | |
773069d4 BM |
221 | /* Check for stack overflow */ |
222 | ||
b7f9f042 | 223 | if (((u32) walk_state->result_size + ACPI_RESULTS_FRAME_OBJ_NUM) > |
773069d4 BM |
224 | ACPI_RESULTS_OBJ_NUM_MAX) { |
225 | ACPI_ERROR((AE_INFO, "Result stack overflow: State=%p Num=%X", | |
226 | walk_state, walk_state->result_size)); | |
227 | return (AE_STACK_OVERFLOW); | |
228 | } | |
229 | ||
4be44fcd | 230 | state = acpi_ut_create_generic_state(); |
1da177e4 LT |
231 | if (!state) { |
232 | return (AE_NO_MEMORY); | |
233 | } | |
234 | ||
61686124 | 235 | state->common.descriptor_type = ACPI_DESC_TYPE_STATE_RESULT; |
4be44fcd | 236 | acpi_ut_push_generic_state(&walk_state->results, state); |
1da177e4 | 237 | |
773069d4 BM |
238 | /* Increase the length of the result stack by the length of frame */ |
239 | ||
240 | walk_state->result_size += ACPI_RESULTS_FRAME_OBJ_NUM; | |
241 | ||
4be44fcd LB |
242 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Results=%p State=%p\n", |
243 | state, walk_state)); | |
1da177e4 LT |
244 | |
245 | return (AE_OK); | |
246 | } | |
247 | ||
1da177e4 LT |
248 | /******************************************************************************* |
249 | * | |
250 | * FUNCTION: acpi_ds_result_stack_pop | |
251 | * | |
252 | * PARAMETERS: walk_state - Current Walk state | |
253 | * | |
254 | * RETURN: Status | |
255 | * | |
773069d4 | 256 | * DESCRIPTION: Pop an object off of the walk_state result stack |
1da177e4 LT |
257 | * |
258 | ******************************************************************************/ | |
259 | ||
773069d4 | 260 | static acpi_status acpi_ds_result_stack_pop(struct acpi_walk_state *walk_state) |
1da177e4 | 261 | { |
4be44fcd | 262 | union acpi_generic_state *state; |
1da177e4 | 263 | |
b229cf92 | 264 | ACPI_FUNCTION_NAME(ds_result_stack_pop); |
1da177e4 LT |
265 | |
266 | /* Check for stack underflow */ | |
267 | ||
268 | if (walk_state->results == NULL) { | |
773069d4 BM |
269 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
270 | "Result stack underflow - State=%p\n", | |
4be44fcd | 271 | walk_state)); |
1da177e4 LT |
272 | return (AE_AML_NO_OPERAND); |
273 | } | |
274 | ||
773069d4 BM |
275 | if (walk_state->result_size < ACPI_RESULTS_FRAME_OBJ_NUM) { |
276 | ACPI_ERROR((AE_INFO, "Insufficient result stack size")); | |
277 | return (AE_AML_INTERNAL); | |
278 | } | |
279 | ||
4be44fcd | 280 | state = acpi_ut_pop_generic_state(&walk_state->results); |
773069d4 BM |
281 | acpi_ut_delete_generic_state(state); |
282 | ||
283 | /* Decrease the length of result stack by the length of frame */ | |
284 | ||
285 | walk_state->result_size -= ACPI_RESULTS_FRAME_OBJ_NUM; | |
1da177e4 | 286 | |
4be44fcd | 287 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
b229cf92 | 288 | "Result=%p RemainingResults=%X State=%p\n", |
773069d4 | 289 | state, walk_state->result_count, walk_state)); |
1da177e4 LT |
290 | |
291 | return (AE_OK); | |
292 | } | |
293 | ||
1da177e4 LT |
294 | /******************************************************************************* |
295 | * | |
296 | * FUNCTION: acpi_ds_obj_stack_push | |
297 | * | |
298 | * PARAMETERS: Object - Object to push | |
299 | * walk_state - Current Walk state | |
300 | * | |
301 | * RETURN: Status | |
302 | * | |
303 | * DESCRIPTION: Push an object onto this walk's object/operand stack | |
304 | * | |
305 | ******************************************************************************/ | |
306 | ||
307 | acpi_status | |
4be44fcd | 308 | acpi_ds_obj_stack_push(void *object, struct acpi_walk_state * walk_state) |
1da177e4 | 309 | { |
b229cf92 | 310 | ACPI_FUNCTION_NAME(ds_obj_stack_push); |
1da177e4 LT |
311 | |
312 | /* Check for stack overflow */ | |
313 | ||
314 | if (walk_state->num_operands >= ACPI_OBJ_NUM_OPERANDS) { | |
b8e4d893 BM |
315 | ACPI_ERROR((AE_INFO, |
316 | "Object stack overflow! Obj=%p State=%p #Ops=%X", | |
317 | object, walk_state, walk_state->num_operands)); | |
1da177e4 LT |
318 | return (AE_STACK_OVERFLOW); |
319 | } | |
320 | ||
321 | /* Put the object onto the stack */ | |
322 | ||
773069d4 | 323 | walk_state->operands[walk_state->operand_index] = object; |
1da177e4 LT |
324 | walk_state->num_operands++; |
325 | ||
773069d4 BM |
326 | /* For the usual order of filling the operand stack */ |
327 | ||
328 | walk_state->operand_index++; | |
329 | ||
4be44fcd LB |
330 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Obj=%p [%s] State=%p #Ops=%X\n", |
331 | object, | |
332 | acpi_ut_get_object_type_name((union | |
333 | acpi_operand_object *) | |
334 | object), walk_state, | |
335 | walk_state->num_operands)); | |
1da177e4 LT |
336 | |
337 | return (AE_OK); | |
338 | } | |
339 | ||
1da177e4 LT |
340 | /******************************************************************************* |
341 | * | |
342 | * FUNCTION: acpi_ds_obj_stack_pop | |
343 | * | |
344 | * PARAMETERS: pop_count - Number of objects/entries to pop | |
345 | * walk_state - Current Walk state | |
346 | * | |
347 | * RETURN: Status | |
348 | * | |
349 | * DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT | |
350 | * deleted by this routine. | |
351 | * | |
352 | ******************************************************************************/ | |
353 | ||
354 | acpi_status | |
4be44fcd | 355 | acpi_ds_obj_stack_pop(u32 pop_count, struct acpi_walk_state * walk_state) |
1da177e4 | 356 | { |
4be44fcd | 357 | u32 i; |
1da177e4 | 358 | |
b229cf92 | 359 | ACPI_FUNCTION_NAME(ds_obj_stack_pop); |
1da177e4 LT |
360 | |
361 | for (i = 0; i < pop_count; i++) { | |
52fc0b02 | 362 | |
1da177e4 LT |
363 | /* Check for stack underflow */ |
364 | ||
365 | if (walk_state->num_operands == 0) { | |
b8e4d893 BM |
366 | ACPI_ERROR((AE_INFO, |
367 | "Object stack underflow! Count=%X State=%p #Ops=%X", | |
368 | pop_count, walk_state, | |
369 | walk_state->num_operands)); | |
1da177e4 LT |
370 | return (AE_STACK_UNDERFLOW); |
371 | } | |
372 | ||
373 | /* Just set the stack entry to null */ | |
374 | ||
375 | walk_state->num_operands--; | |
4be44fcd | 376 | walk_state->operands[walk_state->num_operands] = NULL; |
1da177e4 LT |
377 | } |
378 | ||
4be44fcd | 379 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%X\n", |
1da177e4 LT |
380 | pop_count, walk_state, walk_state->num_operands)); |
381 | ||
382 | return (AE_OK); | |
383 | } | |
384 | ||
1da177e4 LT |
385 | /******************************************************************************* |
386 | * | |
387 | * FUNCTION: acpi_ds_obj_stack_pop_and_delete | |
388 | * | |
389 | * PARAMETERS: pop_count - Number of objects/entries to pop | |
390 | * walk_state - Current Walk state | |
391 | * | |
392 | * RETURN: Status | |
393 | * | |
394 | * DESCRIPTION: Pop this walk's object stack and delete each object that is | |
395 | * popped off. | |
396 | * | |
397 | ******************************************************************************/ | |
398 | ||
773069d4 | 399 | void |
4be44fcd | 400 | acpi_ds_obj_stack_pop_and_delete(u32 pop_count, |
773069d4 | 401 | struct acpi_walk_state *walk_state) |
1da177e4 | 402 | { |
b7f9f042 | 403 | acpi_native_int i; |
4be44fcd | 404 | union acpi_operand_object *obj_desc; |
1da177e4 | 405 | |
b229cf92 | 406 | ACPI_FUNCTION_NAME(ds_obj_stack_pop_and_delete); |
1da177e4 | 407 | |
773069d4 BM |
408 | if (pop_count == 0) { |
409 | return; | |
410 | } | |
1da177e4 | 411 | |
b7f9f042 | 412 | for (i = (acpi_native_int) (pop_count - 1); i >= 0; i--) { |
1da177e4 | 413 | if (walk_state->num_operands == 0) { |
773069d4 | 414 | return; |
1da177e4 LT |
415 | } |
416 | ||
417 | /* Pop the stack and delete an object if present in this stack entry */ | |
418 | ||
419 | walk_state->num_operands--; | |
773069d4 | 420 | obj_desc = walk_state->operands[i]; |
1da177e4 | 421 | if (obj_desc) { |
773069d4 BM |
422 | acpi_ut_remove_reference(walk_state->operands[i]); |
423 | walk_state->operands[i] = NULL; | |
1da177e4 LT |
424 | } |
425 | } | |
426 | ||
4be44fcd | 427 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%X\n", |
1da177e4 | 428 | pop_count, walk_state, walk_state->num_operands)); |
1da177e4 LT |
429 | } |
430 | ||
1da177e4 LT |
431 | /******************************************************************************* |
432 | * | |
433 | * FUNCTION: acpi_ds_get_current_walk_state | |
434 | * | |
435 | * PARAMETERS: Thread - Get current active state for this Thread | |
436 | * | |
437 | * RETURN: Pointer to the current walk state | |
438 | * | |
439 | * DESCRIPTION: Get the walk state that is at the head of the list (the "current" | |
440 | * walk state.) | |
441 | * | |
442 | ******************************************************************************/ | |
443 | ||
4be44fcd LB |
444 | struct acpi_walk_state *acpi_ds_get_current_walk_state(struct acpi_thread_state |
445 | *thread) | |
1da177e4 | 446 | { |
b229cf92 | 447 | ACPI_FUNCTION_NAME(ds_get_current_walk_state); |
1da177e4 LT |
448 | |
449 | if (!thread) { | |
450 | return (NULL); | |
451 | } | |
452 | ||
b229cf92 | 453 | ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "Current WalkState %p\n", |
4be44fcd | 454 | thread->walk_state_list)); |
1da177e4 LT |
455 | |
456 | return (thread->walk_state_list); | |
457 | } | |
458 | ||
1da177e4 LT |
459 | /******************************************************************************* |
460 | * | |
461 | * FUNCTION: acpi_ds_push_walk_state | |
462 | * | |
463 | * PARAMETERS: walk_state - State to push | |
44f6c012 | 464 | * Thread - Thread state object |
1da177e4 LT |
465 | * |
466 | * RETURN: None | |
467 | * | |
773069d4 | 468 | * DESCRIPTION: Place the Thread state at the head of the state list |
1da177e4 LT |
469 | * |
470 | ******************************************************************************/ | |
471 | ||
472 | void | |
4be44fcd LB |
473 | acpi_ds_push_walk_state(struct acpi_walk_state *walk_state, |
474 | struct acpi_thread_state *thread) | |
1da177e4 | 475 | { |
b229cf92 | 476 | ACPI_FUNCTION_TRACE(ds_push_walk_state); |
1da177e4 | 477 | |
4be44fcd | 478 | walk_state->next = thread->walk_state_list; |
1da177e4 LT |
479 | thread->walk_state_list = walk_state; |
480 | ||
481 | return_VOID; | |
482 | } | |
483 | ||
1da177e4 LT |
484 | /******************************************************************************* |
485 | * | |
486 | * FUNCTION: acpi_ds_pop_walk_state | |
487 | * | |
44f6c012 | 488 | * PARAMETERS: Thread - Current thread state |
1da177e4 | 489 | * |
44f6c012 | 490 | * RETURN: A walk_state object popped from the thread's stack |
1da177e4 LT |
491 | * |
492 | * DESCRIPTION: Remove and return the walkstate object that is at the head of | |
493 | * the walk stack for the given walk list. NULL indicates that | |
494 | * the list is empty. | |
495 | * | |
496 | ******************************************************************************/ | |
497 | ||
4be44fcd | 498 | struct acpi_walk_state *acpi_ds_pop_walk_state(struct acpi_thread_state *thread) |
1da177e4 | 499 | { |
4be44fcd | 500 | struct acpi_walk_state *walk_state; |
1da177e4 | 501 | |
b229cf92 | 502 | ACPI_FUNCTION_TRACE(ds_pop_walk_state); |
1da177e4 LT |
503 | |
504 | walk_state = thread->walk_state_list; | |
505 | ||
506 | if (walk_state) { | |
52fc0b02 | 507 | |
1da177e4 LT |
508 | /* Next walk state becomes the current walk state */ |
509 | ||
510 | thread->walk_state_list = walk_state->next; | |
511 | ||
512 | /* | |
513 | * Don't clear the NEXT field, this serves as an indicator | |
514 | * that there is a parent WALK STATE | |
44f6c012 | 515 | * Do Not: walk_state->Next = NULL; |
1da177e4 LT |
516 | */ |
517 | } | |
518 | ||
4be44fcd | 519 | return_PTR(walk_state); |
1da177e4 LT |
520 | } |
521 | ||
1da177e4 LT |
522 | /******************************************************************************* |
523 | * | |
524 | * FUNCTION: acpi_ds_create_walk_state | |
525 | * | |
44f6c012 RM |
526 | * PARAMETERS: owner_id - ID for object creation |
527 | * Origin - Starting point for this walk | |
61686124 | 528 | * method_desc - Method object |
1da177e4 LT |
529 | * Thread - Current thread state |
530 | * | |
531 | * RETURN: Pointer to the new walk state. | |
532 | * | |
533 | * DESCRIPTION: Allocate and initialize a new walk state. The current walk | |
534 | * state is set to this new state. | |
535 | * | |
536 | ******************************************************************************/ | |
537 | ||
fd350943 LB |
538 | struct acpi_walk_state *acpi_ds_create_walk_state(acpi_owner_id owner_id, union acpi_parse_object |
539 | *origin, union acpi_operand_object | |
540 | *method_desc, struct acpi_thread_state | |
4be44fcd | 541 | *thread) |
1da177e4 | 542 | { |
4be44fcd | 543 | struct acpi_walk_state *walk_state; |
1da177e4 | 544 | |
b229cf92 | 545 | ACPI_FUNCTION_TRACE(ds_create_walk_state); |
1da177e4 | 546 | |
8313524a | 547 | walk_state = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_walk_state)); |
1da177e4 | 548 | if (!walk_state) { |
4be44fcd | 549 | return_PTR(NULL); |
1da177e4 LT |
550 | } |
551 | ||
61686124 BM |
552 | walk_state->descriptor_type = ACPI_DESC_TYPE_WALK; |
553 | walk_state->method_desc = method_desc; | |
4be44fcd LB |
554 | walk_state->owner_id = owner_id; |
555 | walk_state->origin = origin; | |
4be44fcd | 556 | walk_state->thread = thread; |
1da177e4 LT |
557 | |
558 | walk_state->parser_state.start_op = origin; | |
559 | ||
560 | /* Init the method args/local */ | |
561 | ||
562 | #if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY)) | |
4be44fcd | 563 | acpi_ds_method_data_init(walk_state); |
1da177e4 LT |
564 | #endif |
565 | ||
1da177e4 LT |
566 | /* Put the new state at the head of the walk list */ |
567 | ||
568 | if (thread) { | |
4be44fcd | 569 | acpi_ds_push_walk_state(walk_state, thread); |
1da177e4 LT |
570 | } |
571 | ||
4be44fcd | 572 | return_PTR(walk_state); |
1da177e4 LT |
573 | } |
574 | ||
1da177e4 LT |
575 | /******************************************************************************* |
576 | * | |
577 | * FUNCTION: acpi_ds_init_aml_walk | |
578 | * | |
579 | * PARAMETERS: walk_state - New state to be initialized | |
580 | * Op - Current parse op | |
581 | * method_node - Control method NS node, if any | |
582 | * aml_start - Start of AML | |
583 | * aml_length - Length of AML | |
44f6c012 | 584 | * Info - Method info block (params, etc.) |
1da177e4 LT |
585 | * pass_number - 1, 2, or 3 |
586 | * | |
587 | * RETURN: Status | |
588 | * | |
589 | * DESCRIPTION: Initialize a walk state for a pass 1 or 2 parse tree walk | |
590 | * | |
591 | ******************************************************************************/ | |
592 | ||
593 | acpi_status | |
4be44fcd LB |
594 | acpi_ds_init_aml_walk(struct acpi_walk_state *walk_state, |
595 | union acpi_parse_object *op, | |
596 | struct acpi_namespace_node *method_node, | |
597 | u8 * aml_start, | |
598 | u32 aml_length, | |
4119532c | 599 | struct acpi_evaluate_info *info, u8 pass_number) |
1da177e4 | 600 | { |
4be44fcd LB |
601 | acpi_status status; |
602 | struct acpi_parse_state *parser_state = &walk_state->parser_state; | |
603 | union acpi_parse_object *extra_op; | |
1da177e4 | 604 | |
b229cf92 | 605 | ACPI_FUNCTION_TRACE(ds_init_aml_walk); |
1da177e4 | 606 | |
4be44fcd LB |
607 | walk_state->parser_state.aml = |
608 | walk_state->parser_state.aml_start = aml_start; | |
1da177e4 | 609 | walk_state->parser_state.aml_end = |
4be44fcd | 610 | walk_state->parser_state.pkg_end = aml_start + aml_length; |
1da177e4 LT |
611 | |
612 | /* The next_op of the next_walk will be the beginning of the method */ | |
613 | ||
44f6c012 | 614 | walk_state->next_op = NULL; |
0c9938cc | 615 | walk_state->pass_number = pass_number; |
1da177e4 LT |
616 | |
617 | if (info) { | |
618 | if (info->parameter_type == ACPI_PARAM_GPE) { | |
4be44fcd LB |
619 | walk_state->gpe_event_info = |
620 | ACPI_CAST_PTR(struct acpi_gpe_event_info, | |
621 | info->parameters); | |
622 | } else { | |
623 | walk_state->params = info->parameters; | |
44f6c012 | 624 | walk_state->caller_return_desc = &info->return_object; |
1da177e4 LT |
625 | } |
626 | } | |
627 | ||
4be44fcd LB |
628 | status = acpi_ps_init_scope(&walk_state->parser_state, op); |
629 | if (ACPI_FAILURE(status)) { | |
630 | return_ACPI_STATUS(status); | |
1da177e4 LT |
631 | } |
632 | ||
633 | if (method_node) { | |
634 | walk_state->parser_state.start_node = method_node; | |
4be44fcd LB |
635 | walk_state->walk_type = ACPI_WALK_METHOD; |
636 | walk_state->method_node = method_node; | |
637 | walk_state->method_desc = | |
638 | acpi_ns_get_attached_object(method_node); | |
1da177e4 LT |
639 | |
640 | /* Push start scope on scope stack and make it current */ | |
641 | ||
4be44fcd LB |
642 | status = |
643 | acpi_ds_scope_stack_push(method_node, ACPI_TYPE_METHOD, | |
644 | walk_state); | |
645 | if (ACPI_FAILURE(status)) { | |
646 | return_ACPI_STATUS(status); | |
1da177e4 LT |
647 | } |
648 | ||
649 | /* Init the method arguments */ | |
650 | ||
4be44fcd LB |
651 | status = acpi_ds_method_data_init_args(walk_state->params, |
652 | ACPI_METHOD_NUM_ARGS, | |
653 | walk_state); | |
654 | if (ACPI_FAILURE(status)) { | |
655 | return_ACPI_STATUS(status); | |
1da177e4 | 656 | } |
4be44fcd | 657 | } else { |
1da177e4 LT |
658 | /* |
659 | * Setup the current scope. | |
660 | * Find a Named Op that has a namespace node associated with it. | |
661 | * search upwards from this Op. Current scope is the first | |
662 | * Op with a namespace node. | |
663 | */ | |
664 | extra_op = parser_state->start_op; | |
665 | while (extra_op && !extra_op->common.node) { | |
666 | extra_op = extra_op->common.parent; | |
667 | } | |
668 | ||
669 | if (!extra_op) { | |
670 | parser_state->start_node = NULL; | |
4be44fcd | 671 | } else { |
1da177e4 LT |
672 | parser_state->start_node = extra_op->common.node; |
673 | } | |
674 | ||
675 | if (parser_state->start_node) { | |
52fc0b02 | 676 | |
1da177e4 LT |
677 | /* Push start scope on scope stack and make it current */ |
678 | ||
4be44fcd LB |
679 | status = |
680 | acpi_ds_scope_stack_push(parser_state->start_node, | |
681 | parser_state->start_node-> | |
682 | type, walk_state); | |
683 | if (ACPI_FAILURE(status)) { | |
684 | return_ACPI_STATUS(status); | |
1da177e4 LT |
685 | } |
686 | } | |
687 | } | |
688 | ||
4be44fcd LB |
689 | status = acpi_ds_init_callbacks(walk_state, pass_number); |
690 | return_ACPI_STATUS(status); | |
1da177e4 LT |
691 | } |
692 | ||
1da177e4 LT |
693 | /******************************************************************************* |
694 | * | |
695 | * FUNCTION: acpi_ds_delete_walk_state | |
696 | * | |
697 | * PARAMETERS: walk_state - State to delete | |
698 | * | |
699 | * RETURN: Status | |
700 | * | |
701 | * DESCRIPTION: Delete a walk state including all internal data structures | |
702 | * | |
703 | ******************************************************************************/ | |
704 | ||
4be44fcd | 705 | void acpi_ds_delete_walk_state(struct acpi_walk_state *walk_state) |
1da177e4 | 706 | { |
4be44fcd | 707 | union acpi_generic_state *state; |
1da177e4 | 708 | |
b229cf92 | 709 | ACPI_FUNCTION_TRACE_PTR(ds_delete_walk_state, walk_state); |
1da177e4 LT |
710 | |
711 | if (!walk_state) { | |
712 | return; | |
713 | } | |
714 | ||
61686124 | 715 | if (walk_state->descriptor_type != ACPI_DESC_TYPE_WALK) { |
b8e4d893 BM |
716 | ACPI_ERROR((AE_INFO, "%p is not a valid walk state", |
717 | walk_state)); | |
1da177e4 LT |
718 | return; |
719 | } | |
720 | ||
4119532c BM |
721 | /* There should not be any open scopes */ |
722 | ||
1da177e4 | 723 | if (walk_state->parser_state.scope) { |
b8e4d893 BM |
724 | ACPI_ERROR((AE_INFO, "%p walk still has a scope list", |
725 | walk_state)); | |
4119532c | 726 | acpi_ps_cleanup_scope(&walk_state->parser_state); |
1da177e4 LT |
727 | } |
728 | ||
729 | /* Always must free any linked control states */ | |
730 | ||
731 | while (walk_state->control_state) { | |
732 | state = walk_state->control_state; | |
733 | walk_state->control_state = state->common.next; | |
734 | ||
4be44fcd | 735 | acpi_ut_delete_generic_state(state); |
1da177e4 LT |
736 | } |
737 | ||
738 | /* Always must free any linked parse states */ | |
739 | ||
740 | while (walk_state->scope_info) { | |
741 | state = walk_state->scope_info; | |
742 | walk_state->scope_info = state->common.next; | |
743 | ||
4be44fcd | 744 | acpi_ut_delete_generic_state(state); |
1da177e4 LT |
745 | } |
746 | ||
747 | /* Always must free any stacked result states */ | |
748 | ||
749 | while (walk_state->results) { | |
750 | state = walk_state->results; | |
751 | walk_state->results = state->common.next; | |
752 | ||
4be44fcd | 753 | acpi_ut_delete_generic_state(state); |
1da177e4 LT |
754 | } |
755 | ||
8313524a | 756 | ACPI_FREE(walk_state); |
1da177e4 LT |
757 | return_VOID; |
758 | } |