Merge /spare/repo/linux-2.6/
[linux-2.6] / drivers / acpi / executer / excreate.c
1 /******************************************************************************
2  *
3  * Module Name: excreate - Named object creation
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2005, R. Byron Moore
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43
44 #include <acpi/acpi.h>
45 #include <acpi/acinterp.h>
46 #include <acpi/amlcode.h>
47 #include <acpi/acnamesp.h>
48 #include <acpi/acevents.h>
49 #include <acpi/actables.h>
50
51 #define _COMPONENT          ACPI_EXECUTER
52 ACPI_MODULE_NAME("excreate")
53
54 #ifndef ACPI_NO_METHOD_EXECUTION
55 /*******************************************************************************
56  *
57  * FUNCTION:    acpi_ex_create_alias
58  *
59  * PARAMETERS:  walk_state           - Current state, contains operands
60  *
61  * RETURN:      Status
62  *
63  * DESCRIPTION: Create a new named alias
64  *
65  ******************************************************************************/
66 acpi_status acpi_ex_create_alias(struct acpi_walk_state *walk_state)
67 {
68         struct acpi_namespace_node *target_node;
69         struct acpi_namespace_node *alias_node;
70         acpi_status status = AE_OK;
71
72         ACPI_FUNCTION_TRACE("ex_create_alias");
73
74         /* Get the source/alias operands (both namespace nodes) */
75
76         alias_node = (struct acpi_namespace_node *)walk_state->operands[0];
77         target_node = (struct acpi_namespace_node *)walk_state->operands[1];
78
79         if ((target_node->type == ACPI_TYPE_LOCAL_ALIAS) ||
80             (target_node->type == ACPI_TYPE_LOCAL_METHOD_ALIAS)) {
81                 /*
82                  * Dereference an existing alias so that we don't create a chain
83                  * of aliases.  With this code, we guarantee that an alias is
84                  * always exactly one level of indirection away from the
85                  * actual aliased name.
86                  */
87                 target_node =
88                     ACPI_CAST_PTR(struct acpi_namespace_node,
89                                   target_node->object);
90         }
91
92         /*
93          * For objects that can never change (i.e., the NS node will
94          * permanently point to the same object), we can simply attach
95          * the object to the new NS node.  For other objects (such as
96          * Integers, buffers, etc.), we have to point the Alias node
97          * to the original Node.
98          */
99         switch (target_node->type) {
100         case ACPI_TYPE_INTEGER:
101         case ACPI_TYPE_STRING:
102         case ACPI_TYPE_BUFFER:
103         case ACPI_TYPE_PACKAGE:
104         case ACPI_TYPE_BUFFER_FIELD:
105
106                 /*
107                  * The new alias has the type ALIAS and points to the original
108                  * NS node, not the object itself.  This is because for these
109                  * types, the object can change dynamically via a Store.
110                  */
111                 alias_node->type = ACPI_TYPE_LOCAL_ALIAS;
112                 alias_node->object =
113                     ACPI_CAST_PTR(union acpi_operand_object, target_node);
114                 break;
115
116         case ACPI_TYPE_METHOD:
117
118                 /*
119                  * The new alias has the type ALIAS and points to the original
120                  * NS node, not the object itself.  This is because for these
121                  * types, the object can change dynamically via a Store.
122                  */
123                 alias_node->type = ACPI_TYPE_LOCAL_METHOD_ALIAS;
124                 alias_node->object =
125                     ACPI_CAST_PTR(union acpi_operand_object, target_node);
126                 break;
127
128         default:
129
130                 /* Attach the original source object to the new Alias Node */
131
132                 /*
133                  * The new alias assumes the type of the target, and it points
134                  * to the same object.  The reference count of the object has an
135                  * additional reference to prevent deletion out from under either the
136                  * target node or the alias Node
137                  */
138                 status = acpi_ns_attach_object(alias_node,
139                                                acpi_ns_get_attached_object
140                                                (target_node),
141                                                target_node->type);
142                 break;
143         }
144
145         /* Since both operands are Nodes, we don't need to delete them */
146
147         return_ACPI_STATUS(status);
148 }
149
150 /*******************************************************************************
151  *
152  * FUNCTION:    acpi_ex_create_event
153  *
154  * PARAMETERS:  walk_state          - Current state
155  *
156  * RETURN:      Status
157  *
158  * DESCRIPTION: Create a new event object
159  *
160  ******************************************************************************/
161
162 acpi_status acpi_ex_create_event(struct acpi_walk_state *walk_state)
163 {
164         acpi_status status;
165         union acpi_operand_object *obj_desc;
166
167         ACPI_FUNCTION_TRACE("ex_create_event");
168
169         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_EVENT);
170         if (!obj_desc) {
171                 status = AE_NO_MEMORY;
172                 goto cleanup;
173         }
174
175         /*
176          * Create the actual OS semaphore, with zero initial units -- meaning
177          * that the event is created in an unsignalled state
178          */
179         status = acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0,
180                                           &obj_desc->event.semaphore);
181         if (ACPI_FAILURE(status)) {
182                 goto cleanup;
183         }
184
185         /* Attach object to the Node */
186
187         status =
188             acpi_ns_attach_object((struct acpi_namespace_node *)walk_state->
189                                   operands[0], obj_desc, ACPI_TYPE_EVENT);
190
191       cleanup:
192         /*
193          * Remove local reference to the object (on error, will cause deletion
194          * of both object and semaphore if present.)
195          */
196         acpi_ut_remove_reference(obj_desc);
197         return_ACPI_STATUS(status);
198 }
199
200 /*******************************************************************************
201  *
202  * FUNCTION:    acpi_ex_create_mutex
203  *
204  * PARAMETERS:  walk_state          - Current state
205  *
206  * RETURN:      Status
207  *
208  * DESCRIPTION: Create a new mutex object
209  *
210  *              Mutex (Name[0], sync_level[1])
211  *
212  ******************************************************************************/
213
214 acpi_status acpi_ex_create_mutex(struct acpi_walk_state *walk_state)
215 {
216         acpi_status status = AE_OK;
217         union acpi_operand_object *obj_desc;
218
219         ACPI_FUNCTION_TRACE_PTR("ex_create_mutex", ACPI_WALK_OPERANDS);
220
221         /* Create the new mutex object */
222
223         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_MUTEX);
224         if (!obj_desc) {
225                 status = AE_NO_MEMORY;
226                 goto cleanup;
227         }
228
229         /*
230          * Create the actual OS semaphore.
231          * One unit max to make it a mutex, with one initial unit to allow
232          * the mutex to be acquired.
233          */
234         status = acpi_os_create_semaphore(1, 1, &obj_desc->mutex.semaphore);
235         if (ACPI_FAILURE(status)) {
236                 goto cleanup;
237         }
238
239         /* Init object and attach to NS node */
240
241         obj_desc->mutex.sync_level =
242             (u8) walk_state->operands[1]->integer.value;
243         obj_desc->mutex.node =
244             (struct acpi_namespace_node *)walk_state->operands[0];
245
246         status = acpi_ns_attach_object(obj_desc->mutex.node,
247                                        obj_desc, ACPI_TYPE_MUTEX);
248
249       cleanup:
250         /*
251          * Remove local reference to the object (on error, will cause deletion
252          * of both object and semaphore if present.)
253          */
254         acpi_ut_remove_reference(obj_desc);
255         return_ACPI_STATUS(status);
256 }
257
258 /*******************************************************************************
259  *
260  * FUNCTION:    acpi_ex_create_region
261  *
262  * PARAMETERS:  aml_start           - Pointer to the region declaration AML
263  *              aml_length          - Max length of the declaration AML
264  *              region_space        - space_iD for the region
265  *              walk_state          - Current state
266  *
267  * RETURN:      Status
268  *
269  * DESCRIPTION: Create a new operation region object
270  *
271  ******************************************************************************/
272
273 acpi_status
274 acpi_ex_create_region(u8 * aml_start,
275                       u32 aml_length,
276                       u8 region_space, struct acpi_walk_state *walk_state)
277 {
278         acpi_status status;
279         union acpi_operand_object *obj_desc;
280         struct acpi_namespace_node *node;
281         union acpi_operand_object *region_obj2;
282
283         ACPI_FUNCTION_TRACE("ex_create_region");
284
285         /* Get the Namespace Node */
286
287         node = walk_state->op->common.node;
288
289         /*
290          * If the region object is already attached to this node,
291          * just return
292          */
293         if (acpi_ns_get_attached_object(node)) {
294                 return_ACPI_STATUS(AE_OK);
295         }
296
297         /*
298          * Space ID must be one of the predefined IDs, or in the user-defined
299          * range
300          */
301         if ((region_space >= ACPI_NUM_PREDEFINED_REGIONS) &&
302             (region_space < ACPI_USER_REGION_BEGIN)) {
303                 ACPI_REPORT_ERROR(("Invalid address_space type %X\n",
304                                    region_space));
305                 return_ACPI_STATUS(AE_AML_INVALID_SPACE_ID);
306         }
307
308         ACPI_DEBUG_PRINT((ACPI_DB_LOAD, "Region Type - %s (%X)\n",
309                           acpi_ut_get_region_name(region_space), region_space));
310
311         /* Create the region descriptor */
312
313         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_REGION);
314         if (!obj_desc) {
315                 status = AE_NO_MEMORY;
316                 goto cleanup;
317         }
318
319         /*
320          * Remember location in AML stream of address & length
321          * operands since they need to be evaluated at run time.
322          */
323         region_obj2 = obj_desc->common.next_object;
324         region_obj2->extra.aml_start = aml_start;
325         region_obj2->extra.aml_length = aml_length;
326
327         /* Init the region from the operands */
328
329         obj_desc->region.space_id = region_space;
330         obj_desc->region.address = 0;
331         obj_desc->region.length = 0;
332         obj_desc->region.node = node;
333
334         /* Install the new region object in the parent Node */
335
336         status = acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_REGION);
337
338       cleanup:
339
340         /* Remove local reference to the object */
341
342         acpi_ut_remove_reference(obj_desc);
343         return_ACPI_STATUS(status);
344 }
345
346 /*******************************************************************************
347  *
348  * FUNCTION:    acpi_ex_create_table_region
349  *
350  * PARAMETERS:  walk_state          - Current state
351  *
352  * RETURN:      Status
353  *
354  * DESCRIPTION: Create a new data_table_region object
355  *
356  ******************************************************************************/
357
358 acpi_status acpi_ex_create_table_region(struct acpi_walk_state *walk_state)
359 {
360         acpi_status status;
361         union acpi_operand_object **operand = &walk_state->operands[0];
362         union acpi_operand_object *obj_desc;
363         struct acpi_namespace_node *node;
364         struct acpi_table_header *table;
365         union acpi_operand_object *region_obj2;
366
367         ACPI_FUNCTION_TRACE("ex_create_table_region");
368
369         /* Get the Node from the object stack  */
370
371         node = walk_state->op->common.node;
372
373         /*
374          * If the region object is already attached to this node,
375          * just return
376          */
377         if (acpi_ns_get_attached_object(node)) {
378                 return_ACPI_STATUS(AE_OK);
379         }
380
381         /* Find the ACPI table */
382
383         status = acpi_tb_find_table(operand[1]->string.pointer,
384                                     operand[2]->string.pointer,
385                                     operand[3]->string.pointer, &table);
386         if (ACPI_FAILURE(status)) {
387                 return_ACPI_STATUS(status);
388         }
389
390         /* Create the region descriptor */
391
392         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_REGION);
393         if (!obj_desc) {
394                 return_ACPI_STATUS(AE_NO_MEMORY);
395         }
396
397         region_obj2 = obj_desc->common.next_object;
398         region_obj2->extra.region_context = NULL;
399
400         /* Init the region from the operands */
401
402         obj_desc->region.space_id = REGION_DATA_TABLE;
403         obj_desc->region.address =
404             (acpi_physical_address) ACPI_TO_INTEGER(table);
405         obj_desc->region.length = table->length;
406         obj_desc->region.node = node;
407         obj_desc->region.flags = AOPOBJ_DATA_VALID;
408
409         /* Install the new region object in the parent Node */
410
411         status = acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_REGION);
412         if (ACPI_FAILURE(status)) {
413                 goto cleanup;
414         }
415
416         status = acpi_ev_initialize_region(obj_desc, FALSE);
417         if (ACPI_FAILURE(status)) {
418                 if (status == AE_NOT_EXIST) {
419                         status = AE_OK;
420                 } else {
421                         goto cleanup;
422                 }
423         }
424
425         obj_desc->region.flags |= AOPOBJ_SETUP_COMPLETE;
426
427       cleanup:
428
429         /* Remove local reference to the object */
430
431         acpi_ut_remove_reference(obj_desc);
432         return_ACPI_STATUS(status);
433 }
434
435 /*******************************************************************************
436  *
437  * FUNCTION:    acpi_ex_create_processor
438  *
439  * PARAMETERS:  walk_state          - Current state
440  *
441  * RETURN:      Status
442  *
443  * DESCRIPTION: Create a new processor object and populate the fields
444  *
445  *              Processor (Name[0], cpu_iD[1], pblock_addr[2], pblock_length[3])
446  *
447  ******************************************************************************/
448
449 acpi_status acpi_ex_create_processor(struct acpi_walk_state *walk_state)
450 {
451         union acpi_operand_object **operand = &walk_state->operands[0];
452         union acpi_operand_object *obj_desc;
453         acpi_status status;
454
455         ACPI_FUNCTION_TRACE_PTR("ex_create_processor", walk_state);
456
457         /* Create the processor object */
458
459         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_PROCESSOR);
460         if (!obj_desc) {
461                 return_ACPI_STATUS(AE_NO_MEMORY);
462         }
463
464         /* Initialize the processor object from the operands */
465
466         obj_desc->processor.proc_id = (u8) operand[1]->integer.value;
467         obj_desc->processor.address =
468             (acpi_io_address) operand[2]->integer.value;
469         obj_desc->processor.length = (u8) operand[3]->integer.value;
470
471         /* Install the processor object in the parent Node */
472
473         status = acpi_ns_attach_object((struct acpi_namespace_node *)operand[0],
474                                        obj_desc, ACPI_TYPE_PROCESSOR);
475
476         /* Remove local reference to the object */
477
478         acpi_ut_remove_reference(obj_desc);
479         return_ACPI_STATUS(status);
480 }
481
482 /*******************************************************************************
483  *
484  * FUNCTION:    acpi_ex_create_power_resource
485  *
486  * PARAMETERS:  walk_state          - Current state
487  *
488  * RETURN:      Status
489  *
490  * DESCRIPTION: Create a new power_resource object and populate the fields
491  *
492  *              power_resource (Name[0], system_level[1], resource_order[2])
493  *
494  ******************************************************************************/
495
496 acpi_status acpi_ex_create_power_resource(struct acpi_walk_state *walk_state)
497 {
498         union acpi_operand_object **operand = &walk_state->operands[0];
499         acpi_status status;
500         union acpi_operand_object *obj_desc;
501
502         ACPI_FUNCTION_TRACE_PTR("ex_create_power_resource", walk_state);
503
504         /* Create the power resource object */
505
506         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_POWER);
507         if (!obj_desc) {
508                 return_ACPI_STATUS(AE_NO_MEMORY);
509         }
510
511         /* Initialize the power object from the operands */
512
513         obj_desc->power_resource.system_level = (u8) operand[1]->integer.value;
514         obj_desc->power_resource.resource_order =
515             (u16) operand[2]->integer.value;
516
517         /* Install the  power resource object in the parent Node */
518
519         status = acpi_ns_attach_object((struct acpi_namespace_node *)operand[0],
520                                        obj_desc, ACPI_TYPE_POWER);
521
522         /* Remove local reference to the object */
523
524         acpi_ut_remove_reference(obj_desc);
525         return_ACPI_STATUS(status);
526 }
527 #endif
528
529 /*******************************************************************************
530  *
531  * FUNCTION:    acpi_ex_create_method
532  *
533  * PARAMETERS:  aml_start       - First byte of the method's AML
534  *              aml_length      - AML byte count for this method
535  *              walk_state      - Current state
536  *
537  * RETURN:      Status
538  *
539  * DESCRIPTION: Create a new method object
540  *
541  ******************************************************************************/
542
543 acpi_status
544 acpi_ex_create_method(u8 * aml_start,
545                       u32 aml_length, struct acpi_walk_state *walk_state)
546 {
547         union acpi_operand_object **operand = &walk_state->operands[0];
548         union acpi_operand_object *obj_desc;
549         acpi_status status;
550         u8 method_flags;
551
552         ACPI_FUNCTION_TRACE_PTR("ex_create_method", walk_state);
553
554         /* Create a new method object */
555
556         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_METHOD);
557         if (!obj_desc) {
558                 return_ACPI_STATUS(AE_NO_MEMORY);
559         }
560
561         /* Save the method's AML pointer and length  */
562
563         obj_desc->method.aml_start = aml_start;
564         obj_desc->method.aml_length = aml_length;
565
566         /*
567          * Disassemble the method flags.  Split off the Arg Count
568          * for efficiency
569          */
570         method_flags = (u8) operand[1]->integer.value;
571
572         obj_desc->method.method_flags =
573             (u8) (method_flags & ~AML_METHOD_ARG_COUNT);
574         obj_desc->method.param_count =
575             (u8) (method_flags & AML_METHOD_ARG_COUNT);
576
577         /*
578          * Get the concurrency count.  If required, a semaphore will be
579          * created for this method when it is parsed.
580          */
581         if (acpi_gbl_all_methods_serialized) {
582                 obj_desc->method.concurrency = 1;
583                 obj_desc->method.method_flags |= AML_METHOD_SERIALIZED;
584         } else if (method_flags & AML_METHOD_SERIALIZED) {
585                 /*
586                  * ACPI 1.0: Concurrency = 1
587                  * ACPI 2.0: Concurrency = (sync_level (in method declaration) + 1)
588                  */
589                 obj_desc->method.concurrency = (u8)
590                     (((method_flags & AML_METHOD_SYNCH_LEVEL) >> 4) + 1);
591         } else {
592                 obj_desc->method.concurrency = ACPI_INFINITE_CONCURRENCY;
593         }
594
595         /* Attach the new object to the method Node */
596
597         status = acpi_ns_attach_object((struct acpi_namespace_node *)operand[0],
598                                        obj_desc, ACPI_TYPE_METHOD);
599
600         /* Remove local reference to the object */
601
602         acpi_ut_remove_reference(obj_desc);
603
604         /* Remove a reference to the operand */
605
606         acpi_ut_remove_reference(operand[1]);
607         return_ACPI_STATUS(status);
608 }