drivers/acpi/tables/tbget.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbget - ACPI Table get* routines
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2006, R. Byron Moore
   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 <acpi/actables.h>
  46
  47 #define _COMPONENT          ACPI_TABLES
  48 ACPI_MODULE_NAME("tbget")
  49
  50 /* Local prototypes */
  51 static acpi_status
  52 acpi_tb_get_this_table(struct acpi_pointer *address,
  53                        struct acpi_table_header *header,
  54                        struct acpi_table_desc *table_info);
  55
  56 static acpi_status
  57 acpi_tb_table_override(struct acpi_table_header *header,
  58                        struct acpi_table_desc *table_info);
  59
  60 /*******************************************************************************
  61  *
  62  * FUNCTION:    acpi_tb_get_table
  63  *
  64  * PARAMETERS:  Address             - Address of table to retrieve.  Can be
  65  *                                    Logical or Physical
  66  *              table_info          - Where table info is returned
  67  *
  68  * RETURN:      None
  69  *
  70  * DESCRIPTION: Get entire table of unknown size.
  71  *
  72  ******************************************************************************/
  73
  74 acpi_status
  75 acpi_tb_get_table(struct acpi_pointer *address,
  76                   struct acpi_table_desc *table_info)
  77 {
  78         acpi_status status;
  79         struct acpi_table_header header;
  80
  81         ACPI_FUNCTION_TRACE("tb_get_table");
  82
  83         /* Get the header in order to get signature and table size */
  84
  85         status = acpi_tb_get_table_header(address, &header);
  86         if (ACPI_FAILURE(status)) {
  87                 return_ACPI_STATUS(status);
  88         }
  89
  90         /* Get the entire table */
  91
  92         status = acpi_tb_get_table_body(address, &header, table_info);
  93         if (ACPI_FAILURE(status)) {
  94                 ACPI_EXCEPTION((AE_INFO, status,
  95                                 "Could not get ACPI table (size %X)",
  96                                 header.length));
  97                 return_ACPI_STATUS(status);
  98         }
  99
 100         return_ACPI_STATUS(AE_OK);
 101 }
 102
 103 /*******************************************************************************
 104  *
 105  * FUNCTION:    acpi_tb_get_table_header
 106  *
 107  * PARAMETERS:  Address             - Address of table to retrieve.  Can be
 108  *                                    Logical or Physical
 109  *              return_header       - Where the table header is returned
 110  *
 111  * RETURN:      Status
 112  *
 113  * DESCRIPTION: Get an ACPI table header.  Works in both physical or virtual
 114  *              addressing mode.  Works with both physical or logical pointers.
 115  *              Table is either copied or mapped, depending on the pointer
 116  *              type and mode of the processor.
 117  *
 118  ******************************************************************************/
 119
 120 acpi_status
 121 acpi_tb_get_table_header(struct acpi_pointer *address,
 122                          struct acpi_table_header *return_header)
 123 {
 124         acpi_status status = AE_OK;
 125         struct acpi_table_header *header = NULL;
 126
 127         ACPI_FUNCTION_TRACE("tb_get_table_header");
 128
 129         /*
 130          * Flags contains the current processor mode (Virtual or Physical
 131          * addressing) The pointer_type is either Logical or Physical
 132          */
 133         switch (address->pointer_type) {
 134         case ACPI_PHYSMODE_PHYSPTR:
 135         case ACPI_LOGMODE_LOGPTR:
 136
 137                 /* Pointer matches processor mode, copy the header */
 138
 139                 ACPI_MEMCPY(return_header, address->pointer.logical,
 140                             sizeof(struct acpi_table_header));
 141                 break;
 142
 143         case ACPI_LOGMODE_PHYSPTR:
 144
 145                 /* Create a logical address for the physical pointer */
 146
 147                 status = acpi_os_map_memory(address->pointer.physical,
 148                                             sizeof(struct acpi_table_header),
 149                                             (void *)&header);
 150                 if (ACPI_FAILURE(status)) {
 151                         ACPI_ERROR((AE_INFO,
 152                                     "Could not map memory at %8.8X%8.8X for table header",
 153                                     ACPI_FORMAT_UINT64(address->pointer.
 154                                                        physical)));
 155                         return_ACPI_STATUS(status);
 156                 }
 157
 158                 /* Copy header and delete mapping */
 159
 160                 ACPI_MEMCPY(return_header, header,
 161                             sizeof(struct acpi_table_header));
 162                 acpi_os_unmap_memory(header, sizeof(struct acpi_table_header));
 163                 break;
 164
 165         default:
 166
 167                 ACPI_ERROR((AE_INFO, "Invalid address flags %X",
 168                             address->pointer_type));
 169                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 170         }
 171
 172         ACPI_DEBUG_PRINT((ACPI_DB_TABLES, "Table Signature: [%4.4s]\n",
 173                           return_header->signature));
 174
 175         return_ACPI_STATUS(AE_OK);
 176 }
 177
 178 /*******************************************************************************
 179  *
 180  * FUNCTION:    acpi_tb_get_table_body
 181  *
 182  * PARAMETERS:  Address             - Address of table to retrieve.  Can be
 183  *                                    Logical or Physical
 184  *              Header              - Header of the table to retrieve
 185  *              table_info          - Where the table info is returned
 186  *
 187  * RETURN:      Status
 188  *
 189  * DESCRIPTION: Get an entire ACPI table with support to allow the host OS to
 190  *              replace the table with a newer version (table override.)
 191  *              Works in both physical or virtual
 192  *              addressing mode.  Works with both physical or logical pointers.
 193  *              Table is either copied or mapped, depending on the pointer
 194  *              type and mode of the processor.
 195  *
 196  ******************************************************************************/
 197
 198 acpi_status
 199 acpi_tb_get_table_body(struct acpi_pointer *address,
 200                        struct acpi_table_header *header,
 201                        struct acpi_table_desc *table_info)
 202 {
 203         acpi_status status;
 204
 205         ACPI_FUNCTION_TRACE("tb_get_table_body");
 206
 207         if (!table_info || !address) {
 208                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 209         }
 210
 211         /* Attempt table override. */
 212
 213         status = acpi_tb_table_override(header, table_info);
 214         if (ACPI_SUCCESS(status)) {
 215
 216                 /* Table was overridden by the host OS */
 217
 218                 return_ACPI_STATUS(status);
 219         }
 220
 221         /* No override, get the original table */
 222
 223         status = acpi_tb_get_this_table(address, header, table_info);
 224         return_ACPI_STATUS(status);
 225 }
 226
 227 /*******************************************************************************
 228  *
 229  * FUNCTION:    acpi_tb_table_override
 230  *
 231  * PARAMETERS:  Header              - Pointer to table header
 232  *              table_info          - Return info if table is overridden
 233  *
 234  * RETURN:      None
 235  *
 236  * DESCRIPTION: Attempts override of current table with a new one if provided
 237  *              by the host OS.
 238  *
 239  ******************************************************************************/
 240
 241 static acpi_status
 242 acpi_tb_table_override(struct acpi_table_header *header,
 243                        struct acpi_table_desc *table_info)
 244 {
 245         struct acpi_table_header *new_table;
 246         acpi_status status;
 247         struct acpi_pointer address;
 248
 249         ACPI_FUNCTION_TRACE("tb_table_override");
 250
 251         /*
 252          * The OSL will examine the header and decide whether to override this
 253          * table.  If it decides to override, a table will be returned in new_table,
 254          * which we will then copy.
 255          */
 256         status = acpi_os_table_override(header, &new_table);
 257         if (ACPI_FAILURE(status)) {
 258
 259                 /* Some severe error from the OSL, but we basically ignore it */
 260
 261                 ACPI_EXCEPTION((AE_INFO, status,
 262                                 "Could not override ACPI table"));
 263                 return_ACPI_STATUS(status);
 264         }
 265
 266         if (!new_table) {
 267
 268                 /* No table override */
 269
 270                 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
 271         }
 272
 273         /*
 274          * We have a new table to override the old one.  Get a copy of
 275          * the new one.  We know that the new table has a logical pointer.
 276          */
 277         address.pointer_type = ACPI_LOGICAL_POINTER | ACPI_LOGICAL_ADDRESSING;
 278         address.pointer.logical = new_table;
 279
 280         status = acpi_tb_get_this_table(&address, new_table, table_info);
 281         if (ACPI_FAILURE(status)) {
 282                 ACPI_EXCEPTION((AE_INFO, status, "Could not copy ACPI table"));
 283                 return_ACPI_STATUS(status);
 284         }
 285
 286         /* Copy the table info */
 287
 288         ACPI_INFO((AE_INFO, "Table [%4.4s] replaced by host OS",
 289                    table_info->pointer->signature));
 290
 291         return_ACPI_STATUS(AE_OK);
 292 }
 293
 294 /*******************************************************************************
 295  *
 296  * FUNCTION:    acpi_tb_get_this_table
 297  *
 298  * PARAMETERS:  Address             - Address of table to retrieve.  Can be
 299  *                                    Logical or Physical
 300  *              Header              - Header of the table to retrieve
 301  *              table_info          - Where the table info is returned
 302  *
 303  * RETURN:      Status
 304  *
 305  * DESCRIPTION: Get an entire ACPI table.  Works in both physical or virtual
 306  *              addressing mode.  Works with both physical or logical pointers.
 307  *              Table is either copied or mapped, depending on the pointer
 308  *              type and mode of the processor.
 309  *
 310  ******************************************************************************/
 311
 312 static acpi_status
 313 acpi_tb_get_this_table(struct acpi_pointer *address,
 314                        struct acpi_table_header *header,
 315                        struct acpi_table_desc *table_info)
 316 {
 317         struct acpi_table_header *full_table = NULL;
 318         u8 allocation;
 319         acpi_status status = AE_OK;
 320
 321         ACPI_FUNCTION_TRACE("tb_get_this_table");
 322
 323         /*
 324          * Flags contains the current processor mode (Virtual or Physical
 325          * addressing) The pointer_type is either Logical or Physical
 326          */
 327         switch (address->pointer_type) {
 328         case ACPI_PHYSMODE_PHYSPTR:
 329         case ACPI_LOGMODE_LOGPTR:
 330
 331                 /* Pointer matches processor mode, copy the table to a new buffer */
 332
 333                 full_table = ACPI_MEM_ALLOCATE(header->length);
 334                 if (!full_table) {
 335                         ACPI_ERROR((AE_INFO,
 336                                     "Could not allocate table memory for [%4.4s] length %X",
 337                                     header->signature, header->length));
 338                         return_ACPI_STATUS(AE_NO_MEMORY);
 339                 }
 340
 341                 /* Copy the entire table (including header) to the local buffer */
 342
 343                 ACPI_MEMCPY(full_table, address->pointer.logical,
 344                             header->length);
 345
 346                 /* Save allocation type */
 347
 348                 allocation = ACPI_MEM_ALLOCATED;
 349                 break;
 350
 351         case ACPI_LOGMODE_PHYSPTR:
 352
 353                 /*
 354                  * Just map the table's physical memory
 355                  * into our address space.
 356                  */
 357                 status = acpi_os_map_memory(address->pointer.physical,
 358                                             (acpi_size) header->length,
 359                                             (void *)&full_table);
 360                 if (ACPI_FAILURE(status)) {
 361                         ACPI_ERROR((AE_INFO,
 362                                     "Could not map memory for table [%4.4s] at %8.8X%8.8X for length %X",
 363                                     header->signature,
 364                                     ACPI_FORMAT_UINT64(address->pointer.
 365                                                        physical),
 366                                     header->length));
 367                         return (status);
 368                 }
 369
 370                 /* Save allocation type */
 371
 372                 allocation = ACPI_MEM_MAPPED;
 373                 break;
 374
 375         default:
 376
 377                 ACPI_ERROR((AE_INFO, "Invalid address flags %X",
 378                             address->pointer_type));
 379                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 380         }
 381
 382         /*
 383          * Validate checksum for _most_ tables,
 384          * even the ones whose signature we don't recognize
 385          */
 386         if (table_info->type != ACPI_TABLE_FACS) {
 387                 status = acpi_tb_verify_table_checksum(full_table);
 388
 389 #if (!ACPI_CHECKSUM_ABORT)
 390                 if (ACPI_FAILURE(status)) {
 391
 392                         /* Ignore the error if configuration says so */
 393
 394                         status = AE_OK;
 395                 }
 396 #endif
 397         }
 398
 399         /* Return values */
 400
 401         table_info->pointer = full_table;
 402         table_info->length = (acpi_size) header->length;
 403         table_info->allocation = allocation;
 404
 405         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 406                           "Found table [%4.4s] at %8.8X%8.8X, mapped/copied to %p\n",
 407                           full_table->signature,
 408                           ACPI_FORMAT_UINT64(address->pointer.physical),
 409                           full_table));
 410
 411         return_ACPI_STATUS(status);
 412 }
 413
 414 /*******************************************************************************
 415  *
 416  * FUNCTION:    acpi_tb_get_table_ptr
 417  *
 418  * PARAMETERS:  table_type      - one of the defined table types
 419  *              Instance        - Which table of this type
 420  *              table_ptr_loc   - pointer to location to place the pointer for
 421  *                                return
 422  *
 423  * RETURN:      Status
 424  *
 425  * DESCRIPTION: This function is called to get the pointer to an ACPI table.
 426  *
 427  ******************************************************************************/
 428
 429 acpi_status
 430 acpi_tb_get_table_ptr(acpi_table_type table_type,
 431                       u32 instance, struct acpi_table_header **table_ptr_loc)
 432 {
 433         struct acpi_table_desc *table_desc;
 434         u32 i;
 435
 436         ACPI_FUNCTION_TRACE("tb_get_table_ptr");
 437
 438         if (!acpi_gbl_DSDT) {
 439                 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
 440         }
 441
 442         if (table_type > ACPI_TABLE_MAX) {
 443                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 444         }
 445
 446         /*
 447          * For all table types (Single/Multiple), the first
 448          * instance is always in the list head.
 449          */
 450         if (instance == 1) {
 451
 452                 /* Get the first */
 453
 454                 *table_ptr_loc = NULL;
 455                 if (acpi_gbl_table_lists[table_type].next) {
 456                         *table_ptr_loc =
 457                             acpi_gbl_table_lists[table_type].next->pointer;
 458                 }
 459                 return_ACPI_STATUS(AE_OK);
 460         }
 461
 462         /* Check for instance out of range */
 463
 464         if (instance > acpi_gbl_table_lists[table_type].count) {
 465                 return_ACPI_STATUS(AE_NOT_EXIST);
 466         }
 467
 468         /* Walk the list to get the desired table
 469          * Since the if (Instance == 1) check above checked for the
 470          * first table, setting table_desc equal to the .Next member
 471          * is actually pointing to the second table.  Therefore, we
 472          * need to walk from the 2nd table until we reach the Instance
 473          * that the user is looking for and return its table pointer.
 474          */
 475         table_desc = acpi_gbl_table_lists[table_type].next;
 476         for (i = 2; i < instance; i++) {
 477                 table_desc = table_desc->next;
 478         }
 479
 480         /* We are now pointing to the requested table's descriptor */
 481
 482         *table_ptr_loc = table_desc->pointer;
 483
 484         return_ACPI_STATUS(AE_OK);
 485 }