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