]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableProtocol.c
projects / mirror_edk2.git / blob
? search:


7795ff7269cab1341874c9ca795315efc0b5a170
[mirror_edk2.git] / MdeModulePkg / Universal / Acpi / AcpiTableDxe / AcpiTableProtocol.c
1 /** @file
2 ACPI Table Protocol Implementation
3
4 Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
5 Copyright (c) 2016, Linaro Ltd. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 //
17 // Includes
18 //
19 #include "AcpiTable.h"
20 //
21 // The maximum number of tables that pre-allocated.
22 //
23 UINTN mEfiAcpiMaxNumTables = EFI_ACPI_MAX_NUM_TABLES;
24
25 //
26 // Allocation strategy to use for AllocatePages ().
27 // Runtime value depends on PcdExposedAcpiTableVersions.
28 //
29 STATIC EFI_ALLOCATE_TYPE mAcpiTableAllocType;
30
31 /**
32 This function adds an ACPI table to the table list. It will detect FACS and
33 allocate the correct type of memory and properly align the table.
34
35 @param AcpiTableInstance Instance of the protocol.
36 @param Table Table to add.
37 @param Checksum Does the table require checksumming.
38 @param Version The version of the list to add the table to.
39 @param Handle Pointer for returning the handle.
40
41 @return EFI_SUCCESS The function completed successfully.
42 @return EFI_OUT_OF_RESOURCES Could not allocate a required resource.
43 @return EFI_ABORTED The table is a duplicate of a table that is required
44 to be unique.
45
46 **/
47 EFI_STATUS
48 AddTableToList (
49 IN EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance,
50 IN VOID *Table,
51 IN BOOLEAN Checksum,
52 IN EFI_ACPI_TABLE_VERSION Version,
53 OUT UINTN *Handle
54 );
55
56 /**
57 This function finds and removes the table specified by the handle.
58
59 @param AcpiTableInstance Instance of the protocol.
60 @param Version Bitmask of which versions to remove.
61 @param Handle Table to remove.
62
63 @return EFI_SUCCESS The function completed successfully.
64 @return EFI_ABORTED An error occurred.
65 @return EFI_NOT_FOUND Handle not found in table list.
66
67 **/
68 EFI_STATUS
69 RemoveTableFromList (
70 IN EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance,
71 IN EFI_ACPI_TABLE_VERSION Version,
72 IN UINTN Handle
73 );
74
75 /**
76 This function calculates and updates an UINT8 checksum.
77
78 @param Buffer Pointer to buffer to checksum
79 @param Size Number of bytes to checksum
80 @param ChecksumOffset Offset to place the checksum result in
81
82 @return EFI_SUCCESS The function completed successfully.
83 **/
84 EFI_STATUS
85 AcpiPlatformChecksum (
86 IN VOID *Buffer,
87 IN UINTN Size,
88 IN UINTN ChecksumOffset
89 );
90
91 /**
92 Checksum all versions of the common tables, RSDP, RSDT, XSDT.
93
94 @param AcpiTableInstance Protocol instance private data.
95
96 @return EFI_SUCCESS The function completed successfully.
97
98 **/
99 EFI_STATUS
100 ChecksumCommonTables (
101 IN OUT EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance
102 );
103
104 //
105 // Protocol function implementations.
106 //
107
108 /**
109 This function publishes the specified versions of the ACPI tables by
110 installing EFI configuration table entries for them. Any combination of
111 table versions can be published.
112
113 @param AcpiTableInstance Instance of the protocol.
114 @param Version Version(s) to publish.
115
116 @return EFI_SUCCESS The function completed successfully.
117 @return EFI_ABORTED The function could not complete successfully.
118
119 **/
120 EFI_STATUS
121 EFIAPI
122 PublishTables (
123 IN EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance,
124 IN EFI_ACPI_TABLE_VERSION Version
125 )
126 {
127 EFI_STATUS Status;
128 UINT32 *CurrentRsdtEntry;
129 VOID *CurrentXsdtEntry;
130 UINT64 Buffer64;
131
132 //
133 // Reorder tables as some operating systems don't seem to find the
134 // FADT correctly if it is not in the first few entries
135 //
136
137 //
138 // Add FADT as the first entry
139 //
140 if ((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
141 CurrentRsdtEntry = (UINT32 *) ((UINT8 *) AcpiTableInstance->Rsdt1 + sizeof (EFI_ACPI_DESCRIPTION_HEADER));
142 *CurrentRsdtEntry = (UINT32) (UINTN) AcpiTableInstance->Fadt1;
143
144 CurrentRsdtEntry = (UINT32 *) ((UINT8 *) AcpiTableInstance->Rsdt3 + sizeof (EFI_ACPI_DESCRIPTION_HEADER));
145 *CurrentRsdtEntry = (UINT32) (UINTN) AcpiTableInstance->Fadt3;
146 }
147 if ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0) {
148 CurrentXsdtEntry = (VOID *) ((UINT8 *) AcpiTableInstance->Xsdt + sizeof (EFI_ACPI_DESCRIPTION_HEADER));
149 //
150 // Add entry to XSDT, XSDT expects 64 bit pointers, but
151 // the table pointers in XSDT are not aligned on 8 byte boundary.
152 //
153 Buffer64 = (UINT64) (UINTN) AcpiTableInstance->Fadt3;
154 CopyMem (
155 CurrentXsdtEntry,
156 &Buffer64,
157 sizeof (UINT64)
158 );
159 }
160
161 //
162 // Do checksum again because Dsdt/Xsdt is updated.
163 //
164 ChecksumCommonTables (AcpiTableInstance);
165
166 //
167 // Add the RSD_PTR to the system table and store that we have installed the
168 // tables.
169 //
170 if ((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
171 Status = gBS->InstallConfigurationTable (&gEfiAcpi10TableGuid, AcpiTableInstance->Rsdp1);
172 if (EFI_ERROR (Status)) {
173 return EFI_ABORTED;
174 }
175 }
176
177 if ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0) {
178 Status = gBS->InstallConfigurationTable (&gEfiAcpiTableGuid, AcpiTableInstance->Rsdp3);
179 if (EFI_ERROR (Status)) {
180 return EFI_ABORTED;
181 }
182 }
183
184 return EFI_SUCCESS;
185 }
186
187
188 /**
189 Installs an ACPI table into the RSDT/XSDT.
190 Note that the ACPI table should be checksumed before installing it.
191 Otherwise it will assert.
192
193 @param This Protocol instance pointer.
194 @param AcpiTableBuffer A pointer to a buffer containing the ACPI table to be installed.
195 @param AcpiTableBufferSize Specifies the size, in bytes, of the AcpiTableBuffer buffer.
196 @param TableKey Reurns a key to refer to the ACPI table.
197
198 @return EFI_SUCCESS The table was successfully inserted.
199 @return EFI_INVALID_PARAMETER Either AcpiTableBuffer is NULL, TableKey is NULL, or AcpiTableBufferSize
200 and the size field embedded in the ACPI table pointed to by AcpiTableBuffer
201 are not in sync.
202 @return EFI_OUT_OF_RESOURCES Insufficient resources exist to complete the request.
203 @retval EFI_ACCESS_DENIED The table signature matches a table already
204 present in the system and platform policy
205 does not allow duplicate tables of this type.
206
207 **/
208 EFI_STATUS
209 EFIAPI
210 InstallAcpiTable (
211 IN EFI_ACPI_TABLE_PROTOCOL *This,
212 IN VOID *AcpiTableBuffer,
213 IN UINTN AcpiTableBufferSize,
214 OUT UINTN *TableKey
215 )
216 {
217 EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance;
218 EFI_STATUS Status;
219 VOID *AcpiTableBufferConst;
220 EFI_ACPI_TABLE_VERSION Version;
221
222 //
223 // Check for invalid input parameters
224 //
225 if ((AcpiTableBuffer == NULL) || (TableKey == NULL)
226 || (((EFI_ACPI_DESCRIPTION_HEADER *) AcpiTableBuffer)->Length != AcpiTableBufferSize)) {
227 return EFI_INVALID_PARAMETER;
228 }
229
230 Version = PcdGet32 (PcdAcpiExposedTableVersions);
231
232 //
233 // Get the instance of the ACPI table protocol
234 //
235 AcpiTableInstance = EFI_ACPI_TABLE_INSTANCE_FROM_THIS (This);
236
237 //
238 // Install the ACPI table
239 //
240 AcpiTableBufferConst = AllocateCopyPool (AcpiTableBufferSize,AcpiTableBuffer);
241 *TableKey = 0;
242 Status = AddTableToList (
243 AcpiTableInstance,
244 AcpiTableBufferConst,
245 TRUE,
246 Version,
247 TableKey
248 );
249 if (!EFI_ERROR (Status)) {
250 Status = PublishTables (
251 AcpiTableInstance,
252 Version
253 );
254 }
255 FreePool (AcpiTableBufferConst);
256
257 //
258 // Add a new table successfully, notify registed callback
259 //
260 if (FeaturePcdGet (PcdInstallAcpiSdtProtocol)) {
261 if (!EFI_ERROR (Status)) {
262 SdtNotifyAcpiList (
263 AcpiTableInstance,
264 Version,
265 *TableKey
266 );
267 }
268 }
269
270 return Status;
271 }
272
273
274 /**
275 Removes an ACPI table from the RSDT/XSDT.
276
277 @param This Protocol instance pointer.
278 @param TableKey Specifies the table to uninstall. The key was returned from InstallAcpiTable().
279
280 @return EFI_SUCCESS The table was successfully uninstalled.
281 @return EFI_NOT_FOUND TableKey does not refer to a valid key for a table entry.
282
283 **/
284 EFI_STATUS
285 EFIAPI
286 UninstallAcpiTable (
287 IN EFI_ACPI_TABLE_PROTOCOL *This,
288 IN UINTN TableKey
289 )
290 {
291 EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance;
292 EFI_STATUS Status;
293
294 //
295 // Get the instance of the ACPI table protocol
296 //
297 AcpiTableInstance = EFI_ACPI_TABLE_INSTANCE_FROM_THIS (This);
298
299 //
300 // Uninstall the ACPI table
301 //
302 Status = RemoveTableFromList (
303 AcpiTableInstance,
304 EFI_ACPI_TABLE_VERSION_1_0B | ACPI_TABLE_VERSION_GTE_2_0,
305 TableKey
306 );
307 if (!EFI_ERROR (Status)) {
308 Status = PublishTables (
309 AcpiTableInstance,
310 EFI_ACPI_TABLE_VERSION_1_0B | ACPI_TABLE_VERSION_GTE_2_0
311 );
312 }
313
314 if (EFI_ERROR (Status)) {
315 return EFI_NOT_FOUND;
316 } else {
317 return EFI_SUCCESS;
318 }
319 }
320
321 /**
322 If the number of APCI tables exceeds the preallocated max table number, enlarge the table buffer.
323
324 @param AcpiTableInstance ACPI table protocol instance data structure.
325
326 @return EFI_SUCCESS reallocate the table beffer successfully.
327 @return EFI_OUT_OF_RESOURCES Unable to allocate required resources.
328
329 **/
330 EFI_STATUS
331 ReallocateAcpiTableBuffer (
332 IN EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance
333 )
334 {
335 UINTN NewMaxTableNumber;
336 UINTN TotalSize;
337 UINT8 *Pointer;
338 EFI_PHYSICAL_ADDRESS PageAddress;
339 EFI_ACPI_TABLE_INSTANCE TempPrivateData;
340 EFI_STATUS Status;
341 UINT64 CurrentData;
342
343 CopyMem (&TempPrivateData, AcpiTableInstance, sizeof (EFI_ACPI_TABLE_INSTANCE));
344 //
345 // Enlarge the max table number from mEfiAcpiMaxNumTables to mEfiAcpiMaxNumTables + EFI_ACPI_MAX_NUM_TABLES
346 //
347 NewMaxTableNumber = mEfiAcpiMaxNumTables + EFI_ACPI_MAX_NUM_TABLES;
348 //
349 // Create RSDT, XSDT structures and allocate buffers.
350 //
351 TotalSize = sizeof (EFI_ACPI_DESCRIPTION_HEADER) + // for ACPI 2.0/3.0 XSDT
352 NewMaxTableNumber * sizeof (UINT64);
353
354 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
355 TotalSize += sizeof (EFI_ACPI_DESCRIPTION_HEADER) + // for ACPI 1.0 RSDT
356 NewMaxTableNumber * sizeof (UINT32) +
357 sizeof (EFI_ACPI_DESCRIPTION_HEADER) + // for ACPI 2.0/3.0 RSDT
358 NewMaxTableNumber * sizeof (UINT32);
359 }
360
361 //
362 // Allocate memory in the lower 32 bit of address range for
363 // compatibility with ACPI 1.0 OS.
364 //
365 // This is done because ACPI 1.0 pointers are 32 bit values.
366 // ACPI 2.0 OS and all 64 bit OS must use the 64 bit ACPI table addresses.
367 // There is no architectural reason these should be below 4GB, it is purely
368 // for convenience of implementation that we force memory below 4GB.
369 //
370 PageAddress = 0xFFFFFFFF;
371 Status = gBS->AllocatePages (
372 mAcpiTableAllocType,
373 EfiACPIReclaimMemory,
374 EFI_SIZE_TO_PAGES (TotalSize),
375 &PageAddress
376 );
377
378 if (EFI_ERROR (Status)) {
379 return EFI_OUT_OF_RESOURCES;
380 }
381
382 Pointer = (UINT8 *) (UINTN) PageAddress;
383 ZeroMem (Pointer, TotalSize);
384
385 AcpiTableInstance->Rsdt1 = (EFI_ACPI_DESCRIPTION_HEADER *) Pointer;
386 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
387 Pointer += (sizeof (EFI_ACPI_DESCRIPTION_HEADER) + NewMaxTableNumber * sizeof (UINT32));
388 AcpiTableInstance->Rsdt3 = (EFI_ACPI_DESCRIPTION_HEADER *) Pointer;
389 Pointer += (sizeof (EFI_ACPI_DESCRIPTION_HEADER) + NewMaxTableNumber * sizeof (UINT32));
390 }
391 AcpiTableInstance->Xsdt = (EFI_ACPI_DESCRIPTION_HEADER *) Pointer;
392
393 //
394 // Update RSDP to point to the new Rsdt and Xsdt address.
395 //
396 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
397 AcpiTableInstance->Rsdp1->RsdtAddress = (UINT32) (UINTN) AcpiTableInstance->Rsdt1;
398 AcpiTableInstance->Rsdp3->RsdtAddress = (UINT32) (UINTN) AcpiTableInstance->Rsdt3;
399 }
400 CurrentData = (UINT64) (UINTN) AcpiTableInstance->Xsdt;
401 CopyMem (&AcpiTableInstance->Rsdp3->XsdtAddress, &CurrentData, sizeof (UINT64));
402
403 //
404 // copy the original Rsdt1, Rsdt3 and Xsdt structure to new buffer
405 //
406 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
407 CopyMem (AcpiTableInstance->Rsdt1, TempPrivateData.Rsdt1, (sizeof (EFI_ACPI_DESCRIPTION_HEADER) + mEfiAcpiMaxNumTables * sizeof (UINT32)));
408 CopyMem (AcpiTableInstance->Rsdt3, TempPrivateData.Rsdt3, (sizeof (EFI_ACPI_DESCRIPTION_HEADER) + mEfiAcpiMaxNumTables * sizeof (UINT32)));
409 }
410 CopyMem (AcpiTableInstance->Xsdt, TempPrivateData.Xsdt, (sizeof (EFI_ACPI_DESCRIPTION_HEADER) + mEfiAcpiMaxNumTables * sizeof (UINT64)));
411
412 //
413 // Calculate orignal ACPI table buffer size
414 //
415 TotalSize = sizeof (EFI_ACPI_DESCRIPTION_HEADER) + // for ACPI 2.0/3.0 XSDT
416 mEfiAcpiMaxNumTables * sizeof (UINT64);
417
418 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
419 TotalSize += sizeof (EFI_ACPI_DESCRIPTION_HEADER) + // for ACPI 1.0 RSDT
420 mEfiAcpiMaxNumTables * sizeof (UINT32) +
421 sizeof (EFI_ACPI_DESCRIPTION_HEADER) + // for ACPI 2.0/3.0 RSDT
422 mEfiAcpiMaxNumTables * sizeof (UINT32);
423 }
424
425 gBS->FreePages ((EFI_PHYSICAL_ADDRESS)(UINTN)TempPrivateData.Rsdt1, EFI_SIZE_TO_PAGES (TotalSize));
426
427 //
428 // Update the Max ACPI table number
429 //
430 mEfiAcpiMaxNumTables = NewMaxTableNumber;
431 return EFI_SUCCESS;
432 }
433 /**
434 This function adds an ACPI table to the table list. It will detect FACS and
435 allocate the correct type of memory and properly align the table.
436
437 @param AcpiTableInstance Instance of the protocol.
438 @param Table Table to add.
439 @param Checksum Does the table require checksumming.
440 @param Version The version of the list to add the table to.
441 @param Handle Pointer for returning the handle.
442
443 @return EFI_SUCCESS The function completed successfully.
444 @return EFI_OUT_OF_RESOURCES Could not allocate a required resource.
445 @retval EFI_ACCESS_DENIED The table signature matches a table already
446 present in the system and platform policy
447 does not allow duplicate tables of this type.
448
449 **/
450 EFI_STATUS
451 AddTableToList (
452 IN EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance,
453 IN VOID *Table,
454 IN BOOLEAN Checksum,
455 IN EFI_ACPI_TABLE_VERSION Version,
456 OUT UINTN *Handle
457 )
458 {
459 EFI_STATUS Status;
460 EFI_ACPI_TABLE_LIST *CurrentTableList;
461 UINT32 CurrentTableSignature;
462 UINT32 CurrentTableSize;
463 UINT32 *CurrentRsdtEntry;
464 VOID *CurrentXsdtEntry;
465 UINT64 Buffer64;
466 BOOLEAN AddToRsdt;
467
468 //
469 // Check for invalid input parameters
470 //
471 ASSERT (AcpiTableInstance);
472 ASSERT (Table);
473 ASSERT (Handle);
474
475 //
476 // Init locals
477 //
478 AddToRsdt = TRUE;
479
480 //
481 // Create a new list entry
482 //
483 CurrentTableList = AllocatePool (sizeof (EFI_ACPI_TABLE_LIST));
484 ASSERT (CurrentTableList);
485
486 //
487 // Determine table type and size
488 //
489 CurrentTableSignature = ((EFI_ACPI_COMMON_HEADER *) Table)->Signature;
490 CurrentTableSize = ((EFI_ACPI_COMMON_HEADER *) Table)->Length;
491
492 //
493 // Allocate a buffer for the table. All tables are allocated in the lower 32 bits of address space
494 // for backwards compatibility with ACPI 1.0 OS.
495 //
496 // This is done because ACPI 1.0 pointers are 32 bit values.
497 // ACPI 2.0 OS and all 64 bit OS must use the 64 bit ACPI table addresses.
498 // There is no architectural reason these should be below 4GB, it is purely
499 // for convenience of implementation that we force memory below 4GB.
500 //
501 CurrentTableList->PageAddress = 0xFFFFFFFF;
502 CurrentTableList->NumberOfPages = EFI_SIZE_TO_PAGES (CurrentTableSize);
503
504 //
505 // Allocation memory type depends on the type of the table
506 //
507 if ((CurrentTableSignature == EFI_ACPI_2_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE) ||
508 (CurrentTableSignature == EFI_ACPI_4_0_UEFI_ACPI_DATA_TABLE_SIGNATURE)) {
509 //
510 // Allocate memory for the FACS. This structure must be aligned
511 // on a 64 byte boundary and must be ACPI NVS memory.
512 // Using AllocatePages should ensure that it is always aligned.
513 // Do not change signature for new ACPI version because they are same.
514 //
515 // UEFI table also need to be in ACPI NVS memory, because some data field
516 // could be updated by OS present agent. For example, BufferPtrAddress in
517 // SMM communication ACPI table.
518 //
519 ASSERT ((EFI_PAGE_SIZE % 64) == 0);
520 Status = gBS->AllocatePages (
521 AllocateMaxAddress,
522 EfiACPIMemoryNVS,
523 CurrentTableList->NumberOfPages,
524 &CurrentTableList->PageAddress
525 );
526 } else {
527 //
528 // All other tables are ACPI reclaim memory, no alignment requirements.
529 //
530 Status = gBS->AllocatePages (
531 mAcpiTableAllocType,
532 EfiACPIReclaimMemory,
533 CurrentTableList->NumberOfPages,
534 &CurrentTableList->PageAddress
535 );
536 }
537 //
538 // Check return value from memory alloc.
539 //
540 if (EFI_ERROR (Status)) {
541 gBS->FreePool (CurrentTableList);
542 return EFI_OUT_OF_RESOURCES;
543 }
544 //
545 // Update the table pointer with the allocated memory start
546 //
547 CurrentTableList->Table = (EFI_ACPI_COMMON_HEADER *) (UINTN) CurrentTableList->PageAddress;
548
549 //
550 // Initialize the table contents
551 //
552 CurrentTableList->Signature = EFI_ACPI_TABLE_LIST_SIGNATURE;
553 CopyMem (CurrentTableList->Table, Table, CurrentTableSize);
554 CurrentTableList->Handle = AcpiTableInstance->CurrentHandle++;
555 *Handle = CurrentTableList->Handle;
556 CurrentTableList->Version = Version;
557
558 //
559 // Update internal pointers if this is a required table. If it is a required
560 // table and a table of that type already exists, return an error.
561 //
562 // Calculate the checksum if the table is not FACS.
563 //
564 switch (CurrentTableSignature) {
565
566 case EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE:
567 //
568 // We don't add the FADT in the standard way because some
569 // OS expect the FADT to be early in the table list.
570 // So we always add it as the first element in the list.
571 //
572 AddToRsdt = FALSE;
573
574 //
575 // Check that the table has not been previously added.
576 //
577 if (((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0 && AcpiTableInstance->Fadt1 != NULL) ||
578 ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0 && AcpiTableInstance->Fadt3 != NULL)
579 ) {
580 gBS->FreePages (CurrentTableList->PageAddress, CurrentTableList->NumberOfPages);
581 gBS->FreePool (CurrentTableList);
582 return EFI_ACCESS_DENIED;
583 }
584 //
585 // Add the table to the appropriate table version
586 //
587 if ((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
588 //
589 // Save a pointer to the table
590 //
591 AcpiTableInstance->Fadt1 = (EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE *) CurrentTableList->Table;
592
593 //
594 // Update pointers in FADT. If tables don't exist this will put NULL pointers there.
595 //
596 AcpiTableInstance->Fadt1->FirmwareCtrl = (UINT32) (UINTN) AcpiTableInstance->Facs1;
597 AcpiTableInstance->Fadt1->Dsdt = (UINT32) (UINTN) AcpiTableInstance->Dsdt1;
598
599 //
600 // RSDP OEM information is updated to match the FADT OEM information
601 //
602 CopyMem (
603 &AcpiTableInstance->Rsdp1->OemId,
604 &AcpiTableInstance->Fadt1->Header.OemId,
605 6
606 );
607
608 //
609 // RSDT OEM information is updated to match the FADT OEM information.
610 //
611 CopyMem (
612 &AcpiTableInstance->Rsdt1->OemId,
613 &AcpiTableInstance->Fadt1->Header.OemId,
614 6
615 );
616
617 CopyMem (
618 &AcpiTableInstance->Rsdt1->OemTableId,
619 &AcpiTableInstance->Fadt1->Header.OemTableId,
620 sizeof (UINT64)
621 );
622 AcpiTableInstance->Rsdt1->OemRevision = AcpiTableInstance->Fadt1->Header.OemRevision;
623 }
624
625 if ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0) {
626 //
627 // Save a pointer to the table
628 //
629 AcpiTableInstance->Fadt3 = (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *) CurrentTableList->Table;
630
631 //
632 // Update pointers in FADT. If tables don't exist this will put NULL pointers there.
633 // Note: If the FIRMWARE_CTRL is non-zero, then X_FIRMWARE_CTRL must be zero, and
634 // vice-versa.
635 //
636 if ((UINT64)(UINTN)AcpiTableInstance->Facs3 < BASE_4GB) {
637 AcpiTableInstance->Fadt3->FirmwareCtrl = (UINT32) (UINTN) AcpiTableInstance->Facs3;
638 ZeroMem (&AcpiTableInstance->Fadt3->XFirmwareCtrl, sizeof (UINT64));
639 } else {
640 Buffer64 = (UINT64) (UINTN) AcpiTableInstance->Facs3;
641 CopyMem (
642 &AcpiTableInstance->Fadt3->XFirmwareCtrl,
643 &Buffer64,
644 sizeof (UINT64)
645 );
646 AcpiTableInstance->Fadt3->FirmwareCtrl = 0;
647 }
648 if ((UINT64)(UINTN)AcpiTableInstance->Dsdt3 < BASE_4GB) {
649 AcpiTableInstance->Fadt3->Dsdt = (UINT32) (UINTN) AcpiTableInstance->Dsdt3;
650 ZeroMem (&AcpiTableInstance->Fadt3->XDsdt, sizeof (UINT64));
651 } else {
652 AcpiTableInstance->Fadt3->Dsdt = 0;
653 Buffer64 = (UINT64) (UINTN) AcpiTableInstance->Dsdt3;
654 CopyMem (&AcpiTableInstance->Fadt3->XDsdt, &Buffer64, sizeof (UINT64));
655 }
656
657 //
658 // RSDP OEM information is updated to match the FADT OEM information
659 //
660 CopyMem (
661 &AcpiTableInstance->Rsdp3->OemId,
662 &AcpiTableInstance->Fadt3->Header.OemId,
663 6
664 );
665
666 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
667 //
668 // RSDT OEM information is updated to match FADT OEM information.
669 //
670 CopyMem (
671 &AcpiTableInstance->Rsdt3->OemId,
672 &AcpiTableInstance->Fadt3->Header.OemId,
673 6
674 );
675 CopyMem (
676 &AcpiTableInstance->Rsdt3->OemTableId,
677 &AcpiTableInstance->Fadt3->Header.OemTableId,
678 sizeof (UINT64)
679 );
680 AcpiTableInstance->Rsdt3->OemRevision = AcpiTableInstance->Fadt3->Header.OemRevision;
681 }
682
683 //
684 // XSDT OEM information is updated to match FADT OEM information.
685 //
686 CopyMem (
687 &AcpiTableInstance->Xsdt->OemId,
688 &AcpiTableInstance->Fadt3->Header.OemId,
689 6
690 );
691 CopyMem (
692 &AcpiTableInstance->Xsdt->OemTableId,
693 &AcpiTableInstance->Fadt3->Header.OemTableId,
694 sizeof (UINT64)
695 );
696 AcpiTableInstance->Xsdt->OemRevision = AcpiTableInstance->Fadt3->Header.OemRevision;
697 }
698 //
699 // Checksum the table
700 //
701 if (Checksum) {
702 AcpiPlatformChecksum (
703 CurrentTableList->Table,
704 CurrentTableList->Table->Length,
705 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
706 Checksum)
707 );
708 }
709 break;
710
711 case EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE:
712 //
713 // Check that the table has not been previously added.
714 //
715 if (((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0 && AcpiTableInstance->Facs1 != NULL) ||
716 ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0 && AcpiTableInstance->Facs3 != NULL)
717 ) {
718 gBS->FreePages (CurrentTableList->PageAddress, CurrentTableList->NumberOfPages);
719 gBS->FreePool (CurrentTableList);
720 return EFI_ACCESS_DENIED;
721 }
722 //
723 // FACS is referenced by FADT and is not part of RSDT
724 //
725 AddToRsdt = FALSE;
726
727 //
728 // Add the table to the appropriate table version
729 //
730 if ((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
731 //
732 // Save a pointer to the table
733 //
734 AcpiTableInstance->Facs1 = (EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *) CurrentTableList->Table;
735
736 //
737 // If FADT already exists, update table pointers.
738 //
739 if (AcpiTableInstance->Fadt1 != NULL) {
740 AcpiTableInstance->Fadt1->FirmwareCtrl = (UINT32) (UINTN) AcpiTableInstance->Facs1;
741
742 //
743 // Checksum FADT table
744 //
745 AcpiPlatformChecksum (
746 AcpiTableInstance->Fadt1,
747 AcpiTableInstance->Fadt1->Header.Length,
748 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
749 Checksum)
750 );
751 }
752 }
753
754 if ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0) {
755 //
756 // Save a pointer to the table
757 //
758 AcpiTableInstance->Facs3 = (EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *) CurrentTableList->Table;
759
760 //
761 // If FADT already exists, update table pointers.
762 //
763 if (AcpiTableInstance->Fadt3 != NULL) {
764 //
765 // Note: If the FIRMWARE_CTRL is non-zero, then X_FIRMWARE_CTRL must be zero, and
766 // vice-versa.
767 //
768 if ((UINT64)(UINTN)AcpiTableInstance->Facs3 < BASE_4GB) {
769 AcpiTableInstance->Fadt3->FirmwareCtrl = (UINT32) (UINTN) AcpiTableInstance->Facs3;
770 ZeroMem (&AcpiTableInstance->Fadt3->XFirmwareCtrl, sizeof (UINT64));
771 } else {
772 Buffer64 = (UINT64) (UINTN) AcpiTableInstance->Facs3;
773 CopyMem (
774 &AcpiTableInstance->Fadt3->XFirmwareCtrl,
775 &Buffer64,
776 sizeof (UINT64)
777 );
778 AcpiTableInstance->Fadt3->FirmwareCtrl = 0;
779 }
780
781 //
782 // Checksum FADT table
783 //
784 AcpiPlatformChecksum (
785 AcpiTableInstance->Fadt3,
786 AcpiTableInstance->Fadt3->Header.Length,
787 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
788 Checksum)
789 );
790 }
791 }
792
793 break;
794
795 case EFI_ACPI_1_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE:
796 //
797 // Check that the table has not been previously added.
798 //
799 if (((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0 && AcpiTableInstance->Dsdt1 != NULL) ||
800 ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0 && AcpiTableInstance->Dsdt3 != NULL)
801 ) {
802 gBS->FreePages (CurrentTableList->PageAddress, CurrentTableList->NumberOfPages);
803 gBS->FreePool (CurrentTableList);
804 return EFI_ACCESS_DENIED;
805 }
806 //
807 // DSDT is referenced by FADT and is not part of RSDT
808 //
809 AddToRsdt = FALSE;
810
811 //
812 // Add the table to the appropriate table version
813 //
814 if ((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
815 //
816 // Save a pointer to the table
817 //
818 AcpiTableInstance->Dsdt1 = (EFI_ACPI_DESCRIPTION_HEADER *) CurrentTableList->Table;
819
820 //
821 // If FADT already exists, update table pointers.
822 //
823 if (AcpiTableInstance->Fadt1 != NULL) {
824 AcpiTableInstance->Fadt1->Dsdt = (UINT32) (UINTN) AcpiTableInstance->Dsdt1;
825
826 //
827 // Checksum FADT table
828 //
829 AcpiPlatformChecksum (
830 AcpiTableInstance->Fadt1,
831 AcpiTableInstance->Fadt1->Header.Length,
832 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
833 Checksum)
834 );
835 }
836 }
837
838 if ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0) {
839 //
840 // Save a pointer to the table
841 //
842 AcpiTableInstance->Dsdt3 = (EFI_ACPI_DESCRIPTION_HEADER *) CurrentTableList->Table;
843
844 //
845 // If FADT already exists, update table pointers.
846 //
847 if (AcpiTableInstance->Fadt3 != NULL) {
848 if ((UINT64)(UINTN)AcpiTableInstance->Dsdt3 < BASE_4GB) {
849 AcpiTableInstance->Fadt3->Dsdt = (UINT32) (UINTN) AcpiTableInstance->Dsdt3;
850 }
851 Buffer64 = (UINT64) (UINTN) AcpiTableInstance->Dsdt3;
852 CopyMem (&AcpiTableInstance->Fadt3->XDsdt, &Buffer64, sizeof (UINT64));
853
854 //
855 // Checksum FADT table
856 //
857 AcpiPlatformChecksum (
858 AcpiTableInstance->Fadt3,
859 AcpiTableInstance->Fadt3->Header.Length,
860 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
861 Checksum)
862 );
863 }
864 }
865 //
866 // Checksum the table
867 //
868 if (Checksum) {
869 AcpiPlatformChecksum (
870 CurrentTableList->Table,
871 CurrentTableList->Table->Length,
872 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
873 Checksum)
874 );
875 }
876 break;
877
878 default:
879 //
880 // Checksum the table
881 //
882 if (Checksum) {
883 AcpiPlatformChecksum (
884 CurrentTableList->Table,
885 CurrentTableList->Table->Length,
886 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
887 Checksum)
888 );
889 }
890 break;
891 }
892 //
893 // Add the table to the current list of tables
894 //
895 InsertTailList (&AcpiTableInstance->TableList, &CurrentTableList->Link);
896
897 //
898 // Add the table to RSDT and/or XSDT table entry lists.
899 //
900 //
901 // Add to ACPI 1.0b table tree
902 //
903 if ((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
904 if (AddToRsdt) {
905 //
906 // If the table number exceed the gEfiAcpiMaxNumTables, enlarge the table buffer
907 //
908 if (AcpiTableInstance->NumberOfTableEntries1 >= mEfiAcpiMaxNumTables) {
909 Status = ReallocateAcpiTableBuffer (AcpiTableInstance);
910 ASSERT_EFI_ERROR (Status);
911 }
912 CurrentRsdtEntry = (UINT32 *)
913 (
914 (UINT8 *) AcpiTableInstance->Rsdt1 +
915 sizeof (EFI_ACPI_DESCRIPTION_HEADER) +
916 AcpiTableInstance->NumberOfTableEntries1 *
917 sizeof (UINT32)
918 );
919
920 //
921 // Add entry to the RSDT unless its the FACS or DSDT
922 //
923 *CurrentRsdtEntry = (UINT32) (UINTN) CurrentTableList->Table;
924
925 //
926 // Update RSDT length
927 //
928 AcpiTableInstance->Rsdt1->Length = AcpiTableInstance->Rsdt1->Length + sizeof (UINT32);
929
930 AcpiTableInstance->NumberOfTableEntries1++;
931 }
932 }
933 //
934 // Add to ACPI 2.0/3.0 table tree
935 //
936 if ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0) {
937 if (AddToRsdt) {
938 //
939 // If the table number exceed the gEfiAcpiMaxNumTables, enlarge the table buffer
940 //
941 if (AcpiTableInstance->NumberOfTableEntries3 >= mEfiAcpiMaxNumTables) {
942 Status = ReallocateAcpiTableBuffer (AcpiTableInstance);
943 ASSERT_EFI_ERROR (Status);
944 }
945
946 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
947 //
948 // At this time, it is assumed that RSDT and XSDT maintain parallel lists of tables.
949 // If it becomes necessary to maintain separate table lists, changes will be required.
950 //
951 CurrentRsdtEntry = (UINT32 *)
952 (
953 (UINT8 *) AcpiTableInstance->Rsdt3 +
954 sizeof (EFI_ACPI_DESCRIPTION_HEADER) +
955 AcpiTableInstance->NumberOfTableEntries3 *
956 sizeof (UINT32)
957 );
958
959 //
960 // Add entry to the RSDT
961 //
962 *CurrentRsdtEntry = (UINT32) (UINTN) CurrentTableList->Table;
963
964 //
965 // Update RSDT length
966 //
967 AcpiTableInstance->Rsdt3->Length = AcpiTableInstance->Rsdt3->Length + sizeof (UINT32);
968 }
969
970 //
971 // This pointer must not be directly dereferenced as the XSDT entries may not
972 // be 64 bit aligned resulting in a possible fault. Use CopyMem to update.
973 //
974 CurrentXsdtEntry = (VOID *)
975 (
976 (UINT8 *) AcpiTableInstance->Xsdt +
977 sizeof (EFI_ACPI_DESCRIPTION_HEADER) +
978 AcpiTableInstance->NumberOfTableEntries3 *
979 sizeof (UINT64)
980 );
981
982 //
983 // Add entry to XSDT, XSDT expects 64 bit pointers, but
984 // the table pointers in XSDT are not aligned on 8 byte boundary.
985 //
986 Buffer64 = (UINT64) (UINTN) CurrentTableList->Table;
987 CopyMem (
988 CurrentXsdtEntry,
989 &Buffer64,
990 sizeof (UINT64)
991 );
992
993 //
994 // Update length
995 //
996 AcpiTableInstance->Xsdt->Length = AcpiTableInstance->Xsdt->Length + sizeof (UINT64);
997
998 AcpiTableInstance->NumberOfTableEntries3++;
999 }
1000 }
1001
1002 ChecksumCommonTables (AcpiTableInstance);
1003 return EFI_SUCCESS;
1004 }
1005
1006
1007 /**
1008 This function finds the table specified by the handle and returns a pointer to it.
1009 If the handle is not found, EFI_NOT_FOUND is returned and the contents of Table are
1010 undefined.
1011
1012 @param Handle Table to find.
1013 @param TableList Table list to search
1014 @param Table Pointer to table found.
1015
1016 @return EFI_SUCCESS The function completed successfully.
1017 @return EFI_NOT_FOUND No table found matching the handle specified.
1018
1019 **/
1020 EFI_STATUS
1021 FindTableByHandle (
1022 IN UINTN Handle,
1023 IN LIST_ENTRY *TableList,
1024 OUT EFI_ACPI_TABLE_LIST **Table
1025 )
1026 {
1027 LIST_ENTRY *CurrentLink;
1028 EFI_ACPI_TABLE_LIST *CurrentTable;
1029
1030 //
1031 // Check for invalid input parameters
1032 //
1033 ASSERT (Table);
1034
1035 //
1036 // Find the table
1037 //
1038 CurrentLink = TableList->ForwardLink;
1039
1040 while (CurrentLink != TableList) {
1041 CurrentTable = EFI_ACPI_TABLE_LIST_FROM_LINK (CurrentLink);
1042 if (CurrentTable->Handle == Handle) {
1043 //
1044 // Found handle, so return this table.
1045 //
1046 *Table = CurrentTable;
1047 return EFI_SUCCESS;
1048 }
1049
1050 CurrentLink = CurrentLink->ForwardLink;
1051 }
1052 //
1053 // Table not found
1054 //
1055 return EFI_NOT_FOUND;
1056 }
1057
1058
1059 /**
1060 This function removes a basic table from the RSDT and/or XSDT.
1061 For Acpi 1.0 tables, pass in the Rsdt.
1062 For Acpi 2.0 tables, pass in both Rsdt and Xsdt.
1063
1064 @param Table Pointer to table found.
1065 @param NumberOfTableEntries Current number of table entries in the RSDT/XSDT
1066 @param Rsdt Pointer to the RSDT to remove from
1067 @param Xsdt Pointer to the Xsdt to remove from
1068
1069 @return EFI_SUCCESS The function completed successfully.
1070 @return EFI_INVALID_PARAMETER The table was not found in both Rsdt and Xsdt.
1071
1072 **/
1073 EFI_STATUS
1074 RemoveTableFromRsdt (
1075 IN OUT EFI_ACPI_TABLE_LIST * Table,
1076 IN OUT UINTN *NumberOfTableEntries,
1077 IN OUT EFI_ACPI_DESCRIPTION_HEADER * Rsdt OPTIONAL,
1078 IN OUT EFI_ACPI_DESCRIPTION_HEADER * Xsdt OPTIONAL
1079 )
1080 {
1081 UINT32 *CurrentRsdtEntry;
1082 VOID *CurrentXsdtEntry;
1083 UINT64 CurrentTablePointer64;
1084 UINTN Index;
1085
1086 //
1087 // Check for invalid input parameters
1088 //
1089 ASSERT (Table);
1090 ASSERT (NumberOfTableEntries);
1091 ASSERT (Rsdt || Xsdt);
1092
1093 //
1094 // Find the table entry in the RSDT and XSDT
1095 //
1096 for (Index = 0; Index < *NumberOfTableEntries; Index++) {
1097 //
1098 // At this time, it is assumed that RSDT and XSDT maintain parallel lists of tables.
1099 // If it becomes necessary to maintain separate table lists, changes will be required.
1100 //
1101 if (Rsdt != NULL) {
1102 CurrentRsdtEntry = (UINT32 *) ((UINT8 *) Rsdt + sizeof (EFI_ACPI_DESCRIPTION_HEADER) + Index * sizeof (UINT32));
1103 } else {
1104 CurrentRsdtEntry = NULL;
1105 }
1106 if (Xsdt != NULL) {
1107 //
1108 // This pointer must not be directly dereferenced as the XSDT entries may not
1109 // be 64 bit aligned resulting in a possible fault. Use CopyMem to update.
1110 //
1111 CurrentXsdtEntry = (VOID *) ((UINT8 *) Xsdt + sizeof (EFI_ACPI_DESCRIPTION_HEADER) + Index * sizeof (UINT64));
1112
1113 //
1114 // Read the entry value out of the XSDT
1115 //
1116 CopyMem (&CurrentTablePointer64, CurrentXsdtEntry, sizeof (UINT64));
1117 } else {
1118 //
1119 // Initialize to NULL
1120 //
1121 CurrentXsdtEntry = 0;
1122 CurrentTablePointer64 = 0;
1123 }
1124 //
1125 // Check if we have found the corresponding entry in both RSDT and XSDT
1126 //
1127 if (((Rsdt == NULL) || *CurrentRsdtEntry == (UINT32) (UINTN) Table->Table) &&
1128 ((Xsdt == NULL) || CurrentTablePointer64 == (UINT64) (UINTN) Table->Table)
1129 ) {
1130 //
1131 // Found entry, so copy all following entries and shrink table
1132 // We actually copy all + 1 to copy the initialized value of memory over
1133 // the last entry.
1134 //
1135 if (Rsdt != NULL) {
1136 CopyMem (CurrentRsdtEntry, CurrentRsdtEntry + 1, (*NumberOfTableEntries - Index) * sizeof (UINT32));
1137 Rsdt->Length = Rsdt->Length - sizeof (UINT32);
1138 }
1139 if (Xsdt != NULL) {
1140 CopyMem (CurrentXsdtEntry, ((UINT64 *) CurrentXsdtEntry) + 1, (*NumberOfTableEntries - Index) * sizeof (UINT64));
1141 Xsdt->Length = Xsdt->Length - sizeof (UINT64);
1142 }
1143 break;
1144 } else if (Index + 1 == *NumberOfTableEntries) {
1145 //
1146 // At the last entry, and table not found
1147 //
1148 return EFI_INVALID_PARAMETER;
1149 }
1150 }
1151 //
1152 // Checksum the tables
1153 //
1154 if (Rsdt != NULL) {
1155 AcpiPlatformChecksum (
1156 Rsdt,
1157 Rsdt->Length,
1158 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
1159 Checksum)
1160 );
1161 }
1162
1163 if (Xsdt != NULL) {
1164 AcpiPlatformChecksum (
1165 Xsdt,
1166 Xsdt->Length,
1167 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
1168 Checksum)
1169 );
1170 }
1171 //
1172 // Decrement the number of tables
1173 //
1174 (*NumberOfTableEntries)--;
1175
1176 return EFI_SUCCESS;
1177 }
1178
1179
1180 /**
1181 This function removes a table and frees any associated memory.
1182
1183 @param AcpiTableInstance Instance of the protocol.
1184 @param Version Version(s) to delete.
1185 @param Table Pointer to table found.
1186
1187 @return EFI_SUCCESS The function completed successfully.
1188
1189 **/
1190 EFI_STATUS
1191 DeleteTable (
1192 IN EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance,
1193 IN EFI_ACPI_TABLE_VERSION Version,
1194 IN OUT EFI_ACPI_TABLE_LIST *Table
1195 )
1196 {
1197 UINT32 CurrentTableSignature;
1198 BOOLEAN RemoveFromRsdt;
1199
1200 //
1201 // Check for invalid input parameters
1202 //
1203 ASSERT (AcpiTableInstance);
1204 ASSERT (Table);
1205
1206 //
1207 // Init locals
1208 //
1209 RemoveFromRsdt = TRUE;
1210 //
1211 // Check for Table->Table
1212 //
1213 ASSERT (Table->Table != NULL);
1214 CurrentTableSignature = ((EFI_ACPI_COMMON_HEADER *) Table->Table)->Signature;
1215
1216 //
1217 // Basic tasks to accomplish delete are:
1218 // Determine removal requirements (in RSDT/XSDT or not)
1219 // Remove entry from RSDT/XSDT
1220 // Remove any table references to the table
1221 // If no one is using the table
1222 // Free the table (removing pointers from private data and tables)
1223 // Remove from list
1224 // Free list structure
1225 //
1226 //
1227 // Determine if this table is in the RSDT or XSDT
1228 //
1229 if ((CurrentTableSignature == EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE) ||
1230 (CurrentTableSignature == EFI_ACPI_2_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) ||
1231 (CurrentTableSignature == EFI_ACPI_3_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE)
1232 ) {
1233 RemoveFromRsdt = FALSE;
1234 }
1235 //
1236 // We don't remove the FADT in the standard way because some
1237 // OS expect the FADT to be early in the table list.
1238 // So we always put it as the first element in the list.
1239 //
1240 if (CurrentTableSignature == EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE) {
1241 RemoveFromRsdt = FALSE;
1242 }
1243
1244 //
1245 // Remove the table from RSDT and XSDT
1246 //
1247 if (Table->Table != NULL) {
1248 //
1249 // This is a basic table, remove it from any lists and the Rsdt and/or Xsdt
1250 //
1251 if (Version & EFI_ACPI_TABLE_VERSION_NONE & Table->Version) {
1252 //
1253 // Remove this version from the table
1254 //
1255 Table->Version = Table->Version &~EFI_ACPI_TABLE_VERSION_NONE;
1256 }
1257
1258 if (Version & EFI_ACPI_TABLE_VERSION_1_0B & Table->Version) {
1259 //
1260 // Remove this version from the table
1261 //
1262 Table->Version = Table->Version &~EFI_ACPI_TABLE_VERSION_1_0B;
1263
1264 //
1265 // Remove from Rsdt. We don't care about the return value because it is
1266 // acceptable for the table to not exist in Rsdt.
1267 // We didn't add some tables so we don't remove them.
1268 //
1269 if (RemoveFromRsdt) {
1270 RemoveTableFromRsdt (
1271 Table,
1272 &AcpiTableInstance->NumberOfTableEntries1,
1273 AcpiTableInstance->Rsdt1,
1274 NULL
1275 );
1276 }
1277 }
1278
1279 if (Version & ACPI_TABLE_VERSION_GTE_2_0 & Table->Version) {
1280 //
1281 // Remove this version from the table
1282 //
1283 Table->Version = Table->Version &~(Version & ACPI_TABLE_VERSION_GTE_2_0);
1284
1285 //
1286 // Remove from Rsdt and Xsdt. We don't care about the return value
1287 // because it is acceptable for the table to not exist in Rsdt/Xsdt.
1288 // We didn't add some tables so we don't remove them.
1289 //
1290 if (RemoveFromRsdt) {
1291 RemoveTableFromRsdt (
1292 Table,
1293 &AcpiTableInstance->NumberOfTableEntries3,
1294 AcpiTableInstance->Rsdt3,
1295 AcpiTableInstance->Xsdt
1296 );
1297 }
1298 }
1299 //
1300 // Free the table, clean up any dependent tables and our private data pointers.
1301 //
1302 switch (Table->Table->Signature) {
1303
1304 case EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE:
1305 if ((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1306 AcpiTableInstance->Fadt1 = NULL;
1307 }
1308
1309 if ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0) {
1310 AcpiTableInstance->Fadt3 = NULL;
1311 }
1312 break;
1313
1314 case EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE:
1315 if ((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1316 AcpiTableInstance->Facs1 = NULL;
1317
1318 //
1319 // Update FADT table pointers
1320 //
1321 if (AcpiTableInstance->Fadt1 != NULL) {
1322 AcpiTableInstance->Fadt1->FirmwareCtrl = 0;
1323
1324 //
1325 // Checksum table
1326 //
1327 AcpiPlatformChecksum (
1328 AcpiTableInstance->Fadt1,
1329 AcpiTableInstance->Fadt1->Header.Length,
1330 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
1331 Checksum)
1332 );
1333 }
1334 }
1335
1336 if ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0) {
1337 AcpiTableInstance->Facs3 = NULL;
1338
1339 //
1340 // Update FADT table pointers
1341 //
1342 if (AcpiTableInstance->Fadt3 != NULL) {
1343 AcpiTableInstance->Fadt3->FirmwareCtrl = 0;
1344 ZeroMem (&AcpiTableInstance->Fadt3->XFirmwareCtrl, sizeof (UINT64));
1345
1346 //
1347 // Checksum table
1348 //
1349 AcpiPlatformChecksum (
1350 AcpiTableInstance->Fadt3,
1351 AcpiTableInstance->Fadt3->Header.Length,
1352 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
1353 Checksum)
1354 );
1355 }
1356 }
1357 break;
1358
1359 case EFI_ACPI_3_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE:
1360 if ((Version & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1361 AcpiTableInstance->Dsdt1 = NULL;
1362
1363 //
1364 // Update FADT table pointers
1365 //
1366 if (AcpiTableInstance->Fadt1 != NULL) {
1367 AcpiTableInstance->Fadt1->Dsdt = 0;
1368
1369 //
1370 // Checksum table
1371 //
1372 AcpiPlatformChecksum (
1373 AcpiTableInstance->Fadt1,
1374 AcpiTableInstance->Fadt1->Header.Length,
1375 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
1376 Checksum)
1377 );
1378 }
1379 }
1380
1381
1382 if ((Version & ACPI_TABLE_VERSION_GTE_2_0) != 0) {
1383 AcpiTableInstance->Dsdt3 = NULL;
1384
1385 //
1386 // Update FADT table pointers
1387 //
1388 if (AcpiTableInstance->Fadt3 != NULL) {
1389 AcpiTableInstance->Fadt3->Dsdt = 0;
1390 ZeroMem (&AcpiTableInstance->Fadt3->XDsdt, sizeof (UINT64));
1391
1392 //
1393 // Checksum table
1394 //
1395 AcpiPlatformChecksum (
1396 AcpiTableInstance->Fadt3,
1397 AcpiTableInstance->Fadt3->Header.Length,
1398 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
1399 Checksum)
1400 );
1401 }
1402 }
1403 break;
1404
1405 default:
1406 //
1407 // Do nothing
1408 //
1409 break;
1410 }
1411 }
1412 //
1413 // If no version is using this table anymore, remove and free list entry.
1414 //
1415 if (Table->Version == 0) {
1416 //
1417 // Free the Table
1418 //
1419 gBS->FreePages (Table->PageAddress, Table->NumberOfPages);
1420 RemoveEntryList (&(Table->Link));
1421 gBS->FreePool (Table);
1422 }
1423 //
1424 // Done
1425 //
1426 return EFI_SUCCESS;
1427 }
1428
1429
1430 /**
1431 This function finds and removes the table specified by the handle.
1432
1433 @param AcpiTableInstance Instance of the protocol.
1434 @param Version Bitmask of which versions to remove.
1435 @param Handle Table to remove.
1436
1437 @return EFI_SUCCESS The function completed successfully.
1438 @return EFI_ABORTED An error occurred.
1439 @return EFI_NOT_FOUND Handle not found in table list.
1440
1441 **/
1442 EFI_STATUS
1443 RemoveTableFromList (
1444 IN EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance,
1445 IN EFI_ACPI_TABLE_VERSION Version,
1446 IN UINTN Handle
1447 )
1448 {
1449 EFI_ACPI_TABLE_LIST *Table;
1450 EFI_STATUS Status;
1451
1452 Table = (EFI_ACPI_TABLE_LIST*) NULL;
1453
1454 //
1455 // Check for invalid input parameters
1456 //
1457 ASSERT (AcpiTableInstance);
1458
1459 //
1460 // Find the table
1461 //
1462 Status = FindTableByHandle (
1463 Handle,
1464 &AcpiTableInstance->TableList,
1465 &Table
1466 );
1467 if (EFI_ERROR (Status)) {
1468 return EFI_NOT_FOUND;
1469 }
1470 //
1471 // Remove the table
1472 //
1473 Status = DeleteTable (AcpiTableInstance, Version, Table);
1474 if (EFI_ERROR (Status)) {
1475 return EFI_ABORTED;
1476 }
1477 //
1478 // Completed successfully
1479 //
1480 return EFI_SUCCESS;
1481 }
1482
1483
1484 /**
1485 This function calculates and updates an UINT8 checksum.
1486
1487 @param Buffer Pointer to buffer to checksum
1488 @param Size Number of bytes to checksum
1489 @param ChecksumOffset Offset to place the checksum result in
1490
1491 @return EFI_SUCCESS The function completed successfully.
1492
1493 **/
1494 EFI_STATUS
1495 AcpiPlatformChecksum (
1496 IN VOID *Buffer,
1497 IN UINTN Size,
1498 IN UINTN ChecksumOffset
1499 )
1500 {
1501 UINT8 Sum;
1502 UINT8 *Ptr;
1503
1504 Sum = 0;
1505 //
1506 // Initialize pointer
1507 //
1508 Ptr = Buffer;
1509
1510 //
1511 // set checksum to 0 first
1512 //
1513 Ptr[ChecksumOffset] = 0;
1514
1515 //
1516 // add all content of buffer
1517 //
1518 while ((Size--) != 0) {
1519 Sum = (UINT8) (Sum + (*Ptr++));
1520 }
1521 //
1522 // set checksum
1523 //
1524 Ptr = Buffer;
1525 Ptr[ChecksumOffset] = (UINT8) (0xff - Sum + 1);
1526
1527 return EFI_SUCCESS;
1528 }
1529
1530
1531 /**
1532 Checksum all versions of the common tables, RSDP, RSDT, XSDT.
1533
1534 @param AcpiTableInstance Protocol instance private data.
1535
1536 @return EFI_SUCCESS The function completed successfully.
1537
1538 **/
1539 EFI_STATUS
1540 ChecksumCommonTables (
1541 IN OUT EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance
1542 )
1543 {
1544 //
1545 // RSDP ACPI 1.0 checksum for 1.0 table. This is only the first 20 bytes of the structure
1546 //
1547 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1548 AcpiPlatformChecksum (
1549 AcpiTableInstance->Rsdp1,
1550 sizeof (EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER),
1551 OFFSET_OF (EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER,
1552 Checksum)
1553 );
1554 }
1555
1556 //
1557 // RSDP ACPI 1.0 checksum for 2.0/3.0 table. This is only the first 20 bytes of the structure
1558 //
1559 AcpiPlatformChecksum (
1560 AcpiTableInstance->Rsdp3,
1561 sizeof (EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER),
1562 OFFSET_OF (EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER,
1563 Checksum)
1564 );
1565
1566 //
1567 // RSDP ACPI 2.0/3.0 checksum, this is the entire table
1568 //
1569 AcpiPlatformChecksum (
1570 AcpiTableInstance->Rsdp3,
1571 sizeof (EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER),
1572 OFFSET_OF (EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER,
1573 ExtendedChecksum)
1574 );
1575
1576 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1577 //
1578 // RSDT checksums
1579 //
1580 AcpiPlatformChecksum (
1581 AcpiTableInstance->Rsdt1,
1582 AcpiTableInstance->Rsdt1->Length,
1583 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
1584 Checksum)
1585 );
1586
1587 AcpiPlatformChecksum (
1588 AcpiTableInstance->Rsdt3,
1589 AcpiTableInstance->Rsdt3->Length,
1590 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
1591 Checksum)
1592 );
1593 }
1594
1595 //
1596 // XSDT checksum
1597 //
1598 AcpiPlatformChecksum (
1599 AcpiTableInstance->Xsdt,
1600 AcpiTableInstance->Xsdt->Length,
1601 OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER,
1602 Checksum)
1603 );
1604
1605 return EFI_SUCCESS;
1606 }
1607
1608
1609 /**
1610 Constructor for the ACPI table protocol. Initializes instance
1611 data.
1612
1613 @param AcpiTableInstance Instance to construct
1614
1615 @return EFI_SUCCESS Instance initialized.
1616 @return EFI_OUT_OF_RESOURCES Unable to allocate required resources.
1617
1618 **/
1619 EFI_STATUS
1620 AcpiTableAcpiTableConstructor (
1621 EFI_ACPI_TABLE_INSTANCE *AcpiTableInstance
1622 )
1623 {
1624 EFI_STATUS Status;
1625 UINT64 CurrentData;
1626 UINTN TotalSize;
1627 UINTN RsdpTableSize;
1628 UINT8 *Pointer;
1629 EFI_PHYSICAL_ADDRESS PageAddress;
1630
1631 //
1632 // Check for invalid input parameters
1633 //
1634 ASSERT (AcpiTableInstance);
1635
1636 //
1637 // If ACPI v1.0b is among the ACPI versions we aim to support, we have to
1638 // ensure that all memory allocations are below 4 GB.
1639 //
1640 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1641 mAcpiTableAllocType = AllocateMaxAddress;
1642 } else {
1643 mAcpiTableAllocType = AllocateAnyPages;
1644 }
1645
1646 InitializeListHead (&AcpiTableInstance->TableList);
1647 AcpiTableInstance->CurrentHandle = 1;
1648
1649 AcpiTableInstance->AcpiTableProtocol.InstallAcpiTable = InstallAcpiTable;
1650 AcpiTableInstance->AcpiTableProtocol.UninstallAcpiTable = UninstallAcpiTable;
1651
1652 if (FeaturePcdGet (PcdInstallAcpiSdtProtocol)) {
1653 SdtAcpiTableAcpiSdtConstructor (AcpiTableInstance);
1654 }
1655
1656 //
1657 // Create RSDP table
1658 //
1659 RsdpTableSize = sizeof (EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER);
1660 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1661 RsdpTableSize += sizeof (EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER);
1662 }
1663
1664 PageAddress = 0xFFFFFFFF;
1665 Status = gBS->AllocatePages (
1666 mAcpiTableAllocType,
1667 EfiACPIReclaimMemory,
1668 EFI_SIZE_TO_PAGES (RsdpTableSize),
1669 &PageAddress
1670 );
1671
1672 if (EFI_ERROR (Status)) {
1673 return EFI_OUT_OF_RESOURCES;
1674 }
1675
1676 Pointer = (UINT8 *) (UINTN) PageAddress;
1677 ZeroMem (Pointer, RsdpTableSize);
1678
1679 AcpiTableInstance->Rsdp1 = (EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER *) Pointer;
1680 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1681 Pointer += sizeof (EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER);
1682 }
1683 AcpiTableInstance->Rsdp3 = (EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER *) Pointer;
1684
1685 //
1686 // Create RSDT, XSDT structures
1687 //
1688 TotalSize = sizeof (EFI_ACPI_DESCRIPTION_HEADER) + // for ACPI 2.0/3.0 XSDT
1689 mEfiAcpiMaxNumTables * sizeof (UINT64);
1690
1691 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1692 TotalSize += sizeof (EFI_ACPI_DESCRIPTION_HEADER) + // for ACPI 1.0 RSDT
1693 mEfiAcpiMaxNumTables * sizeof (UINT32) +
1694 sizeof (EFI_ACPI_DESCRIPTION_HEADER) + // for ACPI 2.0/3.0 RSDT
1695 mEfiAcpiMaxNumTables * sizeof (UINT32);
1696 }
1697
1698 //
1699 // Allocate memory in the lower 32 bit of address range for
1700 // compatibility with ACPI 1.0 OS.
1701 //
1702 // This is done because ACPI 1.0 pointers are 32 bit values.
1703 // ACPI 2.0 OS and all 64 bit OS must use the 64 bit ACPI table addresses.
1704 // There is no architectural reason these should be below 4GB, it is purely
1705 // for convenience of implementation that we force memory below 4GB.
1706 //
1707 PageAddress = 0xFFFFFFFF;
1708 Status = gBS->AllocatePages (
1709 mAcpiTableAllocType,
1710 EfiACPIReclaimMemory,
1711 EFI_SIZE_TO_PAGES (TotalSize),
1712 &PageAddress
1713 );
1714
1715 if (EFI_ERROR (Status)) {
1716 gBS->FreePages ((EFI_PHYSICAL_ADDRESS)(UINTN)AcpiTableInstance->Rsdp1, EFI_SIZE_TO_PAGES (RsdpTableSize));
1717 return EFI_OUT_OF_RESOURCES;
1718 }
1719
1720 Pointer = (UINT8 *) (UINTN) PageAddress;
1721 ZeroMem (Pointer, TotalSize);
1722
1723 AcpiTableInstance->Rsdt1 = (EFI_ACPI_DESCRIPTION_HEADER *) Pointer;
1724 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1725 Pointer += (sizeof (EFI_ACPI_DESCRIPTION_HEADER) + EFI_ACPI_MAX_NUM_TABLES * sizeof (UINT32));
1726 AcpiTableInstance->Rsdt3 = (EFI_ACPI_DESCRIPTION_HEADER *) Pointer;
1727 Pointer += (sizeof (EFI_ACPI_DESCRIPTION_HEADER) + EFI_ACPI_MAX_NUM_TABLES * sizeof (UINT32));
1728 }
1729 AcpiTableInstance->Xsdt = (EFI_ACPI_DESCRIPTION_HEADER *) Pointer;
1730
1731 //
1732 // Initialize RSDP
1733 //
1734 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1735 CurrentData = EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE;
1736 CopyMem (&AcpiTableInstance->Rsdp1->Signature, &CurrentData, sizeof (UINT64));
1737 CopyMem (AcpiTableInstance->Rsdp1->OemId, PcdGetPtr (PcdAcpiDefaultOemId), sizeof (AcpiTableInstance->Rsdp1->OemId));
1738 AcpiTableInstance->Rsdp1->Reserved = EFI_ACPI_RESERVED_BYTE;
1739 AcpiTableInstance->Rsdp1->RsdtAddress = (UINT32) (UINTN) AcpiTableInstance->Rsdt1;
1740 }
1741
1742 CurrentData = EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE;
1743 CopyMem (&AcpiTableInstance->Rsdp3->Signature, &CurrentData, sizeof (UINT64));
1744 CopyMem (AcpiTableInstance->Rsdp3->OemId, PcdGetPtr (PcdAcpiDefaultOemId), sizeof (AcpiTableInstance->Rsdp3->OemId));
1745 AcpiTableInstance->Rsdp3->Revision = EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION;
1746 AcpiTableInstance->Rsdp3->Length = sizeof (EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER);
1747 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1748 AcpiTableInstance->Rsdp3->RsdtAddress = (UINT32) (UINTN) AcpiTableInstance->Rsdt3;
1749 }
1750 CurrentData = (UINT64) (UINTN) AcpiTableInstance->Xsdt;
1751 CopyMem (&AcpiTableInstance->Rsdp3->XsdtAddress, &CurrentData, sizeof (UINT64));
1752 SetMem (AcpiTableInstance->Rsdp3->Reserved, 3, EFI_ACPI_RESERVED_BYTE);
1753
1754 if ((PcdGet32 (PcdAcpiExposedTableVersions) & EFI_ACPI_TABLE_VERSION_1_0B) != 0) {
1755 //
1756 // Initialize Rsdt
1757 //
1758 // Note that we "reserve" one entry for the FADT so it can always be
1759 // at the beginning of the list of tables. Some OS don't seem
1760 // to find it correctly if it is too far down the list.
1761 //
1762 AcpiTableInstance->Rsdt1->Signature = EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE;
1763 AcpiTableInstance->Rsdt1->Length = sizeof (EFI_ACPI_DESCRIPTION_HEADER);
1764 AcpiTableInstance->Rsdt1->Revision = EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION;
1765 CopyMem (AcpiTableInstance->Rsdt1->OemId, PcdGetPtr (PcdAcpiDefaultOemId), sizeof (AcpiTableInstance->Rsdt1->OemId));
1766 CurrentData = PcdGet64 (PcdAcpiDefaultOemTableId);
1767 CopyMem (&AcpiTableInstance->Rsdt1->OemTableId, &CurrentData, sizeof (UINT64));
1768 AcpiTableInstance->Rsdt1->OemRevision = PcdGet32 (PcdAcpiDefaultOemRevision);
1769 AcpiTableInstance->Rsdt1->CreatorId = PcdGet32 (PcdAcpiDefaultCreatorId);
1770 AcpiTableInstance->Rsdt1->CreatorRevision = PcdGet32 (PcdAcpiDefaultCreatorRevision);
1771 //
1772 // We always reserve first one for FADT
1773 //
1774 AcpiTableInstance->NumberOfTableEntries1 = 1;
1775 AcpiTableInstance->Rsdt1->Length = AcpiTableInstance->Rsdt1->Length + sizeof(UINT32);
1776
1777 AcpiTableInstance->Rsdt3->Signature = EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE;
1778 AcpiTableInstance->Rsdt3->Length = sizeof (EFI_ACPI_DESCRIPTION_HEADER);
1779 AcpiTableInstance->Rsdt3->Revision = EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION;
1780 CopyMem (AcpiTableInstance->Rsdt3->OemId, PcdGetPtr (PcdAcpiDefaultOemId), sizeof (AcpiTableInstance->Rsdt3->OemId));
1781 CurrentData = PcdGet64 (PcdAcpiDefaultOemTableId);
1782 CopyMem (&AcpiTableInstance->Rsdt3->OemTableId, &CurrentData, sizeof (UINT64));
1783 AcpiTableInstance->Rsdt3->OemRevision = PcdGet32 (PcdAcpiDefaultOemRevision);
1784 AcpiTableInstance->Rsdt3->CreatorId = PcdGet32 (PcdAcpiDefaultCreatorId);
1785 AcpiTableInstance->Rsdt3->CreatorRevision = PcdGet32 (PcdAcpiDefaultCreatorRevision);
1786 //
1787 // We always reserve first one for FADT
1788 //
1789 AcpiTableInstance->Rsdt3->Length = AcpiTableInstance->Rsdt3->Length + sizeof(UINT32);
1790 }
1791 AcpiTableInstance->NumberOfTableEntries3 = 1;
1792
1793 //
1794 // Initialize Xsdt
1795 //
1796 AcpiTableInstance->Xsdt->Signature = EFI_ACPI_3_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE;
1797 AcpiTableInstance->Xsdt->Length = sizeof (EFI_ACPI_DESCRIPTION_HEADER);
1798 AcpiTableInstance->Xsdt->Revision = EFI_ACPI_3_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_REVISION;
1799 CopyMem (AcpiTableInstance->Xsdt->OemId, PcdGetPtr (PcdAcpiDefaultOemId), sizeof (AcpiTableInstance->Xsdt->OemId));
1800 CurrentData = PcdGet64 (PcdAcpiDefaultOemTableId);
1801 CopyMem (&AcpiTableInstance->Xsdt->OemTableId, &CurrentData, sizeof (UINT64));
1802 AcpiTableInstance->Xsdt->OemRevision = PcdGet32 (PcdAcpiDefaultOemRevision);
1803 AcpiTableInstance->Xsdt->CreatorId = PcdGet32 (PcdAcpiDefaultCreatorId);
1804 AcpiTableInstance->Xsdt->CreatorRevision = PcdGet32 (PcdAcpiDefaultCreatorRevision);
1805 //
1806 // We always reserve first one for FADT
1807 //
1808 AcpiTableInstance->Xsdt->Length = AcpiTableInstance->Xsdt->Length + sizeof(UINT64);
1809
1810 ChecksumCommonTables (AcpiTableInstance);
1811
1812 //
1813 // Completed successfully
1814 //
1815 return EFI_SUCCESS;
1816 }
1817
EFI Development Kit II mirror for PVE