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