diff options
Diffstat (limited to 'drivers/acpi/namespace/nsload.c')
-rw-r--r-- | drivers/acpi/namespace/nsload.c | 264 |
1 files changed, 103 insertions, 161 deletions
diff --git a/drivers/acpi/namespace/nsload.c b/drivers/acpi/namespace/nsload.c index 34e497016601..c28849de465a 100644 --- a/drivers/acpi/namespace/nsload.c +++ b/drivers/acpi/namespace/nsload.c | |||
@@ -41,32 +41,22 @@ | |||
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/acnamesp.h> | 45 | #include <acpi/acnamesp.h> |
47 | #include <acpi/acdispat.h> | 46 | #include <acpi/acdispat.h> |
48 | 47 | ||
49 | |||
50 | #define _COMPONENT ACPI_NAMESPACE | 48 | #define _COMPONENT ACPI_NAMESPACE |
51 | ACPI_MODULE_NAME ("nsload") | 49 | ACPI_MODULE_NAME("nsload") |
52 | 50 | ||
53 | /* Local prototypes */ | 51 | /* Local prototypes */ |
54 | 52 | static acpi_status acpi_ns_load_table_by_type(acpi_table_type table_type); | |
55 | static acpi_status | ||
56 | acpi_ns_load_table_by_type ( | ||
57 | acpi_table_type table_type); | ||
58 | 53 | ||
59 | #ifdef ACPI_FUTURE_IMPLEMENTATION | 54 | #ifdef ACPI_FUTURE_IMPLEMENTATION |
60 | acpi_status | 55 | acpi_status acpi_ns_unload_namespace(acpi_handle handle); |
61 | acpi_ns_unload_namespace ( | ||
62 | acpi_handle handle); | ||
63 | 56 | ||
64 | static acpi_status | 57 | static acpi_status acpi_ns_delete_subtree(acpi_handle start_handle); |
65 | acpi_ns_delete_subtree ( | ||
66 | acpi_handle start_handle); | ||
67 | #endif | 58 | #endif |
68 | 59 | ||
69 | |||
70 | #ifndef ACPI_NO_METHOD_EXECUTION | 60 | #ifndef ACPI_NO_METHOD_EXECUTION |
71 | /******************************************************************************* | 61 | /******************************************************************************* |
72 | * | 62 | * |
@@ -82,40 +72,39 @@ acpi_ns_delete_subtree ( | |||
82 | ******************************************************************************/ | 72 | ******************************************************************************/ |
83 | 73 | ||
84 | acpi_status | 74 | acpi_status |
85 | acpi_ns_load_table ( | 75 | acpi_ns_load_table(struct acpi_table_desc *table_desc, |
86 | struct acpi_table_desc *table_desc, | 76 | struct acpi_namespace_node *node) |
87 | struct acpi_namespace_node *node) | ||
88 | { | 77 | { |
89 | acpi_status status; | 78 | acpi_status status; |
90 | |||
91 | |||
92 | ACPI_FUNCTION_TRACE ("ns_load_table"); | ||
93 | 79 | ||
80 | ACPI_FUNCTION_TRACE("ns_load_table"); | ||
94 | 81 | ||
95 | /* Check if table contains valid AML (must be DSDT, PSDT, SSDT, etc.) */ | 82 | /* Check if table contains valid AML (must be DSDT, PSDT, SSDT, etc.) */ |
96 | 83 | ||
97 | if (!(acpi_gbl_table_data[table_desc->type].flags & ACPI_TABLE_EXECUTABLE)) { | 84 | if (! |
85 | (acpi_gbl_table_data[table_desc->type]. | ||
86 | flags & ACPI_TABLE_EXECUTABLE)) { | ||
98 | /* Just ignore this table */ | 87 | /* Just ignore this table */ |
99 | 88 | ||
100 | return_ACPI_STATUS (AE_OK); | 89 | return_ACPI_STATUS(AE_OK); |
101 | } | 90 | } |
102 | 91 | ||
103 | /* Check validity of the AML start and length */ | 92 | /* Check validity of the AML start and length */ |
104 | 93 | ||
105 | if (!table_desc->aml_start) { | 94 | if (!table_desc->aml_start) { |
106 | ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null AML pointer\n")); | 95 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Null AML pointer\n")); |
107 | return_ACPI_STATUS (AE_BAD_PARAMETER); | 96 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
108 | } | 97 | } |
109 | 98 | ||
110 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "AML block at %p\n", | 99 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "AML block at %p\n", |
111 | table_desc->aml_start)); | 100 | table_desc->aml_start)); |
112 | 101 | ||
113 | /* Ignore table if there is no AML contained within */ | 102 | /* Ignore table if there is no AML contained within */ |
114 | 103 | ||
115 | if (!table_desc->aml_length) { | 104 | if (!table_desc->aml_length) { |
116 | ACPI_REPORT_WARNING (("Zero-length AML block in table [%4.4s]\n", | 105 | ACPI_REPORT_WARNING(("Zero-length AML block in table [%4.4s]\n", |
117 | table_desc->pointer->signature)); | 106 | table_desc->pointer->signature)); |
118 | return_ACPI_STATUS (AE_OK); | 107 | return_ACPI_STATUS(AE_OK); |
119 | } | 108 | } |
120 | 109 | ||
121 | /* | 110 | /* |
@@ -127,19 +116,19 @@ acpi_ns_load_table ( | |||
127 | * to another control method, we can't continue parsing | 116 | * to another control method, we can't continue parsing |
128 | * because we don't know how many arguments to parse next! | 117 | * because we don't know how many arguments to parse next! |
129 | */ | 118 | */ |
130 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, | 119 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
131 | "**** Loading table into namespace ****\n")); | 120 | "**** Loading table into namespace ****\n")); |
132 | 121 | ||
133 | status = acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE); | 122 | status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); |
134 | if (ACPI_FAILURE (status)) { | 123 | if (ACPI_FAILURE(status)) { |
135 | return_ACPI_STATUS (status); | 124 | return_ACPI_STATUS(status); |
136 | } | 125 | } |
137 | 126 | ||
138 | status = acpi_ns_parse_table (table_desc, node->child); | 127 | status = acpi_ns_parse_table(table_desc, node->child); |
139 | (void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE); | 128 | (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); |
140 | 129 | ||
141 | if (ACPI_FAILURE (status)) { | 130 | if (ACPI_FAILURE(status)) { |
142 | return_ACPI_STATUS (status); | 131 | return_ACPI_STATUS(status); |
143 | } | 132 | } |
144 | 133 | ||
145 | /* | 134 | /* |
@@ -148,18 +137,17 @@ acpi_ns_load_table ( | |||
148 | * just-in-time parsing, we delete the control method | 137 | * just-in-time parsing, we delete the control method |
149 | * parse trees. | 138 | * parse trees. |
150 | */ | 139 | */ |
151 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, | 140 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
152 | "**** Begin Table Method Parsing and Object Initialization ****\n")); | 141 | "**** Begin Table Method Parsing and Object Initialization ****\n")); |
153 | 142 | ||
154 | status = acpi_ds_initialize_objects (table_desc, node); | 143 | status = acpi_ds_initialize_objects(table_desc, node); |
155 | 144 | ||
156 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, | 145 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
157 | "**** Completed Table Method Parsing and Object Initialization ****\n")); | 146 | "**** Completed Table Method Parsing and Object Initialization ****\n")); |
158 | 147 | ||
159 | return_ACPI_STATUS (status); | 148 | return_ACPI_STATUS(status); |
160 | } | 149 | } |
161 | 150 | ||
162 | |||
163 | /******************************************************************************* | 151 | /******************************************************************************* |
164 | * | 152 | * |
165 | * FUNCTION: acpi_ns_load_table_by_type | 153 | * FUNCTION: acpi_ns_load_table_by_type |
@@ -174,21 +162,17 @@ acpi_ns_load_table ( | |||
174 | * | 162 | * |
175 | ******************************************************************************/ | 163 | ******************************************************************************/ |
176 | 164 | ||
177 | static acpi_status | 165 | static acpi_status acpi_ns_load_table_by_type(acpi_table_type table_type) |
178 | acpi_ns_load_table_by_type ( | ||
179 | acpi_table_type table_type) | ||
180 | { | 166 | { |
181 | u32 i; | 167 | u32 i; |
182 | acpi_status status; | 168 | acpi_status status; |
183 | struct acpi_table_desc *table_desc; | 169 | struct acpi_table_desc *table_desc; |
184 | |||
185 | 170 | ||
186 | ACPI_FUNCTION_TRACE ("ns_load_table_by_type"); | 171 | ACPI_FUNCTION_TRACE("ns_load_table_by_type"); |
187 | 172 | ||
188 | 173 | status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES); | |
189 | status = acpi_ut_acquire_mutex (ACPI_MTX_TABLES); | 174 | if (ACPI_FAILURE(status)) { |
190 | if (ACPI_FAILURE (status)) { | 175 | return_ACPI_STATUS(status); |
191 | return_ACPI_STATUS (status); | ||
192 | } | 176 | } |
193 | 177 | ||
194 | /* | 178 | /* |
@@ -198,7 +182,7 @@ acpi_ns_load_table_by_type ( | |||
198 | switch (table_type) { | 182 | switch (table_type) { |
199 | case ACPI_TABLE_DSDT: | 183 | case ACPI_TABLE_DSDT: |
200 | 184 | ||
201 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Loading DSDT\n")); | 185 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Namespace load: DSDT\n")); |
202 | 186 | ||
203 | table_desc = acpi_gbl_table_lists[ACPI_TABLE_DSDT].next; | 187 | table_desc = acpi_gbl_table_lists[ACPI_TABLE_DSDT].next; |
204 | 188 | ||
@@ -210,57 +194,33 @@ acpi_ns_load_table_by_type ( | |||
210 | 194 | ||
211 | /* Now load the single DSDT */ | 195 | /* Now load the single DSDT */ |
212 | 196 | ||
213 | status = acpi_ns_load_table (table_desc, acpi_gbl_root_node); | 197 | status = acpi_ns_load_table(table_desc, acpi_gbl_root_node); |
214 | if (ACPI_SUCCESS (status)) { | 198 | if (ACPI_SUCCESS(status)) { |
215 | table_desc->loaded_into_namespace = TRUE; | 199 | table_desc->loaded_into_namespace = TRUE; |
216 | } | 200 | } |
217 | break; | 201 | break; |
218 | 202 | ||
219 | |||
220 | case ACPI_TABLE_SSDT: | 203 | case ACPI_TABLE_SSDT: |
204 | case ACPI_TABLE_PSDT: | ||
221 | 205 | ||
222 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Loading %d SSDTs\n", | 206 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
223 | acpi_gbl_table_lists[ACPI_TABLE_SSDT].count)); | 207 | "Namespace load: %d SSDT or PSDTs\n", |
208 | acpi_gbl_table_lists[table_type].count)); | ||
224 | 209 | ||
225 | /* | 210 | /* |
226 | * Traverse list of SSDT tables | 211 | * Traverse list of SSDT or PSDT tables |
227 | */ | 212 | */ |
228 | table_desc = acpi_gbl_table_lists[ACPI_TABLE_SSDT].next; | 213 | table_desc = acpi_gbl_table_lists[table_type].next; |
229 | for (i = 0; i < acpi_gbl_table_lists[ACPI_TABLE_SSDT].count; i++) { | 214 | for (i = 0; i < acpi_gbl_table_lists[table_type].count; i++) { |
230 | /* | 215 | /* |
231 | * Only attempt to load table if it is not | 216 | * Only attempt to load table into namespace if it is not |
232 | * already loaded! | 217 | * already loaded! |
233 | */ | 218 | */ |
234 | if (!table_desc->loaded_into_namespace) { | 219 | if (!table_desc->loaded_into_namespace) { |
235 | status = acpi_ns_load_table (table_desc, acpi_gbl_root_node); | 220 | status = |
236 | if (ACPI_FAILURE (status)) { | 221 | acpi_ns_load_table(table_desc, |
237 | break; | 222 | acpi_gbl_root_node); |
238 | } | 223 | if (ACPI_FAILURE(status)) { |
239 | |||
240 | table_desc->loaded_into_namespace = TRUE; | ||
241 | } | ||
242 | |||
243 | table_desc = table_desc->next; | ||
244 | } | ||
245 | break; | ||
246 | |||
247 | |||
248 | case ACPI_TABLE_PSDT: | ||
249 | |||
250 | ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Loading %d PSDTs\n", | ||
251 | acpi_gbl_table_lists[ACPI_TABLE_PSDT].count)); | ||
252 | |||
253 | /* | ||
254 | * Traverse list of PSDT tables | ||
255 | */ | ||
256 | table_desc = acpi_gbl_table_lists[ACPI_TABLE_PSDT].next; | ||
257 | |||
258 | for (i = 0; i < acpi_gbl_table_lists[ACPI_TABLE_PSDT].count; i++) { | ||
259 | /* Only attempt to load table if it is not already loaded! */ | ||
260 | |||
261 | if (!table_desc->loaded_into_namespace) { | ||
262 | status = acpi_ns_load_table (table_desc, acpi_gbl_root_node); | ||
263 | if (ACPI_FAILURE (status)) { | ||
264 | break; | 224 | break; |
265 | } | 225 | } |
266 | 226 | ||
@@ -271,19 +231,16 @@ acpi_ns_load_table_by_type ( | |||
271 | } | 231 | } |
272 | break; | 232 | break; |
273 | 233 | ||
274 | |||
275 | default: | 234 | default: |
276 | status = AE_SUPPORT; | 235 | status = AE_SUPPORT; |
277 | break; | 236 | break; |
278 | } | 237 | } |
279 | 238 | ||
280 | 239 | unlock_and_exit: | |
281 | unlock_and_exit: | 240 | (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); |
282 | (void) acpi_ut_release_mutex (ACPI_MTX_TABLES); | 241 | return_ACPI_STATUS(status); |
283 | return_ACPI_STATUS (status); | ||
284 | } | 242 | } |
285 | 243 | ||
286 | |||
287 | /******************************************************************************* | 244 | /******************************************************************************* |
288 | * | 245 | * |
289 | * FUNCTION: acpi_load_namespace | 246 | * FUNCTION: acpi_load_namespace |
@@ -297,45 +254,40 @@ unlock_and_exit: | |||
297 | * | 254 | * |
298 | ******************************************************************************/ | 255 | ******************************************************************************/ |
299 | 256 | ||
300 | acpi_status | 257 | acpi_status acpi_ns_load_namespace(void) |
301 | acpi_ns_load_namespace ( | ||
302 | void) | ||
303 | { | 258 | { |
304 | acpi_status status; | 259 | acpi_status status; |
305 | |||
306 | |||
307 | ACPI_FUNCTION_TRACE ("acpi_load_name_space"); | ||
308 | 260 | ||
261 | ACPI_FUNCTION_TRACE("acpi_load_name_space"); | ||
309 | 262 | ||
310 | /* There must be at least a DSDT installed */ | 263 | /* There must be at least a DSDT installed */ |
311 | 264 | ||
312 | if (acpi_gbl_DSDT == NULL) { | 265 | if (acpi_gbl_DSDT == NULL) { |
313 | ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "DSDT is not in memory\n")); | 266 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "DSDT is not in memory\n")); |
314 | return_ACPI_STATUS (AE_NO_ACPI_TABLES); | 267 | return_ACPI_STATUS(AE_NO_ACPI_TABLES); |
315 | } | 268 | } |
316 | 269 | ||
317 | /* | 270 | /* |
318 | * Load the namespace. The DSDT is required, | 271 | * Load the namespace. The DSDT is required, |
319 | * but the SSDT and PSDT tables are optional. | 272 | * but the SSDT and PSDT tables are optional. |
320 | */ | 273 | */ |
321 | status = acpi_ns_load_table_by_type (ACPI_TABLE_DSDT); | 274 | status = acpi_ns_load_table_by_type(ACPI_TABLE_DSDT); |
322 | if (ACPI_FAILURE (status)) { | 275 | if (ACPI_FAILURE(status)) { |
323 | return_ACPI_STATUS (status); | 276 | return_ACPI_STATUS(status); |
324 | } | 277 | } |
325 | 278 | ||
326 | /* Ignore exceptions from these */ | 279 | /* Ignore exceptions from these */ |
327 | 280 | ||
328 | (void) acpi_ns_load_table_by_type (ACPI_TABLE_SSDT); | 281 | (void)acpi_ns_load_table_by_type(ACPI_TABLE_SSDT); |
329 | (void) acpi_ns_load_table_by_type (ACPI_TABLE_PSDT); | 282 | (void)acpi_ns_load_table_by_type(ACPI_TABLE_PSDT); |
330 | 283 | ||
331 | ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, | 284 | ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, |
332 | "ACPI Namespace successfully loaded at root %p\n", | 285 | "ACPI Namespace successfully loaded at root %p\n", |
333 | acpi_gbl_root_node)); | 286 | acpi_gbl_root_node)); |
334 | 287 | ||
335 | return_ACPI_STATUS (status); | 288 | return_ACPI_STATUS(status); |
336 | } | 289 | } |
337 | 290 | ||
338 | |||
339 | #ifdef ACPI_FUTURE_IMPLEMENTATION | 291 | #ifdef ACPI_FUTURE_IMPLEMENTATION |
340 | /******************************************************************************* | 292 | /******************************************************************************* |
341 | * | 293 | * |
@@ -353,24 +305,20 @@ acpi_ns_load_namespace ( | |||
353 | * | 305 | * |
354 | ******************************************************************************/ | 306 | ******************************************************************************/ |
355 | 307 | ||
356 | static acpi_status | 308 | static acpi_status acpi_ns_delete_subtree(acpi_handle start_handle) |
357 | acpi_ns_delete_subtree ( | ||
358 | acpi_handle start_handle) | ||
359 | { | 309 | { |
360 | acpi_status status; | 310 | acpi_status status; |
361 | acpi_handle child_handle; | 311 | acpi_handle child_handle; |
362 | acpi_handle parent_handle; | 312 | acpi_handle parent_handle; |
363 | acpi_handle next_child_handle; | 313 | acpi_handle next_child_handle; |
364 | acpi_handle dummy; | 314 | acpi_handle dummy; |
365 | u32 level; | 315 | u32 level; |
366 | |||
367 | |||
368 | ACPI_FUNCTION_TRACE ("ns_delete_subtree"); | ||
369 | 316 | ||
317 | ACPI_FUNCTION_TRACE("ns_delete_subtree"); | ||
370 | 318 | ||
371 | parent_handle = start_handle; | 319 | parent_handle = start_handle; |
372 | child_handle = NULL; | 320 | child_handle = NULL; |
373 | level = 1; | 321 | level = 1; |
374 | 322 | ||
375 | /* | 323 | /* |
376 | * Traverse the tree of objects until we bubble back up | 324 | * Traverse the tree of objects until we bubble back up |
@@ -379,18 +327,19 @@ acpi_ns_delete_subtree ( | |||
379 | while (level > 0) { | 327 | while (level > 0) { |
380 | /* Attempt to get the next object in this scope */ | 328 | /* Attempt to get the next object in this scope */ |
381 | 329 | ||
382 | status = acpi_get_next_object (ACPI_TYPE_ANY, parent_handle, | 330 | status = acpi_get_next_object(ACPI_TYPE_ANY, parent_handle, |
383 | child_handle, &next_child_handle); | 331 | child_handle, &next_child_handle); |
384 | 332 | ||
385 | child_handle = next_child_handle; | 333 | child_handle = next_child_handle; |
386 | 334 | ||
387 | /* Did we get a new object? */ | 335 | /* Did we get a new object? */ |
388 | 336 | ||
389 | if (ACPI_SUCCESS (status)) { | 337 | if (ACPI_SUCCESS(status)) { |
390 | /* Check if this object has any children */ | 338 | /* Check if this object has any children */ |
391 | 339 | ||
392 | if (ACPI_SUCCESS (acpi_get_next_object (ACPI_TYPE_ANY, child_handle, | 340 | if (ACPI_SUCCESS |
393 | NULL, &dummy))) { | 341 | (acpi_get_next_object |
342 | (ACPI_TYPE_ANY, child_handle, NULL, &dummy))) { | ||
394 | /* | 343 | /* |
395 | * There is at least one child of this object, | 344 | * There is at least one child of this object, |
396 | * visit the object | 345 | * visit the object |
@@ -399,8 +348,7 @@ acpi_ns_delete_subtree ( | |||
399 | parent_handle = child_handle; | 348 | parent_handle = child_handle; |
400 | child_handle = NULL; | 349 | child_handle = NULL; |
401 | } | 350 | } |
402 | } | 351 | } else { |
403 | else { | ||
404 | /* | 352 | /* |
405 | * No more children in this object, go back up to | 353 | * No more children in this object, go back up to |
406 | * the object's parent | 354 | * the object's parent |
@@ -409,24 +357,23 @@ acpi_ns_delete_subtree ( | |||
409 | 357 | ||
410 | /* Delete all children now */ | 358 | /* Delete all children now */ |
411 | 359 | ||
412 | acpi_ns_delete_children (child_handle); | 360 | acpi_ns_delete_children(child_handle); |
413 | 361 | ||
414 | child_handle = parent_handle; | 362 | child_handle = parent_handle; |
415 | status = acpi_get_parent (parent_handle, &parent_handle); | 363 | status = acpi_get_parent(parent_handle, &parent_handle); |
416 | if (ACPI_FAILURE (status)) { | 364 | if (ACPI_FAILURE(status)) { |
417 | return_ACPI_STATUS (status); | 365 | return_ACPI_STATUS(status); |
418 | } | 366 | } |
419 | } | 367 | } |
420 | } | 368 | } |
421 | 369 | ||
422 | /* Now delete the starting object, and we are done */ | 370 | /* Now delete the starting object, and we are done */ |
423 | 371 | ||
424 | acpi_ns_delete_node (child_handle); | 372 | acpi_ns_delete_node(child_handle); |
425 | 373 | ||
426 | return_ACPI_STATUS (AE_OK); | 374 | return_ACPI_STATUS(AE_OK); |
427 | } | 375 | } |
428 | 376 | ||
429 | |||
430 | /******************************************************************************* | 377 | /******************************************************************************* |
431 | * | 378 | * |
432 | * FUNCTION: acpi_ns_unload_name_space | 379 | * FUNCTION: acpi_ns_unload_name_space |
@@ -441,32 +388,27 @@ acpi_ns_delete_subtree ( | |||
441 | * | 388 | * |
442 | ******************************************************************************/ | 389 | ******************************************************************************/ |
443 | 390 | ||
444 | acpi_status | 391 | acpi_status acpi_ns_unload_namespace(acpi_handle handle) |
445 | acpi_ns_unload_namespace ( | ||
446 | acpi_handle handle) | ||
447 | { | 392 | { |
448 | acpi_status status; | 393 | acpi_status status; |
449 | |||
450 | |||
451 | ACPI_FUNCTION_TRACE ("ns_unload_name_space"); | ||
452 | 394 | ||
395 | ACPI_FUNCTION_TRACE("ns_unload_name_space"); | ||
453 | 396 | ||
454 | /* Parameter validation */ | 397 | /* Parameter validation */ |
455 | 398 | ||
456 | if (!acpi_gbl_root_node) { | 399 | if (!acpi_gbl_root_node) { |
457 | return_ACPI_STATUS (AE_NO_NAMESPACE); | 400 | return_ACPI_STATUS(AE_NO_NAMESPACE); |
458 | } | 401 | } |
459 | 402 | ||
460 | if (!handle) { | 403 | if (!handle) { |
461 | return_ACPI_STATUS (AE_BAD_PARAMETER); | 404 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
462 | } | 405 | } |
463 | 406 | ||
464 | /* This function does the real work */ | 407 | /* This function does the real work */ |
465 | 408 | ||
466 | status = acpi_ns_delete_subtree (handle); | 409 | status = acpi_ns_delete_subtree(handle); |
467 | 410 | ||
468 | return_ACPI_STATUS (status); | 411 | return_ACPI_STATUS(status); |
469 | } | 412 | } |
470 | #endif | 413 | #endif |
471 | #endif | 414 | #endif |
472 | |||