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