Chameleon

Chameleon Svn Source Tree

Root/trunk/i386/libsaio/device_tree.c

1/*␊
2 * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights␊
5 * Reserved. This file contains Original Code and/or Modifications of␊
6 * Original Code as defined in and that are subject to the Apple Public␊
7 * Source License Version 2.0 (the "License"). You may not use this file␊
8 * except in compliance with the License. Please obtain a copy of the␊
9 * License at http://www.apple.com/publicsource and read it before using␊
10 * this file.␊
11 * ␊
12 * The Original Code and all software distributed under the License are␊
13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
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.␊
19 * ␊
20 */␊
21␊
22#if 1␊
23/*␊
24␊
25 Structures for a Flattened Device Tree ␊
26 */␊
27␊
28#define kPropNameLength 32␊
29␊
30typedef struct DeviceTreeNodeProperty {␊
31␉char name[kPropNameLength]; // NUL terminated property name␊
32␉unsigned long length; // Length (bytes) of folloing prop value␊
33 // unsigned long value[1]; // Variable length value of property␊
34 // Padded to a multiple of a longword?␊
35} DeviceTreeNodeProperty;␊
36␊
37typedef struct OpaqueDTEntry {␊
38␉unsigned long nProperties; // Number of props[] elements (0 => end)␊
39␉unsigned long nChildren; // Number of children[] elements␊
40 // DeviceTreeNodeProperty props[];// array size == nProperties␊
41 // DeviceTreeNode children[]; // array size == nChildren␊
42} DeviceTreeNode;␊
43␊
44typedef char DTPropertyNameBuf[32];␊
45␊
46// Entry Name Definitions (Entry Names are C-Strings).␊
47enum {␊
48 kDTMaxEntryNameLength = 31 /* Max length of a C-String Entry Name (terminator not included) */␊
49};␊
50␊
51/* length of DTEntryNameBuf = kDTMaxEntryNameLength +1*/␊
52typedef char DTEntryNameBuf[32];␊
53#endif␊
54␊
55#include "libsaio.h"␊
56#include "device_tree.h"␊
57␊
58#if DEBUG␊
59#define DPRINTF(args...) printf(args)␊
60void␊
61DT__PrintTree(Node *node);␊
62#else␊
63#define DPRINTF(args...)␊
64#endif␊
65␊
66␊
67#define RoundToLong(x)␉(((x) + 3) & ~3)␊
68␊
69static struct _DTSizeInfo {␊
70␉uint32_t␉numNodes;␊
71␉uint32_t␉numProperties;␊
72␉uint32_t␉totalPropertySize;␊
73} DTInfo;␊
74␊
75#define kAllocSize 4096␊
76␊
77static Node *rootNode;␊
78␊
79static Node *freeNodes, *allocedNodes;␊
80static Property *freeProperties, *allocedProperties;␊
81␊
82␊
83//==============================================================================␊
84␊
85Property *␊
86DT__AddProperty(Node *node, const char *name, uint32_t length, void *value)␊
87{␊
88␉Property *prop;␊
89␊
90␉DPRINTF("DT__AddProperty([Node '%s'], '%s', %d, 0x%X)\n", DT__GetName(node), name, length, value);␊
91␊
92␉if (freeProperties == NULL) {␊
93␉␉void *buf = malloc(kAllocSize);␊
94␉␉int i;␊
95␊
96␉␉DPRINTF("DT__AddProperty: Allocating more free properties\n");␊
97␊
98␉␉if (buf == 0) {␊
99␉␉␉return 0;␊
100␉␉}␊
101␊
102␉␉bzero(buf, kAllocSize);␊
103␉␉// Use the first property to record the allocated buffer␊
104␉␉// for later freeing.␊
105␉␉prop = (Property *)buf;␊
106␉␉prop->next = allocedProperties;␊
107␉␉allocedProperties = prop;␊
108␉␉prop->value = buf;␊
109␉␉prop++;␊
110␊
111␉␉for (i = 1; i < (kAllocSize / sizeof(Property)); i++) {␊
112␉␉␉prop->next = freeProperties;␊
113␉␉␉freeProperties = prop;␊
114␉␉␉prop++;␊
115␉␉}␊
116␉}␊
117␊
118␉prop = freeProperties;␊
119␉freeProperties = prop->next;␊
120␊
121␉prop->name = name;␊
122␉prop->length = length;␊
123␉prop->value = value;␊
124␊
125␉// Always add to end of list␊
126␉if (node->properties == 0) {␊
127␉␉node->properties = prop;␊
128␉} else {␊
129␉␉node->last_prop->next = prop;␊
130␉}␊
131␊
132␉node->last_prop = prop;␊
133␉prop->next = 0;␊
134␊
135␉DPRINTF("Done [0x%x]\n", prop);␊
136␊
137␉DTInfo.numProperties++;␊
138␉DTInfo.totalPropertySize += RoundToLong(length);␊
139␊
140␉return prop;␊
141}␊
142␊
143␊
144//==============================================================================␊
145␊
146Node *␊
147DT__AddChild(Node *parent, const char *name)␊
148{␊
149␉Node *node;␊
150␊
151␉if (freeNodes == NULL)␊
152␉{␊
153␉␉void *buf = malloc(kAllocSize);␊
154␊
155␉␉if (buf == 0)␊
156␉␉{␊
157␉␉␉return 0;␊
158␉␉}␊
159␊
160␉␉int i;␊
161␊
162␉␉DPRINTF("DT__AddChild: Allocating more free nodes\n");␊
163␊
164␉␉bzero(buf, kAllocSize);␊
165␉␉node = (Node *)buf;␊
166␊
167␉␉// Use the first node to record the allocated buffer for later freeing.␊
168␉␉node->next = allocedNodes;␊
169␉␉allocedNodes = node;␊
170␉␉node->children = (Node *)buf;␊
171␉␉node++;␊
172␊
173␉␉for (i = 1; i < (kAllocSize / sizeof(Node)); i++)␊
174␉␉{␊
175␉␉␉node->next = freeNodes;␊
176␉␉␉freeNodes = node;␊
177␉␉␉node++;␊
178␉␉}␊
179␉}␊
180␊
181␉DPRINTF("DT__AddChild(0x%x, '%s')\n", parent, name);␊
182␊
183␉node = freeNodes;␊
184␉freeNodes = node->next;␊
185␊
186␉DPRINTF("DT__AddChild: Got free node 0x%x\n", node);␊
187␉DPRINTF("DT__AddChild: prop = 0x%x, children = 0x%x, next = 0x%x\n", node->properties, node->children, node->next);␊
188␊
189␉if (parent == NULL)␊
190␉{␊
191␉␉rootNode = node;␊
192␉␉node->next = 0;␊
193␉}␊
194␉else␊
195␉{␊
196␉␉node->next = parent->children;␊
197␉␉parent->children = node;␊
198␉}␊
199␊
200␉DTInfo.numNodes++;␊
201␉DT__AddProperty(node, "name", strlen(name) + 1, (void *) name);␊
202␊
203␉return node;␊
204}␊
205␊
206␊
207//==============================================================================␊
208␊
209void␊
210DT__FreeProperty(Property *prop)␊
211{␊
212␉prop->next = freeProperties;␊
213␉freeProperties = prop;␊
214}␊
215␊
216//==============================================================================␊
217␊
218void␊
219DT__FreeNode(Node *node)␊
220{␊
221␉node->next = freeNodes;␊
222␉freeNodes = node;␊
223}␊
224␊
225//==============================================================================␊
226␊
227void␊
228DT__Initialize(void)␊
229{␊
230␉DPRINTF("DT__Initialize\n");␊
231␊
232␉freeNodes = 0;␊
233␉allocedNodes = 0;␊
234␉freeProperties = 0;␊
235␉allocedProperties = 0;␊
236␊
237␉DTInfo.numNodes = 0;␊
238␉DTInfo.numProperties = 0;␊
239␉DTInfo.totalPropertySize = 0;␊
240␊
241␉rootNode = DT__AddChild(NULL, "/");␊
242␉DPRINTF("DT__Initialize: done\n");␊
243}␊
244␊
245//==============================================================================␊
246/*␊
247 * Free up memory used by in-memory representation of device tree.␊
248 */␊
249void␊
250DT__Finalize(void)␊
251{␊
252␉Node *node;␊
253␉Property *prop;␊
254␊
255␉DPRINTF("DT__Finalize\n");␊
256␊
257␉for (prop = allocedProperties; prop != NULL; prop = prop->next)␊
258␉{␊
259␉␉free(prop->value);␊
260␉}␊
261␊
262␉allocedProperties = NULL;␊
263␉freeProperties = NULL;␊
264␊
265␉for (node = allocedNodes; node != NULL; node = node->next)␊
266␉{␊
267␉␉free((void *)node->children);␊
268␉}␊
269␊
270␉allocedNodes = NULL;␊
271␉freeNodes = NULL;␊
272␉rootNode = NULL;␊
273 ␊
274␉// XXX leaks any created strings␊
275␉DTInfo.numNodes = 0;␊
276␉DTInfo.numProperties = 0;␊
277␉DTInfo.totalPropertySize = 0;␊
278}␊
279␊
280//==============================================================================␊
281␊
282static void *␊
283FlattenNodes(Node *node, void *buffer)␊
284{␊
285␉Property *prop;␊
286␉DeviceTreeNode *flatNode;␊
287␉DeviceTreeNodeProperty *flatProp;␊
288␉int count;␊
289␊
290␉if (node == 0) {␊
291␉␉return buffer;␊
292␉}␊
293␊
294␉flatNode = (DeviceTreeNode *)buffer;␊
295␉buffer += sizeof(DeviceTreeNode);␊
296␊
297␉for (count = 0, prop = node->properties; prop != 0; count++, prop = prop->next)␊
298␉{␊
299␉␉flatProp = (DeviceTreeNodeProperty *)buffer;␊
300␉␉strncpy(flatProp->name, prop->name, kPropNameLength);␊
301␉␉flatProp->length = prop->length;␊
302␉␉buffer += sizeof(DeviceTreeNodeProperty);␊
303␉␉bcopy(prop->value, buffer, prop->length);␊
304␉␉buffer += RoundToLong(prop->length);␊
305␉}␊
306␊
307␉flatNode->nProperties = count;␊
308␊
309␉for (count = 0, node = node->children; node != 0; count++, node = node->next)␊
310␉{␊
311␉␉buffer = FlattenNodes(node, buffer);␊
312␉}␊
313␊
314␉flatNode->nChildren = count;␊
315␊
316␉return buffer;␊
317}␊
318␊
319␊
320/*==============================================================================␊
321 * Flatten the in-memory representation of the device tree into a binary DT block.␊
322 * To get the buffer size needed, call with result = 0.␊
323 * To have a buffer allocated for you, call with *result = 0.␊
324 * To use your own buffer, call with *result = &buffer.␊
325 */␊
326␊
327void␊
328DT__FlattenDeviceTree(void **buffer_p, uint32_t *length)␊
329{␊
330␉uint32_t totalSize;␊
331␉void * buf;␊
332␊
333␉DPRINTF("DT__FlattenDeviceTree(0x%x, 0x%x)\n", buffer_p, length);␊
334␊
335#if DEBUG␊
336␉if (buffer_p) {␊
337␉␉DT__PrintTree(rootNode);␊
338␉}␊
339#endif␊
340 ␊
341␉totalSize = DTInfo.numNodes * sizeof(DeviceTreeNode) + ␊
342␉␉DTInfo.numProperties * sizeof(DeviceTreeNodeProperty) +␊
343␉␉DTInfo.totalPropertySize;␊
344␊
345␉DPRINTF("Total size 0x%x\n", totalSize);␊
346␊
347␉if (buffer_p != 0)␊
348␉{␊
349␉␉if (totalSize == 0)␊
350␉␉{␊
351␉␉␉buf = 0;␊
352␉␉}␊
353␉␉else␊
354␉␉{␊
355␉␉␉if (*buffer_p == 0)␊
356␉␉␉{␊
357␉␉␉␉buf = malloc(totalSize);␊
358␉␉␉}␊
359␉␉␉else␊
360␉␉␉{␊
361␉␉␉␉buf = *buffer_p;␊
362␉␉␉}␊
363␊
364␉␉␉bzero(buf, totalSize);␊
365␊
366␉␉␉FlattenNodes(rootNode, buf);␊
367␉␉}␊
368␊
369␉␉*buffer_p = buf;␊
370␉}␊
371␊
372␉if (length)␊
373␉{␊
374␉␉*length = totalSize;␊
375␉}␊
376}␊
377␊
378//==============================================================================␊
379␊
380char *␊
381DT__GetName(Node *node)␊
382{␊
383␉Property *prop;␊
384␊
385␉//DPRINTF("DT__GetName(0x%x)\n", node);␊
386␉//DPRINTF("Node properties = 0x%x\n", node->properties);␊
387␉for (prop = node->properties; prop; prop = prop->next)␊
388␉{␊
389␉␉//DPRINTF("Prop '%s'\n", prop->name);␊
390␉␉if (strcmp(prop->name, "name") == 0)␊
391␉␉{␊
392␉␉␉return prop->value;␊
393␉␉}␊
394␉}␊
395␊
396␉//DPRINTF("DT__GetName returns 0\n");␊
397␉return "(null)";␊
398}␊
399␊
400//==============================================================================␊
401// Bungo␊
402Property *␊
403DT__GetProperty(Node *node, const char *name)␊
404{␊
405␉Property *prop;␊
406␊
407␉for (prop = node->properties; prop; prop = prop->next)␊
408␉{␊
409␉␉if (strcmp(prop->name, name) == 0)␊
410␉␉{␊
411␉␉␉return prop;␊
412␉␉}␊
413␉}␊
414␊
415␉return NULL;␊
416}␊
417␊
418//==============================================================================␊
419␊
420Node *␊
421DT__FindNode(const char *path, bool createIfMissing)␊
422{␊
423␉Node *node, *child;␊
424␉DTPropertyNameBuf nameBuf;␊
425␉char *bp;␊
426␉int i;␊
427␊
428␉DPRINTF("DT__FindNode('%s', %d)\n", path, createIfMissing);␊
429 ␊
430␉// Start at root␊
431␉node = rootNode;␊
432␊
433␉DPRINTF("DT__FindNode: root = 0x%x\n", rootNode);␊
434␊
435␉while (node)␊
436␉{␊
437␉␉// Skip leading slash(es)␊
438␉␉while (*path == '/')␊
439␉␉{␊
440␉␉␉path++;␊
441␉␉}␊
442␊
443␉␉for (i = 0, bp = nameBuf; ++i < kDTMaxEntryNameLength && *path && *path != '/'; bp++, path++)␊
444␉␉{␊
445␉␉␉*bp = *path;␊
446␉␉}␊
447␊
448␉␉*bp = '\0';␊
449␊
450␉␉if (nameBuf[0] == '\0')␊
451␉␉{␊
452␉␉␉// last path entry␊
453␉␉␉break;␊
454␉␉}␊
455␊
456␉␉DPRINTF("DT__FindNode: Node '%s'\n", nameBuf);␊
457␊
458␉␉for (child = node->children; child != 0; child = child->next)␊
459␉␉{␊
460␉␉␉DPRINTF("DT__FindNode: Child 0x%x\n", child);␊
461␊
462␉␉␉if (strcmp(DT__GetName(child), nameBuf) == 0)␊
463␉␉␉{␊
464␉␉␉␉break;␊
465␉␉␉}␊
466␉␉}␊
467␊
468␉␉if (child == 0 && createIfMissing)␊
469␉␉{␊
470␉␉␉char *str = malloc(strlen(nameBuf) + 1);␊
471␉␉␉// XXX this will leak␊
472␉␉␉strcpy(str, nameBuf);␊
473␊
474␉␉␉child = DT__AddChild(node, str);␊
475␉␉␉DPRINTF("DT__FindNode: Creating node: %s\n", str);␊
476␉␉}␊
477␊
478␉␉node = child;␊
479␉}␊
480␊
481␉return node;␊
482}␊
483␊
484#if DEBUG␊
485␊
486//==============================================================================␊
487␊
488void␊
489DT__PrintNode(Node *node, int level)␊
490{␊
491␉char spaces[10], *cp = spaces;␊
492␉Property *prop;␊
493␊
494␉if (level > 9)␊
495␉{␊
496␉␉level = 9;␊
497␉}␊
498␊
499␉while (level--)␊
500␉{␊
501␉␉*cp++ = ' ';␊
502␉}␊
503␊
504␉*cp = '\0';␊
505␊
506␉printf("%s===Node===\n", spaces);␊
507␊
508␉for (prop = node->properties; prop; prop = prop->next)␊
509␉{␊
510␉␉char c = *((char *)prop->value);␊
511␉␉if (prop->length < 64 && (strcmp(prop->name, "name") == 0 || (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'))␊
512␉␉{␊
513␉␉␉printf("%s Property '%s' [%d] = '%s'\n", spaces, prop->name, prop->length, prop->value);␊
514␉␉}␊
515␉␉else␊
516␉␉{␊
517␉␉␉printf("%s Property '%s' [%d] = (data)\n", spaces, prop->name, prop->length);␊
518␉␉}␊
519␉}␊
520␊
521␉printf("%s==========\n", spaces);␊
522}␊
523␊
524//==============================================================================␊
525␊
526static void␊
527_PrintTree(Node *node, int level)␊
528{␊
529␉DT__PrintNode(node, level);␊
530␊
531␉level++;␊
532␊
533␉for (node = node->children; node; node = node->next)␊
534␉{␊
535␉␉_PrintTree(node, level);␊
536␉}␊
537}␊
538␊
539//==============================================================================␊
540␊
541void␊
542DT__PrintTree(Node *node)␊
543{␊
544␉if (node == 0) node = rootNode;␊
545␉_PrintTree(node, 0);␊
546}␊
547␊
548//==============================================================================␊
549␊
550void␊
551DT__PrintFlattenedNode(DTEntry entry, int level)␊
552{␊
553␉char spaces[10], *cp = spaces;␊
554␉DTPropertyIterator␉ propIter;␊
555␉char *name;␊
556␉void *prop;␊
557␉int propSize;␊
558␊
559␉if (level > 9) level = 9;␊
560␉while (level--) *cp++ = ' ';␊
561␉␉*cp = '\0';␊
562␊
563␉printf("%s===Entry %p===\n", spaces, entry);␊
564␉␉if (kSuccess != DTCreatePropertyIterator(entry, &propIter))␊
565␉␉{␊
566␉␉␉printf("Couldn't create property iterator\n");␊
567␉␉␉return;␊
568␉␉}␊
569␉␉while( kSuccess == DTIterateProperties( propIter, &name))␊
570␉␉{␊
571␉␉␉if( kSuccess != DTGetProperty( entry, name, &prop, &propSize ))␊
572␉␉␉␉continue;␊
573␉␉printf("%s Property %s = %s\n", spaces, name, prop);␊
574␉}␊
575␉DTDisposePropertyIterator(propIter);␊
576␊
577␉printf("%s==========\n", spaces);␊
578}␊
579␊
580//==============================================================================␊
581␊
582static void␊
583_PrintFlattenedTree(DTEntry entry, int level)␊
584{␊
585␉DTEntryIterator entryIter;␊
586␊
587␉PrintFlattenedNode(entry, level);␊
588␊
589␉if (kSuccess != DTCreateEntryIterator(entry, &entryIter))␊
590␉{␊
591␉␉printf("Couldn't create entry iterator\n");␊
592␉␉return;␊
593␉}␊
594␉level++;␊
595␉while (kSuccess == DTIterateEntries( entryIter, &entry ))␊
596␉{␊
597␉␉_PrintFlattenedTree(entry, level);␊
598␉}␊
599␉DTDisposeEntryIterator(entryIter);␊
600}␊
601␊
602//==============================================================================␊
603␊
604void␊
605DT__PrintFlattenedTree(DTEntry entry)␊
606{␊
607␉_PrintFlattenedTree(entry, 0);␊
608}␊
609␊
610//==============================================================================␊
611␊
612int␊
613main(int argc, char **argv)␊
614{␊
615␉DTEntry␉␉␉dtEntry;␊
616␉DTPropertyIterator␉propIter;␊
617␉DTEntryIterator␉␉entryIter;␊
618␉void␉␉␉*prop;␊
619␉int␉␉␉propSize;␊
620␉char␉␉␉*name;␊
621␉void␉␉␉*flatTree;␊
622␉uint32_t␉␉flatSize;␊
623␊
624␉Node *node;␊
625␊
626␉node = AddChild(NULL, "device-tree");␊
627␉AddProperty(node, "potato", 4, "foo");␊
628␉AddProperty(node, "chemistry", 4, "bar");␊
629␉AddProperty(node, "physics", 4, "baz");␊
630␊
631␉node = AddChild(node, "dev");␊
632␉AddProperty(node, "one", 4, "one");␊
633␉AddProperty(node, "two", 4, "two");␊
634␉AddProperty(node, "three", 6, "three");␊
635␊
636␉node = AddChild(rootNode, "foo");␊
637␉AddProperty(node, "aaa", 4, "aab");␊
638␉AddProperty(node, "bbb", 4, "bbc");␊
639␉AddProperty(node, "cccc", 6, "ccccd");␊
640␊
641␉node = FindNode("/this/is/a/test", 1);␊
642␉AddProperty(node, "dddd", 12, "abcdefghijk");␊
643␊
644␉printf("In-memory tree:\n\n");␊
645␊
646␉PrintTree(rootNode);␊
647␊
648␉FlattenDeviceTree(&flatTree, &flatSize);␊
649␊
650␉printf("Flat tree = %p, size %d\n", flatTree, flatSize);␊
651␊
652␉dtEntry = (DTEntry)flatTree;␊
653␊
654␉printf("\n\nPrinting flat tree\n\n");␊
655␊
656␉DTInit(dtEntry);␊
657␊
658␉PrintFlattenedTree((DTEntry)flatTree);␊
659#if 0␊
660␉printf("=== Entry %p ===\n", dtEntry);␊
661␉if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter))␊
662␉{␊
663␉␉printf("Couldn't create property iterator\n");␊
664␉␉return 1;␊
665␉}␊
666␉while( kSuccess == DTIterateProperties( propIter, &name))␊
667␉{␊
668␉␉if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize ))␊
669␉␉␉continue;␊
670␉␉printf(" Property %s = %s\n", name, prop);␊
671 }␊
672␉DTDisposePropertyIterator(propIter);␊
673␉printf("========\n");␊
674␊
675␉if (kSuccess != DTCreateEntryIterator(dtEntry, &entryIter))␊
676␉{␊
677␉␉printf("Couldn't create entry iterator\n");␊
678␉␉return 1;␊
679␉}␊
680␉while (kSuccess == DTIterateEntries( entryIter, &dtEntry ))␊
681␉{␊
682␉␉printf("=== Entry %p ===\n", dtEntry);␊
683␊
684␉if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter))␊
685␉{␊
686␉␉printf("Couldn't create property iterator\n");␊
687␉␉return 1;␊
688␉}␊
689␉␉while( kSuccess == DTIterateProperties( propIter, &name))␊
690␉␉{␊
691␉␉␉if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize ))␊
692␉␉␉␉continue;␊
693␉␉␉printf(" Property %s = %s\n", name, prop);␊
694␉␉}␊
695␉␉DTDisposePropertyIterator(propIter);␊
696␉␉printf("========\n");␊
697␉}␊
698␉DTDisposeEntryIterator(entryIter);␊
699#endif␊
700␊
701␉return 0;␊
702}␊
703␊
704#endif␊
705␊
706

Archive Download this file

Revision: 2538