DynamicTableManagerDxe.c@ 80924

Last change on this file since 80924 was 80721, checked in by vboxsync, 5 years ago
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
Property svn:eol-style set to `native`
File size: 21.6 KB

Line
1	/** @file
2	Dynamic Table Manager Dxe
3
4	Copyright (c) 2017 - 2019, ARM Limited. All rights reserved.
5
6	SPDX-License-Identifier: BSD-2-Clause-Patent
7
8	**/
9
10	#include <Library/DebugLib.h>
11	#include <Library/PcdLib.h>
12	#include <Library/UefiBootServicesTableLib.h>
13	#include <Protocol/AcpiTable.h>
14
15	// Module specific include files.
16	#include <AcpiTableGenerator.h>
17	#include <ConfigurationManagerObject.h>
18	#include <ConfigurationManagerHelper.h>
19	#include <DeviceTreeTableGenerator.h>
20	#include <Library/TableHelperLib.h>
21	#include <Protocol/ConfigurationManagerProtocol.h>
22	#include <Protocol/DynamicTableFactoryProtocol.h>
23	#include <SmbiosTableGenerator.h>
24
25	/** This macro expands to a function that retrieves the ACPI Table
26	List from the Configuration Manager.
27	*/
28	GET_OBJECT_LIST (
29	EObjNameSpaceStandard,
30	EStdObjAcpiTableList,
31	CM_STD_OBJ_ACPI_TABLE_INFO
32	)
33
34	/** A helper function to build and install a single ACPI table.
35
36	This is a helper function that invokes the Table generator interface
37	for building an ACPI table. It uses the AcpiTableProtocol to install the
38	table, then frees the resources allocated for generating it.
39
40	@param [in] TableFactoryProtocol Pointer to the Table Factory Protocol
41	interface.
42	@param [in] CfgMgrProtocol Pointer to the Configuration Manager
43	Protocol Interface.
44	@param [in] Generator Pointer to the AcpiTable generator.
45	@param [in] AcpiTableProtocol Pointer to the AcpiTable protocol.
46	@param [in] AcpiTableInfo Pointer to the ACPI table Info.
47
48	@retval EFI_SUCCESS Success.
49	@retval EFI_INVALID_PARAMETER A parameter is invalid.
50	@retval EFI_NOT_FOUND Required object is not found.
51	@retval EFI_BAD_BUFFER_SIZE Size returned by the Configuration Manager
52	is less than the Object size for the
53	requested object.
54	**/
55	STATIC
56	EFI_STATUS
57	EFIAPI
58	BuildAndInstallSingleAcpiTable (
59	IN CONST EDKII_DYNAMIC_TABLE_FACTORY_PROTOCOL * CONST TableFactoryProtocol,
60	IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL * CONST CfgMgrProtocol,
61	IN CONST ACPI_TABLE_GENERATOR * CONST Generator,
62	IN EFI_ACPI_TABLE_PROTOCOL * AcpiTableProtocol,
63	IN CONST CM_STD_OBJ_ACPI_TABLE_INFO * CONST AcpiTableInfo
64	)
65	{
66	EFI_STATUS Status;
67	EFI_STATUS Status1;
68	EFI_ACPI_DESCRIPTION_HEADER * AcpiTable;
69	UINTN TableHandle;
70
71	AcpiTable = NULL;
72	Status = Generator->BuildAcpiTable (
73	Generator,
74	AcpiTableInfo,
75	CfgMgrProtocol,
76	&AcpiTable
77	);
78	if (EFI_ERROR (Status)) {
79	DEBUG ((
80	DEBUG_ERROR,
81	"ERROR: Failed to Build Table." \
82	" TableGeneratorId = 0x%x. Status = %r\n",
83	AcpiTableInfo->TableGeneratorId,
84	Status
85	));
86	// Free any allocated resources.
87	goto exit_handler;
88	}
89
90	if (AcpiTable == NULL) {
91	Status = EFI_NOT_FOUND;
92	goto exit_handler;
93	}
94
95	// Dump ACPI Table Header
96	DUMP_ACPI_TABLE_HEADER (AcpiTable);
97
98	// Install ACPI table
99	Status = AcpiTableProtocol->InstallAcpiTable (
100	AcpiTableProtocol,
101	AcpiTable,
102	AcpiTable->Length,
103	&TableHandle
104	);
105	if (EFI_ERROR (Status)) {
106	DEBUG ((
107	DEBUG_ERROR,
108	"ERROR: Failed to Install ACPI Table. Status = %r\n",
109	Status
110	));
111	// Free any allocated resources.
112	goto exit_handler;
113	}
114
115	DEBUG ((
116	DEBUG_INFO,
117	"INFO: ACPI Table installed. Status = %r\n",
118	Status
119	));
120
121	exit_handler:
122	// Free any resources allocated for generating the tables.
123	if (Generator->FreeTableResources != NULL) {
124	Status1 = Generator->FreeTableResources (
125	Generator,
126	AcpiTableInfo,
127	CfgMgrProtocol,
128	&AcpiTable
129	);
130	if (EFI_ERROR (Status1)) {
131	DEBUG ((
132	DEBUG_ERROR,
133	"ERROR: Failed to Free Table Resources." \
134	"TableGeneratorId = 0x%x. Status = %r\n",
135	AcpiTableInfo->TableGeneratorId,
136	Status1
137	));
138	}
139
140	// Return the first error status in case of failure
141	if (!EFI_ERROR (Status)) {
142	Status = Status1;
143	}
144	}
145	return Status;
146	}
147
148	/** A helper function to build and install multiple ACPI tables.
149
150	This is a helper function that invokes the Table generator interface
151	for building an ACPI table. It uses the AcpiTableProtocol to install the
152	table, then frees the resources allocated for generating it.
153
154	@param [in] TableFactoryProtocol Pointer to the Table Factory Protocol
155	interface.
156	@param [in] CfgMgrProtocol Pointer to the Configuration Manager
157	Protocol Interface.
158	@param [in] Generator Pointer to the AcpiTable generator.
159	@param [in] AcpiTableProtocol Pointer to the AcpiTable protocol.
160	@param [in] AcpiTableInfo Pointer to the ACPI table Info.
161
162	@retval EFI_SUCCESS Success.
163	@retval EFI_INVALID_PARAMETER A parameter is invalid.
164	@retval EFI_NOT_FOUND Required object is not found.
165	@retval EFI_BAD_BUFFER_SIZE Size returned by the Configuration Manager
166	is less than the Object size for the
167	requested object.
168	**/
169	STATIC
170	EFI_STATUS
171	EFIAPI
172	BuildAndInstallMultipleAcpiTable (
173	IN CONST EDKII_DYNAMIC_TABLE_FACTORY_PROTOCOL * CONST TableFactoryProtocol,
174	IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL * CONST CfgMgrProtocol,
175	IN CONST ACPI_TABLE_GENERATOR * CONST Generator,
176	IN EFI_ACPI_TABLE_PROTOCOL * AcpiTableProtocol,
177	IN CONST CM_STD_OBJ_ACPI_TABLE_INFO * CONST AcpiTableInfo
178	)
179	{
180	EFI_STATUS Status;
181	EFI_STATUS Status1;
182	EFI_ACPI_DESCRIPTION_HEADER ** AcpiTable;
183	UINTN TableCount;
184	UINTN TableHandle;
185	UINTN Index;
186
187	AcpiTable = NULL;
188	TableCount = 0;
189	Status = Generator->BuildAcpiTableEx (
190	Generator,
191	AcpiTableInfo,
192	CfgMgrProtocol,
193	&AcpiTable,
194	&TableCount
195	);
196	if (EFI_ERROR (Status)) {
197	DEBUG ((
198	DEBUG_ERROR,
199	"ERROR: Failed to Build Table." \
200	" TableGeneratorId = 0x%x. Status = %r\n",
201	AcpiTableInfo->TableGeneratorId,
202	Status
203	));
204	// Free any allocated resources.
205	goto exit_handler;
206	}
207
208	if ((AcpiTable == NULL) \|\| (TableCount == 0)) {
209	Status = EFI_NOT_FOUND;
210	goto exit_handler;
211	}
212
213	for (Index = 0; Index < TableCount; Index++) {
214	// Dump ACPI Table Header
215	DUMP_ACPI_TABLE_HEADER (AcpiTable[Index]);
216	// Install ACPI table
217	Status = AcpiTableProtocol->InstallAcpiTable (
218	AcpiTableProtocol,
219	AcpiTable[Index],
220	AcpiTable[Index]->Length,
221	&TableHandle
222	);
223	if (EFI_ERROR (Status)) {
224	DEBUG ((
225	DEBUG_ERROR,
226	"ERROR: Failed to Install ACPI Table. Status = %r\n",
227	Status
228	));
229	// Free any allocated resources.
230	goto exit_handler;
231	}
232
233	DEBUG ((
234	DEBUG_INFO,
235	"INFO: ACPI Table installed. Status = %r\n",
236	Status
237	));
238	}
239
240	exit_handler:
241	// Free any resources allocated for generating the tables.
242	if (Generator->FreeTableResourcesEx != NULL) {
243	Status1 = Generator->FreeTableResourcesEx (
244	Generator,
245	AcpiTableInfo,
246	CfgMgrProtocol,
247	&AcpiTable,
248	TableCount
249	);
250	if (EFI_ERROR (Status1)) {
251	DEBUG ((
252	DEBUG_ERROR,
253	"ERROR: Failed to Free Table Resources." \
254	"TableGeneratorId = 0x%x. Status = %r\n",
255	AcpiTableInfo->TableGeneratorId,
256	Status1
257	));
258	}
259
260	// Return the first error status in case of failure
261	if (!EFI_ERROR (Status)) {
262	Status = Status1;
263	}
264	}
265	return Status;
266	}
267
268	/** A helper function to invoke a Table generator
269
270	This is a helper function that invokes the Table generator interface
271	for building an ACPI table. It uses the AcpiTableProtocol to install the
272	table, then frees the resources allocated for generating it.
273
274	@param [in] TableFactoryProtocol Pointer to the Table Factory Protocol
275	interface.
276	@param [in] CfgMgrProtocol Pointer to the Configuration Manager
277	Protocol Interface.
278	@param [in] AcpiTableProtocol Pointer to the AcpiTable protocol.
279	@param [in] AcpiTableInfo Pointer to the ACPI table Info.
280
281	@retval EFI_SUCCESS Success.
282	@retval EFI_INVALID_PARAMETER A parameter is invalid.
283	@retval EFI_NOT_FOUND Required object is not found.
284	@retval EFI_BAD_BUFFER_SIZE Size returned by the Configuration Manager
285	is less than the Object size for the
286	requested object.
287	**/
288	STATIC
289	EFI_STATUS
290	EFIAPI
291	BuildAndInstallAcpiTable (
292	IN CONST EDKII_DYNAMIC_TABLE_FACTORY_PROTOCOL * CONST TableFactoryProtocol,
293	IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL * CONST CfgMgrProtocol,
294	IN EFI_ACPI_TABLE_PROTOCOL * AcpiTableProtocol,
295	IN CONST CM_STD_OBJ_ACPI_TABLE_INFO * CONST AcpiTableInfo
296	)
297	{
298	EFI_STATUS Status;
299	CONST ACPI_TABLE_GENERATOR * Generator;
300
301	ASSERT (TableFactoryProtocol != NULL);
302	ASSERT (CfgMgrProtocol != NULL);
303	ASSERT (AcpiTableProtocol != NULL);
304	ASSERT (AcpiTableInfo != NULL);
305
306	DEBUG ((
307	DEBUG_INFO,
308	"INFO: EStdObjAcpiTableList: Address = 0x%p," \
309	" TableGeneratorId = 0x%x\n",
310	AcpiTableInfo,
311	AcpiTableInfo->TableGeneratorId
312	));
313
314	Generator = NULL;
315	Status = TableFactoryProtocol->GetAcpiTableGenerator (
316	TableFactoryProtocol,
317	AcpiTableInfo->TableGeneratorId,
318	&Generator
319	);
320	if (EFI_ERROR (Status)) {
321	DEBUG ((
322	DEBUG_ERROR,
323	"ERROR: Table Generator not found." \
324	" TableGeneratorId = 0x%x. Status = %r\n",
325	AcpiTableInfo->TableGeneratorId,
326	Status
327	));
328	return Status;
329	}
330
331	if (Generator == NULL) {
332	return EFI_NOT_FOUND;
333	}
334
335	DEBUG ((
336	DEBUG_INFO,
337	"INFO: Generator found : %s\n",
338	Generator->Description
339	));
340
341	if (Generator->BuildAcpiTableEx != NULL) {
342	Status = BuildAndInstallMultipleAcpiTable (
343	TableFactoryProtocol,
344	CfgMgrProtocol,
345	Generator,
346	AcpiTableProtocol,
347	AcpiTableInfo
348	);
349	if (EFI_ERROR (Status)) {
350	DEBUG ((
351	DEBUG_ERROR,
352	"ERROR: Failed to find build and install ACPI Table." \
353	" Status = %r\n",
354	Status
355	));
356	}
357	} else if (Generator->BuildAcpiTable != NULL) {
358	Status = BuildAndInstallSingleAcpiTable (
359	TableFactoryProtocol,
360	CfgMgrProtocol,
361	Generator,
362	AcpiTableProtocol,
363	AcpiTableInfo
364	);
365	if (EFI_ERROR (Status)) {
366	DEBUG ((
367	DEBUG_ERROR,
368	"ERROR: Failed to find build and install ACPI Table." \
369	" Status = %r\n",
370	Status
371	));
372	}
373	} else {
374	Status = EFI_INVALID_PARAMETER;
375	DEBUG ((
376	DEBUG_ERROR,
377	"ERROR: Table Generator does not implement the" \
378	" ACPI_TABLE_GENERATOR_BUILD_TABLE interface." \
379	" TableGeneratorId = 0x%x. Status = %r\n",
380	AcpiTableInfo->TableGeneratorId,
381	Status
382	));
383	}
384
385	return Status;
386	}
387
388	/** The function checks if the Configuration Manager has provided the
389	mandatory ACPI tables for installation.
390
391	@param [in] AcpiTableInfo Pointer to the ACPI Table Info list.
392	@param [in] AcpiTableCount Count of ACPI Table Info.
393
394	@retval EFI_SUCCESS Success.
395	@retval EFI_NOT_FOUND If mandatory table is not found.
396	**/
397	STATIC
398	EFI_STATUS
399	EFIAPI
400	VerifyMandatoryTablesArePresent (
401	IN CONST CM_STD_OBJ_ACPI_TABLE_INFO * CONST AcpiTableInfo,
402	IN UINT32 AcpiTableCount
403	)
404	{
405	EFI_STATUS Status;
406	BOOLEAN FadtFound;
407	BOOLEAN MadtFound;
408	BOOLEAN GtdtFound;
409	BOOLEAN DsdtFound;
410	BOOLEAN Dbg2Found;
411	BOOLEAN SpcrFound;
412
413	Status = EFI_SUCCESS;
414	FadtFound = FALSE;
415	MadtFound = FALSE;
416	GtdtFound = FALSE;
417	DsdtFound = FALSE;
418	Dbg2Found = FALSE;
419	SpcrFound = FALSE;
420	ASSERT (AcpiTableInfo != NULL);
421
422	while (AcpiTableCount-- != 0) {
423	switch (AcpiTableInfo[AcpiTableCount].AcpiTableSignature) {
424	case EFI_ACPI_6_2_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE:
425	FadtFound = TRUE;
426	break;
427	case EFI_ACPI_6_2_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE:
428	MadtFound = TRUE;
429	break;
430	case EFI_ACPI_6_2_GENERIC_TIMER_DESCRIPTION_TABLE_SIGNATURE:
431	GtdtFound = TRUE;
432	break;
433	case EFI_ACPI_6_2_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE:
434	DsdtFound = TRUE;
435	break;
436	case EFI_ACPI_6_2_DEBUG_PORT_2_TABLE_SIGNATURE:
437	Dbg2Found = TRUE;
438	break;
439	case EFI_ACPI_6_2_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE:
440	SpcrFound = TRUE;
441	break;
442	default:
443	break;
444	}
445	}
446
447	// We need at least the FADT, MADT, GTDT and the DSDT tables to boot
448	if (!FadtFound) {
449	DEBUG ((DEBUG_ERROR,"ERROR: FADT Table not found\n"));
450	Status = EFI_NOT_FOUND;
451	}
452	if (!MadtFound) {
453	DEBUG ((DEBUG_ERROR, "ERROR: MADT Table not found.\n"));
454	Status = EFI_NOT_FOUND;
455	}
456	if (!GtdtFound) {
457	DEBUG ((DEBUG_ERROR, "ERROR: GTDT Table not found.\n"));
458	Status = EFI_NOT_FOUND;
459	}
460	if (!DsdtFound) {
461	DEBUG ((DEBUG_ERROR, "ERROR: DSDT Table not found.\n"));
462	Status = EFI_NOT_FOUND;
463	}
464	if (!Dbg2Found) {
465	DEBUG ((DEBUG_WARN, "WARNING: DBG2 Table not found.\n"));
466	}
467	if (!SpcrFound) {
468	DEBUG ((DEBUG_WARN, "WARNING: SPCR Table not found.\n"));
469	}
470	return Status;
471	}
472
473	/** Generate and install ACPI tables.
474
475	The function gathers the information necessary for installing the
476	ACPI tables from the Configuration Manager, invokes the generators
477	and installs them (via BuildAndInstallAcpiTable).
478
479	@param [in] TableFactoryProtocol Pointer to the Table Factory Protocol
480	interface.
481	@param [in] CfgMgrProtocol Pointer to the Configuration Manager
482	Protocol Interface.
483
484	@retval EFI_SUCCESS Success.
485	@retval EFI_NOT_FOUND If a mandatory table or a generator is not found.
486	**/
487	STATIC
488	EFI_STATUS
489	EFIAPI
490	ProcessAcpiTables (
491	IN CONST EDKII_DYNAMIC_TABLE_FACTORY_PROTOCOL * CONST TableFactoryProtocol,
492	IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL * CONST CfgMgrProtocol
493	)
494	{
495	EFI_STATUS Status;
496	EFI_ACPI_TABLE_PROTOCOL * AcpiTableProtocol;
497	CM_STD_OBJ_ACPI_TABLE_INFO * AcpiTableInfo;
498	UINT32 AcpiTableCount;
499	UINT32 Idx;
500
501	ASSERT (TableFactoryProtocol != NULL);
502	ASSERT (CfgMgrProtocol != NULL);
503
504	// Find the AcpiTable protocol
505	Status = gBS->LocateProtocol (
506	&gEfiAcpiTableProtocolGuid,
507	NULL,
508	(VOID**)&AcpiTableProtocol
509	);
510	if (EFI_ERROR (Status)) {
511	DEBUG ((
512	DEBUG_ERROR,
513	"ERROR: Failed to find AcpiTable protocol. Status = %r\n",
514	Status
515	));
516	return Status;
517	}
518
519	Status = GetEStdObjAcpiTableList (
520	CfgMgrProtocol,
521	CM_NULL_TOKEN,
522	&AcpiTableInfo,
523	&AcpiTableCount
524	);
525	if (EFI_ERROR (Status)) {
526	DEBUG ((
527	DEBUG_ERROR,
528	"ERROR: Failed to get ACPI Table List. Status = %r\n",
529	Status
530	));
531	return Status;
532	}
533
534	if (0 == AcpiTableCount) {
535	DEBUG ((
536	DEBUG_ERROR,
537	"ERROR: EStdObjAcpiTableList: AcpiTableCount = %d\n",
538	AcpiTableCount
539	));
540	return EFI_NOT_FOUND;
541	}
542
543	DEBUG ((
544	DEBUG_INFO,
545	"INFO: EStdObjAcpiTableList: AcpiTableCount = %d\n",
546	AcpiTableCount
547	));
548
549	// Check if mandatory ACPI tables are present.
550	Status = VerifyMandatoryTablesArePresent (
551	AcpiTableInfo,
552	AcpiTableCount
553	);
554	if (EFI_ERROR (Status)) {
555	DEBUG ((
556	DEBUG_ERROR,
557	"ERROR: Failed to find mandatory ACPI Table(s)."
558	" Status = %r\n",
559	Status
560	));
561	return Status;
562	}
563
564	// Add the FADT Table first.
565	for (Idx = 0; Idx < AcpiTableCount; Idx++) {
566	if (CREATE_STD_ACPI_TABLE_GEN_ID (EStdAcpiTableIdFadt) ==
567	AcpiTableInfo[Idx].TableGeneratorId) {
568	Status = BuildAndInstallAcpiTable (
569	TableFactoryProtocol,
570	CfgMgrProtocol,
571	AcpiTableProtocol,
572	&AcpiTableInfo[Idx]
573	);
574	if (EFI_ERROR (Status)) {
575	DEBUG ((
576	DEBUG_ERROR,
577	"ERROR: Failed to find build and install ACPI FADT Table." \
578	" Status = %r\n",
579	Status
580	));
581	return Status;
582	}
583	break;
584	}
585	} // for
586
587	// Add remaining ACPI Tables
588	for (Idx = 0; Idx < AcpiTableCount; Idx++) {
589	DEBUG ((
590	DEBUG_INFO,
591	"INFO: AcpiTableInfo[%d].TableGeneratorId = 0x%x\n",
592	Idx,
593	AcpiTableInfo[Idx].TableGeneratorId
594	));
595
596	// Skip FADT Table since we have already added
597	if (CREATE_STD_ACPI_TABLE_GEN_ID (EStdAcpiTableIdFadt) ==
598	AcpiTableInfo[Idx].TableGeneratorId) {
599	continue;
600	}
601
602	// Skip the Reserved table Generator ID for standard generators
603	if ((IS_GENERATOR_NAMESPACE_STD (AcpiTableInfo[Idx].TableGeneratorId)) &&
604	((CREATE_STD_ACPI_TABLE_GEN_ID (EStdAcpiTableIdReserved) >=
605	AcpiTableInfo[Idx].TableGeneratorId) \|\|
606	(CREATE_STD_ACPI_TABLE_GEN_ID (EStdAcpiTableIdMax) <=
607	AcpiTableInfo[Idx].TableGeneratorId))) {
608	DEBUG ((
609	DEBUG_WARN,
610	"WARNING: Invalid ACPI Generator table ID = 0x%x, Skipping...\n",
611	AcpiTableInfo[Idx].TableGeneratorId
612	));
613	continue;
614	}
615
616	Status = BuildAndInstallAcpiTable (
617	TableFactoryProtocol,
618	CfgMgrProtocol,
619	AcpiTableProtocol,
620	&AcpiTableInfo[Idx]
621	);
622	if (EFI_ERROR (Status)) {
623	DEBUG ((
624	DEBUG_ERROR,
625	"ERROR: Failed to find, build, and install ACPI Table." \
626	" Status = %r\n",
627	Status
628	));
629	return Status;
630	}
631	} // for
632
633	return Status;
634	}
635
636	/** Entrypoint of Dynamic Table Manager Dxe.
637
638	The Dynamic Table Manager uses the Configuration Manager Protocol
639	to get the list of ACPI and SMBIOS tables to install. For each table
640	in the list it requests the corresponding ACPI/SMBIOS table factory for
641	a generator capable of building the ACPI/SMBIOS table.
642	If a suitable table generator is found, it invokes the generator interface
643	to build the table. The Dynamic Table Manager then installs the
644	table and invokes another generator interface to free any resources
645	allocated for building the table.
646
647	@param ImageHandle
648	@param SystemTable
649
650	@retval EFI_SUCCESS Success.
651	@retval EFI_OUT_OF_RESOURCES Memory allocation failed.
652	@retval EFI_NOT_FOUND Required interface/object was not found.
653	@retval EFI_INVALID_PARAMETER Some parameter is incorrect/invalid.
654	**/
655	EFI_STATUS
656	EFIAPI
657	DynamicTableManagerDxeInitialize (
658	IN CONST EFI_HANDLE ImageHandle,
659	IN EFI_SYSTEM_TABLE * CONST SystemTable
660	)
661	{
662	EFI_STATUS Status;
663	EDKII_CONFIGURATION_MANAGER_PROTOCOL * CfgMgrProtocol;
664	CM_STD_OBJ_CONFIGURATION_MANAGER_INFO * CfgMfrInfo;
665	EDKII_DYNAMIC_TABLE_FACTORY_PROTOCOL * TableFactoryProtocol;
666
667	// Locate the Dynamic Table Factory
668	Status = gBS->LocateProtocol (
669	&gEdkiiDynamicTableFactoryProtocolGuid,
670	NULL,
671	(VOID**)&TableFactoryProtocol
672	);
673	if (EFI_ERROR (Status)) {
674	DEBUG ((
675	DEBUG_ERROR,
676	"ERROR: Failed to find Dynamic Table Factory protocol." \
677	" Status = %r\n",
678	Status
679	));
680	return Status;
681	}
682
683	// Locate the Configuration Manager for the Platform
684	Status = gBS->LocateProtocol (
685	&gEdkiiConfigurationManagerProtocolGuid,
686	NULL,
687	(VOID**)&CfgMgrProtocol
688	);
689	if (EFI_ERROR (Status)) {
690	DEBUG ((
691	DEBUG_ERROR,
692	"ERROR: Failed to find Configuration Manager protocol. Status = %r\n",
693	Status
694	));
695	return Status;
696	}
697
698	Status = GetCgfMgrInfo (CfgMgrProtocol, &CfgMfrInfo);
699	if (EFI_ERROR (Status)) {
700	DEBUG ((
701	DEBUG_ERROR,
702	"ERROR: Failed to get Configuration Manager info. Status = %r\n",
703	Status
704	));
705	return Status;
706	}
707
708	DEBUG ((
709	DEBUG_INFO,
710	"INFO: Configuration Manager Version = 0x%x, OemID = %c%c%c%c%c%c\n",
711	CfgMfrInfo->Revision,
712	CfgMfrInfo->OemId[0],
713	CfgMfrInfo->OemId[1],
714	CfgMfrInfo->OemId[2],
715	CfgMfrInfo->OemId[3],
716	CfgMfrInfo->OemId[4],
717	CfgMfrInfo->OemId[5]
718	));
719
720	Status = ProcessAcpiTables (TableFactoryProtocol, CfgMgrProtocol);
721	if (EFI_ERROR (Status)) {
722	DEBUG ((
723	DEBUG_ERROR,
724	"ERROR: ACPI Table processing failure. Status = %r\n",
725	Status
726	));
727	}
728	return Status;
729	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/DynamicTablesPkg/Drivers/DynamicTableManagerDxe/DynamicTableManagerDxe.c@ 80924

Download in other formats: