sys/contrib/dev/acpica-unix-20040527/TABLES/tbinstal.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbinstal - ACPI table installation and removal
   4  *              $Revision: 73 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117
 118 #define __TBINSTAL_C__
 119
 120 #include "acpi.h"
 121 #include "actables.h"
 122
 123
 124 #define _COMPONENT          ACPI_TABLES
 125         ACPI_MODULE_NAME    ("tbinstal")
 126
 127
 128 /*******************************************************************************
 129  *
 130  * FUNCTION:    AcpiTbMatchSignature
 131  *
 132  * PARAMETERS:  Signature           - Table signature to match
 133  *              TableInfo           - Return data
 134  *
 135  * RETURN:      Status
 136  *
 137  * DESCRIPTION: Compare signature against the list of "ACPI-subsystem-owned"
 138  *              tables (DSDT/FADT/SSDT, etc.) Returns the TableTypeID on match.
 139  *
 140  ******************************************************************************/
 141
 142 ACPI_STATUS
 143 AcpiTbMatchSignature (
 144     char                    *Signature,
 145     ACPI_TABLE_DESC         *TableInfo,
 146     UINT8                   SearchType)
 147 {
 148     ACPI_NATIVE_UINT        i;
 149
 150
 151     ACPI_FUNCTION_TRACE ("TbMatchSignature");
 152
 153
 154     /*
 155      * Search for a signature match among the known table types
 156      */
 157     for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++)
 158     {
 159         if (!(AcpiGbl_TableData[i].Flags & SearchType))
 160         {
 161             continue;
 162         }
 163
 164         if (!ACPI_STRNCMP (Signature, AcpiGbl_TableData[i].Signature,
 165                       AcpiGbl_TableData[i].SigLength))
 166         {
 167             /* Found a signature match, return index if requested */
 168
 169             if (TableInfo)
 170             {
 171                 TableInfo->Type = (UINT8) i;
 172             }
 173
 174             ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 175                 "Table [%4.4s] is an ACPI table consumed by the core subsystem\n",
 176                 (char *) AcpiGbl_TableData[i].Signature));
 177
 178             return_ACPI_STATUS (AE_OK);
 179         }
 180     }
 181
 182     ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 183         "Table [%4.4s] is not an ACPI table consumed by the core subsystem - ignored\n",
 184         (char *) Signature));
 185
 186     return_ACPI_STATUS (AE_TABLE_NOT_SUPPORTED);
 187 }
 188
 189
 190 /*******************************************************************************
 191  *
 192  * FUNCTION:    AcpiTbInstallTable
 193  *
 194  * PARAMETERS:  TableInfo           - Return value from AcpiTbGetTableBody
 195  *
 196  * RETURN:      Status
 197  *
 198  * DESCRIPTION: Load and validate all tables other than the RSDT.  The RSDT must
 199  *              already be loaded and validated.
 200  *              Install the table into the global data structs.
 201  *
 202  ******************************************************************************/
 203
 204 ACPI_STATUS
 205 AcpiTbInstallTable (
 206     ACPI_TABLE_DESC         *TableInfo)
 207 {
 208     ACPI_STATUS             Status;
 209
 210     ACPI_FUNCTION_TRACE ("TbInstallTable");
 211
 212
 213     /* Lock tables while installing */
 214
 215     Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 216     if (ACPI_FAILURE (Status))
 217     {
 218         ACPI_REPORT_ERROR (("Could not acquire table mutex for [%4.4s], %s\n",
 219             TableInfo->Pointer->Signature, AcpiFormatException (Status)));
 220         return_ACPI_STATUS (Status);
 221     }
 222
 223     /* Install the table into the global data structure */
 224
 225     Status = AcpiTbInitTableDescriptor (TableInfo->Type, TableInfo);
 226     if (ACPI_FAILURE (Status))
 227     {
 228         ACPI_REPORT_ERROR (("Could not install ACPI table [%4.4s], %s\n",
 229             TableInfo->Pointer->Signature, AcpiFormatException (Status)));
 230     }
 231
 232     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s located at %p\n",
 233         AcpiGbl_TableData[TableInfo->Type].Name, TableInfo->Pointer));
 234
 235     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 236     return_ACPI_STATUS (Status);
 237 }
 238
 239
 240 /*******************************************************************************
 241  *
 242  * FUNCTION:    AcpiTbRecognizeTable
 243  *
 244  * PARAMETERS:  TableInfo           - Return value from AcpiTbGetTableBody
 245  *
 246  * RETURN:      Status
 247  *
 248  * DESCRIPTION: Check a table signature for a match against known table types
 249  *
 250  * NOTE:  All table pointers are validated as follows:
 251  *          1) Table pointer must point to valid physical memory
 252  *          2) Signature must be 4 ASCII chars, even if we don't recognize the
 253  *             name
 254  *          3) Table must be readable for length specified in the header
 255  *          4) Table checksum must be valid (with the exception of the FACS
 256  *             which has no checksum for some odd reason)
 257  *
 258  ******************************************************************************/
 259
 260 ACPI_STATUS
 261 AcpiTbRecognizeTable (
 262     ACPI_TABLE_DESC         *TableInfo,
 263     UINT8                   SearchType)
 264 {
 265     ACPI_TABLE_HEADER       *TableHeader;
 266     ACPI_STATUS             Status;
 267
 268
 269     ACPI_FUNCTION_TRACE ("TbRecognizeTable");
 270
 271
 272     /* Ensure that we have a valid table pointer */
 273
 274     TableHeader = (ACPI_TABLE_HEADER *) TableInfo->Pointer;
 275     if (!TableHeader)
 276     {
 277         return_ACPI_STATUS (AE_BAD_PARAMETER);
 278     }
 279
 280     /*
 281      * We only "recognize" a limited number of ACPI tables -- namely, the
 282      * ones that are used by the subsystem (DSDT, FADT, etc.)
 283      *
 284      * An AE_TABLE_NOT_SUPPORTED means that the table was not recognized.
 285      * This can be any one of many valid ACPI tables, it just isn't one of
 286      * the tables that is consumed by the core subsystem
 287      */
 288     Status = AcpiTbMatchSignature (TableHeader->Signature, TableInfo, SearchType);
 289     if (ACPI_FAILURE (Status))
 290     {
 291         return_ACPI_STATUS (Status);
 292     }
 293
 294     Status = AcpiTbValidateTableHeader (TableHeader);
 295     if (ACPI_FAILURE (Status))
 296     {
 297         return_ACPI_STATUS (Status);
 298     }
 299
 300     /* Return the table type and length via the info struct */
 301
 302     TableInfo->Length = (ACPI_SIZE) TableHeader->Length;
 303
 304     return_ACPI_STATUS (Status);
 305 }
 306
 307
 308 /*******************************************************************************
 309  *
 310  * FUNCTION:    AcpiTbInitTableDescriptor
 311  *
 312  * PARAMETERS:  TableType           - The type of the table
 313  *              TableInfo           - A table info struct
 314  *
 315  * RETURN:      None.
 316  *
 317  * DESCRIPTION: Install a table into the global data structs.
 318  *
 319  ******************************************************************************/
 320
 321 ACPI_STATUS
 322 AcpiTbInitTableDescriptor (
 323     ACPI_TABLE_TYPE         TableType,
 324     ACPI_TABLE_DESC         *TableInfo)
 325 {
 326     ACPI_TABLE_LIST         *ListHead;
 327     ACPI_TABLE_DESC         *TableDesc;
 328
 329
 330     ACPI_FUNCTION_TRACE_U32 ("TbInitTableDescriptor", TableType);
 331
 332
 333     /* Allocate a descriptor for this table */
 334
 335     TableDesc = ACPI_MEM_CALLOCATE (sizeof (ACPI_TABLE_DESC));
 336     if (!TableDesc)
 337     {
 338         return_ACPI_STATUS (AE_NO_MEMORY);
 339     }
 340
 341     /*
 342      * Install the table into the global data structure
 343      */
 344     ListHead = &AcpiGbl_TableLists[TableType];
 345
 346     /*
 347      * Two major types of tables:  1) Only one instance is allowed.  This
 348      * includes most ACPI tables such as the DSDT.  2) Multiple instances of
 349      * the table are allowed.  This includes SSDT and PSDTs.
 350      */
 351     if (ACPI_IS_SINGLE_TABLE (AcpiGbl_TableData[TableType].Flags))
 352     {
 353         /*
 354          * Only one table allowed, and a table has alread been installed
 355          *  at this location, so return an error.
 356          */
 357         if (ListHead->Next)
 358         {
 359             return_ACPI_STATUS (AE_ALREADY_EXISTS);
 360         }
 361
 362         TableDesc->Next = ListHead->Next;
 363         ListHead->Next = TableDesc;
 364
 365         if (TableDesc->Next)
 366         {
 367             TableDesc->Next->Prev = TableDesc;
 368         }
 369
 370         ListHead->Count++;
 371     }
 372     else
 373     {
 374         /*
 375          * Link the new table in to the list of tables of this type.
 376          * Insert at the end of the list, order IS IMPORTANT.
 377          *
 378          * TableDesc->Prev & Next are already NULL from calloc()
 379          */
 380         ListHead->Count++;
 381
 382         if (!ListHead->Next)
 383         {
 384             ListHead->Next = TableDesc;
 385         }
 386         else
 387         {
 388             TableDesc->Next = ListHead->Next;
 389
 390             while (TableDesc->Next->Next)
 391             {
 392                 TableDesc->Next = TableDesc->Next->Next;
 393             }
 394
 395             TableDesc->Next->Next = TableDesc;
 396             TableDesc->Prev = TableDesc->Next;
 397             TableDesc->Next = NULL;
 398         }
 399     }
 400
 401     /* Finish initialization of the table descriptor */
 402
 403     TableDesc->Type                 = (UINT8) TableType;
 404     TableDesc->Pointer              = TableInfo->Pointer;
 405     TableDesc->Length               = TableInfo->Length;
 406     TableDesc->Allocation           = TableInfo->Allocation;
 407     TableDesc->AmlStart             = (UINT8 *) (TableDesc->Pointer + 1),
 408     TableDesc->AmlLength            = (UINT32) (TableDesc->Length -
 409                                         (UINT32) sizeof (ACPI_TABLE_HEADER));
 410     TableDesc->TableId              = AcpiUtAllocateOwnerId (ACPI_OWNER_TYPE_TABLE);
 411     TableDesc->LoadedIntoNamespace  = FALSE;
 412
 413     /*
 414      * Set the appropriate global pointer (if there is one) to point to the
 415      * newly installed table
 416      */
 417     if (AcpiGbl_TableData[TableType].GlobalPtr)
 418     {
 419         *(AcpiGbl_TableData[TableType].GlobalPtr) = TableInfo->Pointer;
 420     }
 421
 422     /* Return Data */
 423
 424     TableInfo->TableId          = TableDesc->TableId;
 425     TableInfo->InstalledDesc    = TableDesc;
 426
 427     return_ACPI_STATUS (AE_OK);
 428 }
 429
 430
 431 /*******************************************************************************
 432  *
 433  * FUNCTION:    AcpiTbDeleteAllTables
 434  *
 435  * PARAMETERS:  None.
 436  *
 437  * RETURN:      None.
 438  *
 439  * DESCRIPTION: Delete all internal ACPI tables
 440  *
 441  ******************************************************************************/
 442
 443 void
 444 AcpiTbDeleteAllTables (void)
 445 {
 446     ACPI_TABLE_TYPE         Type;
 447
 448
 449     /*
 450      * Free memory allocated for ACPI tables
 451      * Memory can either be mapped or allocated
 452      */
 453     for (Type = 0; Type < NUM_ACPI_TABLE_TYPES; Type++)
 454     {
 455         AcpiTbDeleteTablesByType (Type);
 456     }
 457 }
 458
 459
 460 /*******************************************************************************
 461  *
 462  * FUNCTION:    AcpiTbDeleteTablesByType
 463  *
 464  * PARAMETERS:  Type                - The table type to be deleted
 465  *
 466  * RETURN:      None.
 467  *
 468  * DESCRIPTION: Delete an internal ACPI table
 469  *              Locks the ACPI table mutex
 470  *
 471  ******************************************************************************/
 472
 473 void
 474 AcpiTbDeleteTablesByType (
 475     ACPI_TABLE_TYPE         Type)
 476 {
 477     ACPI_TABLE_DESC         *TableDesc;
 478     UINT32                  Count;
 479     UINT32                  i;
 480
 481
 482     ACPI_FUNCTION_TRACE_U32 ("TbDeleteTablesByType", Type);
 483
 484
 485     if (Type > ACPI_TABLE_MAX)
 486     {
 487         return_VOID;
 488     }
 489
 490     if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_TABLES)))
 491     {
 492         return;
 493     }
 494
 495     /* Clear the appropriate "typed" global table pointer */
 496
 497     switch (Type)
 498     {
 499     case ACPI_TABLE_RSDP:
 500         AcpiGbl_RSDP = NULL;
 501         break;
 502
 503     case ACPI_TABLE_DSDT:
 504         AcpiGbl_DSDT = NULL;
 505         break;
 506
 507     case ACPI_TABLE_FADT:
 508         AcpiGbl_FADT = NULL;
 509         break;
 510
 511     case ACPI_TABLE_FACS:
 512         AcpiGbl_FACS = NULL;
 513         break;
 514
 515     case ACPI_TABLE_XSDT:
 516         AcpiGbl_XSDT = NULL;
 517         break;
 518
 519     case ACPI_TABLE_SSDT:
 520     case ACPI_TABLE_PSDT:
 521     default:
 522         break;
 523     }
 524
 525     /*
 526      * Free the table
 527      * 1) Get the head of the list
 528      */
 529     TableDesc = AcpiGbl_TableLists[Type].Next;
 530     Count     = AcpiGbl_TableLists[Type].Count;
 531
 532     /*
 533      * 2) Walk the entire list, deleting both the allocated tables
 534      *    and the table descriptors
 535      */
 536     for (i = 0; i < Count; i++)
 537     {
 538         TableDesc = AcpiTbUninstallTable (TableDesc);
 539     }
 540
 541     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 542     return_VOID;
 543 }
 544
 545
 546 /*******************************************************************************
 547  *
 548  * FUNCTION:    AcpiTbDeleteSingleTable
 549  *
 550  * PARAMETERS:  TableInfo           - A table info struct
 551  *
 552  * RETURN:      None.
 553  *
 554  * DESCRIPTION: Low-level free for a single ACPI table.  Handles cases where
 555  *              the table was allocated a buffer or was mapped.
 556  *
 557  ******************************************************************************/
 558
 559 void
 560 AcpiTbDeleteSingleTable (
 561     ACPI_TABLE_DESC         *TableDesc)
 562 {
 563
 564     /* Must have a valid table descriptor and pointer */
 565
 566     if ((!TableDesc) ||
 567          (!TableDesc->Pointer))
 568     {
 569         return;
 570     }
 571
 572     /* Valid table, determine type of memory allocation */
 573
 574     switch (TableDesc->Allocation)
 575     {
 576     case ACPI_MEM_NOT_ALLOCATED:
 577         break;
 578
 579     case ACPI_MEM_ALLOCATED:
 580
 581         ACPI_MEM_FREE (TableDesc->Pointer);
 582         break;
 583
 584     case ACPI_MEM_MAPPED:
 585
 586         AcpiOsUnmapMemory (TableDesc->Pointer, TableDesc->Length);
 587         break;
 588
 589     default:
 590         break;
 591     }
 592 }
 593
 594
 595 /*******************************************************************************
 596  *
 597  * FUNCTION:    AcpiTbUninstallTable
 598  *
 599  * PARAMETERS:  TableInfo           - A table info struct
 600  *
 601  * RETURN:      Pointer to the next table in the list (of same type)
 602  *
 603  * DESCRIPTION: Free the memory associated with an internal ACPI table that
 604  *              is either installed or has never been installed.
 605  *              Table mutex should be locked.
 606  *
 607  ******************************************************************************/
 608
 609 ACPI_TABLE_DESC *
 610 AcpiTbUninstallTable (
 611     ACPI_TABLE_DESC         *TableDesc)
 612 {
 613     ACPI_TABLE_DESC         *NextDesc;
 614
 615
 616     ACPI_FUNCTION_TRACE_PTR ("TbUninstallTable", TableDesc);
 617
 618
 619     if (!TableDesc)
 620     {
 621         return_PTR (NULL);
 622     }
 623
 624     /* Unlink the descriptor from the doubly linked list */
 625
 626     if (TableDesc->Prev)
 627     {
 628         TableDesc->Prev->Next = TableDesc->Next;
 629     }
 630     else
 631     {
 632         /* Is first on list, update list head */
 633
 634         AcpiGbl_TableLists[TableDesc->Type].Next = TableDesc->Next;
 635     }
 636
 637     if (TableDesc->Next)
 638     {
 639         TableDesc->Next->Prev = TableDesc->Prev;
 640     }
 641
 642     /* Free the memory allocated for the table itself */
 643
 644     AcpiTbDeleteSingleTable (TableDesc);
 645
 646     /* Free the table descriptor */
 647
 648     NextDesc = TableDesc->Next;
 649     ACPI_MEM_FREE (TableDesc);
 650
 651     /* Return pointer to the next descriptor */
 652
 653     return_PTR (NextDesc);
 654 }
 655
 656