Merge branch 'acpica' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux...
[sfrench/cifs-2.6.git] / drivers / acpi / acpica / tbxface.c
1 /******************************************************************************
2  *
3  * Module Name: tbxface - Public interfaces to the ACPI subsystem
4  *                         ACPI table oriented interfaces
5  *
6  *****************************************************************************/
7
8 /*
9  * Copyright (C) 2000 - 2010, Intel Corp.
10  * All rights reserved.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions, and the following disclaimer,
17  *    without modification.
18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19  *    substantially similar to the "NO WARRANTY" disclaimer below
20  *    ("Disclaimer") and any redistribution must be conditioned upon
21  *    including a substantially similar Disclaimer requirement for further
22  *    binary redistribution.
23  * 3. Neither the names of the above-listed copyright holders nor the names
24  *    of any contributors may be used to endorse or promote products derived
25  *    from this software without specific prior written permission.
26  *
27  * Alternatively, this software may be distributed under the terms of the
28  * GNU General Public License ("GPL") version 2 as published by the Free
29  * Software Foundation.
30  *
31  * NO WARRANTY
32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42  * POSSIBILITY OF SUCH DAMAGES.
43  */
44
45 #include <acpi/acpi.h>
46 #include "accommon.h"
47 #include "acnamesp.h"
48 #include "actables.h"
49
50 #define _COMPONENT          ACPI_TABLES
51 ACPI_MODULE_NAME("tbxface")
52
53 /* Local prototypes */
54 static acpi_status acpi_tb_load_namespace(void);
55
56 static int no_auto_ssdt;
57
58 /*******************************************************************************
59  *
60  * FUNCTION:    acpi_allocate_root_table
61  *
62  * PARAMETERS:  initial_table_count - Size of initial_table_array, in number of
63  *                                    struct acpi_table_desc structures
64  *
65  * RETURN:      Status
66  *
67  * DESCRIPTION: Allocate a root table array. Used by i_aSL compiler and
68  *              acpi_initialize_tables.
69  *
70  ******************************************************************************/
71
72 acpi_status acpi_allocate_root_table(u32 initial_table_count)
73 {
74
75         acpi_gbl_root_table_list.max_table_count = initial_table_count;
76         acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
77
78         return (acpi_tb_resize_root_table_list());
79 }
80
81 /*******************************************************************************
82  *
83  * FUNCTION:    acpi_initialize_tables
84  *
85  * PARAMETERS:  initial_table_array - Pointer to an array of pre-allocated
86  *                                    struct acpi_table_desc structures. If NULL, the
87  *                                    array is dynamically allocated.
88  *              initial_table_count - Size of initial_table_array, in number of
89  *                                    struct acpi_table_desc structures
90  *              allow_realloc       - Flag to tell Table Manager if resize of
91  *                                    pre-allocated array is allowed. Ignored
92  *                                    if initial_table_array is NULL.
93  *
94  * RETURN:      Status
95  *
96  * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
97  *
98  * NOTE:        Allows static allocation of the initial table array in order
99  *              to avoid the use of dynamic memory in confined environments
100  *              such as the kernel boot sequence where it may not be available.
101  *
102  *              If the host OS memory managers are initialized, use NULL for
103  *              initial_table_array, and the table will be dynamically allocated.
104  *
105  ******************************************************************************/
106
107 acpi_status __init
108 acpi_initialize_tables(struct acpi_table_desc * initial_table_array,
109                        u32 initial_table_count, u8 allow_resize)
110 {
111         acpi_physical_address rsdp_address;
112         acpi_status status;
113
114         ACPI_FUNCTION_TRACE(acpi_initialize_tables);
115
116         /*
117          * Set up the Root Table Array
118          * Allocate the table array if requested
119          */
120         if (!initial_table_array) {
121                 status = acpi_allocate_root_table(initial_table_count);
122                 if (ACPI_FAILURE(status)) {
123                         return_ACPI_STATUS(status);
124                 }
125         } else {
126                 /* Root Table Array has been statically allocated by the host */
127
128                 ACPI_MEMSET(initial_table_array, 0,
129                             (acpi_size) initial_table_count *
130                             sizeof(struct acpi_table_desc));
131
132                 acpi_gbl_root_table_list.tables = initial_table_array;
133                 acpi_gbl_root_table_list.max_table_count = initial_table_count;
134                 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
135                 if (allow_resize) {
136                         acpi_gbl_root_table_list.flags |=
137                             ACPI_ROOT_ALLOW_RESIZE;
138                 }
139         }
140
141         /* Get the address of the RSDP */
142
143         rsdp_address = acpi_os_get_root_pointer();
144         if (!rsdp_address) {
145                 return_ACPI_STATUS(AE_NOT_FOUND);
146         }
147
148         /*
149          * Get the root table (RSDT or XSDT) and extract all entries to the local
150          * Root Table Array. This array contains the information of the RSDT/XSDT
151          * in a common, more useable format.
152          */
153         status = acpi_tb_parse_root_table(rsdp_address);
154         return_ACPI_STATUS(status);
155 }
156
157 /*******************************************************************************
158  *
159  * FUNCTION:    acpi_reallocate_root_table
160  *
161  * PARAMETERS:  None
162  *
163  * RETURN:      Status
164  *
165  * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
166  *              root list from the previously provided scratch area. Should
167  *              be called once dynamic memory allocation is available in the
168  *              kernel
169  *
170  ******************************************************************************/
171 acpi_status acpi_reallocate_root_table(void)
172 {
173         struct acpi_table_desc *tables;
174         acpi_size new_size;
175         acpi_size current_size;
176
177         ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
178
179         /*
180          * Only reallocate the root table if the host provided a static buffer
181          * for the table array in the call to acpi_initialize_tables.
182          */
183         if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
184                 return_ACPI_STATUS(AE_SUPPORT);
185         }
186
187         /*
188          * Get the current size of the root table and add the default
189          * increment to create the new table size.
190          */
191         current_size = (acpi_size)
192             acpi_gbl_root_table_list.current_table_count *
193             sizeof(struct acpi_table_desc);
194
195         new_size = current_size +
196             (ACPI_ROOT_TABLE_SIZE_INCREMENT * sizeof(struct acpi_table_desc));
197
198         /* Create new array and copy the old array */
199
200         tables = ACPI_ALLOCATE_ZEROED(new_size);
201         if (!tables) {
202                 return_ACPI_STATUS(AE_NO_MEMORY);
203         }
204
205         ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, current_size);
206
207         /*
208          * Update the root table descriptor. The new size will be the current
209          * number of tables plus the increment, independent of the reserved
210          * size of the original table list.
211          */
212         acpi_gbl_root_table_list.tables = tables;
213         acpi_gbl_root_table_list.max_table_count =
214             acpi_gbl_root_table_list.current_table_count +
215             ACPI_ROOT_TABLE_SIZE_INCREMENT;
216         acpi_gbl_root_table_list.flags =
217             ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE;
218
219         return_ACPI_STATUS(AE_OK);
220 }
221
222 /*******************************************************************************
223  *
224  * FUNCTION:    acpi_load_table
225  *
226  * PARAMETERS:  table_ptr       - pointer to a buffer containing the entire
227  *                                table to be loaded
228  *
229  * RETURN:      Status
230  *
231  * DESCRIPTION: This function is called to load a table from the caller's
232  *              buffer. The buffer must contain an entire ACPI Table including
233  *              a valid header. The header fields will be verified, and if it
234  *              is determined that the table is invalid, the call will fail.
235  *
236  ******************************************************************************/
237 acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
238 {
239         acpi_status status;
240         u32 table_index;
241         struct acpi_table_desc table_desc;
242
243         if (!table_ptr)
244                 return AE_BAD_PARAMETER;
245
246         ACPI_MEMSET(&table_desc, 0, sizeof(struct acpi_table_desc));
247         table_desc.pointer = table_ptr;
248         table_desc.length = table_ptr->length;
249         table_desc.flags = ACPI_TABLE_ORIGIN_UNKNOWN;
250
251         /*
252          * Install the new table into the local data structures
253          */
254         status = acpi_tb_add_table(&table_desc, &table_index);
255         if (ACPI_FAILURE(status)) {
256                 return status;
257         }
258         status = acpi_ns_load_table(table_index, acpi_gbl_root_node);
259         return status;
260 }
261
262 ACPI_EXPORT_SYMBOL(acpi_load_table)
263
264 /*******************************************************************************
265  *
266  * FUNCTION:    acpi_get_table_header
267  *
268  * PARAMETERS:  Signature           - ACPI signature of needed table
269  *              Instance            - Which instance (for SSDTs)
270  *              out_table_header    - The pointer to the table header to fill
271  *
272  * RETURN:      Status and pointer to mapped table header
273  *
274  * DESCRIPTION: Finds an ACPI table header.
275  *
276  * NOTE:        Caller is responsible in unmapping the header with
277  *              acpi_os_unmap_memory
278  *
279  ******************************************************************************/
280 acpi_status
281 acpi_get_table_header(char *signature,
282                       u32 instance, struct acpi_table_header *out_table_header)
283 {
284        u32 i;
285        u32 j;
286         struct acpi_table_header *header;
287
288         /* Parameter validation */
289
290         if (!signature || !out_table_header) {
291                 return (AE_BAD_PARAMETER);
292         }
293
294         /* Walk the root table list */
295
296         for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
297              i++) {
298                 if (!ACPI_COMPARE_NAME
299                     (&(acpi_gbl_root_table_list.tables[i].signature),
300                      signature)) {
301                         continue;
302                 }
303
304                 if (++j < instance) {
305                         continue;
306                 }
307
308                 if (!acpi_gbl_root_table_list.tables[i].pointer) {
309                         if ((acpi_gbl_root_table_list.tables[i].flags &
310                              ACPI_TABLE_ORIGIN_MASK) ==
311                             ACPI_TABLE_ORIGIN_MAPPED) {
312                                 header =
313                                     acpi_os_map_memory(acpi_gbl_root_table_list.
314                                                        tables[i].address,
315                                                        sizeof(struct
316                                                               acpi_table_header));
317                                 if (!header) {
318                                         return AE_NO_MEMORY;
319                                 }
320                                 ACPI_MEMCPY(out_table_header, header,
321                                             sizeof(struct acpi_table_header));
322                                 acpi_os_unmap_memory(header,
323                                                      sizeof(struct
324                                                             acpi_table_header));
325                         } else {
326                                 return AE_NOT_FOUND;
327                         }
328                 } else {
329                         ACPI_MEMCPY(out_table_header,
330                                     acpi_gbl_root_table_list.tables[i].pointer,
331                                     sizeof(struct acpi_table_header));
332                 }
333                 return (AE_OK);
334         }
335
336         return (AE_NOT_FOUND);
337 }
338
339 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
340
341 /*******************************************************************************
342  *
343  * FUNCTION:    acpi_unload_table_id
344  *
345  * PARAMETERS:  id            - Owner ID of the table to be removed.
346  *
347  * RETURN:      Status
348  *
349  * DESCRIPTION: This routine is used to force the unload of a table (by id)
350  *
351  ******************************************************************************/
352 acpi_status acpi_unload_table_id(acpi_owner_id id)
353 {
354         int i;
355         acpi_status status = AE_NOT_EXIST;
356
357         ACPI_FUNCTION_TRACE(acpi_unload_table_id);
358
359         /* Find table in the global table list */
360         for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
361                 if (id != acpi_gbl_root_table_list.tables[i].owner_id) {
362                         continue;
363                 }
364                 /*
365                  * Delete all namespace objects owned by this table. Note that these
366                  * objects can appear anywhere in the namespace by virtue of the AML
367                  * "Scope" operator. Thus, we need to track ownership by an ID, not
368                  * simply a position within the hierarchy
369                  */
370                 acpi_tb_delete_namespace_by_owner(i);
371                 status = acpi_tb_release_owner_id(i);
372                 acpi_tb_set_table_loaded_flag(i, FALSE);
373                 break;
374         }
375         return_ACPI_STATUS(status);
376 }
377
378 ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
379
380 /*******************************************************************************
381  *
382  * FUNCTION:    acpi_get_table_with_size
383  *
384  * PARAMETERS:  Signature           - ACPI signature of needed table
385  *              Instance            - Which instance (for SSDTs)
386  *              out_table           - Where the pointer to the table is returned
387  *
388  * RETURN:      Status and pointer to table
389  *
390  * DESCRIPTION: Finds and verifies an ACPI table.
391  *
392  ******************************************************************************/
393 acpi_status
394 acpi_get_table_with_size(char *signature,
395                u32 instance, struct acpi_table_header **out_table,
396                acpi_size *tbl_size)
397 {
398        u32 i;
399        u32 j;
400         acpi_status status;
401
402         /* Parameter validation */
403
404         if (!signature || !out_table) {
405                 return (AE_BAD_PARAMETER);
406         }
407
408         /* Walk the root table list */
409
410         for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
411              i++) {
412                 if (!ACPI_COMPARE_NAME
413                     (&(acpi_gbl_root_table_list.tables[i].signature),
414                      signature)) {
415                         continue;
416                 }
417
418                 if (++j < instance) {
419                         continue;
420                 }
421
422                 status =
423                     acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]);
424                 if (ACPI_SUCCESS(status)) {
425                         *out_table = acpi_gbl_root_table_list.tables[i].pointer;
426                         *tbl_size = acpi_gbl_root_table_list.tables[i].length;
427                 }
428
429                 if (!acpi_gbl_permanent_mmap) {
430                         acpi_gbl_root_table_list.tables[i].pointer = NULL;
431                 }
432
433                 return (status);
434         }
435
436         return (AE_NOT_FOUND);
437 }
438
439 acpi_status
440 acpi_get_table(char *signature,
441                u32 instance, struct acpi_table_header **out_table)
442 {
443         acpi_size tbl_size;
444
445         return acpi_get_table_with_size(signature,
446                        instance, out_table, &tbl_size);
447 }
448 ACPI_EXPORT_SYMBOL(acpi_get_table)
449
450 /*******************************************************************************
451  *
452  * FUNCTION:    acpi_get_table_by_index
453  *
454  * PARAMETERS:  table_index         - Table index
455  *              Table               - Where the pointer to the table is returned
456  *
457  * RETURN:      Status and pointer to the table
458  *
459  * DESCRIPTION: Obtain a table by an index into the global table list.
460  *
461  ******************************************************************************/
462 acpi_status
463 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **table)
464 {
465         acpi_status status;
466
467         ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
468
469         /* Parameter validation */
470
471         if (!table) {
472                 return_ACPI_STATUS(AE_BAD_PARAMETER);
473         }
474
475         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
476
477         /* Validate index */
478
479         if (table_index >= acpi_gbl_root_table_list.current_table_count) {
480                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
481                 return_ACPI_STATUS(AE_BAD_PARAMETER);
482         }
483
484         if (!acpi_gbl_root_table_list.tables[table_index].pointer) {
485
486                 /* Table is not mapped, map it */
487
488                 status =
489                     acpi_tb_verify_table(&acpi_gbl_root_table_list.
490                                          tables[table_index]);
491                 if (ACPI_FAILURE(status)) {
492                         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
493                         return_ACPI_STATUS(status);
494                 }
495         }
496
497         *table = acpi_gbl_root_table_list.tables[table_index].pointer;
498         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
499         return_ACPI_STATUS(AE_OK);
500 }
501
502 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
503
504 /*******************************************************************************
505  *
506  * FUNCTION:    acpi_tb_load_namespace
507  *
508  * PARAMETERS:  None
509  *
510  * RETURN:      Status
511  *
512  * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in
513  *              the RSDT/XSDT.
514  *
515  ******************************************************************************/
516 static acpi_status acpi_tb_load_namespace(void)
517 {
518         acpi_status status;
519         u32 i;
520         struct acpi_table_header *new_dsdt;
521
522         ACPI_FUNCTION_TRACE(tb_load_namespace);
523
524         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
525
526         /*
527          * Load the namespace. The DSDT is required, but any SSDT and
528          * PSDT tables are optional. Verify the DSDT.
529          */
530         if (!acpi_gbl_root_table_list.current_table_count ||
531             !ACPI_COMPARE_NAME(&
532                                (acpi_gbl_root_table_list.
533                                 tables[ACPI_TABLE_INDEX_DSDT].signature),
534                                ACPI_SIG_DSDT)
535             ||
536             ACPI_FAILURE(acpi_tb_verify_table
537                          (&acpi_gbl_root_table_list.
538                           tables[ACPI_TABLE_INDEX_DSDT]))) {
539                 status = AE_NO_ACPI_TABLES;
540                 goto unlock_and_exit;
541         }
542
543         /*
544          * Save the DSDT pointer for simple access. This is the mapped memory
545          * address. We must take care here because the address of the .Tables
546          * array can change dynamically as tables are loaded at run-time. Note:
547          * .Pointer field is not validated until after call to acpi_tb_verify_table.
548          */
549         acpi_gbl_DSDT =
550             acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].pointer;
551
552         /*
553          * Optionally copy the entire DSDT to local memory (instead of simply
554          * mapping it.) There are some BIOSs that corrupt or replace the original
555          * DSDT, creating the need for this option. Default is FALSE, do not copy
556          * the DSDT.
557          */
558         if (acpi_gbl_copy_dsdt_locally) {
559                 new_dsdt = acpi_tb_copy_dsdt(ACPI_TABLE_INDEX_DSDT);
560                 if (new_dsdt) {
561                         acpi_gbl_DSDT = new_dsdt;
562                 }
563         }
564
565         /*
566          * Save the original DSDT header for detection of table corruption
567          * and/or replacement of the DSDT from outside the OS.
568          */
569         ACPI_MEMCPY(&acpi_gbl_original_dsdt_header, acpi_gbl_DSDT,
570                     sizeof(struct acpi_table_header));
571
572         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
573
574         /* Load and parse tables */
575
576         status = acpi_ns_load_table(ACPI_TABLE_INDEX_DSDT, acpi_gbl_root_node);
577         if (ACPI_FAILURE(status)) {
578                 return_ACPI_STATUS(status);
579         }
580
581         /* Load any SSDT or PSDT tables. Note: Loop leaves tables locked */
582
583         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
584         for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
585                 if ((!ACPI_COMPARE_NAME
586                      (&(acpi_gbl_root_table_list.tables[i].signature),
587                       ACPI_SIG_SSDT)
588                      &&
589                      !ACPI_COMPARE_NAME(&
590                                         (acpi_gbl_root_table_list.tables[i].
591                                          signature), ACPI_SIG_PSDT))
592                     ||
593                     ACPI_FAILURE(acpi_tb_verify_table
594                                  (&acpi_gbl_root_table_list.tables[i]))) {
595                         continue;
596                 }
597
598                 if (no_auto_ssdt) {
599                         printk(KERN_WARNING "ACPI: SSDT ignored due to \"acpi_no_auto_ssdt\"\n");
600                         continue;
601                 }
602
603                 /* Ignore errors while loading tables, get as many as possible */
604
605                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
606                 (void)acpi_ns_load_table(i, acpi_gbl_root_node);
607                 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
608         }
609
610         ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
611
612       unlock_and_exit:
613         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
614         return_ACPI_STATUS(status);
615 }
616
617 /*******************************************************************************
618  *
619  * FUNCTION:    acpi_load_tables
620  *
621  * PARAMETERS:  None
622  *
623  * RETURN:      Status
624  *
625  * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT
626  *
627  ******************************************************************************/
628
629 acpi_status acpi_load_tables(void)
630 {
631         acpi_status status;
632
633         ACPI_FUNCTION_TRACE(acpi_load_tables);
634
635         /* Load the namespace from the tables */
636
637         status = acpi_tb_load_namespace();
638         if (ACPI_FAILURE(status)) {
639                 ACPI_EXCEPTION((AE_INFO, status,
640                                 "While loading namespace from ACPI tables"));
641         }
642
643         return_ACPI_STATUS(status);
644 }
645
646 ACPI_EXPORT_SYMBOL(acpi_load_tables)
647
648
649 /*******************************************************************************
650  *
651  * FUNCTION:    acpi_install_table_handler
652  *
653  * PARAMETERS:  Handler         - Table event handler
654  *              Context         - Value passed to the handler on each event
655  *
656  * RETURN:      Status
657  *
658  * DESCRIPTION: Install table event handler
659  *
660  ******************************************************************************/
661 acpi_status
662 acpi_install_table_handler(acpi_tbl_handler handler, void *context)
663 {
664         acpi_status status;
665
666         ACPI_FUNCTION_TRACE(acpi_install_table_handler);
667
668         if (!handler) {
669                 return_ACPI_STATUS(AE_BAD_PARAMETER);
670         }
671
672         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
673         if (ACPI_FAILURE(status)) {
674                 return_ACPI_STATUS(status);
675         }
676
677         /* Don't allow more than one handler */
678
679         if (acpi_gbl_table_handler) {
680                 status = AE_ALREADY_EXISTS;
681                 goto cleanup;
682         }
683
684         /* Install the handler */
685
686         acpi_gbl_table_handler = handler;
687         acpi_gbl_table_handler_context = context;
688
689       cleanup:
690         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
691         return_ACPI_STATUS(status);
692 }
693
694 ACPI_EXPORT_SYMBOL(acpi_install_table_handler)
695
696 /*******************************************************************************
697  *
698  * FUNCTION:    acpi_remove_table_handler
699  *
700  * PARAMETERS:  Handler         - Table event handler that was installed
701  *                                previously.
702  *
703  * RETURN:      Status
704  *
705  * DESCRIPTION: Remove table event handler
706  *
707  ******************************************************************************/
708 acpi_status acpi_remove_table_handler(acpi_tbl_handler handler)
709 {
710         acpi_status status;
711
712         ACPI_FUNCTION_TRACE(acpi_remove_table_handler);
713
714         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
715         if (ACPI_FAILURE(status)) {
716                 return_ACPI_STATUS(status);
717         }
718
719         /* Make sure that the installed handler is the same */
720
721         if (!handler || handler != acpi_gbl_table_handler) {
722                 status = AE_BAD_PARAMETER;
723                 goto cleanup;
724         }
725
726         /* Remove the handler */
727
728         acpi_gbl_table_handler = NULL;
729
730       cleanup:
731         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
732         return_ACPI_STATUS(status);
733 }
734
735 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler)
736
737
738 static int __init acpi_no_auto_ssdt_setup(char *s) {
739
740         printk(KERN_NOTICE "ACPI: SSDT auto-load disabled\n");
741
742         no_auto_ssdt = 1;
743
744         return 1;
745 }
746
747 __setup("acpi_no_auto_ssdt", acpi_no_auto_ssdt_setup);