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