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

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * 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. 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_HEADER_END@
 */
/*
 * @OSF_FREE_COPYRIGHT@
 */

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