1 /****************************************************************************** 2 * 3 * Module Name: aetables - ACPI table setup/install for acpiexec utility 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, 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 #include "aecommon.h" 45 #include "aetables.h" 46 47 #define _COMPONENT ACPI_TOOLS 48 ACPI_MODULE_NAME ("aetables") 49 50 /* Local prototypes */ 51 52 static void 53 AeInitializeTableHeader ( 54 ACPI_TABLE_HEADER *Header, 55 char *Signature, 56 UINT32 Length); 57 58 void 59 AeTableOverride ( 60 ACPI_TABLE_HEADER *ExistingTable, 61 ACPI_TABLE_HEADER **NewTable); 62 63 /* User table (DSDT) */ 64 65 static ACPI_TABLE_HEADER *DsdtToInstallOverride; 66 67 /* Non-AML tables that are constructed locally and installed */ 68 69 static ACPI_TABLE_RSDP LocalRSDP; 70 static ACPI_TABLE_FACS LocalFACS; 71 static ACPI_TABLE_HEADER LocalTEST; 72 static ACPI_TABLE_HEADER LocalBADTABLE; 73 74 /* 75 * We need a local FADT so that the hardware subcomponent will function, 76 * even though the underlying OSD HW access functions don't do anything. 77 */ 78 static ACPI_TABLE_FADT LocalFADT; 79 80 /* 81 * Use XSDT so that both 32- and 64-bit versions of this utility will 82 * function automatically. 83 */ 84 static ACPI_TABLE_XSDT *LocalXSDT; 85 86 #define BASE_XSDT_TABLES 9 87 #define BASE_XSDT_SIZE ((BASE_XSDT_TABLES) * sizeof (UINT64)) 88 89 #define ACPI_MAX_INIT_TABLES (32) 90 91 92 /****************************************************************************** 93 * 94 * FUNCTION: AeTableOverride 95 * 96 * DESCRIPTION: Local implementation of AcpiOsTableOverride. 97 * Exercise the override mechanism 98 * 99 *****************************************************************************/ 100 101 void 102 AeTableOverride ( 103 ACPI_TABLE_HEADER *ExistingTable, 104 ACPI_TABLE_HEADER **NewTable) 105 { 106 107 if (!AcpiGbl_LoadTestTables) 108 { 109 *NewTable = NULL; 110 return; 111 } 112 113 /* This code exercises the table override mechanism in the core */ 114 115 if (ACPI_COMPARE_NAME (ExistingTable->Signature, ACPI_SIG_DSDT)) 116 { 117 *NewTable = DsdtToInstallOverride; 118 } 119 120 /* This code tests override of dynamically loaded tables */ 121 122 else if (ACPI_COMPARE_NAME (ExistingTable->Signature, "OEM9")) 123 { 124 *NewTable = ACPI_CAST_PTR (ACPI_TABLE_HEADER, Ssdt3Code); 125 } 126 } 127 128 129 /****************************************************************************** 130 * 131 * FUNCTION: AeInitializeTableHeader 132 * 133 * PARAMETERS: Header - A valid standard ACPI table header 134 * Signature - Signature to insert 135 * Length - Length of the table 136 * 137 * RETURN: None. Header is modified. 138 * 139 * DESCRIPTION: Initialize the table header for a local ACPI table. 140 * 141 *****************************************************************************/ 142 143 static void 144 AeInitializeTableHeader ( 145 ACPI_TABLE_HEADER *Header, 146 char *Signature, 147 UINT32 Length) 148 { 149 150 ACPI_MOVE_NAME (Header->Signature, Signature); 151 Header->Length = Length; 152 153 Header->OemRevision = 0x1001; 154 strncpy (Header->OemId, "Intel", ACPI_OEM_ID_SIZE); 155 strncpy (Header->OemTableId, "AcpiExec", ACPI_OEM_TABLE_ID_SIZE); 156 strncpy (Header->AslCompilerId, "INTL", ACPI_NAME_SIZE); 157 Header->AslCompilerRevision = ACPI_CA_VERSION; 158 159 /* Set the checksum, must set to zero first */ 160 161 Header->Checksum = 0; 162 Header->Checksum = (UINT8) -AcpiTbChecksum ( 163 (void *) Header, Header->Length); 164 } 165 166 167 /****************************************************************************** 168 * 169 * FUNCTION: AeBuildLocalTables 170 * 171 * PARAMETERS: TableCount - Number of tables on the command line 172 * ListHead - List of actual tables from files 173 * 174 * RETURN: Status 175 * 176 * DESCRIPTION: Build a complete ACPI table chain, with a local RSDP, XSDT, 177 * FADT, and several other test tables. 178 * 179 *****************************************************************************/ 180 181 ACPI_STATUS 182 AeBuildLocalTables ( 183 ACPI_NEW_TABLE_DESC *ListHead) 184 { 185 UINT32 TableCount = 1; 186 ACPI_PHYSICAL_ADDRESS DsdtAddress = 0; 187 UINT32 XsdtSize; 188 ACPI_NEW_TABLE_DESC *NextTable; 189 UINT32 NextIndex; 190 ACPI_TABLE_FADT *ExternalFadt = NULL; 191 192 193 /* 194 * Update the table count. For the DSDT, it is not put into the XSDT. 195 * For the FADT, this table is already accounted for since we usually 196 * install a local FADT. 197 */ 198 NextTable = ListHead; 199 while (NextTable) 200 { 201 if (!ACPI_COMPARE_NAME (NextTable->Table->Signature, ACPI_SIG_DSDT) && 202 !ACPI_COMPARE_NAME (NextTable->Table->Signature, ACPI_SIG_FADT)) 203 { 204 TableCount++; 205 } 206 207 NextTable = NextTable->Next; 208 } 209 210 XsdtSize = (((TableCount + 1) * sizeof (UINT64)) + 211 sizeof (ACPI_TABLE_HEADER)); 212 if (AcpiGbl_LoadTestTables) 213 { 214 XsdtSize += BASE_XSDT_SIZE; 215 } 216 217 /* Build an XSDT */ 218 219 LocalXSDT = AcpiOsAllocate (XsdtSize); 220 if (!LocalXSDT) 221 { 222 return (AE_NO_MEMORY); 223 } 224 225 memset (LocalXSDT, 0, XsdtSize); 226 LocalXSDT->TableOffsetEntry[0] = ACPI_PTR_TO_PHYSADDR (&LocalFADT); 227 NextIndex = 1; 228 229 /* 230 * Install the user tables. The DSDT must be installed in the FADT. 231 * All other tables are installed directly into the XSDT. 232 */ 233 NextTable = ListHead; 234 while (NextTable) 235 { 236 /* 237 * Incoming DSDT or FADT are special cases. All other tables are 238 * just immediately installed into the XSDT. 239 */ 240 if (ACPI_COMPARE_NAME (NextTable->Table->Signature, ACPI_SIG_DSDT)) 241 { 242 if (DsdtAddress) 243 { 244 printf ("Already found a DSDT, only one allowed\n"); 245 return (AE_ALREADY_EXISTS); 246 } 247 248 /* The incoming user table is a DSDT */ 249 250 DsdtAddress = ACPI_PTR_TO_PHYSADDR (NextTable->Table); 251 DsdtToInstallOverride = NextTable->Table; 252 } 253 else if (ACPI_COMPARE_NAME (NextTable->Table->Signature, ACPI_SIG_FADT)) 254 { 255 ExternalFadt = ACPI_CAST_PTR (ACPI_TABLE_FADT, NextTable->Table); 256 LocalXSDT->TableOffsetEntry[0] = ACPI_PTR_TO_PHYSADDR (NextTable->Table); 257 } 258 else 259 { 260 /* Install the table in the XSDT */ 261 262 LocalXSDT->TableOffsetEntry[NextIndex] = 263 ACPI_PTR_TO_PHYSADDR (NextTable->Table); 264 NextIndex++; 265 } 266 267 NextTable = NextTable->Next; 268 } 269 270 /* Install the optional extra local tables */ 271 272 if (AcpiGbl_LoadTestTables) 273 { 274 LocalXSDT->TableOffsetEntry[NextIndex++] = ACPI_PTR_TO_PHYSADDR (&LocalTEST); 275 LocalXSDT->TableOffsetEntry[NextIndex++] = ACPI_PTR_TO_PHYSADDR (&LocalBADTABLE); 276 277 /* Install two SSDTs to test multiple table support */ 278 279 LocalXSDT->TableOffsetEntry[NextIndex++] = ACPI_PTR_TO_PHYSADDR (&Ssdt1Code); 280 LocalXSDT->TableOffsetEntry[NextIndex++] = ACPI_PTR_TO_PHYSADDR (&Ssdt2Code); 281 282 /* Install the OEM1 table to test LoadTable */ 283 284 LocalXSDT->TableOffsetEntry[NextIndex++] = ACPI_PTR_TO_PHYSADDR (&Oem1Code); 285 286 /* Install the OEMx table to test LoadTable */ 287 288 LocalXSDT->TableOffsetEntry[NextIndex++] = ACPI_PTR_TO_PHYSADDR (&OemxCode); 289 290 /* Install the ECDT table to test _REG */ 291 292 LocalXSDT->TableOffsetEntry[NextIndex++] = ACPI_PTR_TO_PHYSADDR (&EcdtCode); 293 294 /* Install two UEFIs to test multiple table support */ 295 296 LocalXSDT->TableOffsetEntry[NextIndex++] = ACPI_PTR_TO_PHYSADDR (&Uefi1Code); 297 LocalXSDT->TableOffsetEntry[NextIndex++] = ACPI_PTR_TO_PHYSADDR (&Uefi2Code); 298 } 299 300 /* Build an RSDP. Contains a valid XSDT only, no RSDT */ 301 302 memset (&LocalRSDP, 0, sizeof (ACPI_TABLE_RSDP)); 303 ACPI_MAKE_RSDP_SIG (LocalRSDP.Signature); 304 memcpy (LocalRSDP.OemId, "Intel", 6); 305 306 LocalRSDP.Revision = 2; 307 LocalRSDP.XsdtPhysicalAddress = ACPI_PTR_TO_PHYSADDR (LocalXSDT); 308 LocalRSDP.Length = sizeof (ACPI_TABLE_RSDP); 309 310 /* Set checksums for both XSDT and RSDP */ 311 312 AeInitializeTableHeader ((void *) LocalXSDT, ACPI_SIG_XSDT, XsdtSize); 313 314 LocalRSDP.Checksum = 0; 315 LocalRSDP.Checksum = (UINT8) -AcpiTbChecksum ( 316 (void *) &LocalRSDP, ACPI_RSDP_CHECKSUM_LENGTH); 317 318 if (!DsdtAddress) 319 { 320 /* Use the local DSDT because incoming table(s) are all SSDT(s) */ 321 322 DsdtAddress = ACPI_PTR_TO_PHYSADDR (LocalDsdtCode); 323 DsdtToInstallOverride = ACPI_CAST_PTR (ACPI_TABLE_HEADER, LocalDsdtCode); 324 } 325 326 /* 327 * Build an FADT. There are three options for the FADT: 328 * 1) Incoming external FADT specified on the command line 329 * 2) A "hardware reduced" local FADT 330 * 3) A fully featured local FADT 331 */ 332 memset (&LocalFADT, 0, sizeof (ACPI_TABLE_FADT)); 333 334 if (ExternalFadt) 335 { 336 /* 337 * Use the external FADT, but we must update the DSDT/FACS 338 * addresses as well as the checksum 339 */ 340 ExternalFadt->Dsdt = (UINT32) DsdtAddress; 341 if (!AcpiGbl_ReducedHardware) 342 { 343 ExternalFadt->Facs = ACPI_PTR_TO_PHYSADDR (&LocalFACS); 344 } 345 346 /* 347 * If there room in the FADT for the XDsdt and XFacs 64-bit 348 * pointers, use them. 349 */ 350 if (ExternalFadt->Header.Length > ACPI_PTR_DIFF ( 351 &ExternalFadt->XDsdt, ExternalFadt)) 352 { 353 ExternalFadt->Dsdt = 0; 354 ExternalFadt->Facs = 0; 355 356 ExternalFadt->XDsdt = DsdtAddress; 357 if (!AcpiGbl_ReducedHardware) 358 { 359 ExternalFadt->XFacs = ACPI_PTR_TO_PHYSADDR (&LocalFACS); 360 } 361 } 362 363 /* Complete the external FADT with the checksum */ 364 365 ExternalFadt->Header.Checksum = 0; 366 ExternalFadt->Header.Checksum = (UINT8) -AcpiTbChecksum ( 367 (void *) ExternalFadt, ExternalFadt->Header.Length); 368 } 369 else if (AcpiGbl_UseHwReducedFadt) 370 { 371 memcpy (&LocalFADT, HwReducedFadtCode, ACPI_FADT_V5_SIZE); 372 LocalFADT.Dsdt = 0; 373 LocalFADT.XDsdt = DsdtAddress; 374 } 375 else 376 { 377 /* 378 * Build a local FADT so we can test the hardware/event init 379 */ 380 LocalFADT.Header.Revision = 5; 381 382 /* Setup FADT header and DSDT/FACS addresses */ 383 384 LocalFADT.Dsdt = 0; 385 LocalFADT.Facs = 0; 386 387 LocalFADT.XDsdt = DsdtAddress; 388 LocalFADT.XFacs = ACPI_PTR_TO_PHYSADDR (&LocalFACS); 389 390 /* Miscellaneous FADT fields */ 391 392 LocalFADT.Gpe0BlockLength = 0x08; 393 LocalFADT.Gpe0Block = 0x00001234; 394 395 LocalFADT.Gpe1BlockLength = 0x80; 396 LocalFADT.Gpe1Block = 0x00005678; 397 LocalFADT.Gpe1Base = 100; 398 399 LocalFADT.Pm1EventLength = 4; 400 LocalFADT.Pm1aEventBlock = 0x00001aaa; 401 LocalFADT.Pm1bEventBlock = 0x00001bbb; 402 403 LocalFADT.Pm1ControlLength = 2; 404 LocalFADT.Pm1aControlBlock = 0xB0; 405 406 LocalFADT.PmTimerLength = 4; 407 LocalFADT.PmTimerBlock = 0xA0; 408 409 LocalFADT.Pm2ControlBlock = 0xC0; 410 LocalFADT.Pm2ControlLength = 1; 411 412 /* Setup one example X-64 GAS field */ 413 414 LocalFADT.XPm1bEventBlock.SpaceId = ACPI_ADR_SPACE_SYSTEM_IO; 415 LocalFADT.XPm1bEventBlock.Address = LocalFADT.Pm1bEventBlock; 416 LocalFADT.XPm1bEventBlock.BitWidth = (UINT8) 417 ACPI_MUL_8 (LocalFADT.Pm1EventLength); 418 } 419 420 AeInitializeTableHeader ((void *) &LocalFADT, 421 ACPI_SIG_FADT, sizeof (ACPI_TABLE_FADT)); 422 423 /* Build a FACS */ 424 425 memset (&LocalFACS, 0, sizeof (ACPI_TABLE_FACS)); 426 ACPI_MOVE_NAME (LocalFACS.Signature, ACPI_SIG_FACS); 427 428 LocalFACS.Length = sizeof (ACPI_TABLE_FACS); 429 LocalFACS.GlobalLock = 0x11AA0011; 430 431 /* Build the optional local tables */ 432 433 if (AcpiGbl_LoadTestTables) 434 { 435 /* 436 * Build a fake table [TEST] so that we make sure that the 437 * ACPICA core ignores it 438 */ 439 memset (&LocalTEST, 0, sizeof (ACPI_TABLE_HEADER)); 440 ACPI_MOVE_NAME (LocalTEST.Signature, "TEST"); 441 442 LocalTEST.Revision = 1; 443 LocalTEST.Length = sizeof (ACPI_TABLE_HEADER); 444 445 LocalTEST.Checksum = 0; 446 LocalTEST.Checksum = (UINT8) -AcpiTbChecksum ( 447 (void *) &LocalTEST, LocalTEST.Length); 448 449 /* 450 * Build a fake table with a bad signature [BAD!] so that we make 451 * sure that the ACPICA core ignores it 452 */ 453 memset (&LocalBADTABLE, 0, sizeof (ACPI_TABLE_HEADER)); 454 ACPI_MOVE_NAME (LocalBADTABLE.Signature, "BAD!"); 455 456 LocalBADTABLE.Revision = 1; 457 LocalBADTABLE.Length = sizeof (ACPI_TABLE_HEADER); 458 459 LocalBADTABLE.Checksum = 0; 460 LocalBADTABLE.Checksum = (UINT8) -AcpiTbChecksum ( 461 (void *) &LocalBADTABLE, LocalBADTABLE.Length); 462 } 463 464 return (AE_OK); 465 } 466 467 468 /****************************************************************************** 469 * 470 * FUNCTION: AeInstallTables 471 * 472 * PARAMETERS: None 473 * 474 * RETURN: Status 475 * 476 * DESCRIPTION: Install the various ACPI tables 477 * 478 *****************************************************************************/ 479 480 ACPI_STATUS 481 AeInstallTables ( 482 void) 483 { 484 ACPI_STATUS Status; 485 ACPI_TABLE_HEADER Header; 486 ACPI_TABLE_HEADER *Table; 487 UINT32 i; 488 489 490 Status = AcpiInitializeTables (NULL, ACPI_MAX_INIT_TABLES, TRUE); 491 ACPI_CHECK_OK (AcpiInitializeTables, Status); 492 493 if (AcpiGbl_LoadTestTables) 494 { 495 /* Test multiple table/UEFI support. First, get the headers */ 496 497 Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 1, &Header); 498 ACPI_CHECK_OK (AcpiGetTableHeader, Status); 499 500 Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 2, &Header); 501 ACPI_CHECK_OK (AcpiGetTableHeader, Status); 502 503 Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 3, &Header); 504 ACPI_CHECK_STATUS (AcpiGetTableHeader, Status, AE_NOT_FOUND); 505 506 /* Now get the actual tables */ 507 508 Status = AcpiGetTable (ACPI_SIG_UEFI, 1, &Table); 509 ACPI_CHECK_OK (AcpiGetTable, Status); 510 511 Status = AcpiGetTable (ACPI_SIG_UEFI, 2, &Table); 512 ACPI_CHECK_OK (AcpiGetTable, Status); 513 514 Status = AcpiGetTable (ACPI_SIG_UEFI, 3, &Table); 515 ACPI_CHECK_STATUS (AcpiGetTable, Status, AE_NOT_FOUND); 516 } 517 518 /* Check that we can get all of the ACPI tables */ 519 520 for (i = 0; ; i++) 521 { 522 Status = AcpiGetTableByIndex (i, &Table); 523 if ((Status == AE_BAD_PARAMETER) || !Table) 524 { 525 break; 526 } 527 528 ACPI_CHECK_OK (AcpiGetTableByIndex, Status); 529 } 530 531 return (AE_OK); 532 } 533 534 535 /****************************************************************************** 536 * 537 * FUNCTION: AeLoadTables 538 * 539 * PARAMETERS: None 540 * 541 * RETURN: Status 542 * 543 * DESCRIPTION: Load the definition block ACPI tables 544 * 545 *****************************************************************************/ 546 547 ACPI_STATUS 548 AeLoadTables ( 549 void) 550 { 551 ACPI_STATUS Status; 552 553 554 Status = AcpiLoadTables (); 555 ACPI_CHECK_OK (AcpiLoadTables, Status); 556 557 /* 558 * Test run-time control method installation. Do it twice to test code 559 * for an existing name. 560 */ 561 Status = AcpiInstallMethod (MethodCode); 562 if (ACPI_FAILURE (Status)) 563 { 564 AcpiOsPrintf ("%s, Could not install method\n", 565 AcpiFormatException (Status)); 566 } 567 568 Status = AcpiInstallMethod (MethodCode); 569 if (ACPI_FAILURE (Status)) 570 { 571 AcpiOsPrintf ("%s, Could not install method\n", 572 AcpiFormatException (Status)); 573 } 574 575 return (AE_OK); 576 } 577 578 579 /****************************************************************************** 580 * 581 * FUNCTION: AcpiOsGetRootPointer 582 * 583 * PARAMETERS: Flags - not used 584 * Address - Where the root pointer is returned 585 * 586 * RETURN: Status 587 * 588 * DESCRIPTION: Return a local RSDP, used to dynamically load tables via the 589 * standard ACPI mechanism. 590 * 591 *****************************************************************************/ 592 593 ACPI_PHYSICAL_ADDRESS 594 AcpiOsGetRootPointer ( 595 void) 596 { 597 598 return (ACPI_PTR_TO_PHYSADDR (&LocalRSDP)); 599 } 600