[apple/xnu.git] / pexpert / gen / device_tree.c

/*
 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_FREE_COPYRIGHT@
 */

#include <pexpert/protos.h>
#include <pexpert/boot.h>
#include <pexpert/device_tree.h>

#include <mach/mach_types.h>
#include <mach/machine/vm_types.h>
#include <kern/kern_types.h>
#include <kern/kalloc.h>

#include <sys/types.h>

#ifndef NULL
#define       NULL    ((void *) 0)
#endif

#define round_long(x)	(((x) + 3UL) & ~(3UL))
#define next_prop(x)	((DeviceTreeNodeProperty *) (((uintptr_t)x) + sizeof(DeviceTreeNodeProperty) + round_long(x->length)))

/* Entry*/
typedef DeviceTreeNode *RealDTEntry;

typedef struct DTSavedScope {
	struct DTSavedScope * nextScope;
	RealDTEntry scope;
	RealDTEntry entry;
	unsigned long index;		
} *DTSavedScopePtr;

/* Entry Iterator*/
typedef struct OpaqueDTEntryIterator {
	RealDTEntry outerScope;
	RealDTEntry currentScope;
	RealDTEntry currentEntry;
	DTSavedScopePtr savedScope;
	unsigned long currentIndex;		
} *RealDTEntryIterator;

/* Property Iterator*/
typedef struct OpaqueDTPropertyIterator {
	RealDTEntry entry;
	DeviceTreeNodeProperty *currentProperty;
	unsigned long currentIndex;
} *RealDTPropertyIterator;

static int DTInitialized;
static RealDTEntry DTRootNode;

/*
 * Support Routines
 */
static RealDTEntry
skipProperties(RealDTEntry entry)
{
	DeviceTreeNodeProperty *prop;
	unsigned int k;

	if (entry == NULL || entry->nProperties == 0) {
		return NULL;
	} else {
		prop = (DeviceTreeNodeProperty *) (entry + 1);
		for (k = 0; k < entry->nProperties; k++) {
			prop = next_prop(prop);
		}
	}
	return ((RealDTEntry) prop);
}

static RealDTEntry
skipTree(RealDTEntry root)
{
	RealDTEntry entry;
	unsigned int k;

	entry = skipProperties(root);
	if (entry == NULL) {
		return NULL;
	}
	for (k = 0; k < root->nChildren; k++) {
		entry = skipTree(entry);
	}
	return entry;
}

static RealDTEntry
GetFirstChild(RealDTEntry parent)
{
	return skipProperties(parent);
}

static RealDTEntry
GetNextChild(RealDTEntry sibling)
{
	return skipTree(sibling);
}

static const char *
GetNextComponent(const char *cp, char *bp)
{
	size_t length = 0;
	char *origbp = bp;

	while (*cp != 0) {
		if (*cp == kDTPathNameSeparator) {
			cp++;
			break;
		}
		if (++length > kDTMaxEntryNameLength) {
			*origbp = '\0';
			return cp;
		}
		*bp++ = *cp++;
	}
	*bp = 0;
	return cp;
}

static RealDTEntry
FindChild(RealDTEntry cur, char *buf)
{
	RealDTEntry	child;
	unsigned long	index;
	char *			str;
	unsigned int	dummy;

	if (cur->nChildren == 0) {
		return NULL;
	}
	index = 1;
	child = GetFirstChild(cur);
	while (1) {
		if (DTGetProperty(child, "name", (void **)&str, &dummy) != kSuccess) {
			break;
		}
		if (strcmp(str, buf) == 0) {
			return child;
		}
		if (index >= cur->nChildren) {
			break;
		}
		child = GetNextChild(child);
		index++;
	}
	return NULL;
}


/*
 * External Routines
 */
void
DTInit(void *base)
{
	DTRootNode = (RealDTEntry) base;
	DTInitialized = (DTRootNode != 0);
}

