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

/*
 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This 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 OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_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>
#ifdef i386
#include <i386/fakePPCStructs.h>
#endif

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

#define round_long(x)	(((x) + 3) & -4)
#define next_prop(x)	((DeviceTreeNodeProperty *) (((int)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;

void DTInit(void *base);

/*
 * Support Routines
 */
static RealDTEntry
skipProperties(RealDTEntry entry)
{
	DeviceTreeNodeProperty *prop;
	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;
	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)
{
	while (*cp != 0) {
		if (*cp == kDTPathNameSeparator) {
			cp++;
			break;
		}
		*bp++ = *cp++;
	}
	*bp = 0;
	return cp;
}

static RealDTEntry
FindChild(RealDTEntry cur, char *buf)
{
	RealDTEntry	child;
	unsigned long	index;
	char *		str;
	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 *) startingP;
	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 *) startingP;

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

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