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

/*
 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_OSREFERENCE_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_LICENSE_OSREFERENCE_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	3	*
8ad349bb	4	* @APPLE_LICENSE_OSREFERENCE_HEADER_START@
1c79356b	5	*
8ad349bb 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
	10	* License may not be used to create, or enable the creation or
	11	* redistribution of, unlawful or unlicensed copies of an Apple operating
	12	* system, or to circumvent, violate, or enable the circumvention or
	13	* violation of, any terms of an Apple operating system software license
	14	* agreement.
	15	*
	16	* Please obtain a copy of the License at
	17	* http://www.opensource.apple.com/apsl/ and read it before using this
	18	* file.
	19	*
	20	* The Original Code and all software distributed under the License are
	21	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	22	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	23	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	24	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	25	* Please see the License for the specific language governing rights and
	26	* limitations under the License.
	27	*
	28	* @APPLE_LICENSE_OSREFERENCE_HEADER_END@
1c79356b A	29	*/
	30	/*
	31	* @OSF_FREE_COPYRIGHT@
	32	*/
	33
	34	#include <pexpert/protos.h>
	35	#include <pexpert/boot.h>
	36	#include <pexpert/device_tree.h>
91447636 A	37
91447636 A	38	#include <mach/mach_types.h>
1c79356b	39	#include <mach/machine/vm_types.h>
91447636 A	40	#include <kern/kern_types.h>
	41	#include <kern/kalloc.h>
	42
1c79356b A	43	#include <sys/types.h>
	44	#ifdef i386
	45	#include <i386/fakePPCStructs.h>
	46	#endif
	47
	48	#ifndef NULL
	49	#define NULL ((void *) 0)
	50	#endif
	51
	52	#define round_long(x) (((x) + 3) & -4)
	53	#define next_prop(x) ((DeviceTreeNodeProperty *) (((int)x) + sizeof(DeviceTreeNodeProperty) + round_long(x->length)))
	54
	55	/* Entry*/
	56	typedef DeviceTreeNode *RealDTEntry;
	57
	58	typedef struct DTSavedScope {
	59	struct DTSavedScope * nextScope;
	60	RealDTEntry scope;
	61	RealDTEntry entry;
	62	unsigned long index;
	63	} *DTSavedScopePtr;
	64
	65	/* Entry Iterator*/
	66	typedef struct OpaqueDTEntryIterator {
	67	RealDTEntry outerScope;
	68	RealDTEntry currentScope;
	69	RealDTEntry currentEntry;
	70	DTSavedScopePtr savedScope;
	71	unsigned long currentIndex;
	72	} *RealDTEntryIterator;
	73
	74	/* Property Iterator*/
	75	typedef struct OpaqueDTPropertyIterator {
	76	RealDTEntry entry;
	77	DeviceTreeNodeProperty *currentProperty;
	78	unsigned long currentIndex;
	79	} *RealDTPropertyIterator;
	80
	81	static int DTInitialized;
	82	static RealDTEntry DTRootNode;
	83
	84	void DTInit(void *base);
	85
	86	/*
	87	* Support Routines
	88	*/
	89	static RealDTEntry
	90	skipProperties(RealDTEntry entry)
	91	{
	92	DeviceTreeNodeProperty *prop;
	93	int k;
	94
	95	if (entry == NULL \|\| entry->nProperties == 0) {
	96	return NULL;
	97	} else {
	98	prop = (DeviceTreeNodeProperty *) (entry + 1);
	99	for (k = 0; k < entry->nProperties; k++) {
	100	prop = next_prop(prop);
	101	}
	102	}
	103	return ((RealDTEntry) prop);
	104	}
	105
	106	static RealDTEntry
107	skipTree(RealDTEntry root)
108	{
109	RealDTEntry entry;
110	int k;
111
112	entry = skipProperties(root);
113	if (entry == NULL) {
114	return NULL;
115	}
116	for (k = 0; k < root->nChildren; k++) {
117	entry = skipTree(entry);
118	}
119	return entry;
120	}
121
122	static RealDTEntry
123	GetFirstChild(RealDTEntry parent)
124	{
125	return skipProperties(parent);
126	}
127
128	static RealDTEntry
129	GetNextChild(RealDTEntry sibling)
130	{
131	return skipTree(sibling);
132	}
133
134	static const char *
135	GetNextComponent(const char cp, char bp)
136	{
137	while (*cp != 0) {
138	if (*cp == kDTPathNameSeparator) {
139	cp++;
140	break;
141	}
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;
153	char * str;
154	int dummy;
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	{
210	DeviceTreeNode nodeP = (DeviceTreeNode ) startingP;
211	int k;
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) {
218	DeviceTreeNodeProperty propP = (DeviceTreeNodeProperty ) startingP;
219
220	startingP += sizeof (*propP) + ((propP->length + 3) & -4);
221
222	if (strcmp (propP->name, propName) == 0) {
223	if (strcmp( (char *)(propP + 1), propValue) == 0)
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
	409	DTGetProperty(const DTEntry entry, const char propertyName, void propertyValue, int propertySize)
	410	{
	411	DeviceTreeNodeProperty *prop;
	412	int k;
	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) {
	420	propertyValue = (void ) (((int)prop)
	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