int
DTEntryIsEqual(const DTEntry ref1, const DTEntry ref2)
{
	/* equality of pointers */
	return (ref1 == ref2);
}

static char *startingP;		// needed for find_entry
int find_entry(const char *propName, const char *propValue, DTEntry *entryH);

int DTFindEntry(const char *propName, const char *propValue, DTEntry *entryH)
{
	if (!DTInitialized) {
		return kError;
	}

	startingP = (char *)DTRootNode;
	return(find_entry(propName, propValue, entryH));
}

int find_entry(const char *propName, const char *propValue, DTEntry *entryH)
{
	DeviceTreeNode *nodeP = (DeviceTreeNode *) (void *) startingP;
	unsigned int k;

	if (nodeP->nProperties == 0) return(kError);	// End of the list of nodes
	startingP = (char *) (nodeP + 1);

	// Search current entry
	for (k = 0; k < nodeP->nProperties; ++k) {
		DeviceTreeNodeProperty *propP = (DeviceTreeNodeProperty *) (void *) startingP;

		startingP += sizeof (*propP) + ((propP->length + 3) & -4);

		if (strcmp (propP->name, propName) == 0) {
			if (propValue == NULL || strcmp( (char *)(propP + 1), propValue) == 0)
			{
				*entryH = (DTEntry)nodeP;
				return(kSuccess);
			}
		}
	}

	// Search child nodes
	for (k = 0; k < nodeP->nChildren; ++k)
	{
		if (find_entry(propName, propValue, entryH) == kSuccess)
			return(kSuccess);
	}
	return(kError);
}

int
DTLookupEntry(const DTEntry searchPoint, const char *pathName, DTEntry *foundEntry)
{
	DTEntryNameBuf	buf;
	RealDTEntry	cur;
	const char *	cp;

	if (!DTInitialized) {
		return kError;
	}
	if (searchPoint == NULL) {
		cur = DTRootNode;
	} else {
		cur = searchPoint;
	}
	cp = pathName;
	if (*cp == kDTPathNameSeparator) {
		cp++;
		if (*cp == 0) {
			*foundEntry = cur;
			return kSuccess;
		}
	}
	do {
		cp = GetNextComponent(cp, buf);

		/* Check for done */
		if (*buf == 0) {
			if (*cp == 0) {
				*foundEntry = cur;
				return kSuccess;
			}
			break;
		}

		cur = FindChild(cur, buf);

	} while (cur != NULL);

	return kError;
}

int
DTCreateEntryIterator(const DTEntry startEntry, DTEntryIterator *iterator)
{
	RealDTEntryIterator iter;

	if (!DTInitialized) {
		return kError;
	}

	iter = (RealDTEntryIterator) kalloc(sizeof(struct OpaqueDTEntryIterator));
	if (startEntry != NULL) {
		iter->outerScope = (RealDTEntry) startEntry;
		iter->currentScope = (RealDTEntry) startEntry;
	} else {
		iter->outerScope = DTRootNode;
		iter->currentScope = DTRootNode;
	}
	iter->currentEntry = NULL;
	iter->savedScope = NULL;
	iter->currentIndex = 0;

	*iterator = iter;
	return kSuccess;
}

int
DTDisposeEntryIterator(DTEntryIterator iterator)
{
	RealDTEntryIterator iter = iterator;
	DTSavedScopePtr scope;

	while ((scope = iter->savedScope) != NULL) {
		iter->savedScope = scope->nextScope;
		kfree(scope, sizeof(struct DTSavedScope));
	}
	kfree(iterator, sizeof(struct OpaqueDTEntryIterator));
	return kSuccess;
}

int
DTEnterEntry(DTEntryIterator iterator, DTEntry childEntry)
{
	RealDTEntryIterator iter = iterator;
	DTSavedScopePtr newScope;

	if (childEntry == NULL) {
		return kError;
	}
	newScope = (DTSavedScopePtr) kalloc(sizeof(struct DTSavedScope));
	newScope->nextScope = iter->savedScope;
	newScope->scope = iter->currentScope;
	newScope->entry = iter->currentEntry;
	newScope->index = iter->currentIndex;		

	iter->currentScope = childEntry;
	iter->currentEntry = NULL;
	iter->savedScope = newScope;
	iter->currentIndex = 0;

	return kSuccess;
}

