git.oblomov.eu Git - linux-2.6/blob - drivers/acpi/tables/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 - 2006, R. Byron Moore
  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 <acpi/acnamesp.h>
  47 #include <acpi/actables.h>
  48
  49 #define _COMPONENT          ACPI_TABLES
  50 ACPI_MODULE_NAME("tbxface")
  51
  52 /* Local prototypes */
  53 static acpi_status acpi_tb_load_namespace(void);
  54
  55 /*******************************************************************************
  56  *
  57  * FUNCTION:    acpi_initialize_tables
  58  *
  59  * PARAMETERS:  initial_table_array - Pointer to an array of pre-allocated
  60  *                                    struct acpi_table_desc structures. If NULL, the
  61  *                                    array is dynamically allocated.
  62  *              initial_table_count - Size of initial_table_array, in number of
  63  *                                    struct acpi_table_desc structures
  64  *              allow_realloc       - Flag to tell Table Manager if resize of
  65  *                                    pre-allocated array is allowed. Ignored
  66  *                                    if initial_table_array is NULL.
  67  *
  68  * RETURN:      Status
  69  *
  70  * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
  71  *
  72  * NOTE:        Allows static allocation of the initial table array in order
  73  *              to avoid the use of dynamic memory in confined environments
  74  *              such as the kernel boot sequence where it may not be available.
  75  *
  76  *              If the host OS memory managers are initialized, use NULL for
  77  *              initial_table_array, and the table will be dynamically allocated.
  78  *
  79  ******************************************************************************/
  80
  81 acpi_status
  82 acpi_initialize_tables(struct acpi_table_desc *initial_table_array,
  83                        u32 initial_table_count, u8 allow_resize)
  84 {
  85         acpi_physical_address rsdp_address;
  86         acpi_status status;
  87
  88         ACPI_FUNCTION_TRACE(acpi_initialize_tables);
  89
  90         /*
  91          * Set up the Root Table Array
  92          * Allocate the table array if requested
  93          */
  94         if (!initial_table_array) {
  95                 acpi_gbl_root_table_list.size = initial_table_count;
  96                 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
  97
  98                 status = acpi_tb_resize_root_table_list();
  99                 if (ACPI_FAILURE(status)) {
 100                         return_ACPI_STATUS(status);
 101                 }
 102         } else {
 103                 /* Root Table Array has been statically allocated by the host */
 104
 105                 ACPI_MEMSET(initial_table_array, 0,
 106                             initial_table_count *
 107                             sizeof(struct acpi_table_desc));
 108
 109                 acpi_gbl_root_table_list.tables = initial_table_array;
 110                 acpi_gbl_root_table_list.size = initial_table_count;
 111                 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
 112                 if (allow_resize) {
 113                         acpi_gbl_root_table_list.flags |=
 114                             ACPI_ROOT_ALLOW_RESIZE;
 115                 }
 116         }
 117
 118         /* Get the address of the RSDP */
 119
 120         rsdp_address = acpi_os_get_root_pointer();
 121         if (!rsdp_address) {
 122                 return_ACPI_STATUS(AE_NOT_FOUND);
 123         }
 124
 125         /*
 126          * Get the root table (RSDT or XSDT) and extract all entries to the local
 127          * Root Table Array. This array contains the information of the RSDT/XSDT
 128          * in a common, more useable format.
 129          */
 130         status =
 131             acpi_tb_parse_root_table(rsdp_address, ACPI_TABLE_ORIGIN_MAPPED);
 132         return_ACPI_STATUS(status);
 133 }
 134
 135 ACPI_EXPORT_SYMBOL(acpi_initialize_tables)
 136
 137 /*******************************************************************************
 138  *
 139  * FUNCTION:    acpi_reallocate_root_table
 140  *
 141  * PARAMETERS:  None
 142  *
 143  * RETURN:      Status
 144  *
 145  * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
 146  *              root list from the previously provided scratch area. Should
 147  *              be called once dynamic memory allocation is available in the
 148  *              kernel
 149  *
 150  ******************************************************************************/
 151 acpi_status acpi_reallocate_root_table(void)
 152 {
 153         struct acpi_table_desc *tables;
 154         acpi_size new_size;
 155
 156         ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
 157
 158         /*
 159          * Only reallocate the root table if the host provided a static buffer
 160          * for the table array in the call to acpi_initialize_tables.
 161          */
 162         if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
 163                 return_ACPI_STATUS(AE_SUPPORT);
 164         }
 165
 166         new_size =
 167             (acpi_gbl_root_table_list.count +
 168              ACPI_ROOT_TABLE_SIZE_INCREMENT) * sizeof(struct acpi_table_desc);
 169
 170         /* Create new array and copy the old array */
 171
 172         tables = ACPI_ALLOCATE_ZEROED(new_size);
 173         if (!tables) {
 174                 return_ACPI_STATUS(AE_NO_MEMORY);
 175         }
 176
 177         ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, new_size);
 178
 179         acpi_gbl_root_table_list.size = acpi_gbl_root_table_list.count;
 180         acpi_gbl_root_table_list.tables = tables;
 181         acpi_gbl_root_table_list.flags =
 182             ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE;
 183
 184         return_ACPI_STATUS(AE_OK);
 185 }
 186 /*******************************************************************************
 187  *
 188  * FUNCTION:    acpi_load_table
 189  *
 190  * PARAMETERS:  table_ptr       - pointer to a buffer containing the entire
 191  *                                table to be loaded
 192  *
 193  * RETURN:      Status
 194  *
 195  * DESCRIPTION: This function is called to load a table from the caller's
 196  *              buffer. The buffer must contain an entire ACPI Table including
 197  *              a valid header. The header fields will be verified, and if it
 198  *              is determined that the table is invalid, the call will fail.
 199  *
 200  ******************************************************************************/
 201 acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
 202 {
 203         acpi_status status;
 204         acpi_native_uint table_index;
 205
 206         /*
 207          * Install the new table into the local data structures
 208          */
 209         status = acpi_tb_add_table(table_ptr, &table_index);
 210         if (ACPI_FAILURE(status)) {
 211                 return_ACPI_STATUS(status);
 212         }
 213         status = acpi_ns_load_table(table_index, acpi_gbl_root_node);
 214         return_ACPI_STATUS(status);
 215 }
 216
 217 ACPI_EXPORT_SYMBOL(acpi_load_table)
 218
 219 /******************************************************************************
 220  *
 221  * FUNCTION:    acpi_get_table_header
 222  *
 223  * PARAMETERS:  Signature           - ACPI signature of needed table
 224  *              Instance            - Which instance (for SSDTs)
 225  *              out_table_header    - Where the pointer to the table header
 226  *                                    is returned
 227  *
 228  * RETURN:      Status and pointer to mapped table header
 229  *
 230  * DESCRIPTION: Finds an ACPI table header.
 231  *
 232  * NOTE:        Caller is responsible in unmapping the header with
 233  *              acpi_os_unmap_memory
 234  *
 235  *****************************************************************************/
 236 acpi_status
 237 acpi_get_table_header(char *signature,
 238                       acpi_native_uint instance,
 239                       struct acpi_table_header **out_table_header)
 240 {
 241         acpi_native_uint i;
 242         acpi_native_uint j;
 243
 244         /* Parameter validation */
 245
 246         if (!signature || !out_table_header) {
 247                 return (AE_BAD_PARAMETER);
 248         }
 249
 250         /*
 251          * Walk the root table list
 252          */
 253         for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
 254                 if (!ACPI_COMPARE_NAME
 255                     (&(acpi_gbl_root_table_list.tables[i].signature),
 256                      signature)) {
 257                         continue;
 258                 }
 259
 260                 if (++j < instance) {
 261                         continue;
 262                 }
 263
 264                 *out_table_header =
 265                     acpi_tb_map(acpi_gbl_root_table_list.tables[i].address,
 266                                 (u32) sizeof(struct acpi_table_header),
 267                                 acpi_gbl_root_table_list.tables[i].
 268                                 flags & ACPI_TABLE_ORIGIN_MASK);
 269
 270                 if (!(*out_table_header)) {
 271                         return (AE_NO_MEMORY);
 272                 }
 273
 274                 return (AE_OK);
 275         }
 276
 277         return (AE_NOT_FOUND);
 278 }
 279
 280 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
 281
 282
 283 /******************************************************************************
 284  *
 285  * FUNCTION:    acpi_unload_table_id
 286  *
 287  * PARAMETERS:  id            - Owner ID of the table to be removed.
 288  *
 289  * RETURN:      Status
 290  *
 291  * DESCRIPTION: This routine is used to force the unload of a table (by id)
 292  *
 293  ******************************************************************************/
 294 acpi_status acpi_unload_table_id(acpi_owner_id id)
 295 {
 296         int i;
 297         acpi_status status = AE_NOT_EXIST;
 298
 299         ACPI_FUNCTION_TRACE(acpi_unload_table);
 300
 301         /* Find table from the requested type list */
 302         for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
 303                 if (id != acpi_gbl_root_table_list.tables[i].owner_id) {
 304                         continue;
 305                 }
 306                 /*
 307                 * Delete all namespace objects owned by this table. Note that these
 308                 * objects can appear anywhere in the namespace by virtue of the AML
 309                 * "Scope" operator. Thus, we need to track ownership by an ID, not
 310                 * simply a position within the hierarchy
 311                 */
 312                 acpi_tb_delete_namespace_by_owner(i);
 313                 acpi_tb_release_owner_id(i);
 314                 acpi_tb_set_table_loaded_flag(i, FALSE);
 315         }
 316         return_ACPI_STATUS(status);
 317 }
 318
 319 ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
 320
 321 /*******************************************************************************
 322  *
 323  * FUNCTION:    acpi_get_table
 324  *
 325  * PARAMETERS:  Signature           - ACPI signature of needed table
 326  *              Instance            - Which instance (for SSDTs)
 327  *              out_table           - Where the pointer to the table is returned
 328  *
 329  * RETURN:      Status and pointer to table
 330  *
 331  * DESCRIPTION: Finds and verifies an ACPI table.
 332  *
 333  *****************************************************************************/
 334 acpi_status
 335 acpi_get_table(char *signature,
 336                acpi_native_uint instance, struct acpi_table_header ** out_table)
 337 {
 338         acpi_native_uint i;
 339         acpi_native_uint j;
 340         acpi_status status;
 341
 342         /* Parameter validation */
 343
 344         if (!signature || !out_table) {
 345                 return (AE_BAD_PARAMETER);
 346         }
 347
 348         /*
 349          * Walk the root table list
 350          */
 351         for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
 352                 if (!ACPI_COMPARE_NAME
 353                     (&(acpi_gbl_root_table_list.tables[i].signature),
 354                      signature)) {
 355                         continue;
 356                 }
 357
 358                 if (++j < instance) {
 359                         continue;
 360                 }
 361
 362                 status =
 363                     acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]);
 364                 if (ACPI_SUCCESS(status)) {
 365                         *out_table = acpi_gbl_root_table_list.tables[i].pointer;
 366                 }
 367
 368                 return (status);
 369         }
 370
 371         return (AE_NOT_FOUND);
 372 }
 373
 374 ACPI_EXPORT_SYMBOL(acpi_get_table)
 375
 376 /*******************************************************************************
 377  *
 378  * FUNCTION:    acpi_get_table_by_index
 379  *
 380  * PARAMETERS:  table_index         - Table index
 381  *              Table               - Where the pointer to the table is returned
 382  *
 383  * RETURN:      Status and pointer to the table
 384  *
 385  * DESCRIPTION: Obtain a table by an index into the global table list.
 386  *
 387  ******************************************************************************/
 388 acpi_status
 389 acpi_get_table_by_index(acpi_native_uint table_index,
 390                         struct acpi_table_header ** table)
 391 {
 392         acpi_status status;
 393
 394         ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
 395
 396         /* Parameter validation */
 397
 398         if (!table) {
 399                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 400         }
 401
 402         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 403
 404         /* Validate index */
 405
 406         if (table_index >= acpi_gbl_root_table_list.count) {
 407                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 408                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 409         }
 410
 411         if (!acpi_gbl_root_table_list.tables[table_index].pointer) {
 412
 413                 /* Table is not mapped, map it */
 414
 415                 status =
 416                     acpi_tb_verify_table(&acpi_gbl_root_table_list.
 417                                          tables[table_index]);
 418                 if (ACPI_FAILURE(status)) {
 419                         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 420                         return_ACPI_STATUS(status);
 421                 }
 422         }
 423
 424         *table = acpi_gbl_root_table_list.tables[table_index].pointer;
 425         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 426         return_ACPI_STATUS(AE_OK);
 427 }
 428
 429 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
 430
 431 /*******************************************************************************
 432  *
 433  * FUNCTION:    acpi_tb_load_namespace
 434  *
 435  * PARAMETERS:  None
 436  *
 437  * RETURN:      Status
 438  *
 439  * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in
 440  *              the RSDT/XSDT.
 441  *
 442  ******************************************************************************/
 443 static acpi_status acpi_tb_load_namespace(void)
 444 {
 445         acpi_status status;
 446         struct acpi_table_header *table;
 447         acpi_native_uint i;
 448
 449         ACPI_FUNCTION_TRACE(tb_load_namespace);
 450
 451         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 452
 453         /*
 454          * Load the namespace. The DSDT is required, but any SSDT and PSDT tables
 455          * are optional.
 456          */
 457         if (!acpi_gbl_root_table_list.count ||
 458             !ACPI_COMPARE_NAME(&
 459                                (acpi_gbl_root_table_list.
 460                                 tables[ACPI_TABLE_INDEX_DSDT].signature),
 461                                ACPI_SIG_DSDT)
 462             ||
 463             ACPI_FAILURE(acpi_tb_verify_table
 464                          (&acpi_gbl_root_table_list.
 465                           tables[ACPI_TABLE_INDEX_DSDT]))) {
 466                 status = AE_NO_ACPI_TABLES;
 467                 goto unlock_and_exit;
 468         }
 469
 470         /*
 471          * Find DSDT table
 472          */
 473         status =
 474             acpi_os_table_override(acpi_gbl_root_table_list.
 475                                    tables[ACPI_TABLE_INDEX_DSDT].pointer,
 476                                    &table);
 477         if (ACPI_SUCCESS(status) && table) {
 478                 /*
 479                  * DSDT table has been found
 480                  */
 481                 acpi_tb_delete_table(ACPI_TABLE_INDEX_DSDT);
 482                 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].pointer =
 483                     table;
 484                 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].length =
 485                     table->length;
 486                 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].flags =
 487                     ACPI_TABLE_ORIGIN_UNKNOWN;
 488
 489                 ACPI_INFO((AE_INFO, "Table DSDT replaced by host OS"));
 490                 acpi_tb_print_table_header(0, table);
 491         }
 492
 493         status =
 494             acpi_tb_verify_table(&acpi_gbl_root_table_list.
 495                                  tables[ACPI_TABLE_INDEX_DSDT]);
 496         if (ACPI_FAILURE(status)) {
 497
 498                 /* A valid DSDT is required */
 499
 500                 status = AE_NO_ACPI_TABLES;
 501                 goto unlock_and_exit;
 502         }
 503
 504         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 505
 506         /*
 507          * Load and parse tables.
 508          */
 509         status = acpi_ns_load_table(ACPI_TABLE_INDEX_DSDT, acpi_gbl_root_node);
 510         if (ACPI_FAILURE(status)) {
 511                 return_ACPI_STATUS(status);
 512         }
 513
 514         /*
 515          * Load any SSDT or PSDT tables. Note: Loop leaves tables locked
 516          */
 517         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 518         for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
 519                 if ((!ACPI_COMPARE_NAME
 520                      (&(acpi_gbl_root_table_list.tables[i].signature),
 521                       ACPI_SIG_SSDT)
 522                      &&
 523                      !ACPI_COMPARE_NAME(&
 524                                         (acpi_gbl_root_table_list.tables[i].
 525                                          signature), ACPI_SIG_PSDT))
 526                     ||
 527                     ACPI_FAILURE(acpi_tb_verify_table
 528                                  (&acpi_gbl_root_table_list.tables[i]))) {
 529                         continue;
 530                 }
 531
 532                 /* Ignore errors while loading tables, get as many as possible */
 533
 534                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 535                 (void)acpi_ns_load_table(i, acpi_gbl_root_node);
 536                 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 537         }
 538
 539         ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
 540
 541       unlock_and_exit:
 542         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 543         return_ACPI_STATUS(status);
 544 }
 545
 546 /*******************************************************************************
 547  *
 548  * FUNCTION:    acpi_load_tables
 549  *
 550  * PARAMETERS:  None
 551  *
 552  * RETURN:      Status
 553  *
 554  * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT
 555  *
 556  ******************************************************************************/
 557
 558 acpi_status acpi_load_tables(void)
 559 {
 560         acpi_status status;
 561
 562         ACPI_FUNCTION_TRACE(acpi_load_tables);
 563
 564         /*
 565          * Load the namespace from the tables
 566          */
 567         status = acpi_tb_load_namespace();
 568         if (ACPI_FAILURE(status)) {
 569                 ACPI_EXCEPTION((AE_INFO, status,
 570                                 "While loading namespace from ACPI tables"));
 571         }
 572
 573         return_ACPI_STATUS(status);
 574 }
 575
 576 ACPI_EXPORT_SYMBOL(acpi_load_tables)