Revert "ARM: tegra: tegratab: dummy change"
[linux-2.6.git] / drivers / acpi / acpica / tbinstal.c
1 /******************************************************************************
2  *
3  * Module Name: tbinstal - ACPI table installation and removal
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2012, 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 "acnamesp.h"
47 #include "actables.h"
48
49 #define _COMPONENT          ACPI_TABLES
50 ACPI_MODULE_NAME("tbinstal")
51
52 /******************************************************************************
53  *
54  * FUNCTION:    acpi_tb_verify_table
55  *
56  * PARAMETERS:  table_desc          - table
57  *
58  * RETURN:      Status
59  *
60  * DESCRIPTION: this function is called to verify and map table
61  *
62  *****************************************************************************/
63 acpi_status acpi_tb_verify_table(struct acpi_table_desc *table_desc)
64 {
65         acpi_status status = AE_OK;
66
67         ACPI_FUNCTION_TRACE(tb_verify_table);
68
69         /* Map the table if necessary */
70
71         if (!table_desc->pointer) {
72                 if ((table_desc->flags & ACPI_TABLE_ORIGIN_MASK) ==
73                     ACPI_TABLE_ORIGIN_MAPPED) {
74                         table_desc->pointer =
75                             acpi_os_map_memory(table_desc->address,
76                                                table_desc->length);
77                 }
78                 if (!table_desc->pointer) {
79                         return_ACPI_STATUS(AE_NO_MEMORY);
80                 }
81         }
82
83         /* FACS is the odd table, has no standard ACPI header and no checksum */
84
85         if (!ACPI_COMPARE_NAME(&table_desc->signature, ACPI_SIG_FACS)) {
86
87                 /* Always calculate checksum, ignore bad checksum if requested */
88
89                 status =
90                     acpi_tb_verify_checksum(table_desc->pointer,
91                                             table_desc->length);
92         }
93
94         return_ACPI_STATUS(status);
95 }
96
97 /*******************************************************************************
98  *
99  * FUNCTION:    acpi_tb_add_table
100  *
101  * PARAMETERS:  table_desc          - Table descriptor
102  *              table_index         - Where the table index is returned
103  *
104  * RETURN:      Status
105  *
106  * DESCRIPTION: This function is called to add an ACPI table. It is used to
107  *              dynamically load tables via the Load and load_table AML
108  *              operators.
109  *
110  ******************************************************************************/
111
112 acpi_status
113 acpi_tb_add_table(struct acpi_table_desc *table_desc, u32 *table_index)
114 {
115         u32 i;
116         acpi_status status = AE_OK;
117
118         ACPI_FUNCTION_TRACE(tb_add_table);
119
120         if (!table_desc->pointer) {
121                 status = acpi_tb_verify_table(table_desc);
122                 if (ACPI_FAILURE(status) || !table_desc->pointer) {
123                         return_ACPI_STATUS(status);
124                 }
125         }
126
127         /*
128          * Validate the incoming table signature.
129          *
130          * 1) Originally, we checked the table signature for "SSDT" or "PSDT".
131          * 2) We added support for OEMx tables, signature "OEM".
132          * 3) Valid tables were encountered with a null signature, so we just
133          *    gave up on validating the signature, (05/2008).
134          * 4) We encountered non-AML tables such as the MADT, which caused
135          *    interpreter errors and kernel faults. So now, we once again allow
136          *    only "SSDT", "OEMx", and now, also a null signature. (05/2011).
137          */
138         if ((table_desc->pointer->signature[0] != 0x00) &&
139             (!ACPI_COMPARE_NAME(table_desc->pointer->signature, ACPI_SIG_SSDT))
140             && (ACPI_STRNCMP(table_desc->pointer->signature, "OEM", 3))) {
141                 ACPI_ERROR((AE_INFO,
142                             "Table has invalid signature [%4.4s] (0x%8.8X), must be SSDT or OEMx",
143                             acpi_ut_valid_acpi_name(*(u32 *)table_desc->
144                                                     pointer->
145                                                     signature) ? table_desc->
146                             pointer->signature : "????",
147                             *(u32 *)table_desc->pointer->signature));
148
149                 return_ACPI_STATUS(AE_BAD_SIGNATURE);
150         }
151
152         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
153
154         /* Check if table is already registered */
155
156         for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
157                 if (!acpi_gbl_root_table_list.tables[i].pointer) {
158                         status =
159                             acpi_tb_verify_table(&acpi_gbl_root_table_list.
160                                                  tables[i]);
161                         if (ACPI_FAILURE(status)
162                             || !acpi_gbl_root_table_list.tables[i].pointer) {
163                                 continue;
164                         }
165                 }
166
167                 /*
168                  * Check for a table match on the entire table length,
169                  * not just the header.
170                  */
171                 if (table_desc->length !=
172                     acpi_gbl_root_table_list.tables[i].length) {
173                         continue;
174                 }
175
176                 if (ACPI_MEMCMP(table_desc->pointer,
177                                 acpi_gbl_root_table_list.tables[i].pointer,
178                                 acpi_gbl_root_table_list.tables[i].length)) {
179                         continue;
180                 }
181
182                 /*
183                  * Note: the current mechanism does not unregister a table if it is
184                  * dynamically unloaded. The related namespace entries are deleted,
185                  * but the table remains in the root table list.
186                  *
187                  * The assumption here is that the number of different tables that
188                  * will be loaded is actually small, and there is minimal overhead
189                  * in just keeping the table in case it is needed again.
190                  *
191                  * If this assumption changes in the future (perhaps on large
192                  * machines with many table load/unload operations), tables will
193                  * need to be unregistered when they are unloaded, and slots in the
194                  * root table list should be reused when empty.
195                  */
196
197                 /*
198                  * Table is already registered.
199                  * We can delete the table that was passed as a parameter.
200                  */
201                 acpi_tb_delete_table(table_desc);
202                 *table_index = i;
203
204                 if (acpi_gbl_root_table_list.tables[i].
205                     flags & ACPI_TABLE_IS_LOADED) {
206
207                         /* Table is still loaded, this is an error */
208
209                         status = AE_ALREADY_EXISTS;
210                         goto release;
211                 } else {
212                         /* Table was unloaded, allow it to be reloaded */
213
214                         table_desc->pointer =
215                             acpi_gbl_root_table_list.tables[i].pointer;
216                         table_desc->address =
217                             acpi_gbl_root_table_list.tables[i].address;
218                         status = AE_OK;
219                         goto print_header;
220                 }
221         }
222
223         /*
224          * ACPI Table Override:
225          * Allow the host to override dynamically loaded tables.
226          * NOTE: the table is fully mapped at this point, and the mapping will
227          * be deleted by tb_table_override if the table is actually overridden.
228          */
229         (void)acpi_tb_table_override(table_desc->pointer, table_desc);
230
231         /* Add the table to the global root table list */
232
233         status = acpi_tb_store_table(table_desc->address, table_desc->pointer,
234                                      table_desc->length, table_desc->flags,
235                                      table_index);
236         if (ACPI_FAILURE(status)) {
237                 goto release;
238         }
239
240       print_header:
241         acpi_tb_print_table_header(table_desc->address, table_desc->pointer);
242
243       release:
244         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
245         return_ACPI_STATUS(status);
246 }
247
248 /*******************************************************************************
249  *
250  * FUNCTION:    acpi_tb_table_override
251  *
252  * PARAMETERS:  table_header        - Header for the original table
253  *              table_desc          - Table descriptor initialized for the
254  *                                    original table. May or may not be mapped.
255  *
256  * RETURN:      Pointer to the entire new table. NULL if table not overridden.
257  *              If overridden, installs the new table within the input table
258  *              descriptor.
259  *
260  * DESCRIPTION: Attempt table override by calling the OSL override functions.
261  *              Note: If the table is overridden, then the entire new table
262  *              is mapped and returned by this function.
263  *
264  ******************************************************************************/
265
266 struct acpi_table_header *acpi_tb_table_override(struct acpi_table_header
267                                                  *table_header,
268                                                  struct acpi_table_desc
269                                                  *table_desc)
270 {
271         acpi_status status;
272         struct acpi_table_header *new_table = NULL;
273         acpi_physical_address new_address = 0;
274         u32 new_table_length = 0;
275         u8 new_flags;
276         char *override_type;
277
278         /* (1) Attempt logical override (returns a logical address) */
279
280         status = acpi_os_table_override(table_header, &new_table);
281         if (ACPI_SUCCESS(status) && new_table) {
282                 new_address = ACPI_PTR_TO_PHYSADDR(new_table);
283                 new_table_length = new_table->length;
284                 new_flags = ACPI_TABLE_ORIGIN_OVERRIDE;
285                 override_type = "Logical";
286                 goto finish_override;
287         }
288
289         /* (2) Attempt physical override (returns a physical address) */
290
291         status = acpi_os_physical_table_override(table_header,
292                                                  &new_address,
293                                                  &new_table_length);
294         if (ACPI_SUCCESS(status) && new_address && new_table_length) {
295
296                 /* Map the entire new table */
297
298                 new_table = acpi_os_map_memory(new_address, new_table_length);
299                 if (!new_table) {
300                         ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
301                                         "%4.4s %p Attempted physical table override failed",
302                                         table_header->signature,
303                                         ACPI_CAST_PTR(void,
304                                                       table_desc->address)));
305                         return (NULL);
306                 }
307
308                 override_type = "Physical";
309                 new_flags = ACPI_TABLE_ORIGIN_MAPPED;
310                 goto finish_override;
311         }
312
313         return (NULL);          /* There was no override */
314
315       finish_override:
316
317         ACPI_INFO((AE_INFO,
318                    "%4.4s %p %s table override, new table: %p",
319                    table_header->signature,
320                    ACPI_CAST_PTR(void, table_desc->address),
321                    override_type, new_table));
322
323         /* We can now unmap/delete the original table (if fully mapped) */
324
325         acpi_tb_delete_table(table_desc);
326
327         /* Setup descriptor for the new table */
328
329         table_desc->address = new_address;
330         table_desc->pointer = new_table;
331         table_desc->length = new_table_length;
332         table_desc->flags = new_flags;
333
334         return (new_table);
335 }
336
337 /*******************************************************************************
338  *
339  * FUNCTION:    acpi_tb_resize_root_table_list
340  *
341  * PARAMETERS:  None
342  *
343  * RETURN:      Status
344  *
345  * DESCRIPTION: Expand the size of global table array
346  *
347  ******************************************************************************/
348
349 acpi_status acpi_tb_resize_root_table_list(void)
350 {
351         struct acpi_table_desc *tables;
352
353         ACPI_FUNCTION_TRACE(tb_resize_root_table_list);
354
355         /* allow_resize flag is a parameter to acpi_initialize_tables */
356
357         if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) {
358                 ACPI_ERROR((AE_INFO,
359                             "Resize of Root Table Array is not allowed"));
360                 return_ACPI_STATUS(AE_SUPPORT);
361         }
362
363         /* Increase the Table Array size */
364
365         tables = ACPI_ALLOCATE_ZEROED(((acpi_size) acpi_gbl_root_table_list.
366                                        max_table_count +
367                                        ACPI_ROOT_TABLE_SIZE_INCREMENT) *
368                                       sizeof(struct acpi_table_desc));
369         if (!tables) {
370                 ACPI_ERROR((AE_INFO,
371                             "Could not allocate new root table array"));
372                 return_ACPI_STATUS(AE_NO_MEMORY);
373         }
374
375         /* Copy and free the previous table array */
376
377         if (acpi_gbl_root_table_list.tables) {
378                 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables,
379                             (acpi_size) acpi_gbl_root_table_list.
380                             max_table_count * sizeof(struct acpi_table_desc));
381
382                 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
383                         ACPI_FREE(acpi_gbl_root_table_list.tables);
384                 }
385         }
386
387         acpi_gbl_root_table_list.tables = tables;
388         acpi_gbl_root_table_list.max_table_count +=
389             ACPI_ROOT_TABLE_SIZE_INCREMENT;
390         acpi_gbl_root_table_list.flags |= (u8)ACPI_ROOT_ORIGIN_ALLOCATED;
391
392         return_ACPI_STATUS(AE_OK);
393 }
394
395 /*******************************************************************************
396  *
397  * FUNCTION:    acpi_tb_store_table
398  *
399  * PARAMETERS:  Address             - Table address
400  *              Table               - Table header
401  *              Length              - Table length
402  *              Flags               - flags
403  *
404  * RETURN:      Status and table index.
405  *
406  * DESCRIPTION: Add an ACPI table to the global table list
407  *
408  ******************************************************************************/
409
410 acpi_status
411 acpi_tb_store_table(acpi_physical_address address,
412                     struct acpi_table_header *table,
413                     u32 length, u8 flags, u32 *table_index)
414 {
415         acpi_status status;
416         struct acpi_table_desc *new_table;
417
418         /* Ensure that there is room for the table in the Root Table List */
419
420         if (acpi_gbl_root_table_list.current_table_count >=
421             acpi_gbl_root_table_list.max_table_count) {
422                 status = acpi_tb_resize_root_table_list();
423                 if (ACPI_FAILURE(status)) {
424                         return (status);
425                 }
426         }
427
428         new_table =
429             &acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.
430                                              current_table_count];
431
432         /* Initialize added table */
433
434         new_table->address = address;
435         new_table->pointer = table;
436         new_table->length = length;
437         new_table->owner_id = 0;
438         new_table->flags = flags;
439
440         ACPI_MOVE_32_TO_32(&new_table->signature, table->signature);
441
442         *table_index = acpi_gbl_root_table_list.current_table_count;
443         acpi_gbl_root_table_list.current_table_count++;
444         return (AE_OK);
445 }
446
447 /*******************************************************************************
448  *
449  * FUNCTION:    acpi_tb_delete_table
450  *
451  * PARAMETERS:  table_index         - Table index
452  *
453  * RETURN:      None
454  *
455  * DESCRIPTION: Delete one internal ACPI table
456  *
457  ******************************************************************************/
458
459 void acpi_tb_delete_table(struct acpi_table_desc *table_desc)
460 {
461         /* Table must be mapped or allocated */
462         if (!table_desc->pointer) {
463                 return;
464         }
465         switch (table_desc->flags & ACPI_TABLE_ORIGIN_MASK) {
466         case ACPI_TABLE_ORIGIN_MAPPED:
467                 acpi_os_unmap_memory(table_desc->pointer, table_desc->length);
468                 break;
469         case ACPI_TABLE_ORIGIN_ALLOCATED:
470                 ACPI_FREE(table_desc->pointer);
471                 break;
472
473                 /* Not mapped or allocated, there is nothing we can do */
474
475         default:
476                 return;
477         }
478
479         table_desc->pointer = NULL;
480 }
481
482 /*******************************************************************************
483  *
484  * FUNCTION:    acpi_tb_terminate
485  *
486  * PARAMETERS:  None
487  *
488  * RETURN:      None
489  *
490  * DESCRIPTION: Delete all internal ACPI tables
491  *
492  ******************************************************************************/
493
494 void acpi_tb_terminate(void)
495 {
496         u32 i;
497
498         ACPI_FUNCTION_TRACE(tb_terminate);
499
500         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
501
502         /* Delete the individual tables */
503
504         for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
505                 acpi_tb_delete_table(&acpi_gbl_root_table_list.tables[i]);
506         }
507
508         /*
509          * Delete the root table array if allocated locally. Array cannot be
510          * mapped, so we don't need to check for that flag.
511          */
512         if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
513                 ACPI_FREE(acpi_gbl_root_table_list.tables);
514         }
515
516         acpi_gbl_root_table_list.tables = NULL;
517         acpi_gbl_root_table_list.flags = 0;
518         acpi_gbl_root_table_list.current_table_count = 0;
519
520         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n"));
521         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
522 }
523
524 /*******************************************************************************
525  *
526  * FUNCTION:    acpi_tb_delete_namespace_by_owner
527  *
528  * PARAMETERS:  table_index         - Table index
529  *
530  * RETURN:      Status
531  *
532  * DESCRIPTION: Delete all namespace objects created when this table was loaded.
533  *
534  ******************************************************************************/
535
536 acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index)
537 {
538         acpi_owner_id owner_id;
539         acpi_status status;
540
541         ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner);
542
543         status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
544         if (ACPI_FAILURE(status)) {
545                 return_ACPI_STATUS(status);
546         }
547
548         if (table_index >= acpi_gbl_root_table_list.current_table_count) {
549
550                 /* The table index does not exist */
551
552                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
553                 return_ACPI_STATUS(AE_NOT_EXIST);
554         }
555
556         /* Get the owner ID for this table, used to delete namespace nodes */
557
558         owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id;
559         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
560
561         /*
562          * Need to acquire the namespace writer lock to prevent interference
563          * with any concurrent namespace walks. The interpreter must be
564          * released during the deletion since the acquisition of the deletion
565          * lock may block, and also since the execution of a namespace walk
566          * must be allowed to use the interpreter.
567          */
568         (void)acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
569         status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock);
570
571         acpi_ns_delete_namespace_by_owner(owner_id);
572         if (ACPI_FAILURE(status)) {
573                 return_ACPI_STATUS(status);
574         }
575
576         acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock);
577
578         status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
579         return_ACPI_STATUS(status);
580 }
581
582 /*******************************************************************************
583  *
584  * FUNCTION:    acpi_tb_allocate_owner_id
585  *
586  * PARAMETERS:  table_index         - Table index
587  *
588  * RETURN:      Status
589  *
590  * DESCRIPTION: Allocates owner_id in table_desc
591  *
592  ******************************************************************************/
593
594 acpi_status acpi_tb_allocate_owner_id(u32 table_index)
595 {
596         acpi_status status = AE_BAD_PARAMETER;
597
598         ACPI_FUNCTION_TRACE(tb_allocate_owner_id);
599
600         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
601         if (table_index < acpi_gbl_root_table_list.current_table_count) {
602                 status = acpi_ut_allocate_owner_id
603                     (&(acpi_gbl_root_table_list.tables[table_index].owner_id));
604         }
605
606         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
607         return_ACPI_STATUS(status);
608 }
609
610 /*******************************************************************************
611  *
612  * FUNCTION:    acpi_tb_release_owner_id
613  *
614  * PARAMETERS:  table_index         - Table index
615  *
616  * RETURN:      Status
617  *
618  * DESCRIPTION: Releases owner_id in table_desc
619  *
620  ******************************************************************************/
621
622 acpi_status acpi_tb_release_owner_id(u32 table_index)
623 {
624         acpi_status status = AE_BAD_PARAMETER;
625
626         ACPI_FUNCTION_TRACE(tb_release_owner_id);
627
628         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
629         if (table_index < acpi_gbl_root_table_list.current_table_count) {
630                 acpi_ut_release_owner_id(&
631                                          (acpi_gbl_root_table_list.
632                                           tables[table_index].owner_id));
633                 status = AE_OK;
634         }
635
636         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
637         return_ACPI_STATUS(status);
638 }
639
640 /*******************************************************************************
641  *
642  * FUNCTION:    acpi_tb_get_owner_id
643  *
644  * PARAMETERS:  table_index         - Table index
645  *              owner_id            - Where the table owner_id is returned
646  *
647  * RETURN:      Status
648  *
649  * DESCRIPTION: returns owner_id for the ACPI table
650  *
651  ******************************************************************************/
652
653 acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id *owner_id)
654 {
655         acpi_status status = AE_BAD_PARAMETER;
656
657         ACPI_FUNCTION_TRACE(tb_get_owner_id);
658
659         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
660         if (table_index < acpi_gbl_root_table_list.current_table_count) {
661                 *owner_id =
662                     acpi_gbl_root_table_list.tables[table_index].owner_id;
663                 status = AE_OK;
664         }
665
666         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
667         return_ACPI_STATUS(status);
668 }
669
670 /*******************************************************************************
671  *
672  * FUNCTION:    acpi_tb_is_table_loaded
673  *
674  * PARAMETERS:  table_index         - Table index
675  *
676  * RETURN:      Table Loaded Flag
677  *
678  ******************************************************************************/
679
680 u8 acpi_tb_is_table_loaded(u32 table_index)
681 {
682         u8 is_loaded = FALSE;
683
684         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
685         if (table_index < acpi_gbl_root_table_list.current_table_count) {
686                 is_loaded = (u8)
687                     (acpi_gbl_root_table_list.tables[table_index].flags &
688                      ACPI_TABLE_IS_LOADED);
689         }
690
691         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
692         return (is_loaded);
693 }
694
695 /*******************************************************************************
696  *
697  * FUNCTION:    acpi_tb_set_table_loaded_flag
698  *
699  * PARAMETERS:  table_index         - Table index
700  *              is_loaded           - TRUE if table is loaded, FALSE otherwise
701  *
702  * RETURN:      None
703  *
704  * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
705  *
706  ******************************************************************************/
707
708 void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded)
709 {
710
711         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
712         if (table_index < acpi_gbl_root_table_list.current_table_count) {
713                 if (is_loaded) {
714                         acpi_gbl_root_table_list.tables[table_index].flags |=
715                             ACPI_TABLE_IS_LOADED;
716                 } else {
717                         acpi_gbl_root_table_list.tables[table_index].flags &=
718                             ~ACPI_TABLE_IS_LOADED;
719                 }
720         }
721
722         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
723 }