LXR linux/drivers/acpi/acpica/tbxface.c

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