int
DTExitEntry(DTEntryIterator iterator, DTEntry *currentPosition)
{
	RealDTEntryIterator iter = iterator;
	DTSavedScopePtr newScope;

	newScope = iter->savedScope;
	if (newScope == NULL) {
		return kError;
	}
	iter->savedScope = newScope->nextScope;
	iter->currentScope = newScope->scope;
	iter->currentEntry = newScope->entry;
	iter->currentIndex = newScope->index;
	*currentPosition = iter->currentEntry;

	kfree(newScope, sizeof(struct DTSavedScope));

	return kSuccess;
}

int
DTIterateEntries(DTEntryIterator iterator, DTEntry *nextEntry)
{
	RealDTEntryIterator iter = iterator;

	if (iter->currentIndex >= iter->currentScope->nChildren) {
		*nextEntry = NULL;
		return kIterationDone;
	} else {
		iter->currentIndex++;
		if (iter->currentIndex == 1) {
			iter->currentEntry = GetFirstChild(iter->currentScope);
		} else {
			iter->currentEntry = GetNextChild(iter->currentEntry);
		}
		*nextEntry = iter->currentEntry;
		return kSuccess;
	}
}

int
DTRestartEntryIteration(DTEntryIterator iterator)
{
	RealDTEntryIterator iter = iterator;
#if 0
	// This commented out code allows a second argument (outer)
	// which (if true) causes restarting at the outer scope
	// rather than the current scope.
	DTSavedScopePtr scope;

	if (outer) {
		while ((scope = iter->savedScope) != NULL) {
			iter->savedScope = scope->nextScope;
			kfree((vm_offset_t) scope, sizeof(struct DTSavedScope));
		}
		iter->currentScope = iter->outerScope;
	}
#endif
	iter->currentEntry = NULL;
	iter->currentIndex = 0;
	return kSuccess;
}

int
DTGetProperty(const DTEntry entry, const char *propertyName, void **propertyValue, unsigned int *propertySize)
{
	DeviceTreeNodeProperty *prop;
	unsigned int k;

	if (entry == NULL || entry->nProperties == 0) {
		return kError;
	} else {
		prop = (DeviceTreeNodeProperty *) (entry + 1);
		for (k = 0; k < entry->nProperties; k++) {
			if (strcmp(prop->name, propertyName) == 0) {
				*propertyValue = (void *) (((uintptr_t)prop)
						+ sizeof(DeviceTreeNodeProperty));
				*propertySize = prop->length;
				return kSuccess;
			}
			prop = next_prop(prop);
		}
	}
	return kError;
}

int
DTCreatePropertyIterator(const DTEntry entry, DTPropertyIterator *iterator)
{
	RealDTPropertyIterator iter;

	iter = (RealDTPropertyIterator) kalloc(sizeof(struct OpaqueDTPropertyIterator));
	iter->entry = entry;
	iter->currentProperty = NULL;
	iter->currentIndex = 0;

	*iterator = iter;
	return kSuccess;
}

int
DTDisposePropertyIterator(DTPropertyIterator iterator)
{
	kfree(iterator, sizeof(struct OpaqueDTPropertyIterator));
	return kSuccess;
}

int
DTIterateProperties(DTPropertyIterator iterator, char **foundProperty)
{
	RealDTPropertyIterator iter = iterator;

	if (iter->currentIndex >= iter->entry->nProperties) {
		*foundProperty = NULL;
		return kIterationDone;
	} else {
		iter->currentIndex++;
		if (iter->currentIndex == 1) {
			iter->currentProperty = (DeviceTreeNodeProperty *) (iter->entry + 1);
		} else {
			iter->currentProperty = next_prop(iter->currentProperty);
		}
		*foundProperty = iter->currentProperty->name;
		return kSuccess;
	}
}

