drivers/acpi/acpica/tbxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbxface - ACPI table-oriented external interfaces
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2018, 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 #define EXPORT_ACPI_INTERFACES
  45
  46 #include <acpi/acpi.h>
  47 #include "accommon.h"
  48 #include "actables.h"
  49
  50 #define _COMPONENT          ACPI_TABLES
  51 ACPI_MODULE_NAME("tbxface")
  52
  53 /*******************************************************************************
  54  *
  55  * FUNCTION:    acpi_allocate_root_table
  56  *
  57  * PARAMETERS:  initial_table_count - Size of initial_table_array, in number of
  58  *                                    struct acpi_table_desc structures
  59  *
  60  * RETURN:      Status
  61  *
  62  * DESCRIPTION: Allocate a root table array. Used by iASL compiler and
  63  *              acpi_initialize_tables.
  64  *
  65  ******************************************************************************/
  66 acpi_status acpi_allocate_root_table(u32 initial_table_count)
  67 {
  68
  69         acpi_gbl_root_table_list.max_table_count = initial_table_count;
  70         acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
  71
  72         return (acpi_tb_resize_root_table_list());
  73 }
  74
  75 /*******************************************************************************
  76  *
  77  * FUNCTION:    acpi_initialize_tables
  78  *
  79  * PARAMETERS:  initial_table_array - Pointer to an array of pre-allocated
  80  *                                    struct acpi_table_desc structures. If NULL, the
  81  *                                    array is dynamically allocated.
  82  *              initial_table_count - Size of initial_table_array, in number of
  83  *                                    struct acpi_table_desc structures
  84  *              allow_resize        - Flag to tell Table Manager if resize of
  85  *                                    pre-allocated array is allowed. Ignored
  86  *                                    if initial_table_array is NULL.
  87  *
  88  * RETURN:      Status
  89  *
  90  * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
  91  *
  92  * NOTE:        Allows static allocation of the initial table array in order
  93  *              to avoid the use of dynamic memory in confined environments
  94  *              such as the kernel boot sequence where it may not be available.
  95  *
  96  *              If the host OS memory managers are initialized, use NULL for
  97  *              initial_table_array, and the table will be dynamically allocated.
  98  *
  99  ******************************************************************************/
 100
 101 acpi_status ACPI_INIT_FUNCTION
 102 acpi_initialize_tables(struct acpi_table_desc *initial_table_array,
 103                        u32 initial_table_count, u8 allow_resize)
 104 {
 105         acpi_physical_address rsdp_address;
 106         acpi_status status;
 107
 108         ACPI_FUNCTION_TRACE(acpi_initialize_tables);
 109
 110         /*
 111          * Setup the Root Table Array and allocate the table array
 112          * if requested
 113          */
 114         if (!initial_table_array) {
 115                 status = acpi_allocate_root_table(initial_table_count);
 116                 if (ACPI_FAILURE(status)) {
 117                         return_ACPI_STATUS(status);
 118                 }
 119         } else {
 120                 /* Root Table Array has been statically allocated by the host */
 121
 122                 memset(initial_table_array, 0,
 123                        (acpi_size)initial_table_count *
 124                        sizeof(struct acpi_table_desc));
 125
 126                 acpi_gbl_root_table_list.tables = initial_table_array;
 127                 acpi_gbl_root_table_list.max_table_count = initial_table_count;
 128                 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
 129                 if (allow_resize) {
 130                         acpi_gbl_root_table_list.flags |=
 131                             ACPI_ROOT_ALLOW_RESIZE;
 132                 }
 133         }
 134
 135         /* Get the address of the RSDP */
 136
 137         rsdp_address = acpi_os_get_root_pointer();
 138         if (!rsdp_address) {
 139                 return_ACPI_STATUS(AE_NOT_FOUND);
 140         }
 141
 142         /*
 143          * Get the root table (RSDT or XSDT) and extract all entries to the local
 144          * Root Table Array. This array contains the information of the RSDT/XSDT
 145          * in a common, more useable format.
 146          */
 147         status = acpi_tb_parse_root_table(rsdp_address);
 148         return_ACPI_STATUS(status);
 149 }
 150
 151 ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_tables)
 152
 153 /*******************************************************************************
 154  *
 155  * FUNCTION:    acpi_reallocate_root_table
 156  *
 157  * PARAMETERS:  None
 158  *
 159  * RETURN:      Status
 160  *
 161  * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
 162  *              root list from the previously provided scratch area. Should
 163  *              be called once dynamic memory allocation is available in the
 164  *              kernel.
 165  *
 166  ******************************************************************************/
 167 acpi_status ACPI_INIT_FUNCTION acpi_reallocate_root_table(void)
 168 {
 169         acpi_status status;
 170         struct acpi_table_desc *table_desc;
 171         u32 i, j;
 172
 173         ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
 174
 175         /*
 176          * If there are tables unverified, it is required to reallocate the
 177          * root table list to clean up invalid table entries. Otherwise only
 178          * reallocate the root table list if the host provided a static buffer
 179          * for the table array in the call to acpi_initialize_tables().
 180          */
 181         if ((acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) &&
 182             acpi_gbl_enable_table_validation) {
 183                 return_ACPI_STATUS(AE_SUPPORT);
 184         }
 185
 186         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 187
 188         /*
 189          * Ensure OS early boot logic, which is required by some hosts. If the
 190          * table state is reported to be wrong, developers should fix the
 191          * issue by invoking acpi_put_table() for the reported table during the
 192          * early stage.
 193          */
 194         for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
 195                 table_desc = &acpi_gbl_root_table_list.tables[i];
 196                 if (table_desc->pointer) {
 197                         ACPI_ERROR((AE_INFO,
 198                                     "Table [%4.4s] is not invalidated during early boot stage",
 199                                     table_desc->signature.ascii));
 200                 }
 201         }
 202
 203         if (!acpi_gbl_enable_table_validation) {
 204                 /*
 205                  * Now it's safe to do full table validation. We can do deferred
 206                  * table initilization here once the flag is set.
 207                  */
 208                 acpi_gbl_enable_table_validation = TRUE;
 209                 for (i = 0; i < acpi_gbl_root_table_list.current_table_count;
 210                      ++i) {
 211                         table_desc = &acpi_gbl_root_table_list.tables[i];
 212                         if (!(table_desc->flags & ACPI_TABLE_IS_VERIFIED)) {
 213                                 status =
 214                                     acpi_tb_verify_temp_table(table_desc, NULL,
 215                                                               &j);
 216                                 if (ACPI_FAILURE(status)) {
 217                                         acpi_tb_uninstall_table(table_desc);
 218                                 }
 219                         }
 220                 }
 221         }
 222
 223         acpi_gbl_root_table_list.flags |= ACPI_ROOT_ALLOW_RESIZE;
 224         status = acpi_tb_resize_root_table_list();
 225         acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
 226
 227         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 228         return_ACPI_STATUS(status);
 229 }
 230
 231 ACPI_EXPORT_SYMBOL_INIT(acpi_reallocate_root_table)
 232
 233 /*******************************************************************************
 234  *
 235  * FUNCTION:    acpi_get_table_header
 236  *
 237  * PARAMETERS:  signature           - ACPI signature of needed table
 238  *              instance            - Which instance (for SSDTs)
 239  *              out_table_header    - The pointer to the table header to fill
 240  *
 241  * RETURN:      Status and pointer to mapped table header
 242  *
 243  * DESCRIPTION: Finds an ACPI table header.
 244  *
 245  * NOTE:        Caller is responsible in unmapping the header with
 246  *              acpi_os_unmap_memory
 247  *
 248  ******************************************************************************/
 249 acpi_status
 250 acpi_get_table_header(char *signature,
 251                       u32 instance, struct acpi_table_header *out_table_header)
 252 {
 253         u32 i;
 254         u32 j;
 255         struct acpi_table_header *header;
 256
 257         /* Parameter validation */
 258
 259         if (!signature || !out_table_header) {
 260                 return (AE_BAD_PARAMETER);
 261         }
 262
 263         /* Walk the root table list */
 264
 265         for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
 266              i++) {
 267                 if (!ACPI_COMPARE_NAME
 268                     (&(acpi_gbl_root_table_list.tables[i].signature),
 269                      signature)) {
 270                         continue;
 271                 }
 272
 273                 if (++j < instance) {
 274                         continue;
 275                 }
 276
 277                 if (!acpi_gbl_root_table_list.tables[i].pointer) {
 278                         if ((acpi_gbl_root_table_list.tables[i].flags &
 279                              ACPI_TABLE_ORIGIN_MASK) ==
 280                             ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL) {
 281                                 header =
 282                                     acpi_os_map_memory(acpi_gbl_root_table_list.
 283                                                        tables[i].address,
 284                                                        sizeof(struct
 285                                                               acpi_table_header));
 286                                 if (!header) {
 287                                         return (AE_NO_MEMORY);
 288                                 }
 289
 290                                 memcpy(out_table_header, header,
 291                                        sizeof(struct acpi_table_header));
 292                                 acpi_os_unmap_memory(header,
 293                                                      sizeof(struct
 294                                                             acpi_table_header));
 295                         } else {
 296                                 return (AE_NOT_FOUND);
 297                         }
 298                 } else {
 299                         memcpy(out_table_header,
 300                                acpi_gbl_root_table_list.tables[i].pointer,
 301                                sizeof(struct acpi_table_header));
 302                 }
 303                 return (AE_OK);
 304         }
 305
 306         return (AE_NOT_FOUND);
 307 }
 308
 309 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
 310
 311 /*******************************************************************************
 312  *
 313  * FUNCTION:    acpi_get_table
 314  *
 315  * PARAMETERS:  signature           - ACPI signature of needed table
 316  *              instance            - Which instance (for SSDTs)
 317  *              out_table           - Where the pointer to the table is returned
 318  *
 319  * RETURN:      Status and pointer to the requested table
 320  *
 321  * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
 322  *              RSDT/XSDT.
 323  *              Note that an early stage acpi_get_table() call must be paired
 324  *              with an early stage acpi_put_table() call. otherwise the table
 325  *              pointer mapped by the early stage mapping implementation may be
 326  *              erroneously unmapped by the late stage unmapping implementation
 327  *              in an acpi_put_table() invoked during the late stage.
 328  *
 329  ******************************************************************************/
 330 acpi_status
 331 acpi_get_table(char *signature,
 332                u32 instance, struct acpi_table_header ** out_table)
 333 {
 334         u32 i;
 335         u32 j;
 336         acpi_status status = AE_NOT_FOUND;
 337         struct acpi_table_desc *table_desc;
 338
 339         /* Parameter validation */
 340
 341         if (!signature || !out_table) {
 342                 return (AE_BAD_PARAMETER);
 343         }
 344
 345         /*
 346          * Note that the following line is required by some OSPMs, they only
 347          * check if the returned table is NULL instead of the returned status
 348          * to determined if this function is succeeded.
 349          */
 350         *out_table = NULL;
 351
 352         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 353
 354         /* Walk the root table list */
 355
 356         for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
 357              i++) {
 358                 table_desc = &acpi_gbl_root_table_list.tables[i];
 359
 360                 if (!ACPI_COMPARE_NAME(&table_desc->signature, signature)) {
 361                         continue;
 362                 }
 363
 364                 if (++j < instance) {
 365                         continue;
 366                 }
 367
 368                 status = acpi_tb_get_table(table_desc, out_table);
 369                 break;
 370         }
 371
 372         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 373         return (status);
 374 }
 375
 376 ACPI_EXPORT_SYMBOL(acpi_get_table)
 377
 378 /*******************************************************************************
 379  *
 380  * FUNCTION:    acpi_put_table
 381  *
 382  * PARAMETERS:  table               - The pointer to the table
 383  *
 384  * RETURN:      None
 385  *
 386  * DESCRIPTION: Release a table returned by acpi_get_table() and its clones.
 387  *              Note that it is not safe if this function was invoked after an
 388  *              uninstallation happened to the original table descriptor.
 389  *              Currently there is no OSPMs' requirement to handle such
 390  *              situations.
 391  *
 392  ******************************************************************************/
 393 void acpi_put_table(struct acpi_table_header *table)
 394 {
 395         u32 i;
 396         struct acpi_table_desc *table_desc;
 397
 398         ACPI_FUNCTION_TRACE(acpi_put_table);
 399
 400         if (!table) {
 401                 return_VOID;
 402         }
 403
 404         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 405
 406         /* Walk the root table list */
 407
 408         for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
 409                 table_desc = &acpi_gbl_root_table_list.tables[i];
 410
 411                 if (table_desc->pointer != table) {
 412                         continue;
 413                 }
 414
 415                 acpi_tb_put_table(table_desc);
 416                 break;
 417         }
 418
 419         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 420         return_VOID;
 421 }
 422
 423 ACPI_EXPORT_SYMBOL(acpi_put_table)
 424
 425 /*******************************************************************************
 426  *
 427  * FUNCTION:    acpi_get_table_by_index
 428  *
 429  * PARAMETERS:  table_index         - Table index
 430  *              out_table           - Where the pointer to the table is returned
 431  *
 432  * RETURN:      Status and pointer to the requested table
 433  *
 434  * DESCRIPTION: Obtain a table by an index into the global table list. Used
 435  *              internally also.
 436  *
 437  ******************************************************************************/
 438 acpi_status
 439 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **out_table)
 440 {
 441         acpi_status status;
 442
 443         ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
 444
 445         /* Parameter validation */
 446
 447         if (!out_table) {
 448                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 449         }
 450
 451         /*
 452          * Note that the following line is required by some OSPMs, they only
 453          * check if the returned table is NULL instead of the returned status
 454          * to determined if this function is succeeded.
 455          */
 456         *out_table = NULL;
 457
 458         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 459
 460         /* Validate index */
 461
 462         if (table_index >= acpi_gbl_root_table_list.current_table_count) {
 463                 status = AE_BAD_PARAMETER;
 464                 goto unlock_and_exit;
 465         }
 466
 467         status =
 468             acpi_tb_get_table(&acpi_gbl_root_table_list.tables[table_index],
 469                               out_table);
 470
 471 unlock_and_exit:
 472         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
 473         return_ACPI_STATUS(status);
 474 }
 475
 476 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
 477
 478 /*******************************************************************************
 479  *
 480  * FUNCTION:    acpi_install_table_handler
 481  *
 482  * PARAMETERS:  handler         - Table event handler
 483  *              context         - Value passed to the handler on each event
 484  *
 485  * RETURN:      Status
 486  *
 487  * DESCRIPTION: Install a global table event handler.
 488  *
 489  ******************************************************************************/
 490 acpi_status
 491 acpi_install_table_handler(acpi_table_handler handler, void *context)
 492 {
 493         acpi_status status;
 494
 495         ACPI_FUNCTION_TRACE(acpi_install_table_handler);
 496
 497         if (!handler) {
 498                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 499         }
 500
 501         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
 502         if (ACPI_FAILURE(status)) {
 503                 return_ACPI_STATUS(status);
 504         }
 505
 506         /* Don't allow more than one handler */
 507
 508         if (acpi_gbl_table_handler) {
 509                 status = AE_ALREADY_EXISTS;
 510                 goto cleanup;
 511         }
 512
 513         /* Install the handler */
 514
 515         acpi_gbl_table_handler = handler;
 516         acpi_gbl_table_handler_context = context;
 517
 518 cleanup:
 519         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
 520         return_ACPI_STATUS(status);
 521 }
 522
 523 ACPI_EXPORT_SYMBOL(acpi_install_table_handler)
 524
 525 /*******************************************************************************
 526  *
 527  * FUNCTION:    acpi_remove_table_handler
 528  *
 529  * PARAMETERS:  handler         - Table event handler that was installed
 530  *                                previously.
 531  *
 532  * RETURN:      Status
 533  *
 534  * DESCRIPTION: Remove a table event handler
 535  *
 536  ******************************************************************************/
 537 acpi_status acpi_remove_table_handler(acpi_table_handler handler)
 538 {
 539         acpi_status status;
 540
 541         ACPI_FUNCTION_TRACE(acpi_remove_table_handler);
 542
 543         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
 544         if (ACPI_FAILURE(status)) {
 545                 return_ACPI_STATUS(status);
 546         }
 547
 548         /* Make sure that the installed handler is the same */
 549
 550         if (!handler || handler != acpi_gbl_table_handler) {
 551                 status = AE_BAD_PARAMETER;
 552                 goto cleanup;
 553         }
 554
 555         /* Remove the handler */
 556
 557         acpi_gbl_table_handler = NULL;
 558
 559 cleanup:
 560         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
 561         return_ACPI_STATUS(status);
 562 }
 563
 564 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler)