ACPICA: Update all ACPICA copyrights and signons to 2010
[linux-3.10.git] / drivers / acpi / acpica / exconfig.c
1 /******************************************************************************
2  *
3  * Module Name: exconfig - Namespace reconfiguration (Load/Unload opcodes)
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2010, Intel Corp.
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 "accommon.h"
46 #include "acinterp.h"
47 #include "acnamesp.h"
48 #include "actables.h"
49 #include "acdispat.h"
50 #include "acevents.h"
51
52 #define _COMPONENT          ACPI_EXECUTER
53 ACPI_MODULE_NAME("exconfig")
54
55 /* Local prototypes */
56 static acpi_status
57 acpi_ex_add_table(u32 table_index,
58                   struct acpi_namespace_node *parent_node,
59                   union acpi_operand_object **ddb_handle);
60
61 static acpi_status
62 acpi_ex_region_read(union acpi_operand_object *obj_desc,
63                     u32 length, u8 *buffer);
64
65 /*******************************************************************************
66  *
67  * FUNCTION:    acpi_ex_add_table
68  *
69  * PARAMETERS:  Table               - Pointer to raw table
70  *              parent_node         - Where to load the table (scope)
71  *              ddb_handle          - Where to return the table handle.
72  *
73  * RETURN:      Status
74  *
75  * DESCRIPTION: Common function to Install and Load an ACPI table with a
76  *              returned table handle.
77  *
78  ******************************************************************************/
79
80 static acpi_status
81 acpi_ex_add_table(u32 table_index,
82                   struct acpi_namespace_node *parent_node,
83                   union acpi_operand_object **ddb_handle)
84 {
85         acpi_status status;
86         union acpi_operand_object *obj_desc;
87
88         ACPI_FUNCTION_TRACE(ex_add_table);
89
90         /* Create an object to be the table handle */
91
92         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_REFERENCE);
93         if (!obj_desc) {
94                 return_ACPI_STATUS(AE_NO_MEMORY);
95         }
96
97         /* Init the table handle */
98
99         obj_desc->common.flags |= AOPOBJ_DATA_VALID;
100         obj_desc->reference.class = ACPI_REFCLASS_TABLE;
101         *ddb_handle = obj_desc;
102
103         /* Install the new table into the local data structures */
104
105         obj_desc->reference.value = table_index;
106
107         /* Add the table to the namespace */
108
109         status = acpi_ns_load_table(table_index, parent_node);
110         if (ACPI_FAILURE(status)) {
111                 acpi_ut_remove_reference(obj_desc);
112                 *ddb_handle = NULL;
113                 return_ACPI_STATUS(status);
114         }
115
116         /* Execute any module-level code that was found in the table */
117
118         acpi_ex_exit_interpreter();
119         acpi_ns_exec_module_code_list();
120         acpi_ex_enter_interpreter();
121
122         return_ACPI_STATUS(status);
123 }
124
125 /*******************************************************************************
126  *
127  * FUNCTION:    acpi_ex_load_table_op
128  *
129  * PARAMETERS:  walk_state          - Current state with operands
130  *              return_desc         - Where to store the return object
131  *
132  * RETURN:      Status
133  *
134  * DESCRIPTION: Load an ACPI table from the RSDT/XSDT
135  *
136  ******************************************************************************/
137
138 acpi_status
139 acpi_ex_load_table_op(struct acpi_walk_state *walk_state,
140                       union acpi_operand_object **return_desc)
141 {
142         acpi_status status;
143         union acpi_operand_object **operand = &walk_state->operands[0];
144         struct acpi_namespace_node *parent_node;
145         struct acpi_namespace_node *start_node;
146         struct acpi_namespace_node *parameter_node = NULL;
147         union acpi_operand_object *ddb_handle;
148         struct acpi_table_header *table;
149         u32 table_index;
150
151         ACPI_FUNCTION_TRACE(ex_load_table_op);
152
153         /* Validate lengths for the signature_string, OEMIDString, OEMtable_iD */
154
155         if ((operand[0]->string.length > ACPI_NAME_SIZE) ||
156             (operand[1]->string.length > ACPI_OEM_ID_SIZE) ||
157             (operand[2]->string.length > ACPI_OEM_TABLE_ID_SIZE)) {
158                 return_ACPI_STATUS(AE_BAD_PARAMETER);
159         }
160
161         /* Find the ACPI table in the RSDT/XSDT */
162
163         status = acpi_tb_find_table(operand[0]->string.pointer,
164                                     operand[1]->string.pointer,
165                                     operand[2]->string.pointer, &table_index);
166         if (ACPI_FAILURE(status)) {
167                 if (status != AE_NOT_FOUND) {
168                         return_ACPI_STATUS(status);
169                 }
170
171                 /* Table not found, return an Integer=0 and AE_OK */
172
173                 ddb_handle = acpi_ut_create_integer_object((u64) 0);
174                 if (!ddb_handle) {
175                         return_ACPI_STATUS(AE_NO_MEMORY);
176                 }
177
178                 *return_desc = ddb_handle;
179                 return_ACPI_STATUS(AE_OK);
180         }
181
182         /* Default nodes */
183
184         start_node = walk_state->scope_info->scope.node;
185         parent_node = acpi_gbl_root_node;
186
187         /* root_path (optional parameter) */
188
189         if (operand[3]->string.length > 0) {
190                 /*
191                  * Find the node referenced by the root_path_string. This is the
192                  * location within the namespace where the table will be loaded.
193                  */
194                 status =
195                     acpi_ns_get_node(start_node, operand[3]->string.pointer,
196                                      ACPI_NS_SEARCH_PARENT, &parent_node);
197                 if (ACPI_FAILURE(status)) {
198                         return_ACPI_STATUS(status);
199                 }
200         }
201
202         /* parameter_path (optional parameter) */
203
204         if (operand[4]->string.length > 0) {
205                 if ((operand[4]->string.pointer[0] != '\\') &&
206                     (operand[4]->string.pointer[0] != '^')) {
207                         /*
208                          * Path is not absolute, so it will be relative to the node
209                          * referenced by the root_path_string (or the NS root if omitted)
210                          */
211                         start_node = parent_node;
212                 }
213
214                 /* Find the node referenced by the parameter_path_string */
215
216                 status =
217                     acpi_ns_get_node(start_node, operand[4]->string.pointer,
218                                      ACPI_NS_SEARCH_PARENT, &parameter_node);
219                 if (ACPI_FAILURE(status)) {
220                         return_ACPI_STATUS(status);
221                 }
222         }
223
224         /* Load the table into the namespace */
225
226         status = acpi_ex_add_table(table_index, parent_node, &ddb_handle);
227         if (ACPI_FAILURE(status)) {
228                 return_ACPI_STATUS(status);
229         }
230
231         /* Parameter Data (optional) */
232
233         if (parameter_node) {
234
235                 /* Store the parameter data into the optional parameter object */
236
237                 status = acpi_ex_store(operand[5],
238                                        ACPI_CAST_PTR(union acpi_operand_object,
239                                                      parameter_node),
240                                        walk_state);
241                 if (ACPI_FAILURE(status)) {
242                         (void)acpi_ex_unload_table(ddb_handle);
243
244                         acpi_ut_remove_reference(ddb_handle);
245                         return_ACPI_STATUS(status);
246                 }
247         }
248
249         status = acpi_get_table_by_index(table_index, &table);
250         if (ACPI_SUCCESS(status)) {
251                 ACPI_INFO((AE_INFO,
252                            "Dynamic OEM Table Load - [%.4s] OemId [%.6s] OemTableId [%.8s]",
253                            table->signature, table->oem_id,
254                            table->oem_table_id));
255         }
256
257         /* Invoke table handler if present */
258
259         if (acpi_gbl_table_handler) {
260                 (void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_LOAD, table,
261                                              acpi_gbl_table_handler_context);
262         }
263
264         *return_desc = ddb_handle;
265         return_ACPI_STATUS(status);
266 }
267
268 /*******************************************************************************
269  *
270  * FUNCTION:    acpi_ex_region_read
271  *
272  * PARAMETERS:  obj_desc        - Region descriptor
273  *              Length          - Number of bytes to read
274  *              Buffer          - Pointer to where to put the data
275  *
276  * RETURN:      Status
277  *
278  * DESCRIPTION: Read data from an operation region. The read starts from the
279  *              beginning of the region.
280  *
281  ******************************************************************************/
282
283 static acpi_status
284 acpi_ex_region_read(union acpi_operand_object *obj_desc, u32 length, u8 *buffer)
285 {
286         acpi_status status;
287         acpi_integer value;
288         u32 region_offset = 0;
289         u32 i;
290
291         /* Bytewise reads */
292
293         for (i = 0; i < length; i++) {
294                 status = acpi_ev_address_space_dispatch(obj_desc, ACPI_READ,
295                                                         region_offset, 8,
296                                                         &value);
297                 if (ACPI_FAILURE(status)) {
298                         return status;
299                 }
300
301                 *buffer = (u8)value;
302                 buffer++;
303                 region_offset++;
304         }
305
306         return AE_OK;
307 }
308
309 /*******************************************************************************
310  *
311  * FUNCTION:    acpi_ex_load_op
312  *
313  * PARAMETERS:  obj_desc        - Region or Buffer/Field where the table will be
314  *                                obtained
315  *              Target          - Where a handle to the table will be stored
316  *              walk_state      - Current state
317  *
318  * RETURN:      Status
319  *
320  * DESCRIPTION: Load an ACPI table from a field or operation region
321  *
322  * NOTE: Region Fields (Field, bank_field, index_fields) are resolved to buffer
323  *       objects before this code is reached.
324  *
325  *       If source is an operation region, it must refer to system_memory, as
326  *       per the ACPI specification.
327  *
328  ******************************************************************************/
329
330 acpi_status
331 acpi_ex_load_op(union acpi_operand_object *obj_desc,
332                 union acpi_operand_object *target,
333                 struct acpi_walk_state *walk_state)
334 {
335         union acpi_operand_object *ddb_handle;
336         struct acpi_table_header *table;
337         struct acpi_table_desc table_desc;
338         u32 table_index;
339         acpi_status status;
340         u32 length;
341
342         ACPI_FUNCTION_TRACE(ex_load_op);
343
344         ACPI_MEMSET(&table_desc, 0, sizeof(struct acpi_table_desc));
345
346         /* Source Object can be either an op_region or a Buffer/Field */
347
348         switch (obj_desc->common.type) {
349         case ACPI_TYPE_REGION:
350
351                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
352                                   "Load table from Region %p\n", obj_desc));
353
354                 /* Region must be system_memory (from ACPI spec) */
355
356                 if (obj_desc->region.space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) {
357                         return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
358                 }
359
360                 /*
361                  * If the Region Address and Length have not been previously evaluated,
362                  * evaluate them now and save the results.
363                  */
364                 if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
365                         status = acpi_ds_get_region_arguments(obj_desc);
366                         if (ACPI_FAILURE(status)) {
367                                 return_ACPI_STATUS(status);
368                         }
369                 }
370
371                 /* Get the table header first so we can get the table length */
372
373                 table = ACPI_ALLOCATE(sizeof(struct acpi_table_header));
374                 if (!table) {
375                         return_ACPI_STATUS(AE_NO_MEMORY);
376                 }
377
378                 status =
379                     acpi_ex_region_read(obj_desc,
380                                         sizeof(struct acpi_table_header),
381                                         ACPI_CAST_PTR(u8, table));
382                 length = table->length;
383                 ACPI_FREE(table);
384
385                 if (ACPI_FAILURE(status)) {
386                         return_ACPI_STATUS(status);
387                 }
388
389                 /* Must have at least an ACPI table header */
390
391                 if (length < sizeof(struct acpi_table_header)) {
392                         return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
393                 }
394
395                 /*
396                  * The original implementation simply mapped the table, with no copy.
397                  * However, the memory region is not guaranteed to remain stable and
398                  * we must copy the table to a local buffer. For example, the memory
399                  * region is corrupted after suspend on some machines. Dynamically
400                  * loaded tables are usually small, so this overhead is minimal.
401                  *
402                  * The latest implementation (5/2009) does not use a mapping at all.
403                  * We use the low-level operation region interface to read the table
404                  * instead of the obvious optimization of using a direct mapping.
405                  * This maintains a consistent use of operation regions across the
406                  * entire subsystem. This is important if additional processing must
407                  * be performed in the (possibly user-installed) operation region
408                  * handler. For example, acpi_exec and ASLTS depend on this.
409                  */
410
411                 /* Allocate a buffer for the table */
412
413                 table_desc.pointer = ACPI_ALLOCATE(length);
414                 if (!table_desc.pointer) {
415                         return_ACPI_STATUS(AE_NO_MEMORY);
416                 }
417
418                 /* Read the entire table */
419
420                 status = acpi_ex_region_read(obj_desc, length,
421                                              ACPI_CAST_PTR(u8,
422                                                            table_desc.pointer));
423                 if (ACPI_FAILURE(status)) {
424                         ACPI_FREE(table_desc.pointer);
425                         return_ACPI_STATUS(status);
426                 }
427
428                 table_desc.address = obj_desc->region.address;
429                 break;
430
431         case ACPI_TYPE_BUFFER:  /* Buffer or resolved region_field */
432
433                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
434                                   "Load table from Buffer or Field %p\n",
435                                   obj_desc));
436
437                 /* Must have at least an ACPI table header */
438
439                 if (obj_desc->buffer.length < sizeof(struct acpi_table_header)) {
440                         return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
441                 }
442
443                 /* Get the actual table length from the table header */
444
445                 table =
446                     ACPI_CAST_PTR(struct acpi_table_header,
447                                   obj_desc->buffer.pointer);
448                 length = table->length;
449
450                 /* Table cannot extend beyond the buffer */
451
452                 if (length > obj_desc->buffer.length) {
453                         return_ACPI_STATUS(AE_AML_BUFFER_LIMIT);
454                 }
455                 if (length < sizeof(struct acpi_table_header)) {
456                         return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
457                 }
458
459                 /*
460                  * Copy the table from the buffer because the buffer could be modified
461                  * or even deleted in the future
462                  */
463                 table_desc.pointer = ACPI_ALLOCATE(length);
464                 if (!table_desc.pointer) {
465                         return_ACPI_STATUS(AE_NO_MEMORY);
466                 }
467
468                 ACPI_MEMCPY(table_desc.pointer, table, length);
469                 table_desc.address = ACPI_TO_INTEGER(table_desc.pointer);
470                 break;
471
472         default:
473                 return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
474         }
475
476         /* Validate table checksum (will not get validated in tb_add_table) */
477
478         status = acpi_tb_verify_checksum(table_desc.pointer, length);
479         if (ACPI_FAILURE(status)) {
480                 ACPI_FREE(table_desc.pointer);
481                 return_ACPI_STATUS(status);
482         }
483
484         /* Complete the table descriptor */
485
486         table_desc.length = length;
487         table_desc.flags = ACPI_TABLE_ORIGIN_ALLOCATED;
488
489         /* Install the new table into the local data structures */
490
491         status = acpi_tb_add_table(&table_desc, &table_index);
492         if (ACPI_FAILURE(status)) {
493
494                 /* Delete allocated table buffer */
495
496                 acpi_tb_delete_table(&table_desc);
497                 return_ACPI_STATUS(status);
498         }
499
500         /*
501          * Add the table to the namespace.
502          *
503          * Note: Load the table objects relative to the root of the namespace.
504          * This appears to go against the ACPI specification, but we do it for
505          * compatibility with other ACPI implementations.
506          */
507         status =
508             acpi_ex_add_table(table_index, acpi_gbl_root_node, &ddb_handle);
509         if (ACPI_FAILURE(status)) {
510
511                 /* On error, table_ptr was deallocated above */
512
513                 return_ACPI_STATUS(status);
514         }
515
516         /* Store the ddb_handle into the Target operand */
517
518         status = acpi_ex_store(ddb_handle, target, walk_state);
519         if (ACPI_FAILURE(status)) {
520                 (void)acpi_ex_unload_table(ddb_handle);
521
522                 /* table_ptr was deallocated above */
523
524                 acpi_ut_remove_reference(ddb_handle);
525                 return_ACPI_STATUS(status);
526         }
527
528         /* Remove the reference by added by acpi_ex_store above */
529
530         acpi_ut_remove_reference(ddb_handle);
531
532         /* Invoke table handler if present */
533
534         if (acpi_gbl_table_handler) {
535                 (void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_LOAD,
536                                              table_desc.pointer,
537                                              acpi_gbl_table_handler_context);
538         }
539
540         return_ACPI_STATUS(status);
541 }
542
543 /*******************************************************************************
544  *
545  * FUNCTION:    acpi_ex_unload_table
546  *
547  * PARAMETERS:  ddb_handle          - Handle to a previously loaded table
548  *
549  * RETURN:      Status
550  *
551  * DESCRIPTION: Unload an ACPI table
552  *
553  ******************************************************************************/
554
555 acpi_status acpi_ex_unload_table(union acpi_operand_object *ddb_handle)
556 {
557         acpi_status status = AE_OK;
558         union acpi_operand_object *table_desc = ddb_handle;
559         u32 table_index;
560         struct acpi_table_header *table;
561
562         ACPI_FUNCTION_TRACE(ex_unload_table);
563
564         /*
565          * Validate the handle
566          * Although the handle is partially validated in acpi_ex_reconfiguration()
567          * when it calls acpi_ex_resolve_operands(), the handle is more completely
568          * validated here.
569          *
570          * Handle must be a valid operand object of type reference. Also, the
571          * ddb_handle must still be marked valid (table has not been previously
572          * unloaded)
573          */
574         if ((!ddb_handle) ||
575             (ACPI_GET_DESCRIPTOR_TYPE(ddb_handle) != ACPI_DESC_TYPE_OPERAND) ||
576             (ddb_handle->common.type != ACPI_TYPE_LOCAL_REFERENCE) ||
577             (!(ddb_handle->common.flags & AOPOBJ_DATA_VALID))) {
578                 return_ACPI_STATUS(AE_BAD_PARAMETER);
579         }
580
581         /* Get the table index from the ddb_handle */
582
583         table_index = table_desc->reference.value;
584
585         /* Ensure the table is still loaded */
586
587         if (!acpi_tb_is_table_loaded(table_index)) {
588                 return_ACPI_STATUS(AE_NOT_EXIST);
589         }
590
591         /* Invoke table handler if present */
592
593         if (acpi_gbl_table_handler) {
594                 status = acpi_get_table_by_index(table_index, &table);
595                 if (ACPI_SUCCESS(status)) {
596                         (void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_UNLOAD,
597                                                      table,
598                                                      acpi_gbl_table_handler_context);
599                 }
600         }
601
602         /* Delete the portion of the namespace owned by this table */
603
604         status = acpi_tb_delete_namespace_by_owner(table_index);
605         if (ACPI_FAILURE(status)) {
606                 return_ACPI_STATUS(status);
607         }
608
609         (void)acpi_tb_release_owner_id(table_index);
610         acpi_tb_set_table_loaded_flag(table_index, FALSE);
611
612         /*
613          * Invalidate the handle. We do this because the handle may be stored
614          * in a named object and may not be actually deleted until much later.
615          */
616         ddb_handle->common.flags &= ~AOPOBJ_DATA_VALID;
617         return_ACPI_STATUS(AE_OK);
618 }