int
DTRestartPropertyIteration(DTPropertyIterator iterator)
{
	RealDTPropertyIterator iter = iterator;

	iter->currentProperty = NULL;
	iter->currentIndex = 0;
	return kSuccess;
}
Commit	Line	Data
1c79356b	1	/*
91447636	2	* Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
8f6c56a5	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* @OSF_FREE_COPYRIGHT@
	30	*/
	31
	32	#include <pexpert/protos.h>
	33	#include <pexpert/boot.h>
	34	#include <pexpert/device_tree.h>
91447636 A	35
91447636 A	36	#include <mach/mach_types.h>
1c79356b	37	#include <mach/machine/vm_types.h>
91447636 A	38	#include <kern/kern_types.h>
	39	#include <kern/kalloc.h>
	40
1c79356b	41	#include <sys/types.h>
1c79356b A	42
	43	#ifndef NULL
	44	#define NULL ((void *) 0)
	45	#endif
	46
b0d623f7 A	47	#define round_long(x) (((x) + 3UL) & ~(3UL))
b0d623f7 A	48	#define next_prop(x) ((DeviceTreeNodeProperty *) (((uintptr_t)x) + sizeof(DeviceTreeNodeProperty) + round_long(x->length)))
1c79356b A	49
	50	/* Entry*/
	51	typedef DeviceTreeNode *RealDTEntry;
	52
	53	typedef struct DTSavedScope {
	54	struct DTSavedScope * nextScope;
	55	RealDTEntry scope;
	56	RealDTEntry entry;
	57	unsigned long index;
	58	} *DTSavedScopePtr;
	59
	60	/* Entry Iterator*/
	61	typedef struct OpaqueDTEntryIterator {
	62	RealDTEntry outerScope;
	63	RealDTEntry currentScope;
	64	RealDTEntry currentEntry;
	65	DTSavedScopePtr savedScope;
	66	unsigned long currentIndex;
	67	} *RealDTEntryIterator;
	68
	69	/* Property Iterator*/
	70	typedef struct OpaqueDTPropertyIterator {
	71	RealDTEntry entry;
	72	DeviceTreeNodeProperty *currentProperty;
	73	unsigned long currentIndex;
	74	} *RealDTPropertyIterator;
	75
	76	static int DTInitialized;
	77	static RealDTEntry DTRootNode;
	78
