WebSVN – Kolibri OS – Blame – /drivers/devman/acpica/compiler/dttable.c

Rev	Author	Line No.	Line
1498	serge	1	/******************************************************************************
		2	*
		3	* Module Name: dttable.c - handling for specific ACPI tables
		4	*
		5	*****************************************************************************/
		6
		7	/******************************************************************************
		8	*
		9	* 1. Copyright Notice
		10	*
		11	* Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
		12	* All rights reserved.
		13	*
		14	* 2. License
		15	*
		16	* 2.1. This is your license from Intel Corp. under its intellectual property
		17	* rights. You may have additional license terms from the party that provided
		18	* you this software, covering your right to use that party's intellectual
		19	* property rights.
		20	*
		21	* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
		22	* copy of the source code appearing in this file ("Covered Code") an
		23	* irrevocable, perpetual, worldwide license under Intel's copyrights in the
		24	* base code distributed originally by Intel ("Original Intel Code") to copy,
		25	* make derivatives, distribute, use and display any portion of the Covered
		26	* Code in any form, with the right to sublicense such rights; and
		27	*
		28	* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
		29	* license (with the right to sublicense), under only those claims of Intel
		30	* patents that are infringed by the Original Intel Code, to make, use, sell,
		31	* offer to sell, and import the Covered Code and derivative works thereof
		32	* solely to the minimum extent necessary to exercise the above copyright
		33	* license, and in no event shall the patent license extend to any additions
		34	* to or modifications of the Original Intel Code. No other license or right
		35	* is granted directly or by implication, estoppel or otherwise;
		36	*
		37	* The above copyright and patent license is granted only if the following
		38	* conditions are met:
		39	*
		40	* 3. Conditions
		41	*
		42	* 3.1. Redistribution of Source with Rights to Further Distribute Source.
		43	* Redistribution of source code of any substantial portion of the Covered
		44	* Code or modification with rights to further distribute source must include
		45	* the above Copyright Notice, the above License, this list of Conditions,
		46	* and the following Disclaimer and Export Compliance provision. In addition,
		47	* Licensee must cause all Covered Code to which Licensee contributes to
		48	* contain a file documenting the changes Licensee made to create that Covered
		49	* Code and the date of any change. Licensee must include in that file the
		50	* documentation of any changes made by any predecessor Licensee. Licensee
		51	* must include a prominent statement that the modification is derived,
		52	* directly or indirectly, from Original Intel Code.
		53	*
		54	* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
		55	* Redistribution of source code of any substantial portion of the Covered
		56	* Code or modification without rights to further distribute source must
		57	* include the following Disclaimer and Export Compliance provision in the
		58	* documentation and/or other materials provided with distribution. In
		59	* addition, Licensee may not authorize further sublicense of source of any
		60	* portion of the Covered Code, and must include terms to the effect that the
		61	* license from Licensee to its licensee is limited to the intellectual
		62	* property embodied in the software Licensee provides to its licensee, and
		63	* not to intellectual property embodied in modifications its licensee may
		64	* make.
		65	*
		66	* 3.3. Redistribution of Executable. Redistribution in executable form of any
		67	* substantial portion of the Covered Code or modification must reproduce the
		68	* above Copyright Notice, and the following Disclaimer and Export Compliance
		69	* provision in the documentation and/or other materials provided with the
		70	* distribution.
		71	*
		72	* 3.4. Intel retains all right, title, and interest in and to the Original
		73	* Intel Code.
		74	*
		75	* 3.5. Neither the name Intel nor any other trademark owned or controlled by
		76	* Intel shall be used in advertising or otherwise to promote the sale, use or
		77	* other dealings in products derived from or relating to the Covered Code
		78	* without prior written authorization from Intel.
		79	*
		80	* 4. Disclaimer and Export Compliance
		81	*
		82	* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
		83	* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
		84	* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
		85	* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
		86	* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
		87	* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
		88	* PARTICULAR PURPOSE.
		89	*
		90	* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
		91	* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
		92	* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
		93	* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
		94	* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
		95	* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
		96	* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
		97	* LIMITED REMEDY.
		98	*
		99	* 4.3. Licensee shall not export, either directly or indirectly, any of this
		100	* software or system incorporating such software without first obtaining any
		101	* required license or other approval from the U. S. Department of Commerce or
		102	* any other agency or department of the United States Government. In the
		103	* event Licensee exports any such software from the United States or
		104	* re-exports any such software from a foreign destination, Licensee shall
		105	* ensure that the distribution and export/re-export of the software is in
		106	* compliance with all laws, regulations, orders, or other restrictions of the
		107	* U.S. Export Administration Regulations. Licensee agrees that neither it nor
		108	* any of its subsidiaries will export/re-export any technical data, process,
		109	* software, or service, directly or indirectly, to any country for which the
		110	* United States government or any agency thereof requires an export license,
		111	* other governmental approval, or letter of assurance, without first obtaining
		112	* such license, approval or letter.
		113	*
		114	*****************************************************************************/
		115
		116	#define __DTTABLE_C__
		117
		118	/* Compile all complex data tables */
		119
		120	#include "aslcompiler.h"
		121	#include "dtcompiler.h"
		122
		123	#define _COMPONENT DT_COMPILER
		124	ACPI_MODULE_NAME ("dttable")
		125
		126
		127	/* TBD: merge these into dmtbinfo.c? */
		128
		129	static ACPI_DMTABLE_INFO TableInfoAsfAddress[] =
		130	{
		131	{ACPI_DMT_BUFFER, 0, "Addresses", 0},
		132	{ACPI_DMT_EXIT, 0, NULL, 0}
		133	};
		134
		135	static ACPI_DMTABLE_INFO TableInfoDmarPciPath[] =
		136	{
		137	{ACPI_DMT_PCI_PATH, 0, "PCI Path", 0},
		138	{ACPI_DMT_EXIT, 0, NULL, 0}
		139	};
		140
		141
		142	/* TBD: move to acmacros.h */
		143
		144	#define ACPI_SUB_PTR(t, a, b) \
		145	ACPI_CAST_PTR (t, (ACPI_CAST_PTR (UINT8, (a)) - (ACPI_SIZE)(b)))
		146
		147
		148	/* Local prototypes */
		149
		150	static ACPI_STATUS
		151	DtCompileTwoSubtables (
		152	void **List,
		153	ACPI_DMTABLE_INFO *TableInfo1,
		154	ACPI_DMTABLE_INFO *TableInfo2);
		155
		156
		157	/******************************************************************************
		158	*
		159	* FUNCTION: DtCompileTwoSubtables
		160	*
		161	* PARAMETERS: List - Current field list pointer
		162	* TableInfo1 - Info table 1
		163	* TableInfo1 - Info table 2
		164	*
		165	* RETURN: Status
		166	*
		167	* DESCRIPTION: Compile tables with a header and one or more same subtables.
		168	* Include CPEP, EINJ, ERST, MCFG, MSCT, WDAT
		169	*
		170	*****************************************************************************/
		171
		172	static ACPI_STATUS
		173	DtCompileTwoSubtables (
		174	void **List,
		175	ACPI_DMTABLE_INFO *TableInfo1,
		176	ACPI_DMTABLE_INFO *TableInfo2)
		177	{
		178	ACPI_STATUS Status;
		179	DT_SUBTABLE *Subtable;
		180	DT_SUBTABLE *ParentTable;
		181	DT_FIELD PFieldList = (DT_FIELD ) List;
		182
		183
		184	Status = DtCompileTable (PFieldList, TableInfo1, &Subtable, TRUE);
		185	if (ACPI_FAILURE (Status))
		186	{
		187	return (Status);
		188	}
		189
		190	ParentTable = DtPeekSubtable ();
		191	DtInsertSubtable (ParentTable, Subtable);
		192
		193	while (*PFieldList)
		194	{
		195	Status = DtCompileTable (PFieldList, TableInfo2, &Subtable, FALSE);
		196	if (ACPI_FAILURE (Status))
		197	{
		198	return (Status);
		199	}
		200
		201	DtInsertSubtable (ParentTable, Subtable);
		202	}
		203
		204	return (AE_OK);
		205	}
		206
		207
		208	/******************************************************************************
		209	*
		210	* FUNCTION: DtCompileFacs
		211	*
		212	* PARAMETERS: PFieldList - Current field list pointer
		213	*
		214	* RETURN: Status
		215	*
		216	* DESCRIPTION: Compile FACS.
		217	*
		218	*****************************************************************************/
		219
		220	ACPI_STATUS
		221	DtCompileFacs (
		222	DT_FIELD **PFieldList)
		223	{
		224	DT_SUBTABLE *Subtable;
		225	UINT8 *ReservedBuffer;
		226	ACPI_STATUS Status;
		227	UINT32 ReservedSize;
		228
		229
		230	Status = DtCompileTable (PFieldList, AcpiDmTableInfoFacs,
		231	&Gbl_RootTable, TRUE);
		232	if (ACPI_FAILURE (Status))
		233	{
		234	return (Status);
		235	}
		236
		237	/* Large FACS reserved area at the end of the table */
		238
		239	ReservedSize = (UINT32) sizeof (((ACPI_TABLE_FACS *) NULL)->Reserved1);
		240	ReservedBuffer = UtLocalCalloc (ReservedSize);
		241
		242	DtCreateSubtable (ReservedBuffer, ReservedSize, &Subtable);
		243
		244	ACPI_FREE (ReservedBuffer);
		245	DtInsertSubtable (Gbl_RootTable, Subtable);
		246	return (AE_OK);
		247	}
		248
		249
		250	/******************************************************************************
		251	*
		252	* FUNCTION: DtCompileRsdp
		253	*
		254	* PARAMETERS: PFieldList - Current field list pointer
		255	*
		256	* RETURN: Status
		257	*
		258	* DESCRIPTION: Compile RSDP.
		259	*
		260	*****************************************************************************/
		261
		262	ACPI_STATUS
		263	DtCompileRsdp (
		264	DT_FIELD **PFieldList)
		265	{
		266	DT_SUBTABLE *Subtable;
		267	ACPI_TABLE_RSDP *Table;
		268	ACPI_STATUS Status;
		269
		270
		271	Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp1,
		272	&Gbl_RootTable, TRUE);
		273	if (ACPI_FAILURE (Status))
		274	{
		275	return (Status);
		276	}
		277
		278	Table = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Gbl_RootTable->Buffer);
		279	DtSetTableChecksum (&Table->Checksum);
		280
		281	if (Table->Revision > 0)
		282	{
		283	Status = DtCompileTable (PFieldList, AcpiDmTableInfoRsdp2,
		284	&Subtable, TRUE);
		285	if (ACPI_FAILURE (Status))
		286	{
		287	return (Status);
		288	}
		289
		290	DtInsertSubtable (Gbl_RootTable, Subtable);
		291	DtSetTableChecksum (&Table->ExtendedChecksum);
		292	}
		293
		294	return (AE_OK);
		295	}
		296
		297
		298	/******************************************************************************
		299	*
		300	* FUNCTION: DtCompileAsf
		301	*
		302	* PARAMETERS: List - Current field list pointer
		303	*
		304	* RETURN: Status
		305	*
		306	* DESCRIPTION: Compile ASF!.
		307	*
		308	*****************************************************************************/
		309
		310	ACPI_STATUS
		311	DtCompileAsf (
		312	void **List)
		313	{
		314	ACPI_ASF_INFO *AsfTable;
		315	DT_SUBTABLE *Subtable;
		316	DT_SUBTABLE *ParentTable;
		317	ACPI_DMTABLE_INFO *InfoTable;
		318	ACPI_DMTABLE_INFO *DataInfoTable = NULL;
		319	UINT32 DataCount = 0;
		320	ACPI_STATUS Status;
		321	UINT32 i;
		322	DT_FIELD PFieldList = (DT_FIELD ) List;
		323	DT_FIELD *SubtableStart;
		324
		325
		326	while (*PFieldList)
		327	{
		328	SubtableStart = *PFieldList;
		329	Status = DtCompileTable (PFieldList, AcpiDmTableInfoAsfHdr,
		330	&Subtable, TRUE);
		331	if (ACPI_FAILURE (Status))
		332	{
		333	return (Status);
		334	}
		335
		336	ParentTable = DtPeekSubtable ();
		337	DtInsertSubtable (ParentTable, Subtable);
		338	DtPushSubtable (Subtable);
		339
		340	AsfTable = ACPI_CAST_PTR (ACPI_ASF_INFO, Subtable->Buffer);
		341
		342	switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */
		343	{
		344	case ACPI_ASF_TYPE_INFO:
		345	InfoTable = AcpiDmTableInfoAsf0;
		346	break;
		347
		348	case ACPI_ASF_TYPE_ALERT:
		349	InfoTable = AcpiDmTableInfoAsf1;
		350	break;
		351
		352	case ACPI_ASF_TYPE_CONTROL:
		353	InfoTable = AcpiDmTableInfoAsf2;
		354	break;
		355
		356	case ACPI_ASF_TYPE_BOOT:
		357	InfoTable = AcpiDmTableInfoAsf3;
		358	break;
		359
		360	case ACPI_ASF_TYPE_ADDRESS:
		361	InfoTable = AcpiDmTableInfoAsf4;
		362	break;
		363
		364	default:
		365	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");
		366	return (AE_ERROR);
		367	}
		368
		369	Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
		370	if (ACPI_FAILURE (Status))
		371	{
		372	return (Status);
		373	}
		374
		375	ParentTable = DtPeekSubtable ();
		376	DtInsertSubtable (ParentTable, Subtable);
		377
		378	switch (AsfTable->Header.Type & 0x7F) /* Mask off top bit */
		379	{
		380	case ACPI_ASF_TYPE_INFO:
		381	DataInfoTable = NULL;
		382	break;
		383
		384	case ACPI_ASF_TYPE_ALERT:
		385	DataInfoTable = AcpiDmTableInfoAsf1a;
		386	DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT,
		387	ACPI_SUB_PTR (UINT8, Subtable->Buffer,
		388	sizeof (ACPI_ASF_HEADER)))->Alerts;
		389	break;
		390
		391	case ACPI_ASF_TYPE_CONTROL:
		392	DataInfoTable = AcpiDmTableInfoAsf2a;
		393	DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE,
		394	ACPI_SUB_PTR (UINT8, Subtable->Buffer,
		395	sizeof (ACPI_ASF_HEADER)))->Controls;
		396	break;
		397
		398	case ACPI_ASF_TYPE_BOOT:
		399	DataInfoTable = NULL;
		400	break;
		401
		402	case ACPI_ASF_TYPE_ADDRESS:
		403	DataInfoTable = TableInfoAsfAddress;
		404	DataCount = ACPI_CAST_PTR (ACPI_ASF_ADDRESS,
		405	ACPI_SUB_PTR (UINT8, Subtable->Buffer,
		406	sizeof (ACPI_ASF_HEADER)))->Devices;
		407	break;
		408
		409	default:
		410	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "ASF!");
		411	return (AE_ERROR);
		412	}
		413
		414	if (DataInfoTable)
		415	{
		416	switch (AsfTable->Header.Type & 0x7F)
		417	{
		418	case ACPI_ASF_TYPE_ADDRESS:
		419
		420	while (DataCount > 0)
		421	{
		422	Status = DtCompileTable (PFieldList, DataInfoTable,
		423	&Subtable, TRUE);
		424	if (ACPI_FAILURE (Status))
		425	{
		426	return (Status);
		427	}
		428
		429	DtInsertSubtable (ParentTable, Subtable);
		430	DataCount = DataCount - Subtable->Length;
		431	}
		432	break;
		433
		434	default:
		435
		436	for (i = 0; i < DataCount; i++)
		437	{
		438	Status = DtCompileTable (PFieldList, DataInfoTable,
		439	&Subtable, TRUE);
		440	if (ACPI_FAILURE (Status))
		441	{
		442	return (Status);
		443	}
		444
		445	DtInsertSubtable (ParentTable, Subtable);
		446	}
		447	break;
		448	}
		449	}
		450
		451	DtPopSubtable ();
		452	}
		453
		454	return (AE_OK);
		455	}
		456
		457
		458	/******************************************************************************
		459	*
		460	* FUNCTION: DtCompileCpep
		461	*
		462	* PARAMETERS: List - Current field list pointer
		463	*
		464	* RETURN: Status
		465	*
		466	* DESCRIPTION: Compile CPEP.
		467	*
		468	*****************************************************************************/
		469
		470	ACPI_STATUS
		471	DtCompileCpep (
		472	void **List)
		473	{
		474	ACPI_STATUS Status;
		475
		476
		477	Status = DtCompileTwoSubtables (List,
		478	AcpiDmTableInfoCpep, AcpiDmTableInfoCpep0);
		479	return (Status);
		480	}
		481
		482
		483	/******************************************************************************
		484	*
		485	* FUNCTION: DtCompileDmar
		486	*
		487	* PARAMETERS: List - Current field list pointer
		488	*
		489	* RETURN: Status
		490	*
		491	* DESCRIPTION: Compile DMAR.
		492	*
		493	*****************************************************************************/
		494
		495	ACPI_STATUS
		496	DtCompileDmar (
		497	void **List)
		498	{
		499	ACPI_STATUS Status;
		500	DT_SUBTABLE *Subtable;
		501	DT_SUBTABLE *ParentTable;
		502	DT_FIELD PFieldList = (DT_FIELD ) List;
		503	DT_FIELD *SubtableStart;
		504	ACPI_DMTABLE_INFO *InfoTable;
		505	ACPI_DMAR_HEADER *DmarHeader;
		506	UINT8 *ReservedBuffer;
		507	UINT32 ReservedSize;
		508
		509
		510	Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmar, &Subtable, TRUE);
		511	if (ACPI_FAILURE (Status))
		512	{
		513	return (Status);
		514	}
		515
		516	ParentTable = DtPeekSubtable ();
		517	DtInsertSubtable (ParentTable, Subtable);
		518
		519	/* DMAR Reserved area */
		520
		521	ReservedSize = (UINT32) sizeof (((ACPI_TABLE_DMAR *) NULL)->Reserved);
		522	ReservedBuffer = UtLocalCalloc (ReservedSize);
		523
		524	DtCreateSubtable (ReservedBuffer, ReservedSize, &Subtable);
		525
		526	ACPI_FREE (ReservedBuffer);
		527	ParentTable = DtPeekSubtable ();
		528	DtInsertSubtable (ParentTable, Subtable);
		529
		530	while (*PFieldList)
		531	{
		532	/* DMAR Header */
		533
		534	SubtableStart = *PFieldList;
		535	Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarHdr,
		536	&Subtable, TRUE);
		537	if (ACPI_FAILURE (Status))
		538	{
		539	return (Status);
		540	}
		541
		542	ParentTable = DtPeekSubtable ();
		543	DtInsertSubtable (ParentTable, Subtable);
		544	DtPushSubtable (Subtable);
		545
		546	DmarHeader = ACPI_CAST_PTR (ACPI_DMAR_HEADER, Subtable->Buffer);
		547
		548	switch (DmarHeader->Type)
		549	{
		550	case ACPI_DMAR_TYPE_HARDWARE_UNIT:
		551	InfoTable = AcpiDmTableInfoDmar0;
		552	break;
		553	case ACPI_DMAR_TYPE_RESERVED_MEMORY:
		554	InfoTable = AcpiDmTableInfoDmar1;
		555	break;
		556	case ACPI_DMAR_TYPE_ATSR:
		557	InfoTable = AcpiDmTableInfoDmar2;
		558	break;
		559	case ACPI_DMAR_HARDWARE_AFFINITY:
		560	InfoTable = AcpiDmTableInfoDmar3;
		561	break;
		562	default:
		563	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "DMAR");
		564	return (AE_ERROR);
		565	}
		566
		567	/* DMAR Subtable */
		568
		569	Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
		570	if (ACPI_FAILURE (Status))
		571	{
		572	return (Status);
		573	}
		574
		575	ParentTable = DtPeekSubtable ();
		576	DtInsertSubtable (ParentTable, Subtable);
		577
		578	/* Optional Device Scope subtables */
		579
		580	while (*PFieldList)
		581	{
		582	Status = DtCompileTable (PFieldList, AcpiDmTableInfoDmarScope,
		583	&Subtable, FALSE);
		584	if (Status == AE_NOT_FOUND)
		585	{
		586	break;
		587	}
		588
		589	ParentTable = DtPeekSubtable ();
		590	DtInsertSubtable (ParentTable, Subtable);
		591	DtPushSubtable (Subtable);
		592
		593	/* Optional PCI Paths */
		594
		595	while (*PFieldList)
		596	{
		597	Status = DtCompileTable (PFieldList, TableInfoDmarPciPath,
		598	&Subtable, FALSE);
		599	if (Status == AE_NOT_FOUND)
		600	{
		601	DtPopSubtable ();
		602	break;
		603	}
		604
		605	ParentTable = DtPeekSubtable ();
		606	DtInsertSubtable (ParentTable, Subtable);
		607	}
		608	}
		609
		610	DtPopSubtable ();
		611	}
		612
		613	return (AE_OK);
		614	}
		615
		616
		617	/******************************************************************************
		618	*
		619	* FUNCTION: DtCompileEinj
		620	*
		621	* PARAMETERS: List - Current field list pointer
		622	*
		623	* RETURN: Status
		624	*
		625	* DESCRIPTION: Compile EINJ.
		626	*
		627	*****************************************************************************/
		628
		629	ACPI_STATUS
		630	DtCompileEinj (
		631	void **List)
		632	{
		633	ACPI_STATUS Status;
		634
		635
		636	Status = DtCompileTwoSubtables (List,
		637	AcpiDmTableInfoEinj, AcpiDmTableInfoEinj0);
		638	return (Status);
		639	}
		640
		641
		642	/******************************************************************************
		643	*
		644	* FUNCTION: DtCompileErst
		645	*
		646	* PARAMETERS: List - Current field list pointer
		647	*
		648	* RETURN: Status
		649	*
		650	* DESCRIPTION: Compile ERST.
		651	*
		652	*****************************************************************************/
		653
		654	ACPI_STATUS
		655	DtCompileErst (
		656	void **List)
		657	{
		658	ACPI_STATUS Status;
		659
		660
		661	Status = DtCompileTwoSubtables (List,
		662	AcpiDmTableInfoErst, AcpiDmTableInfoEinj0);
		663	return (Status);
		664	}
		665
		666
		667	/******************************************************************************
		668	*
		669	* FUNCTION: DtCompileFadt
		670	*
		671	* PARAMETERS: List - Current field list pointer
		672	*
		673	* RETURN: Status
		674	*
		675	* DESCRIPTION: Compile FADT.
		676	*
		677	*****************************************************************************/
		678
		679	ACPI_STATUS
		680	DtCompileFadt (
		681	void **List)
		682	{
		683	ACPI_STATUS Status;
		684	DT_SUBTABLE *Subtable;
		685	DT_SUBTABLE *ParentTable;
		686	DT_FIELD PFieldList = (DT_FIELD ) List;
		687	ACPI_TABLE_HEADER *Table;
		688	UINT8 Revision;
		689
		690
		691	Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt1,
		692	&Subtable, TRUE);
		693	if (ACPI_FAILURE (Status))
		694	{
		695	return (Status);
		696	}
		697
		698	ParentTable = DtPeekSubtable ();
		699	DtInsertSubtable (ParentTable, Subtable);
		700
		701	Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer);
		702	Revision = Table->Revision;
		703
		704	if (Revision == 2)
		705	{
		706	Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt2,
		707	&Subtable, TRUE);
		708	if (ACPI_FAILURE (Status))
		709	{
		710	return (Status);
		711	}
		712
		713	DtInsertSubtable (ParentTable, Subtable);
		714	}
		715	else if (Revision >= 2)
		716	{
		717	Status = DtCompileTable (PFieldList, AcpiDmTableInfoFadt3,
		718	&Subtable, TRUE);
		719	if (ACPI_FAILURE (Status))
		720	{
		721	return (Status);
		722	}
		723
		724	DtInsertSubtable (ParentTable, Subtable);
		725	}
		726
		727	return (AE_OK);
		728	}
		729
		730
		731	/******************************************************************************
		732	*
		733	* FUNCTION: DtCompileHest
		734	*
		735	* PARAMETERS: List - Current field list pointer
		736	*
		737	* RETURN: Status
		738	*
		739	* DESCRIPTION: Compile HEST.
		740	*
		741	*****************************************************************************/
		742
		743	ACPI_STATUS
		744	DtCompileHest (
		745	void **List)
		746	{
		747	ACPI_STATUS Status;
		748	DT_SUBTABLE *Subtable;
		749	DT_SUBTABLE *ParentTable;
		750	DT_FIELD PFieldList = (DT_FIELD ) List;
		751	DT_FIELD *SubtableStart;
		752	ACPI_DMTABLE_INFO *InfoTable;
		753	UINT16 Type;
		754	UINT32 BankCount;
		755
		756
		757	Status = DtCompileTable (PFieldList, AcpiDmTableInfoHest,
		758	&Subtable, TRUE);
		759	if (ACPI_FAILURE (Status))
		760	{
		761	return (Status);
		762	}
		763
		764	ParentTable = DtPeekSubtable ();
		765	DtInsertSubtable (ParentTable, Subtable);
		766
		767	while (*PFieldList)
		768	{
		769	/* Get subtable type */
		770
		771	SubtableStart = *PFieldList;
		772	DtCompileInteger ((UINT8 ) &Type, PFieldList, 2, 0);
		773
		774	switch (Type)
		775	{
		776	case ACPI_HEST_TYPE_IA32_CHECK:
		777	InfoTable = AcpiDmTableInfoHest0;
		778	break;
		779
		780	case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
		781	InfoTable = AcpiDmTableInfoHest1;
		782	break;
		783
		784	case ACPI_HEST_TYPE_IA32_NMI:
		785	InfoTable = AcpiDmTableInfoHest2;
		786	break;
		787
		788	case ACPI_HEST_TYPE_AER_ROOT_PORT:
		789	InfoTable = AcpiDmTableInfoHest6;
		790	break;
		791
		792	case ACPI_HEST_TYPE_AER_ENDPOINT:
		793	InfoTable = AcpiDmTableInfoHest7;
		794	break;
		795
		796	case ACPI_HEST_TYPE_AER_BRIDGE:
		797	InfoTable = AcpiDmTableInfoHest8;
		798	break;
		799
		800	case ACPI_HEST_TYPE_GENERIC_ERROR:
		801	InfoTable = AcpiDmTableInfoHest9;
		802	break;
		803
		804	default:
		805	/* Cannot continue on unknown type */
		806
		807	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "HEST");
		808	return (AE_ERROR);
		809	}
		810
		811	Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
		812	if (ACPI_FAILURE (Status))
		813	{
		814	return (Status);
		815	}
		816
		817	DtInsertSubtable (ParentTable, Subtable);
		818
		819	/*
		820	* Additional subtable data - IA32 Error Bank(s)
		821	*/
		822	BankCount = 0;
		823	switch (Type)
		824	{
		825	case ACPI_HEST_TYPE_IA32_CHECK:
		826	BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
		827	Subtable->Buffer))->NumHardwareBanks;
		828	break;
		829
		830	case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
		831	BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
		832	Subtable->Buffer))->NumHardwareBanks;
		833	break;
		834
		835	default:
		836	break;
		837	}
		838
		839	while (BankCount)
		840	{
		841	Status = DtCompileTable (PFieldList, AcpiDmTableInfoHestBank,
		842	&Subtable, TRUE);
		843	if (ACPI_FAILURE (Status))
		844	{
		845	return (Status);
		846	}
		847
		848	DtInsertSubtable (ParentTable, Subtable);
		849	BankCount--;
		850	}
		851	}
		852
		853	return AE_OK;
		854	}
		855
		856
		857	/******************************************************************************
		858	*
		859	* FUNCTION: DtCompileIvrs
		860	*
		861	* PARAMETERS: List - Current field list pointer
		862	*
		863	* RETURN: Status
		864	*
		865	* DESCRIPTION: Compile IVRS.
		866	*
		867	*****************************************************************************/
		868
		869	ACPI_STATUS
		870	DtCompileIvrs (
		871	void **List)
		872	{
		873	ACPI_STATUS Status;
		874	DT_SUBTABLE *Subtable;
		875	DT_SUBTABLE *ParentTable;
		876	DT_FIELD PFieldList = (DT_FIELD ) List;
		877	DT_FIELD *SubtableStart;
		878	ACPI_DMTABLE_INFO *InfoTable;
		879	ACPI_IVRS_HEADER *IvrsHeader;
		880	UINT8 EntryType;
		881
		882
		883	Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrs,
		884	&Subtable, TRUE);
		885	if (ACPI_FAILURE (Status))
		886	{
		887	return (Status);
		888	}
		889
		890	ParentTable = DtPeekSubtable ();
		891	DtInsertSubtable (ParentTable, Subtable);
		892
		893	while (*PFieldList)
		894	{
		895	SubtableStart = *PFieldList;
		896	Status = DtCompileTable (PFieldList, AcpiDmTableInfoIvrsHdr,
		897	&Subtable, TRUE);
		898	if (ACPI_FAILURE (Status))
		899	{
		900	return (Status);
		901	}
		902
		903	ParentTable = DtPeekSubtable ();
		904	DtInsertSubtable (ParentTable, Subtable);
		905	DtPushSubtable (Subtable);
		906
		907	IvrsHeader = ACPI_CAST_PTR (ACPI_IVRS_HEADER, Subtable->Buffer);
		908
		909	switch (IvrsHeader->Type)
		910	{
		911	case ACPI_IVRS_TYPE_HARDWARE:
		912	InfoTable = AcpiDmTableInfoIvrs0;
		913	break;
		914
		915	case ACPI_IVRS_TYPE_MEMORY1:
		916	case ACPI_IVRS_TYPE_MEMORY2:
		917	case ACPI_IVRS_TYPE_MEMORY3:
		918	InfoTable = AcpiDmTableInfoIvrs1;
		919	break;
		920
		921	default:
		922	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "IVRS");
		923	return (AE_ERROR);
		924	}
		925
		926	Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
		927	if (ACPI_FAILURE (Status))
		928	{
		929	return (Status);
		930	}
		931
		932	ParentTable = DtPeekSubtable ();
		933	DtInsertSubtable (ParentTable, Subtable);
		934
		935	if (IvrsHeader->Type == ACPI_IVRS_TYPE_HARDWARE)
		936	{
		937	while (*PFieldList &&
		938	!ACPI_STRCMP ((*PFieldList)->Name, "Entry Type"))
		939	{
		940	SubtableStart = *PFieldList;
		941	DtCompileInteger (&EntryType, *PFieldList, 1, 0);
		942
		943	switch (EntryType)
		944	{
		945	/* 4-byte device entries */
		946
		947	case ACPI_IVRS_TYPE_PAD4:
		948	case ACPI_IVRS_TYPE_ALL:
		949	case ACPI_IVRS_TYPE_SELECT:
		950	case ACPI_IVRS_TYPE_START:
		951	case ACPI_IVRS_TYPE_END:
		952
		953	InfoTable = AcpiDmTableInfoIvrs4;
		954	break;
		955
		956	/* 8-byte entries, type A */
		957
		958	case ACPI_IVRS_TYPE_ALIAS_SELECT:
		959	case ACPI_IVRS_TYPE_ALIAS_START:
		960
		961	InfoTable = AcpiDmTableInfoIvrs8a;
		962	break;
		963
		964	/* 8-byte entries, type B */
		965
		966	case ACPI_IVRS_TYPE_PAD8:
		967	case ACPI_IVRS_TYPE_EXT_SELECT:
		968	case ACPI_IVRS_TYPE_EXT_START:
		969
		970	InfoTable = AcpiDmTableInfoIvrs8b;
		971	break;
		972
		973	/* 8-byte entries, type C */
		974
		975	case ACPI_IVRS_TYPE_SPECIAL:
		976
		977	InfoTable = AcpiDmTableInfoIvrs8c;
		978	break;
		979
		980	default:
		981	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart,
		982	"IVRS Device Entry");
		983	return (AE_ERROR);
		984	}
		985
		986	Status = DtCompileTable (PFieldList, InfoTable,
		987	&Subtable, TRUE);
		988	if (ACPI_FAILURE (Status))
		989	{
		990	return (Status);
		991	}
		992
		993	DtInsertSubtable (ParentTable, Subtable);
		994	}
		995	}
		996
		997	DtPopSubtable ();
		998	}
		999
		1000	return (AE_OK);
		1001	}
		1002
		1003
		1004	/******************************************************************************
		1005	*
		1006	* FUNCTION: DtCompileMadt
		1007	*
		1008	* PARAMETERS: List - Current field list pointer
		1009	*
		1010	* RETURN: Status
		1011	*
		1012	* DESCRIPTION: Compile MADT.
		1013	*
		1014	*****************************************************************************/
		1015
		1016	ACPI_STATUS
		1017	DtCompileMadt (
		1018	void **List)
		1019	{
		1020	ACPI_STATUS Status;
		1021	DT_SUBTABLE *Subtable;
		1022	DT_SUBTABLE *ParentTable;
		1023	DT_FIELD PFieldList = (DT_FIELD ) List;
		1024	DT_FIELD *SubtableStart;
		1025	ACPI_SUBTABLE_HEADER *MadtHeader;
		1026	ACPI_DMTABLE_INFO *InfoTable;
		1027
		1028
		1029	Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt,
		1030	&Subtable, TRUE);
		1031	if (ACPI_FAILURE (Status))
		1032	{
		1033	return (Status);
		1034	}
		1035
		1036	ParentTable = DtPeekSubtable ();
		1037	DtInsertSubtable (ParentTable, Subtable);
		1038
		1039	while (*PFieldList)
		1040	{
		1041	SubtableStart = *PFieldList;
		1042	Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr,
		1043	&Subtable, TRUE);
		1044	if (ACPI_FAILURE (Status))
		1045	{
		1046	return (Status);
		1047	}
		1048
		1049	ParentTable = DtPeekSubtable ();
		1050	DtInsertSubtable (ParentTable, Subtable);
		1051	DtPushSubtable (Subtable);
		1052
		1053	MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
		1054
		1055	switch (MadtHeader->Type)
		1056	{
		1057	case ACPI_MADT_TYPE_LOCAL_APIC:
		1058	InfoTable = AcpiDmTableInfoMadt0;
		1059	break;
		1060	case ACPI_MADT_TYPE_IO_APIC:
		1061	InfoTable = AcpiDmTableInfoMadt1;
		1062	break;
		1063	case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
		1064	InfoTable = AcpiDmTableInfoMadt2;
		1065	break;
		1066	case ACPI_MADT_TYPE_NMI_SOURCE:
		1067	InfoTable = AcpiDmTableInfoMadt3;
		1068	break;
		1069	case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
		1070	InfoTable = AcpiDmTableInfoMadt4;
		1071	break;
		1072	case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
		1073	InfoTable = AcpiDmTableInfoMadt5;
		1074	break;
		1075	case ACPI_MADT_TYPE_IO_SAPIC:
		1076	InfoTable = AcpiDmTableInfoMadt6;
		1077	break;
		1078	case ACPI_MADT_TYPE_LOCAL_SAPIC:
		1079	InfoTable = AcpiDmTableInfoMadt7;
		1080	break;
		1081	case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
		1082	InfoTable = AcpiDmTableInfoMadt8;
		1083	break;
		1084	case ACPI_MADT_TYPE_LOCAL_X2APIC:
		1085	InfoTable = AcpiDmTableInfoMadt9;
		1086	break;
		1087	case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
		1088	InfoTable = AcpiDmTableInfoMadt10;
		1089	break;
		1090	default:
		1091	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT");
		1092	return (AE_ERROR);
		1093	}
		1094
		1095	Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
		1096	if (ACPI_FAILURE (Status))
		1097	{
		1098	return (Status);
		1099	}
		1100
		1101	ParentTable = DtPeekSubtable ();
		1102	DtInsertSubtable (ParentTable, Subtable);
		1103	DtPopSubtable ();
		1104	}
		1105
		1106	return (AE_OK);
		1107	}
		1108
		1109
		1110	/******************************************************************************
		1111	*
		1112	* FUNCTION: DtCompileMcfg
		1113	*
		1114	* PARAMETERS: List - Current field list pointer
		1115	*
		1116	* RETURN: Status
		1117	*
		1118	* DESCRIPTION: Compile MCFG.
		1119	*
		1120	*****************************************************************************/
		1121
		1122	ACPI_STATUS
		1123	DtCompileMcfg (
		1124	void **List)
		1125	{
		1126	ACPI_STATUS Status;
		1127
		1128
		1129	Status = DtCompileTwoSubtables (List,
		1130	AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0);
		1131	return (Status);
		1132	}
		1133
		1134
		1135	/******************************************************************************
		1136	*
		1137	* FUNCTION: DtCompileMsct
		1138	*
		1139	* PARAMETERS: List - Current field list pointer
		1140	*
		1141	* RETURN: Status
		1142	*
		1143	* DESCRIPTION: Compile MSCT.
		1144	*
		1145	*****************************************************************************/
		1146
		1147	ACPI_STATUS
		1148	DtCompileMsct (
		1149	void **List)
		1150	{
		1151	ACPI_STATUS Status;
		1152
		1153
		1154	Status = DtCompileTwoSubtables (List,
		1155	AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0);
		1156	return (Status);
		1157	}
		1158
		1159
		1160	/******************************************************************************
		1161	*
		1162	* FUNCTION: DtCompileRsdt
		1163	*
		1164	* PARAMETERS: List - Current field list pointer
		1165	*
		1166	* RETURN: Status
		1167	*
		1168	* DESCRIPTION: Compile RSDT.
		1169	*
		1170	*****************************************************************************/
		1171
		1172	ACPI_STATUS
		1173	DtCompileRsdt (
		1174	void **List)
		1175	{
		1176	DT_SUBTABLE *Subtable;
		1177	DT_SUBTABLE *ParentTable;
		1178	DT_FIELD FieldList = (DT_FIELD **) List;
		1179	UINT32 Address;
		1180
		1181
		1182	ParentTable = DtPeekSubtable ();
		1183
		1184	while (FieldList)
		1185	{
		1186	DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO);
		1187
		1188	DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable);
		1189	DtInsertSubtable (ParentTable, Subtable);
		1190	FieldList = FieldList->Next;
		1191	}
		1192
		1193	return (AE_OK);
		1194	}
		1195
		1196
		1197	/******************************************************************************
		1198	*
		1199	* FUNCTION: DtCompileSlit
		1200	*
		1201	* PARAMETERS: List - Current field list pointer
		1202	*
		1203	* RETURN: Status
		1204	*
		1205	* DESCRIPTION: Compile SLIT.
		1206	*
		1207	*****************************************************************************/
		1208
		1209	ACPI_STATUS
		1210	DtCompileSlit (
		1211	void **List)
		1212	{
		1213	ACPI_STATUS Status;
		1214	DT_SUBTABLE *Subtable;
		1215	DT_SUBTABLE *ParentTable;
		1216	DT_FIELD PFieldList = (DT_FIELD ) List;
		1217	DT_FIELD *FieldList;
		1218	UINT32 Localities;
		1219	UINT8 *LocalityBuffer;
		1220	UINT32 RemainingData;
		1221
		1222
		1223	Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
		1224	&Subtable, TRUE);
		1225	if (ACPI_FAILURE (Status))
		1226	{
		1227	return (Status);
		1228	}
		1229
		1230	ParentTable = DtPeekSubtable ();
		1231	DtInsertSubtable (ParentTable, Subtable);
		1232
		1233	Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
		1234	LocalityBuffer = UtLocalCalloc (Localities);
		1235
		1236	FieldList = *PFieldList;
		1237	while (FieldList)
		1238	{
		1239	/* Handle multiple-line buffer */
		1240
		1241	RemainingData = Localities;
		1242	while (RemainingData && FieldList)
		1243	{
		1244	RemainingData = DtCompileBuffer (
		1245	LocalityBuffer + (Localities - RemainingData),
		1246	FieldList->Value, FieldList, RemainingData);
		1247	FieldList = FieldList->Next;
		1248	}
		1249
		1250	DtCreateSubtable (LocalityBuffer, Localities, &Subtable);
		1251	DtInsertSubtable (ParentTable, Subtable);
		1252	}
		1253
		1254	ACPI_FREE (LocalityBuffer);
		1255	return (AE_OK);
		1256	}
		1257
		1258
		1259	/******************************************************************************
		1260	*
		1261	* FUNCTION: DtCompileSrat
		1262	*
		1263	* PARAMETERS: List - Current field list pointer
		1264	*
		1265	* RETURN: Status
		1266	*
		1267	* DESCRIPTION: Compile SRAT.
		1268	*
		1269	*****************************************************************************/
		1270
		1271	ACPI_STATUS
		1272	DtCompileSrat (
		1273	void **List)
		1274	{
		1275	ACPI_STATUS Status;
		1276	DT_SUBTABLE *Subtable;
		1277	DT_SUBTABLE *ParentTable;
		1278	DT_FIELD PFieldList = (DT_FIELD ) List;
		1279	DT_FIELD *SubtableStart;
		1280	ACPI_SUBTABLE_HEADER *SratHeader;
		1281	ACPI_DMTABLE_INFO *InfoTable;
		1282
		1283
		1284	Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat,
		1285	&Subtable, TRUE);
		1286	if (ACPI_FAILURE (Status))
		1287	{
		1288	return (Status);
		1289	}
		1290
		1291	ParentTable = DtPeekSubtable ();
		1292	DtInsertSubtable (ParentTable, Subtable);
		1293
		1294	while (*PFieldList)
		1295	{
		1296	SubtableStart = *PFieldList;
		1297	Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr,
		1298	&Subtable, TRUE);
		1299	if (ACPI_FAILURE (Status))
		1300	{
		1301	return (Status);
		1302	}
		1303
		1304	ParentTable = DtPeekSubtable ();
		1305	DtInsertSubtable (ParentTable, Subtable);
		1306	DtPushSubtable (Subtable);
		1307
		1308	SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
		1309
		1310	switch (SratHeader->Type)
		1311	{
		1312	case ACPI_SRAT_TYPE_CPU_AFFINITY:
		1313	InfoTable = AcpiDmTableInfoSrat0;
		1314	break;
		1315	case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
		1316	InfoTable = AcpiDmTableInfoSrat1;
		1317	break;
		1318	case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
		1319	InfoTable = AcpiDmTableInfoSrat2;
		1320	break;
		1321	default:
		1322	DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT");
		1323	return (AE_ERROR);
		1324	}
		1325
		1326	Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
		1327	if (ACPI_FAILURE (Status))
		1328	{
		1329	return (Status);
		1330	}
		1331
		1332	ParentTable = DtPeekSubtable ();
		1333	DtInsertSubtable (ParentTable, Subtable);
		1334	DtPopSubtable ();
		1335	}
		1336
		1337	return (AE_OK);
		1338	}
		1339
		1340
		1341	/******************************************************************************
		1342	*
		1343	* FUNCTION: DtCompileWdat
		1344	*
		1345	* PARAMETERS: List - Current field list pointer
		1346	*
		1347	* RETURN: Status
		1348	*
		1349	* DESCRIPTION: Compile WDAT.
		1350	*
		1351	*****************************************************************************/
		1352
		1353	ACPI_STATUS
		1354	DtCompileWdat (
		1355	void **List)
		1356	{
		1357	ACPI_STATUS Status;
		1358
		1359
		1360	Status = DtCompileTwoSubtables (List,
		1361	AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0);
		1362	return (Status);
		1363	}
		1364
		1365
		1366	/******************************************************************************
		1367	*
		1368	* FUNCTION: DtCompileXsdt
		1369	*
		1370	* PARAMETERS: List - Current field list pointer
		1371	*
		1372	* RETURN: Status
		1373	*
		1374	* DESCRIPTION: Compile XSDT.
		1375	*
		1376	*****************************************************************************/
		1377
		1378	ACPI_STATUS
		1379	DtCompileXsdt (
		1380	void **List)
		1381	{
		1382	DT_SUBTABLE *Subtable;
		1383	DT_SUBTABLE *ParentTable;
		1384	DT_FIELD FieldList = (DT_FIELD **) List;
		1385	UINT64 Address;
		1386
		1387	ParentTable = DtPeekSubtable ();
		1388
		1389	while (FieldList)
		1390	{
		1391	DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO);
		1392
		1393	DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable);
		1394	DtInsertSubtable (ParentTable, Subtable);
		1395	FieldList = FieldList->Next;
		1396	}
		1397
		1398	return (AE_OK);
		1399	}

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpica/compiler/dttable.c @ 2223 – Rev 1498