Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: dswstate - Dispatcher parse tree walk management routines | |
4 | * | |
5 | *****************************************************************************/ | |
6 | ||
7 | /* | |
6c9deb72 | 8 | * Copyright (C) 2000 - 2007, R. Byron Moore |
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 | |
44f6c012 | 52 | /* Local prototypes */ |
44f6c012 | 53 | #ifdef ACPI_OBSOLETE_FUNCTIONS |
1da177e4 | 54 | acpi_status |
4be44fcd LB |
55 | acpi_ds_result_insert(void *object, |
56 | u32 index, struct acpi_walk_state *walk_state); | |
1da177e4 | 57 | |
4be44fcd | 58 | acpi_status acpi_ds_obj_stack_delete_all(struct acpi_walk_state *walk_state); |
1da177e4 | 59 | |
44f6c012 | 60 | acpi_status |
4be44fcd LB |
61 | acpi_ds_obj_stack_pop_object(union acpi_operand_object **object, |
62 | struct acpi_walk_state *walk_state); | |
63 | ||
64 | void *acpi_ds_obj_stack_get_value(u32 index, | |
65 | struct acpi_walk_state *walk_state); | |
44f6c012 | 66 | #endif |
1da177e4 | 67 | |
44f6c012 | 68 | #ifdef ACPI_FUTURE_USAGE |
1da177e4 LT |
69 | /******************************************************************************* |
70 | * | |
71 | * FUNCTION: acpi_ds_result_remove | |
72 | * | |
73 | * PARAMETERS: Object - Where to return the popped object | |
74 | * Index - Where to extract the object | |
75 | * walk_state - Current Walk state | |
76 | * | |
77 | * RETURN: Status | |
78 | * | |
79 | * DESCRIPTION: Pop an object off the bottom of this walk's result stack. In | |
80 | * other words, this is a FIFO. | |
81 | * | |
82 | ******************************************************************************/ | |
83 | ||
84 | acpi_status | |
4be44fcd LB |
85 | acpi_ds_result_remove(union acpi_operand_object **object, |
86 | u32 index, struct acpi_walk_state *walk_state) | |
1da177e4 | 87 | { |
4be44fcd | 88 | union acpi_generic_state *state; |
1da177e4 | 89 | |
b229cf92 | 90 | ACPI_FUNCTION_NAME(ds_result_remove); |
1da177e4 LT |
91 | |
92 | state = walk_state->results; | |
93 | if (!state) { | |
b8e4d893 BM |
94 | ACPI_ERROR((AE_INFO, "No result object pushed! State=%p", |
95 | walk_state)); | |
1da177e4 LT |
96 | return (AE_NOT_EXIST); |
97 | } | |
98 | ||
99 | if (index >= ACPI_OBJ_MAX_OPERAND) { | |
b8e4d893 BM |
100 | ACPI_ERROR((AE_INFO, |
101 | "Index out of range: %X State=%p Num=%X", | |
102 | index, walk_state, state->results.num_results)); | |
1da177e4 LT |
103 | } |
104 | ||
105 | /* Check for a valid result object */ | |
106 | ||
4be44fcd | 107 | if (!state->results.obj_desc[index]) { |
b8e4d893 BM |
108 | ACPI_ERROR((AE_INFO, |
109 | "Null operand! State=%p #Ops=%X, Index=%X", | |
110 | walk_state, state->results.num_results, index)); | |
1da177e4 LT |
111 | return (AE_AML_NO_RETURN_VALUE); |
112 | } | |
113 | ||
114 | /* Remove the object */ | |
115 | ||
116 | state->results.num_results--; | |
117 | ||
4be44fcd LB |
118 | *object = state->results.obj_desc[index]; |
119 | state->results.obj_desc[index] = NULL; | |
1da177e4 | 120 | |
4be44fcd LB |
121 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
122 | "Obj=%p [%s] Index=%X State=%p Num=%X\n", | |
123 | *object, | |
124 | (*object) ? acpi_ut_get_object_type_name(*object) : | |
125 | "NULL", index, walk_state, | |
126 | state->results.num_results)); | |
1da177e4 LT |
127 | |
128 | return (AE_OK); | |
129 | } | |
4be44fcd | 130 | #endif /* ACPI_FUTURE_USAGE */ |
1da177e4 | 131 | |
1da177e4 LT |
132 | /******************************************************************************* |
133 | * | |
134 | * FUNCTION: acpi_ds_result_pop | |
135 | * | |
136 | * PARAMETERS: Object - Where to return the popped object | |
137 | * walk_state - Current Walk state | |
138 | * | |
139 | * RETURN: Status | |
140 | * | |
141 | * DESCRIPTION: Pop an object off the bottom of this walk's result stack. In | |
142 | * other words, this is a FIFO. | |
143 | * | |
144 | ******************************************************************************/ | |
145 | ||
146 | acpi_status | |
4be44fcd LB |
147 | acpi_ds_result_pop(union acpi_operand_object ** object, |
148 | struct acpi_walk_state * walk_state) | |
1da177e4 | 149 | { |
4be44fcd LB |
150 | acpi_native_uint index; |
151 | union acpi_generic_state *state; | |
1da177e4 | 152 | |
b229cf92 | 153 | ACPI_FUNCTION_NAME(ds_result_pop); |
1da177e4 LT |
154 | |
155 | state = walk_state->results; | |
156 | if (!state) { | |
157 | return (AE_OK); | |
158 | } | |
159 | ||
160 | if (!state->results.num_results) { | |
b8e4d893 BM |
161 | ACPI_ERROR((AE_INFO, "Result stack is empty! State=%p", |
162 | walk_state)); | |
1da177e4 LT |
163 | return (AE_AML_NO_RETURN_VALUE); |
164 | } | |
165 | ||
166 | /* Remove top element */ | |
167 | ||
168 | state->results.num_results--; | |
169 | ||
170 | for (index = ACPI_OBJ_NUM_OPERANDS; index; index--) { | |
52fc0b02 | 171 | |
1da177e4 LT |
172 | /* Check for a valid result object */ |
173 | ||
4be44fcd LB |
174 | if (state->results.obj_desc[index - 1]) { |
175 | *object = state->results.obj_desc[index - 1]; | |
176 | state->results.obj_desc[index - 1] = NULL; | |
1da177e4 | 177 | |
4be44fcd LB |
178 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
179 | "Obj=%p [%s] Index=%X State=%p Num=%X\n", | |
180 | *object, | |
181 | (*object) ? | |
182 | acpi_ut_get_object_type_name(*object) | |
183 | : "NULL", (u32) index - 1, walk_state, | |
184 | state->results.num_results)); | |
1da177e4 LT |
185 | |
186 | return (AE_OK); | |
187 | } | |
188 | } | |
189 | ||
b8e4d893 | 190 | ACPI_ERROR((AE_INFO, "No result objects! State=%p", walk_state)); |
1da177e4 LT |
191 | return (AE_AML_NO_RETURN_VALUE); |
192 | } | |
193 | ||
1da177e4 LT |
194 | /******************************************************************************* |
195 | * | |
196 | * FUNCTION: acpi_ds_result_pop_from_bottom | |
197 | * | |
198 | * PARAMETERS: Object - Where to return the popped object | |
199 | * walk_state - Current Walk state | |
200 | * | |
201 | * RETURN: Status | |
202 | * | |
203 | * DESCRIPTION: Pop an object off the bottom of this walk's result stack. In | |
204 | * other words, this is a FIFO. | |
205 | * | |
206 | ******************************************************************************/ | |
207 | ||
208 | acpi_status | |
4be44fcd LB |
209 | acpi_ds_result_pop_from_bottom(union acpi_operand_object ** object, |
210 | struct acpi_walk_state * walk_state) | |
1da177e4 | 211 | { |
4be44fcd LB |
212 | acpi_native_uint index; |
213 | union acpi_generic_state *state; | |
1da177e4 | 214 | |
b229cf92 | 215 | ACPI_FUNCTION_NAME(ds_result_pop_from_bottom); |
1da177e4 LT |
216 | |
217 | state = walk_state->results; | |
218 | if (!state) { | |
b8e4d893 BM |
219 | ACPI_ERROR((AE_INFO, |
220 | "No result object pushed! State=%p", walk_state)); | |
1da177e4 LT |
221 | return (AE_NOT_EXIST); |
222 | } | |
223 | ||
224 | if (!state->results.num_results) { | |
b8e4d893 BM |
225 | ACPI_ERROR((AE_INFO, "No result objects! State=%p", |
226 | walk_state)); | |
1da177e4 LT |
227 | return (AE_AML_NO_RETURN_VALUE); |
228 | } | |
229 | ||
230 | /* Remove Bottom element */ | |
231 | ||
4be44fcd | 232 | *object = state->results.obj_desc[0]; |
1da177e4 LT |
233 | |
234 | /* Push entire stack down one element */ | |
235 | ||
236 | for (index = 0; index < state->results.num_results; index++) { | |
4be44fcd LB |
237 | state->results.obj_desc[index] = |
238 | state->results.obj_desc[index + 1]; | |
1da177e4 LT |
239 | } |
240 | ||
241 | state->results.num_results--; | |
242 | ||
243 | /* Check for a valid result object */ | |
244 | ||
245 | if (!*object) { | |
b8e4d893 BM |
246 | ACPI_ERROR((AE_INFO, |
247 | "Null operand! State=%p #Ops=%X Index=%X", | |
248 | walk_state, state->results.num_results, | |
249 | (u32) index)); | |
1da177e4 LT |
250 | return (AE_AML_NO_RETURN_VALUE); |
251 | } | |
252 | ||
4be44fcd LB |
253 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Obj=%p [%s] Results=%p State=%p\n", |
254 | *object, | |
255 | (*object) ? acpi_ut_get_object_type_name(*object) : | |
256 | "NULL", state, walk_state)); | |
1da177e4 LT |
257 | |
258 | return (AE_OK); | |
259 | } | |
260 | ||
1da177e4 LT |
261 | /******************************************************************************* |
262 | * | |
263 | * FUNCTION: acpi_ds_result_push | |
264 | * | |
265 | * PARAMETERS: Object - Where to return the popped object | |
266 | * walk_state - Current Walk state | |
267 | * | |
268 | * RETURN: Status | |
269 | * | |
270 | * DESCRIPTION: Push an object onto the current result stack | |
271 | * | |
272 | ******************************************************************************/ | |
273 | ||
274 | acpi_status | |
4be44fcd LB |
275 | acpi_ds_result_push(union acpi_operand_object * object, |
276 | struct acpi_walk_state * walk_state) | |
1da177e4 | 277 | { |
4be44fcd | 278 | union acpi_generic_state *state; |
1da177e4 | 279 | |
b229cf92 | 280 | ACPI_FUNCTION_NAME(ds_result_push); |
1da177e4 LT |
281 | |
282 | state = walk_state->results; | |
283 | if (!state) { | |
b8e4d893 | 284 | ACPI_ERROR((AE_INFO, "No result stack frame during push")); |
1da177e4 LT |
285 | return (AE_AML_INTERNAL); |
286 | } | |
287 | ||
288 | if (state->results.num_results == ACPI_OBJ_NUM_OPERANDS) { | |
b8e4d893 BM |
289 | ACPI_ERROR((AE_INFO, |
290 | "Result stack overflow: Obj=%p State=%p Num=%X", | |
291 | object, walk_state, state->results.num_results)); | |
1da177e4 LT |
292 | return (AE_STACK_OVERFLOW); |
293 | } | |
294 | ||
295 | if (!object) { | |
b8e4d893 BM |
296 | ACPI_ERROR((AE_INFO, |
297 | "Null Object! Obj=%p State=%p Num=%X", | |
298 | object, walk_state, state->results.num_results)); | |
1da177e4 LT |
299 | return (AE_BAD_PARAMETER); |
300 | } | |
301 | ||
4be44fcd | 302 | state->results.obj_desc[state->results.num_results] = object; |
1da177e4 LT |
303 | state->results.num_results++; |
304 | ||
4be44fcd LB |
305 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Obj=%p [%s] State=%p Num=%X Cur=%X\n", |
306 | object, | |
307 | object ? | |
308 | acpi_ut_get_object_type_name((union | |
309 | acpi_operand_object *) | |
310 | object) : "NULL", | |
311 | walk_state, state->results.num_results, | |
312 | walk_state->current_result)); | |
1da177e4 LT |
313 | |
314 | return (AE_OK); | |
315 | } | |
316 | ||
1da177e4 LT |
317 | /******************************************************************************* |
318 | * | |
319 | * FUNCTION: acpi_ds_result_stack_push | |
320 | * | |
321 | * PARAMETERS: walk_state - Current Walk state | |
322 | * | |
323 | * RETURN: Status | |
324 | * | |
325 | * DESCRIPTION: Push an object onto the walk_state result stack. | |
326 | * | |
327 | ******************************************************************************/ | |
328 | ||
4be44fcd | 329 | acpi_status acpi_ds_result_stack_push(struct acpi_walk_state * walk_state) |
1da177e4 | 330 | { |
4be44fcd | 331 | union acpi_generic_state *state; |
1da177e4 | 332 | |
b229cf92 | 333 | ACPI_FUNCTION_NAME(ds_result_stack_push); |
1da177e4 | 334 | |
4be44fcd | 335 | state = acpi_ut_create_generic_state(); |
1da177e4 LT |
336 | if (!state) { |
337 | return (AE_NO_MEMORY); | |
338 | } | |
339 | ||
61686124 | 340 | state->common.descriptor_type = ACPI_DESC_TYPE_STATE_RESULT; |
4be44fcd | 341 | acpi_ut_push_generic_state(&walk_state->results, state); |
1da177e4 | 342 | |
4be44fcd LB |
343 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Results=%p State=%p\n", |
344 | state, walk_state)); | |
1da177e4 LT |
345 | |
346 | return (AE_OK); | |
347 | } | |
348 | ||
1da177e4 LT |
349 | /******************************************************************************* |
350 | * | |
351 | * FUNCTION: acpi_ds_result_stack_pop | |
352 | * | |
353 | * PARAMETERS: walk_state - Current Walk state | |
354 | * | |
355 | * RETURN: Status | |
356 | * | |
357 | * DESCRIPTION: Pop an object off of the walk_state result stack. | |
358 | * | |
359 | ******************************************************************************/ | |
360 | ||
4be44fcd | 361 | acpi_status acpi_ds_result_stack_pop(struct acpi_walk_state * walk_state) |
1da177e4 | 362 | { |
4be44fcd | 363 | union acpi_generic_state *state; |
1da177e4 | 364 | |
b229cf92 | 365 | ACPI_FUNCTION_NAME(ds_result_stack_pop); |
1da177e4 LT |
366 | |
367 | /* Check for stack underflow */ | |
368 | ||
369 | if (walk_state->results == NULL) { | |
4be44fcd LB |
370 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Underflow - State=%p\n", |
371 | walk_state)); | |
1da177e4 LT |
372 | return (AE_AML_NO_OPERAND); |
373 | } | |
374 | ||
4be44fcd | 375 | state = acpi_ut_pop_generic_state(&walk_state->results); |
1da177e4 | 376 | |
4be44fcd | 377 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
b229cf92 | 378 | "Result=%p RemainingResults=%X State=%p\n", |
4be44fcd | 379 | state, state->results.num_results, walk_state)); |
1da177e4 | 380 | |
4be44fcd | 381 | acpi_ut_delete_generic_state(state); |
1da177e4 LT |
382 | |
383 | return (AE_OK); | |
384 | } | |
385 | ||
1da177e4 LT |
386 | /******************************************************************************* |
387 | * | |
388 | * FUNCTION: acpi_ds_obj_stack_push | |
389 | * | |
390 | * PARAMETERS: Object - Object to push | |
391 | * walk_state - Current Walk state | |
392 | * | |
393 | * RETURN: Status | |
394 | * | |
395 | * DESCRIPTION: Push an object onto this walk's object/operand stack | |
396 | * | |
397 | ******************************************************************************/ | |
398 | ||
399 | acpi_status | |
4be44fcd | 400 | acpi_ds_obj_stack_push(void *object, struct acpi_walk_state * walk_state) |
1da177e4 | 401 | { |
b229cf92 | 402 | ACPI_FUNCTION_NAME(ds_obj_stack_push); |
1da177e4 LT |
403 | |
404 | /* Check for stack overflow */ | |
405 | ||
406 | if (walk_state->num_operands >= ACPI_OBJ_NUM_OPERANDS) { | |
b8e4d893 BM |
407 | ACPI_ERROR((AE_INFO, |
408 | "Object stack overflow! Obj=%p State=%p #Ops=%X", | |
409 | object, walk_state, walk_state->num_operands)); | |
1da177e4 LT |
410 | return (AE_STACK_OVERFLOW); |
411 | } | |
412 | ||
413 | /* Put the object onto the stack */ | |
414 | ||
4be44fcd | 415 | walk_state->operands[walk_state->num_operands] = object; |
1da177e4 LT |
416 | walk_state->num_operands++; |
417 | ||
4be44fcd LB |
418 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Obj=%p [%s] State=%p #Ops=%X\n", |
419 | object, | |
420 | acpi_ut_get_object_type_name((union | |
421 | acpi_operand_object *) | |
422 | object), walk_state, | |
423 | walk_state->num_operands)); | |
1da177e4 LT |
424 | |
425 | return (AE_OK); | |
426 | } | |
427 | ||
1da177e4 LT |
428 | /******************************************************************************* |
429 | * | |
430 | * FUNCTION: acpi_ds_obj_stack_pop | |
431 | * | |
432 | * PARAMETERS: pop_count - Number of objects/entries to pop | |
433 | * walk_state - Current Walk state | |
434 | * | |
435 | * RETURN: Status | |
436 | * | |
437 | * DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT | |
438 | * deleted by this routine. | |
439 | * | |
440 | ******************************************************************************/ | |
441 | ||
442 | acpi_status | |
4be44fcd | 443 | acpi_ds_obj_stack_pop(u32 pop_count, struct acpi_walk_state * walk_state) |
1da177e4 | 444 | { |
4be44fcd | 445 | u32 i; |
1da177e4 | 446 | |
b229cf92 | 447 | ACPI_FUNCTION_NAME(ds_obj_stack_pop); |
1da177e4 LT |
448 | |
449 | for (i = 0; i < pop_count; i++) { | |
52fc0b02 | 450 | |
1da177e4 LT |
451 | /* Check for stack underflow */ |
452 | ||
453 | if (walk_state->num_operands == 0) { | |
b8e4d893 BM |
454 | ACPI_ERROR((AE_INFO, |
455 | "Object stack underflow! Count=%X State=%p #Ops=%X", | |
456 | pop_count, walk_state, | |
457 | walk_state->num_operands)); | |
1da177e4 LT |
458 | return (AE_STACK_UNDERFLOW); |
459 | } | |
460 | ||
461 | /* Just set the stack entry to null */ | |
462 | ||
463 | walk_state->num_operands--; | |
4be44fcd | 464 | walk_state->operands[walk_state->num_operands] = NULL; |
1da177e4 LT |
465 | } |
466 | ||
4be44fcd | 467 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%X\n", |
1da177e4 LT |
468 | pop_count, walk_state, walk_state->num_operands)); |
469 | ||
470 | return (AE_OK); | |
471 | } | |
472 | ||
1da177e4 LT |
473 | /******************************************************************************* |
474 | * | |
475 | * FUNCTION: acpi_ds_obj_stack_pop_and_delete | |
476 | * | |
477 | * PARAMETERS: pop_count - Number of objects/entries to pop | |
478 | * walk_state - Current Walk state | |
479 | * | |
480 | * RETURN: Status | |
481 | * | |
482 | * DESCRIPTION: Pop this walk's object stack and delete each object that is | |
483 | * popped off. | |
484 | * | |
485 | ******************************************************************************/ | |
486 | ||
487 | acpi_status | |
4be44fcd LB |
488 | acpi_ds_obj_stack_pop_and_delete(u32 pop_count, |
489 | struct acpi_walk_state * walk_state) | |
1da177e4 | 490 | { |
4be44fcd LB |
491 | u32 i; |
492 | union acpi_operand_object *obj_desc; | |
1da177e4 | 493 | |
b229cf92 | 494 | ACPI_FUNCTION_NAME(ds_obj_stack_pop_and_delete); |
1da177e4 LT |
495 | |
496 | for (i = 0; i < pop_count; i++) { | |
52fc0b02 | 497 | |
1da177e4 LT |
498 | /* Check for stack underflow */ |
499 | ||
500 | if (walk_state->num_operands == 0) { | |
b8e4d893 BM |
501 | ACPI_ERROR((AE_INFO, |
502 | "Object stack underflow! Count=%X State=%p #Ops=%X", | |
503 | pop_count, walk_state, | |
504 | walk_state->num_operands)); | |
1da177e4 LT |
505 | return (AE_STACK_UNDERFLOW); |
506 | } | |
507 | ||
508 | /* Pop the stack and delete an object if present in this stack entry */ | |
509 | ||
510 | walk_state->num_operands--; | |
4be44fcd | 511 | obj_desc = walk_state->operands[walk_state->num_operands]; |
1da177e4 | 512 | if (obj_desc) { |
4be44fcd LB |
513 | acpi_ut_remove_reference(walk_state-> |
514 | operands[walk_state-> | |
515 | num_operands]); | |
516 | walk_state->operands[walk_state->num_operands] = NULL; | |
1da177e4 LT |
517 | } |
518 | } | |
519 | ||
4be44fcd | 520 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Count=%X State=%p #Ops=%X\n", |
1da177e4 LT |
521 | pop_count, walk_state, walk_state->num_operands)); |
522 | ||
523 | return (AE_OK); | |
524 | } | |
525 | ||
1da177e4 LT |
526 | /******************************************************************************* |
527 | * | |
528 | * FUNCTION: acpi_ds_get_current_walk_state | |
529 | * | |
530 | * PARAMETERS: Thread - Get current active state for this Thread | |
531 | * | |
532 | * RETURN: Pointer to the current walk state | |
533 | * | |
534 | * DESCRIPTION: Get the walk state that is at the head of the list (the "current" | |
535 | * walk state.) | |
536 | * | |
537 | ******************************************************************************/ | |
538 | ||
4be44fcd LB |
539 | struct acpi_walk_state *acpi_ds_get_current_walk_state(struct acpi_thread_state |
540 | *thread) | |
1da177e4 | 541 | { |
b229cf92 | 542 | ACPI_FUNCTION_NAME(ds_get_current_walk_state); |
1da177e4 LT |
543 | |
544 | if (!thread) { | |
545 | return (NULL); | |
546 | } | |
547 | ||
b229cf92 | 548 | ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "Current WalkState %p\n", |
4be44fcd | 549 | thread->walk_state_list)); |
1da177e4 LT |
550 | |
551 | return (thread->walk_state_list); | |
552 | } | |
553 | ||
1da177e4 LT |
554 | /******************************************************************************* |
555 | * | |
556 | * FUNCTION: acpi_ds_push_walk_state | |
557 | * | |
558 | * PARAMETERS: walk_state - State to push | |
44f6c012 | 559 | * Thread - Thread state object |
1da177e4 LT |
560 | * |
561 | * RETURN: None | |
562 | * | |
44f6c012 | 563 | * DESCRIPTION: Place the Thread state at the head of the state list. |
1da177e4 LT |
564 | * |
565 | ******************************************************************************/ | |
566 | ||
567 | void | |
4be44fcd LB |
568 | acpi_ds_push_walk_state(struct acpi_walk_state *walk_state, |
569 | struct acpi_thread_state *thread) | |
1da177e4 | 570 | { |
b229cf92 | 571 | ACPI_FUNCTION_TRACE(ds_push_walk_state); |
1da177e4 | 572 | |
4be44fcd | 573 | walk_state->next = thread->walk_state_list; |
1da177e4 LT |
574 | thread->walk_state_list = walk_state; |
575 | ||
576 | return_VOID; | |
577 | } | |
578 | ||
1da177e4 LT |
579 | /******************************************************************************* |
580 | * | |
581 | * FUNCTION: acpi_ds_pop_walk_state | |
582 | * | |
44f6c012 | 583 | * PARAMETERS: Thread - Current thread state |
1da177e4 | 584 | * |
44f6c012 | 585 | * RETURN: A walk_state object popped from the thread's stack |
1da177e4 LT |
586 | * |
587 | * DESCRIPTION: Remove and return the walkstate object that is at the head of | |
588 | * the walk stack for the given walk list. NULL indicates that | |
589 | * the list is empty. | |
590 | * | |
591 | ******************************************************************************/ | |
592 | ||
4be44fcd | 593 | struct acpi_walk_state *acpi_ds_pop_walk_state(struct acpi_thread_state *thread) |
1da177e4 | 594 | { |
4be44fcd | 595 | struct acpi_walk_state *walk_state; |
1da177e4 | 596 | |
b229cf92 | 597 | ACPI_FUNCTION_TRACE(ds_pop_walk_state); |
1da177e4 LT |
598 | |
599 | walk_state = thread->walk_state_list; | |
600 | ||
601 | if (walk_state) { | |
52fc0b02 | 602 | |
1da177e4 LT |
603 | /* Next walk state becomes the current walk state */ |
604 | ||
605 | thread->walk_state_list = walk_state->next; | |
606 | ||
607 | /* | |
608 | * Don't clear the NEXT field, this serves as an indicator | |
609 | * that there is a parent WALK STATE | |
44f6c012 | 610 | * Do Not: walk_state->Next = NULL; |
1da177e4 LT |
611 | */ |
612 | } | |
613 | ||
4be44fcd | 614 | return_PTR(walk_state); |
1da177e4 LT |
615 | } |
616 | ||
1da177e4 LT |
617 | /******************************************************************************* |
618 | * | |
619 | * FUNCTION: acpi_ds_create_walk_state | |
620 | * | |
44f6c012 RM |
621 | * PARAMETERS: owner_id - ID for object creation |
622 | * Origin - Starting point for this walk | |
61686124 | 623 | * method_desc - Method object |
1da177e4 LT |
624 | * Thread - Current thread state |
625 | * | |
626 | * RETURN: Pointer to the new walk state. | |
627 | * | |
628 | * DESCRIPTION: Allocate and initialize a new walk state. The current walk | |
629 | * state is set to this new state. | |
630 | * | |
631 | ******************************************************************************/ | |
632 | ||
4be44fcd LB |
633 | struct acpi_walk_state *acpi_ds_create_walk_state(acpi_owner_id owner_id, |
634 | union acpi_parse_object | |
635 | *origin, | |
636 | union acpi_operand_object | |
61686124 | 637 | *method_desc, |
4be44fcd LB |
638 | struct acpi_thread_state |
639 | *thread) | |
1da177e4 | 640 | { |
4be44fcd LB |
641 | struct acpi_walk_state *walk_state; |
642 | acpi_status status; | |
1da177e4 | 643 | |
b229cf92 | 644 | ACPI_FUNCTION_TRACE(ds_create_walk_state); |
1da177e4 | 645 | |
8313524a | 646 | walk_state = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_walk_state)); |
1da177e4 | 647 | if (!walk_state) { |
4be44fcd | 648 | return_PTR(NULL); |
1da177e4 LT |
649 | } |
650 | ||
61686124 BM |
651 | walk_state->descriptor_type = ACPI_DESC_TYPE_WALK; |
652 | walk_state->method_desc = method_desc; | |
4be44fcd LB |
653 | walk_state->owner_id = owner_id; |
654 | walk_state->origin = origin; | |
4be44fcd | 655 | walk_state->thread = thread; |
1da177e4 LT |
656 | |
657 | walk_state->parser_state.start_op = origin; | |
658 | ||
659 | /* Init the method args/local */ | |
660 | ||
661 | #if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY)) | |
4be44fcd | 662 | acpi_ds_method_data_init(walk_state); |
1da177e4 LT |
663 | #endif |
664 | ||
665 | /* Create an initial result stack entry */ | |
666 | ||
4be44fcd LB |
667 | status = acpi_ds_result_stack_push(walk_state); |
668 | if (ACPI_FAILURE(status)) { | |
8313524a | 669 | ACPI_FREE(walk_state); |
4be44fcd | 670 | return_PTR(NULL); |
1da177e4 LT |
671 | } |
672 | ||
673 | /* Put the new state at the head of the walk list */ | |
674 | ||
675 | if (thread) { | |
4be44fcd | 676 | acpi_ds_push_walk_state(walk_state, thread); |
1da177e4 LT |
677 | } |
678 | ||
4be44fcd | 679 | return_PTR(walk_state); |
1da177e4 LT |
680 | } |
681 | ||
1da177e4 LT |
682 | /******************************************************************************* |
683 | * | |
684 | * FUNCTION: acpi_ds_init_aml_walk | |
685 | * | |
686 | * PARAMETERS: walk_state - New state to be initialized | |
687 | * Op - Current parse op | |
688 | * method_node - Control method NS node, if any | |
689 | * aml_start - Start of AML | |
690 | * aml_length - Length of AML | |
44f6c012 | 691 | * Info - Method info block (params, etc.) |
1da177e4 LT |
692 | * pass_number - 1, 2, or 3 |
693 | * | |
694 | * RETURN: Status | |
695 | * | |
696 | * DESCRIPTION: Initialize a walk state for a pass 1 or 2 parse tree walk | |
697 | * | |
698 | ******************************************************************************/ | |
699 | ||
700 | acpi_status | |
4be44fcd LB |
701 | acpi_ds_init_aml_walk(struct acpi_walk_state *walk_state, |
702 | union acpi_parse_object *op, | |
703 | struct acpi_namespace_node *method_node, | |
704 | u8 * aml_start, | |
705 | u32 aml_length, | |
4119532c | 706 | struct acpi_evaluate_info *info, u8 pass_number) |
1da177e4 | 707 | { |
4be44fcd LB |
708 | acpi_status status; |
709 | struct acpi_parse_state *parser_state = &walk_state->parser_state; | |
710 | union acpi_parse_object *extra_op; | |
1da177e4 | 711 | |
b229cf92 | 712 | ACPI_FUNCTION_TRACE(ds_init_aml_walk); |
1da177e4 | 713 | |
4be44fcd LB |
714 | walk_state->parser_state.aml = |
715 | walk_state->parser_state.aml_start = aml_start; | |
1da177e4 | 716 | walk_state->parser_state.aml_end = |
4be44fcd | 717 | walk_state->parser_state.pkg_end = aml_start + aml_length; |
1da177e4 LT |
718 | |
719 | /* The next_op of the next_walk will be the beginning of the method */ | |
720 | ||
44f6c012 | 721 | walk_state->next_op = NULL; |
0c9938cc | 722 | walk_state->pass_number = pass_number; |
1da177e4 LT |
723 | |
724 | if (info) { | |
725 | if (info->parameter_type == ACPI_PARAM_GPE) { | |
4be44fcd LB |
726 | walk_state->gpe_event_info = |
727 | ACPI_CAST_PTR(struct acpi_gpe_event_info, | |
728 | info->parameters); | |
729 | } else { | |
730 | walk_state->params = info->parameters; | |
44f6c012 | 731 | walk_state->caller_return_desc = &info->return_object; |
1da177e4 LT |
732 | } |
733 | } | |
734 | ||
4be44fcd LB |
735 | status = acpi_ps_init_scope(&walk_state->parser_state, op); |
736 | if (ACPI_FAILURE(status)) { | |
737 | return_ACPI_STATUS(status); | |
1da177e4 LT |
738 | } |
739 | ||
740 | if (method_node) { | |
741 | walk_state->parser_state.start_node = method_node; | |
4be44fcd LB |
742 | walk_state->walk_type = ACPI_WALK_METHOD; |
743 | walk_state->method_node = method_node; | |
744 | walk_state->method_desc = | |
745 | acpi_ns_get_attached_object(method_node); | |
1da177e4 LT |
746 | |
747 | /* Push start scope on scope stack and make it current */ | |
748 | ||
4be44fcd LB |
749 | status = |
750 | acpi_ds_scope_stack_push(method_node, ACPI_TYPE_METHOD, | |
751 | walk_state); | |
752 | if (ACPI_FAILURE(status)) { | |
753 | return_ACPI_STATUS(status); | |
1da177e4 LT |
754 | } |
755 | ||
756 | /* Init the method arguments */ | |
757 | ||
4be44fcd LB |
758 | status = acpi_ds_method_data_init_args(walk_state->params, |
759 | ACPI_METHOD_NUM_ARGS, | |
760 | walk_state); | |
761 | if (ACPI_FAILURE(status)) { | |
762 | return_ACPI_STATUS(status); | |
1da177e4 | 763 | } |
4be44fcd | 764 | } else { |
1da177e4 LT |
765 | /* |
766 | * Setup the current scope. | |
767 | * Find a Named Op that has a namespace node associated with it. | |
768 | * search upwards from this Op. Current scope is the first | |
769 | * Op with a namespace node. | |
770 | */ | |
771 | extra_op = parser_state->start_op; | |
772 | while (extra_op && !extra_op->common.node) { | |
773 | extra_op = extra_op->common.parent; | |
774 | } | |
775 | ||
776 | if (!extra_op) { | |
777 | parser_state->start_node = NULL; | |
4be44fcd | 778 | } else { |
1da177e4 LT |
779 | parser_state->start_node = extra_op->common.node; |
780 | } | |
781 | ||
782 | if (parser_state->start_node) { | |
52fc0b02 | 783 | |
1da177e4 LT |
784 | /* Push start scope on scope stack and make it current */ |
785 | ||
4be44fcd LB |
786 | status = |
787 | acpi_ds_scope_stack_push(parser_state->start_node, | |
788 | parser_state->start_node-> | |
789 | type, walk_state); | |
790 | if (ACPI_FAILURE(status)) { | |
791 | return_ACPI_STATUS(status); | |
1da177e4 LT |
792 | } |
793 | } | |
794 | } | |
795 | ||
4be44fcd LB |
796 | status = acpi_ds_init_callbacks(walk_state, pass_number); |
797 | return_ACPI_STATUS(status); | |
1da177e4 LT |
798 | } |
799 | ||
1da177e4 LT |
800 | /******************************************************************************* |
801 | * | |
802 | * FUNCTION: acpi_ds_delete_walk_state | |
803 | * | |
804 | * PARAMETERS: walk_state - State to delete | |
805 | * | |
806 | * RETURN: Status | |
807 | * | |
808 | * DESCRIPTION: Delete a walk state including all internal data structures | |
809 | * | |
810 | ******************************************************************************/ | |
811 | ||
4be44fcd | 812 | void acpi_ds_delete_walk_state(struct acpi_walk_state *walk_state) |
1da177e4 | 813 | { |
4be44fcd | 814 | union acpi_generic_state *state; |
1da177e4 | 815 | |
b229cf92 | 816 | ACPI_FUNCTION_TRACE_PTR(ds_delete_walk_state, walk_state); |
1da177e4 LT |
817 | |
818 | if (!walk_state) { | |
819 | return; | |
820 | } | |
821 | ||
61686124 | 822 | if (walk_state->descriptor_type != ACPI_DESC_TYPE_WALK) { |
b8e4d893 BM |
823 | ACPI_ERROR((AE_INFO, "%p is not a valid walk state", |
824 | walk_state)); | |
1da177e4 LT |
825 | return; |
826 | } | |
827 | ||
4119532c BM |
828 | /* There should not be any open scopes */ |
829 | ||
1da177e4 | 830 | if (walk_state->parser_state.scope) { |
b8e4d893 BM |
831 | ACPI_ERROR((AE_INFO, "%p walk still has a scope list", |
832 | walk_state)); | |
4119532c | 833 | acpi_ps_cleanup_scope(&walk_state->parser_state); |
1da177e4 LT |
834 | } |
835 | ||
836 | /* Always must free any linked control states */ | |
837 | ||
838 | while (walk_state->control_state) { | |
839 | state = walk_state->control_state; | |
840 | walk_state->control_state = state->common.next; | |
841 | ||
4be44fcd | 842 | acpi_ut_delete_generic_state(state); |
1da177e4 LT |
843 | } |
844 | ||
845 | /* Always must free any linked parse states */ | |
846 | ||
847 | while (walk_state->scope_info) { | |
848 | state = walk_state->scope_info; | |
849 | walk_state->scope_info = state->common.next; | |
850 | ||
4be44fcd | 851 | acpi_ut_delete_generic_state(state); |
1da177e4 LT |
852 | } |
853 | ||
854 | /* Always must free any stacked result states */ | |
855 | ||
856 | while (walk_state->results) { | |
857 | state = walk_state->results; | |
858 | walk_state->results = state->common.next; | |
859 | ||
4be44fcd | 860 | acpi_ut_delete_generic_state(state); |
1da177e4 LT |
861 | } |
862 | ||
8313524a | 863 | ACPI_FREE(walk_state); |
1da177e4 LT |
864 | return_VOID; |
865 | } | |
866 | ||
44f6c012 RM |
867 | #ifdef ACPI_OBSOLETE_FUNCTIONS |
868 | /******************************************************************************* | |
869 | * | |
870 | * FUNCTION: acpi_ds_result_insert | |
871 | * | |
872 | * PARAMETERS: Object - Object to push | |
873 | * Index - Where to insert the object | |
874 | * walk_state - Current Walk state | |
875 | * | |
876 | * RETURN: Status | |
877 | * | |
878 | * DESCRIPTION: Insert an object onto this walk's result stack | |
879 | * | |
880 | ******************************************************************************/ | |
881 | ||
882 | acpi_status | |
4be44fcd LB |
883 | acpi_ds_result_insert(void *object, |
884 | u32 index, struct acpi_walk_state *walk_state) | |
44f6c012 | 885 | { |
4be44fcd | 886 | union acpi_generic_state *state; |
44f6c012 | 887 | |
b229cf92 | 888 | ACPI_FUNCTION_NAME(ds_result_insert); |
44f6c012 RM |
889 | |
890 | state = walk_state->results; | |
891 | if (!state) { | |
b8e4d893 BM |
892 | ACPI_ERROR((AE_INFO, "No result object pushed! State=%p", |
893 | walk_state)); | |
44f6c012 RM |
894 | return (AE_NOT_EXIST); |
895 | } | |
896 | ||
897 | if (index >= ACPI_OBJ_NUM_OPERANDS) { | |
b8e4d893 BM |
898 | ACPI_ERROR((AE_INFO, |
899 | "Index out of range: %X Obj=%p State=%p Num=%X", | |
900 | index, object, walk_state, | |
901 | state->results.num_results)); | |
44f6c012 RM |
902 | return (AE_BAD_PARAMETER); |
903 | } | |
904 | ||
905 | if (!object) { | |
b8e4d893 BM |
906 | ACPI_ERROR((AE_INFO, |
907 | "Null Object! Index=%X Obj=%p State=%p Num=%X", | |
908 | index, object, walk_state, | |
909 | state->results.num_results)); | |
44f6c012 RM |
910 | return (AE_BAD_PARAMETER); |
911 | } | |
912 | ||
4be44fcd | 913 | state->results.obj_desc[index] = object; |
44f6c012 RM |
914 | state->results.num_results++; |
915 | ||
4be44fcd LB |
916 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
917 | "Obj=%p [%s] State=%p Num=%X Cur=%X\n", | |
918 | object, | |
919 | object ? | |
920 | acpi_ut_get_object_type_name((union | |
921 | acpi_operand_object *) | |
922 | object) : "NULL", | |
923 | walk_state, state->results.num_results, | |
924 | walk_state->current_result)); | |
44f6c012 RM |
925 | |
926 | return (AE_OK); | |
927 | } | |
928 | ||
44f6c012 RM |
929 | /******************************************************************************* |
930 | * | |
931 | * FUNCTION: acpi_ds_obj_stack_delete_all | |
932 | * | |
933 | * PARAMETERS: walk_state - Current Walk state | |
934 | * | |
935 | * RETURN: Status | |
936 | * | |
937 | * DESCRIPTION: Clear the object stack by deleting all objects that are on it. | |
938 | * Should be used with great care, if at all! | |
939 | * | |
940 | ******************************************************************************/ | |
941 | ||
4be44fcd | 942 | acpi_status acpi_ds_obj_stack_delete_all(struct acpi_walk_state * walk_state) |
44f6c012 | 943 | { |
4be44fcd | 944 | u32 i; |
44f6c012 | 945 | |
b229cf92 | 946 | ACPI_FUNCTION_TRACE_PTR(ds_obj_stack_delete_all, walk_state); |
44f6c012 RM |
947 | |
948 | /* The stack size is configurable, but fixed */ | |
949 | ||
950 | for (i = 0; i < ACPI_OBJ_NUM_OPERANDS; i++) { | |
951 | if (walk_state->operands[i]) { | |
4be44fcd | 952 | acpi_ut_remove_reference(walk_state->operands[i]); |
44f6c012 RM |
953 | walk_state->operands[i] = NULL; |
954 | } | |
955 | } | |
956 | ||
4be44fcd | 957 | return_ACPI_STATUS(AE_OK); |
44f6c012 RM |
958 | } |
959 | ||
44f6c012 RM |
960 | /******************************************************************************* |
961 | * | |
962 | * FUNCTION: acpi_ds_obj_stack_pop_object | |
963 | * | |
964 | * PARAMETERS: Object - Where to return the popped object | |
965 | * walk_state - Current Walk state | |
966 | * | |
967 | * RETURN: Status | |
968 | * | |
969 | * DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT | |
970 | * deleted by this routine. | |
971 | * | |
972 | ******************************************************************************/ | |
973 | ||
974 | acpi_status | |
4be44fcd LB |
975 | acpi_ds_obj_stack_pop_object(union acpi_operand_object **object, |
976 | struct acpi_walk_state *walk_state) | |
44f6c012 | 977 | { |
b229cf92 | 978 | ACPI_FUNCTION_NAME(ds_obj_stack_pop_object); |
44f6c012 RM |
979 | |
980 | /* Check for stack underflow */ | |
981 | ||
982 | if (walk_state->num_operands == 0) { | |
b8e4d893 BM |
983 | ACPI_ERROR((AE_INFO, |
984 | "Missing operand/stack empty! State=%p #Ops=%X", | |
985 | walk_state, walk_state->num_operands)); | |
44f6c012 RM |
986 | *object = NULL; |
987 | return (AE_AML_NO_OPERAND); | |
988 | } | |
989 | ||
990 | /* Pop the stack */ | |
991 | ||
992 | walk_state->num_operands--; | |
993 | ||
994 | /* Check for a valid operand */ | |
995 | ||
4be44fcd | 996 | if (!walk_state->operands[walk_state->num_operands]) { |
b8e4d893 BM |
997 | ACPI_ERROR((AE_INFO, |
998 | "Null operand! State=%p #Ops=%X", | |
999 | walk_state, walk_state->num_operands)); | |
44f6c012 RM |
1000 | *object = NULL; |
1001 | return (AE_AML_NO_OPERAND); | |
1002 | } | |
1003 | ||
1004 | /* Get operand and set stack entry to null */ | |
1005 | ||
4be44fcd LB |
1006 | *object = walk_state->operands[walk_state->num_operands]; |
1007 | walk_state->operands[walk_state->num_operands] = NULL; | |
44f6c012 | 1008 | |
4be44fcd LB |
1009 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Obj=%p [%s] State=%p #Ops=%X\n", |
1010 | *object, acpi_ut_get_object_type_name(*object), | |
44f6c012 RM |
1011 | walk_state, walk_state->num_operands)); |
1012 | ||
1013 | return (AE_OK); | |
1014 | } | |
1015 | ||
44f6c012 RM |
1016 | /******************************************************************************* |
1017 | * | |
1018 | * FUNCTION: acpi_ds_obj_stack_get_value | |
1019 | * | |
1020 | * PARAMETERS: Index - Stack index whose value is desired. Based | |
1021 | * on the top of the stack (index=0 == top) | |
1022 | * walk_state - Current Walk state | |
1023 | * | |
1024 | * RETURN: Pointer to the requested operand | |
1025 | * | |
1026 | * DESCRIPTION: Retrieve an object from this walk's operand stack. Index must | |
1027 | * be within the range of the current stack pointer. | |
1028 | * | |
1029 | ******************************************************************************/ | |
1030 | ||
4be44fcd | 1031 | void *acpi_ds_obj_stack_get_value(u32 index, struct acpi_walk_state *walk_state) |
44f6c012 RM |
1032 | { |
1033 | ||
b229cf92 | 1034 | ACPI_FUNCTION_TRACE_PTR(ds_obj_stack_get_value, walk_state); |
44f6c012 RM |
1035 | |
1036 | /* Can't do it if the stack is empty */ | |
1037 | ||
1038 | if (walk_state->num_operands == 0) { | |
4be44fcd | 1039 | return_PTR(NULL); |
44f6c012 RM |
1040 | } |
1041 | ||
1042 | /* or if the index is past the top of the stack */ | |
1043 | ||
1044 | if (index > (walk_state->num_operands - (u32) 1)) { | |
4be44fcd | 1045 | return_PTR(NULL); |
44f6c012 RM |
1046 | } |
1047 | ||
4be44fcd LB |
1048 | return_PTR(walk_state-> |
1049 | operands[(acpi_native_uint) (walk_state->num_operands - 1) - | |
1050 | index]); | |
44f6c012 RM |
1051 | } |
1052 | #endif |