1c79356b A	79	/*
	80	* Support Routines
	81	*/
	82	static RealDTEntry
	83	skipProperties(RealDTEntry entry)
	84	{
	85	DeviceTreeNodeProperty *prop;
2d21ac55	86	unsigned int k;
1c79356b A	87
	88	if (entry == NULL \|\| entry->nProperties == 0) {
	89	return NULL;
	90	} else {
	91	prop = (DeviceTreeNodeProperty *) (entry + 1);
	92	for (k = 0; k < entry->nProperties; k++) {
	93	prop = next_prop(prop);
	94	}
	95	}
	96	return ((RealDTEntry) prop);
	97	}
	98
	99	static RealDTEntry
	100	skipTree(RealDTEntry root)
	101	{
	102	RealDTEntry entry;
2d21ac55	103	unsigned int k;
1c79356b A	104
	105	entry = skipProperties(root);
	106	if (entry == NULL) {
	107	return NULL;
	108	}
	109	for (k = 0; k < root->nChildren; k++) {
	110	entry = skipTree(entry);
	111	}
	112	return entry;
	113	}
	114
	115	static RealDTEntry
	116	GetFirstChild(RealDTEntry parent)
	117	{
	118	return skipProperties(parent);
	119	}
	120
	121	static RealDTEntry
	122	GetNextChild(RealDTEntry sibling)
	123	{
	124	return skipTree(sibling);
	125	}
	126
	127	static const char *
	128	GetNextComponent(const char cp, char bp)
	129	{
316670eb A	130	size_t length = 0;
	131	char *origbp = bp;
	132
1c79356b A	133	while (*cp != 0) {
	134	if (*cp == kDTPathNameSeparator) {
	135	cp++;
	136	break;
	137	}
316670eb A	138	if (++length > kDTMaxEntryNameLength) {
	139	*origbp = '\0';
	140	return cp;
	141	}
1c79356b A	142	bp++ = cp++;
	143	}
	144	*bp = 0;
	145	return cp;
	146	}
	147
	148	static RealDTEntry
	149	FindChild(RealDTEntry cur, char *buf)
	150	{
	151	RealDTEntry child;
	152	unsigned long index;
2d21ac55 A	153	char * str;
2d21ac55 A	154	unsigned int dummy;
1c79356b A	155
	156	if (cur->nChildren == 0) {
	157	return NULL;
	158	}
	159	index = 1;
	160	child = GetFirstChild(cur);
	161	while (1) {
	162	if (DTGetProperty(child, "name", (void **)&str, &dummy) != kSuccess) {
	163	break;
	164	}
	165	if (strcmp(str, buf) == 0) {
	166	return child;
	167	}
	168	if (index >= cur->nChildren) {
	169	break;
	170	}
	171	child = GetNextChild(child);
	172	index++;
	173	}
	174	return NULL;
	175	}
	176
	177
	178	/*
	179	* External Routines
	180	*/
	181	void
	182	DTInit(void *base)
	183	{
	184	DTRootNode = (RealDTEntry) base;
	185	DTInitialized = (DTRootNode != 0);
	186	}
	187
	188	int
	189	DTEntryIsEqual(const DTEntry ref1, const DTEntry ref2)
	190	{
	191	/* equality of pointers */
	192	return (ref1 == ref2);
	193	}
	194
	195	static char *startingP; // needed for find_entry
	196	int find_entry(const char propName, const char propValue, DTEntry *entryH);
	197
	198	int DTFindEntry(const char propName, const char propValue, DTEntry *entryH)
	199	{
	200	if (!DTInitialized) {
	201	return kError;
	202	}
	203
	204	startingP = (char *)DTRootNode;
	205	return(find_entry(propName, propValue, entryH));
	206	}
	207
	208	int find_entry(const char propName, const char propValue, DTEntry *entryH)
	209	{
b0d623f7	210	DeviceTreeNode nodeP = (DeviceTreeNode ) (void *) startingP;
2d21ac55	211	unsigned int k;
1c79356b A	212
	213	if (nodeP->nProperties == 0) return(kError); // End of the list of nodes
	214	startingP = (char *) (nodeP + 1);
	215
	216	// Search current entry
	217	for (k = 0; k < nodeP->nProperties; ++k) {
b0d623f7	218	DeviceTreeNodeProperty propP = (DeviceTreeNodeProperty ) (void *) startingP;
1c79356b A	219
	220	startingP += sizeof (*propP) + ((propP->length + 3) & -4);
	221
	222	if (strcmp (propP->name, propName) == 0) {
2d21ac55	223	if (propValue == NULL \|\| strcmp( (char *)(propP + 1), propValue) == 0)
1c79356b A	224	{
	225	*entryH = (DTEntry)nodeP;
	226	return(kSuccess);
	227	}
	228	}
	229	}
	230
	231	// Search child nodes
	232	for (k = 0; k < nodeP->nChildren; ++k)
	233	{
	234	if (find_entry(propName, propValue, entryH) == kSuccess)
	235	return(kSuccess);
	236	}
	237	return(kError);
	238	}
	239
	240	int
	241	DTLookupEntry(const DTEntry searchPoint, const char pathName, DTEntry foundEntry)
	242	{
	243	DTEntryNameBuf buf;
	244	RealDTEntry cur;
	245	const char * cp;
	246
	247	if (!DTInitialized) {
	248	return kError;
	249	}
	250	if (searchPoint == NULL) {
	251	cur = DTRootNode;
	252	} else {
	253	cur = searchPoint;
	254	}
	255	cp = pathName;
	256	if (*cp == kDTPathNameSeparator) {
	257	cp++;
	258	if (*cp == 0) {
	259	*foundEntry = cur;
	260	return kSuccess;
	261	}
	262	}
	263	do {
	264	cp = GetNextComponent(cp, buf);
	265
	266	/* Check for done */
	267	if (*buf == 0) {
	268	if (*cp == 0) {
	269	*foundEntry = cur;
	270	return kSuccess;
	271	}
	272	break;
	273	}
	274
	275	cur = FindChild(cur, buf);
	276
	277	} while (cur != NULL);
	278
	279	return kError;
	280	}
	281
	282	int
	283	DTCreateEntryIterator(const DTEntry startEntry, DTEntryIterator *iterator)
	284	{
	285	RealDTEntryIterator iter;
	286
	287	if (!DTInitialized) {
288	return kError;
289	}
290
291	iter = (RealDTEntryIterator) kalloc(sizeof(struct OpaqueDTEntryIterator));
292	if (startEntry != NULL) {
293	iter->outerScope = (RealDTEntry) startEntry;
294	iter->currentScope = (RealDTEntry) startEntry;
295	} else {
296	iter->outerScope = DTRootNode;
297	iter->currentScope = DTRootNode;
298	}
299	iter->currentEntry = NULL;
300	iter->savedScope = NULL;
301	iter->currentIndex = 0;
302
303	*iterator = iter;
304	return kSuccess;
305	}
306
307	int
308	DTDisposeEntryIterator(DTEntryIterator iterator)
309	{
310	RealDTEntryIterator iter = iterator;
311	DTSavedScopePtr scope;
312
313	while ((scope = iter->savedScope) != NULL) {
314	iter->savedScope = scope->nextScope;
91447636	315	kfree(scope, sizeof(struct DTSavedScope));
1c79356b	316	}
91447636	317	kfree(iterator, sizeof(struct OpaqueDTEntryIterator));
1c79356b A	318	return kSuccess;
	319	}
	320
	321	int
	322	DTEnterEntry(DTEntryIterator iterator, DTEntry childEntry)
	323	{
	324	RealDTEntryIterator iter = iterator;
	325	DTSavedScopePtr newScope;
	326
	327	if (childEntry == NULL) {
	328	return kError;
	329	}
	330	newScope = (DTSavedScopePtr) kalloc(sizeof(struct DTSavedScope));
	331	newScope->nextScope = iter->savedScope;
	332	newScope->scope = iter->currentScope;
	333	newScope->entry = iter->currentEntry;
	334	newScope->index = iter->currentIndex;
	335
	336	iter->currentScope = childEntry;
	337	iter->currentEntry = NULL;
	338	iter->savedScope = newScope;
	339	iter->currentIndex = 0;
	340
	341	return kSuccess;
	342	}
	343
	344	int
	345	DTExitEntry(DTEntryIterator iterator, DTEntry *currentPosition)
	346	{
	347	RealDTEntryIterator iter = iterator;
	348	DTSavedScopePtr newScope;
	349
	350	newScope = iter->savedScope;
	351	if (newScope == NULL) {
	352	return kError;
	353	}
	354	iter->savedScope = newScope->nextScope;
	355	iter->currentScope = newScope->scope;
	356	iter->currentEntry = newScope->entry;
	357	iter->currentIndex = newScope->index;
	358	*currentPosition = iter->currentEntry;
	359
91447636	360	kfree(newScope, sizeof(struct DTSavedScope));
1c79356b A	361
	362	return kSuccess;
	363	}
	364
	365	int
	366	DTIterateEntries(DTEntryIterator iterator, DTEntry *nextEntry)
	367	{
	368	RealDTEntryIterator iter = iterator;
	369
	370	if (iter->currentIndex >= iter->currentScope->nChildren) {
	371	*nextEntry = NULL;
	372	return kIterationDone;
	373	} else {
	374	iter->currentIndex++;
	375	if (iter->currentIndex == 1) {
	376	iter->currentEntry = GetFirstChild(iter->currentScope);
	377	} else {
	378	iter->currentEntry = GetNextChild(iter->currentEntry);
	379	}
	380	*nextEntry = iter->currentEntry;
	381	return kSuccess;
	382	}
	383	}
	384
	385	int
	386	DTRestartEntryIteration(DTEntryIterator iterator)
	387	{
	388	RealDTEntryIterator iter = iterator;
	389	#if 0
	390	// This commented out code allows a second argument (outer)
	391	// which (if true) causes restarting at the outer scope
	392	// rather than the current scope.
	393	DTSavedScopePtr scope;
	394
	395	if (outer) {
	396	while ((scope = iter->savedScope) != NULL) {
	397	iter->savedScope = scope->nextScope;
	398	kfree((vm_offset_t) scope, sizeof(struct DTSavedScope));
	399	}
	400	iter->currentScope = iter->outerScope;
	401	}
	402	#endif
	403	iter->currentEntry = NULL;
	404	iter->currentIndex = 0;
	405	return kSuccess;
	406	}
	407
	408	int
2d21ac55	409	DTGetProperty(const DTEntry entry, const char propertyName, void propertyValue, unsigned int propertySize)
1c79356b A	410	{
1c79356b A	411	DeviceTreeNodeProperty *prop;
2d21ac55	412	unsigned int k;
1c79356b A	413
	414	if (entry == NULL \|\| entry->nProperties == 0) {
	415	return kError;
	416	} else {
	417	prop = (DeviceTreeNodeProperty *) (entry + 1);
	418	for (k = 0; k < entry->nProperties; k++) {
	419	if (strcmp(prop->name, propertyName) == 0) {
b0d623f7	420	propertyValue = (void ) (((uintptr_t)prop)
1c79356b A	421	+ sizeof(DeviceTreeNodeProperty));
	422	*propertySize = prop->length;
	423	return kSuccess;
	424	}
	425	prop = next_prop(prop);
	426	}
	427	}
	428	return kError;
	429	}
	430
	431	int
	432	DTCreatePropertyIterator(const DTEntry entry, DTPropertyIterator *iterator)
	433	{
	434	RealDTPropertyIterator iter;
	435
	436	iter = (RealDTPropertyIterator) kalloc(sizeof(struct OpaqueDTPropertyIterator));
	437	iter->entry = entry;
	438	iter->currentProperty = NULL;
	439	iter->currentIndex = 0;
	440
	441	*iterator = iter;
	442	return kSuccess;
	443	}
	444
	445	int
	446	DTDisposePropertyIterator(DTPropertyIterator iterator)
	447	{
91447636	448	kfree(iterator, sizeof(struct OpaqueDTPropertyIterator));
1c79356b A	449	return kSuccess;
	450	}
	451
	452	int
	453	DTIterateProperties(DTPropertyIterator iterator, char **foundProperty)
	454	{
	455	RealDTPropertyIterator iter = iterator;
	456
	457	if (iter->currentIndex >= iter->entry->nProperties) {
	458	*foundProperty = NULL;
	459	return kIterationDone;
	460	} else {
	461	iter->currentIndex++;
	462	if (iter->currentIndex == 1) {
	463	iter->currentProperty = (DeviceTreeNodeProperty *) (iter->entry + 1);
	464	} else {
	465	iter->currentProperty = next_prop(iter->currentProperty);
	466	}
	467	*foundProperty = iter->currentProperty->name;
	468	return kSuccess;
	469	}
	470	}
	471
	472	int
	473	DTRestartPropertyIteration(DTPropertyIterator iterator)
	474	{
	475	RealDTPropertyIterator iter = iterator;
	476
	477	iter->currentProperty = NULL;
	478	iter->currentIndex = 0;
	479	return kSuccess;
	480	}
	481