![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IODeviceTreeSupport.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Kernel|
Return to IODeviceTreeSupport.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Kernel |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
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.
11: *
12: * This 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: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1998 Apple Computer, Inc. All rights reserved.
24: *
25: * HISTORY
26: * 23 Nov 98 sdouglas, created from IODeviceTreeBus.m, & MacOS exp mgr.
27: * 05 Apr 99 sdouglas, add interrupt mapping.
28: *
29: */
30:
31: #include <IOKit/IODeviceTreeSupport.h>
32: #include <libkern/c++/OSContainers.h>
33: #include <IOKit/IODeviceMemory.h>
34: #include <IOKit/IOService.h>
35:
36: #include <IOKit/IOLib.h>
37: #include <IOKit/IOKitKeys.h>
38:
39: #include <DeviceTree.h>
40: extern "C" {
41: #include <machine/machine_routines.h>
42: void DTInit( void * data );
43:
44: int IODTGetLoaderInfo( char *key, void **infoAddr, int *infosize );
45: void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize );
46: }
47:
48: #include <IOKit/assert.h>
49:
50:
51: const IORegistryPlane * gIODTPlane;
52:
53: static OSArray * gIODTPHandles;
54: static OSArray * gIODTPHandleMap;
55:
56: const OSSymbol * gIODTNameKey;
57: const OSSymbol * gIODTUnitKey;
58: const OSSymbol * gIODTCompatibleKey;
59: const OSSymbol * gIODTTypeKey;
60: const OSSymbol * gIODTModelKey;
61:
62: const OSSymbol * gIODTSizeCellKey;
63: const OSSymbol * gIODTAddressCellKey;
64: const OSSymbol * gIODTRangeKey;
65:
66: const OSSymbol * gIODTPersistKey;
67:
68: const OSSymbol * gIODTDefaultInterruptController;
69: const OSSymbol * gIODTAAPLInterruptsKey;
70: const OSSymbol * gIODTPHandleKey;
71: const OSSymbol * gIODTInterruptCellKey;
72: const OSSymbol * gIODTInterruptParentKey;
73: const OSSymbol * gIODTNWInterruptMappingKey;
74:
75:
76: static IORegistryEntry * MakeReferenceTable( DTEntry dtEntry, bool copy );
77: static void AddPHandle( IORegistryEntry * regEntry );
78: static void FreePhysicalMemory( vm_offset_t * range );
79:
80: IORegistryEntry *
81: IODeviceTreeAlloc( void * dtTop )
82: {
83: IORegistryEntry * parent;
84: IORegistryEntry * child;
85: IORegistryIterator * regIter;
86: DTEntryIterator iter;
87: DTEntry dtChild;
88: DTEntry mapEntry;
89: OSArray * stack;
90: OSData * prop;
91: OSObject * obj;
92: vm_offset_t * dtMap;
93: int propSize;
94: bool intMap;
95: bool freeDT;
96:
97: IOLog("IODeviceTreeSupport ");
98:
99: gIODTPlane = IORegistryEntry::makePlane( kIODeviceTreePlane );
100:
101: gIODTNameKey = OSSymbol::withCStringNoCopy( "name" );
102: gIODTUnitKey = OSSymbol::withCStringNoCopy( "AAPL,unit-string" );
103: gIODTCompatibleKey = OSSymbol::withCStringNoCopy( "compatible" );
104: gIODTTypeKey = OSSymbol::withCStringNoCopy( "device_type" );
105: gIODTModelKey = OSSymbol::withCStringNoCopy( "model" );
106: gIODTSizeCellKey = OSSymbol::withCStringNoCopy( "#size-cells" );
107: gIODTAddressCellKey = OSSymbol::withCStringNoCopy( "#address-cells" );
108: gIODTRangeKey = OSSymbol::withCStringNoCopy( "ranges" );
109:
110: gIODTPersistKey = OSSymbol::withCStringNoCopy( "IODTPersist" );
111:
112: assert( gIODTPlane && gIODTCompatibleKey
113: && gIODTTypeKey && gIODTModelKey
114: && gIODTSizeCellKey && gIODTAddressCellKey && gIODTRangeKey
115: && gIODTPersistKey );
116:
117: gIODTDefaultInterruptController
118: = OSSymbol::withCStringNoCopy("IOPrimaryInterruptController");
119: gIODTNWInterruptMappingKey
120: = OSSymbol::withCStringNoCopy("IONWInterrupts");
121:
122: gIODTAAPLInterruptsKey
123: = OSSymbol::withCStringNoCopy("AAPL,interrupts");
124: gIODTPHandleKey
125: = OSSymbol::withCStringNoCopy("AAPL,phandle");
126:
127: gIODTInterruptParentKey
128: = OSSymbol::withCStringNoCopy("interrupt-parent");
129:
130: gIODTPHandles = OSArray::withCapacity( 1 );
131: gIODTPHandleMap = OSArray::withCapacity( 1 );
132:
133: gIODTInterruptCellKey
134: = OSSymbol::withCStringNoCopy("#interrupt-cells");
135:
136: assert( gIODTDefaultInterruptController && gIODTNWInterruptMappingKey
137: && gIODTAAPLInterruptsKey
138: && gIODTPHandleKey && gIODTInterruptParentKey
139: && gIODTPHandles && gIODTPHandleMap
140: && gIODTInterruptCellKey
141: );
142:
143: freeDT = (kSuccess == DTLookupEntry( 0, "/chosen/memory-map", &mapEntry ))
144: && (kSuccess == DTGetProperty( mapEntry,
145: "DeviceTree", (void **) &dtMap, &propSize ))
146: && ((2 * sizeof( vm_offset_t)) == propSize);
147:
148: parent = MakeReferenceTable( (DTEntry)dtTop, freeDT );
149:
150: stack = OSArray::withObjects( (OSObject **)&parent, 1, 10 );
151: DTCreateEntryIterator( (DTEntry)dtTop, &iter );
152:
153: do {
154: parent = (IORegistryEntry *)stack->getObject( stack->getCount() - 1);
155: //parent->release();
156: stack->removeObject( stack->getCount() - 1);
157:
158: while( kSuccess == DTIterateEntries( iter, &dtChild) ) {
159:
160: child = MakeReferenceTable( dtChild, freeDT );
161: child->attachToParent( parent, gIODTPlane);
162:
163: AddPHandle( child );
164:
165: if( kSuccess == DTEnterEntry( iter, dtChild)) {
166: stack->setObject( parent);
167: parent = child;
168: }
169: // only registry holds retain
170: child->release();
171: }
172:
173: } while( stack->getCount()
174: && (kSuccess == DTExitEntry( iter, &dtChild)));
175:
176: stack->release();
177: DTDisposeEntryIterator( iter);
178:
179: // parent is now root of the created tree
180:
181: // make root name first compatible entry (purely cosmetic)
182: if( (prop = (OSData *) parent->getProperty( gIODTCompatibleKey))) {
183: parent->setName( parent->getName(), gIODTPlane );
184: parent->setName( (const char *) prop->getBytesNoCopy() );
185: }
186:
187: // attach tree to meta root
188: parent->attachToParent( IORegistryEntry::getRegistryRoot(), gIODTPlane);
189: parent->release();
190:
191: if( freeDT ) {
192: // free original device tree
193: DTInit(0);
194: IODTFreeLoaderInfo( "DeviceTree",
195: (void *)dtMap[0], round_page(dtMap[1]) );
196: }
197:
198: // adjust tree
199: intMap = false;
200: regIter = IORegistryIterator::iterateOver( gIODTPlane,
201: kIORegistryIterateRecursively );
202: assert( regIter );
203: if( regIter) {
204: while( (child = regIter->getNextObject())) {
205: IODTMapInterrupts( child );
206: if( !intMap && child->getProperty( gIODTInterruptParentKey))
207: intMap = true;
208:
209: // some gross pruning
210: child->removeProperty( "lanLib,AAPL,MacOS,PowerPC");
211:
212: if( (obj = child->getProperty( "driver,AAPL,MacOS,PowerPC"))) {
213:
214: if( (0 == (prop = (OSData *)child->getProperty( gIODTTypeKey )))
215: || (strcmp( "display", (char *) prop->getBytesNoCopy())) ) {
216:
217: child->removeProperty( "driver,AAPL,MacOS,PowerPC");
218: }
219: }
220: }
221: regIter->release();
222: }
223:
224: if( intMap)
225: // set a key in the root to indicate we found NW interrupt mapping
226: parent->setProperty( gIODTNWInterruptMappingKey,
227: (OSObject *) gIODTNWInterruptMappingKey );
228:
229: IOLog("done\n");
230:
231: return( parent);
232: }
233:
234: int IODTGetLoaderInfo( char *key, void **infoAddr, int *infoSize )
235: {
236: IORegistryEntry *chosen;
237: OSData *propObj;
238: unsigned int *propPtr;
239: unsigned int propSize;
240:
241: chosen = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane );
242: if ( chosen == 0 ) return -1;
243:
244: propObj = OSDynamicCast( OSData, chosen->getProperty(key) );
245: if ( propObj == 0 ) return -1;
246:
247: propSize = propObj->getLength();
248: if ( propSize != (2 * sizeof(UInt32)) ) return -1;
249:
250: propPtr = (unsigned int *)propObj->getBytesNoCopy();
251: if ( propPtr == 0 ) return -1;
252:
253: *infoAddr = (void *)propPtr[0] ;
254: *infoSize = (int) propPtr[1];
255:
256: return 0;
257: }
258:
259: void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize )
260: {
261: vm_offset_t range[2];
262: IORegistryEntry *chosen;
263:
264: range[0] = (vm_offset_t)infoAddr;
265: range[1] = (vm_offset_t)infoSize;
266: FreePhysicalMemory( range );
267:
268: if ( key != 0 ) {
269: chosen = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane );
270: if ( chosen != 0 ) {
271: chosen->removeProperty(key);
272: }
273: }
274: }
275:
276: static void FreePhysicalMemory( vm_offset_t * range )
277: {
278: vm_offset_t virt;
279:
280: virt = ml_static_ptovirt( range[0] );
281: if( virt) {
282: ml_static_mfree( virt, range[1] );
283: }
284: }
285:
286: static IORegistryEntry *
287: MakeReferenceTable( DTEntry dtEntry, bool copy )
288: {
289: IORegistryEntry * regEntry;
290: OSDictionary * propTable;
291: const OSSymbol * nameKey;
292: OSData * data;
293: const OSSymbol * sym;
294: DTPropertyIterator dtIter;
295: void * prop;
296: int propSize;
297: char * name;
298: char location[ 32 ];
299: bool noLocation = true;
300:
301: regEntry = new IOService;
302:
303: if( regEntry && (false == regEntry->init())) {
304: regEntry->release();
305: regEntry = 0;
306: }
307:
308: if( regEntry &&
309: (kSuccess == DTCreatePropertyIterator( dtEntry, &dtIter))) {
310:
311: propTable = regEntry->getPropertyTable();
312:
313: while( kSuccess == DTIterateProperties( dtIter, &name)) {
314:
315: if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize ))
316: continue;
317:
318: if( copy) {
319: nameKey = OSSymbol::withCString(name);
320: data = OSData::withBytes(prop, propSize);
321: } else {
322: nameKey = OSSymbol::withCStringNoCopy(name);
323: data = OSData::withBytesNoCopy(prop, propSize);
324: }
325: assert( nameKey && data );
326:
327: propTable->setObject( nameKey, data);
328: data->release();
329: nameKey->release();
330:
331: if( nameKey == gIODTNameKey ) {
332: if( copy)
333: sym = OSSymbol::withCString( (const char *) prop);
334: else
335: sym = OSSymbol::withCStringNoCopy( (const char *) prop);
336: regEntry->setName( sym );
337: sym->release();
338:
339: } else if( nameKey == gIODTUnitKey ) {
340: // all OF strings are null terminated... except this one
341: if( propSize >= (int) sizeof( location))
342: propSize = sizeof( location) - 1;
343: strncpy( location, (const char *) prop, propSize );
344: location[ propSize ] = 0;
345: regEntry->setLocation( location );
346: propTable->removeObject( gIODTUnitKey );
347: noLocation = false;
348:
349: } else if( noLocation && (0 == strcmp( name, "reg"))) {
350: // default location - override later
351: sprintf( location, "%lX", *((UInt32 *) prop) );
352: regEntry->setLocation( location );
353: }
354: }
355: DTDisposePropertyIterator( dtIter);
356: }
357:
358: return( regEntry);
359: }
360:
361: static void AddPHandle( IORegistryEntry * regEntry )
362: {
363: OSData * data;
364:
365: if( regEntry->getProperty( gIODTInterruptCellKey)
366: && (data = OSDynamicCast( OSData, regEntry->getProperty( gIODTPHandleKey )))) {
367: // a possible interrupt-parent
368: gIODTPHandles->setObject( data );
369: gIODTPHandleMap->setObject( regEntry );
370: }
371: }
372:
373: static IORegistryEntry * FindPHandle( UInt32 phandle )
374: {
375: OSData * data;
376: IORegistryEntry * regEntry = 0;
377: int i;
378:
379: for( i = 0;
380: (data = (OSData *)gIODTPHandles->getObject( i ));
381: i++ ) {
382: if( phandle == *((UInt32 *)data->getBytesNoCopy())) {
383: regEntry = (IORegistryEntry *)
384: gIODTPHandleMap->getObject( i );
385: break;
386: }
387: }
388:
389: return( regEntry );
390: }
391:
392: static bool GetUInt32( IORegistryEntry * regEntry, const OSSymbol * name,
393: UInt32 * value )
394: {
395: OSData * data;
396:
397: if( (data = OSDynamicCast( OSData, regEntry->getProperty( name )))
398: && (4 == data->getLength())) {
399: *value = *((UInt32 *) data->getBytesNoCopy());
400: return( true );
401: } else
402: return( false );
403: }
404:
405: IORegistryEntry * IODTFindInterruptParent( IORegistryEntry * regEntry )
406: {
407: IORegistryEntry * parent;
408: UInt32 phandle;
409:
410: if( GetUInt32( regEntry, gIODTInterruptParentKey, &phandle))
411: parent = FindPHandle( phandle );
412:
413: else if( 0 == regEntry->getProperty( "interrupt-controller"))
414: parent = regEntry->getParentEntry( gIODTPlane);
415: else
416: parent = 0;
417:
418: return( parent );
419: }
420:
421: const OSSymbol * IODTInterruptControllerName( IORegistryEntry * regEntry )
422: {
423: const OSSymbol * sym;
424: UInt32 phandle;
425: bool ok;
426: char buf[48];
427:
428: ok = GetUInt32( regEntry, gIODTPHandleKey, &phandle);
429: assert( ok );
430:
431: if( ok) {
432: sprintf( buf, "IOInterruptController%08lX", phandle);
433: sym = OSSymbol::withCString( buf );
434: } else
435: sym = 0;
436:
437: return( sym );
438: }
439:
440: #define unexpected(a) { kprintf("unexpected %s:%d\n", __FILE__, __LINE__); a; }
441:
442: static void IODTGetICellCounts( IORegistryEntry * regEntry,
443: UInt32 * iCellCount, UInt32 * aCellCount)
444: {
445: if( !GetUInt32( regEntry, gIODTInterruptCellKey, iCellCount))
446: unexpected( *iCellCount = 1 );
447: if( !GetUInt32( regEntry, gIODTAddressCellKey, aCellCount))
448: *aCellCount = 0;
449: }
450:
451: UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec,
452: OSData ** spec, const OSSymbol ** controller )
453: {
454: IORegistryEntry * parent = 0;
455: OSData * data;
456: UInt32 * addrCmp;
457: UInt32 * maskCmp;
458: UInt32 * map;
459: UInt32 * endMap;
460: UInt32 acells, icells, pacells, picells, cell;
461: UInt32 i, skip = 0;
462: bool cmp, ok = false;
463:
464: do {
465: if( parent && (data = OSDynamicCast( OSData,
466: regEntry->getProperty( "interrupt-controller")))) {
467: // found a controller - don't want to follow cascaded controllers
468: parent = 0;
469: *spec = OSData::withBytesNoCopy( (void *) intSpec,
470: icells * sizeof( UInt32));
471: *controller = IODTInterruptControllerName( regEntry );
472: ok = (*spec && *controller);
473:
474: } else if( parent && (data = OSDynamicCast( OSData,
475: regEntry->getProperty( "interrupt-map")))) {
476: // interrupt-map
477: map = (UInt32 *) data->getBytesNoCopy();
478: endMap = map + (data->getLength() / sizeof(UInt32));
479: data = OSDynamicCast( OSData, regEntry->getProperty( "interrupt-map-mask" ));
480: if( data && (data->getLength() >= ((acells + icells) * sizeof( UInt32))))
481: maskCmp = (UInt32 *) data->getBytesNoCopy();
482: else
483: maskCmp = 0;
484:
485: do {
486: for( i = 0, cmp = true;
487: cmp && (i < (acells + icells));
488: i++) {
489: cell = (i < acells) ? addrCmp[i] : intSpec[ i - acells ];
490: if( maskCmp)
491: cell &= maskCmp[i];
492: cmp = (cell == map[i]);
493: }
494:
495: map += acells + icells;
496: if( 0 == (parent = FindPHandle( *(map++) )))
497: unexpected(break);
498:
499: if( cmp)
500: intSpec = map;
501: else {
502: IODTGetICellCounts( parent, &picells, &pacells );
503: map += pacells + picells;
504: parent = 0;
505: }
506: } while( !cmp && (map < endMap) );
507:
508: } else
509: // first time (usually)
510: parent = IODTFindInterruptParent( regEntry );
511:
512: if( parent) {
513: IODTGetICellCounts( parent, &icells, &acells );
514: addrCmp = 0;
515: if( acells) {
516: data = OSDynamicCast( OSData, regEntry->getProperty( "reg" ));
517: if( data && (data->getLength() >= (acells * sizeof( UInt32))))
518: addrCmp = (UInt32 *) data->getBytesNoCopy();
519: }
520: regEntry = parent;
521: if( !skip)
522: skip = icells;
523: }
524: } while( parent);
525:
526: if( ok)
527: return( skip );
528: else
529: return( 0 );
530: }
531:
532: bool IODTMapInterrupts( IORegistryEntry * regEntry )
533: {
534: IORegistryEntry * parent;
535: OSData * local;
536: OSData * local2;
537: UInt32 * localBits;
538: UInt32 * localEnd;
539: OSData * map;
540: OSArray * mapped;
541: const OSSymbol * controller;
542: OSArray * controllers;
543: UInt32 skip = 1;
544: bool ok, nw;
545:
546: nw = (0 == (local = OSDynamicCast( OSData,
547: regEntry->getProperty( gIODTAAPLInterruptsKey))));
548: if( nw
549: && (0 == (local = OSDynamicCast( OSData,
550: regEntry->getProperty( "interrupts")))))
551: return( true ); // nothing to see here
552:
553: if( nw && (parent = regEntry->getParentEntry( gIODTPlane))) {
554: // check for bridges on old world
555: if( (local2 = OSDynamicCast( OSData,
556: parent->getProperty( gIODTAAPLInterruptsKey)))) {
557: local = local2;
558: nw = false;
559: }
560: }
561:
562: localBits = (UInt32 *) local->getBytesNoCopy();
563: localEnd = localBits + (local->getLength() / sizeof( UInt32));
564: mapped = OSArray::withCapacity( 1 );
565: controllers = OSArray::withCapacity( 1 );
566:
567: ok = (mapped && controllers);
568:
569: if( ok) do {
570: if( nw) {
571: skip = IODTMapOneInterrupt( regEntry, localBits, &map, &controller );
572: if( 0 == skip) {
573: IOLog("%s: error mapping interrupt[%d]\n",
574: regEntry->getName(), mapped->getCount());
575: break;
576: }
577: } else {
578: map = OSData::withData( local, mapped->getCount() * sizeof( UInt32),
579: sizeof( UInt32));
580: controller = gIODTDefaultInterruptController;
581: }
582:
583: localBits += skip;
584: mapped->setObject( map );
585: map->release();
586: controllers->setObject( (OSObject *) controller );
587: controller->release();
588:
589: } while( localBits < localEnd);
590:
591: ok &= (localBits == localEnd);
592:
593: if( ok ) {
594: // store results
595: ok = regEntry->setProperty( gIOInterruptControllersKey, controllers);
596: ok &= regEntry->setProperty( gIOInterruptSpecifiersKey, mapped);
597: }
598:
599: if( controllers)
600: controllers->release();
601: if( mapped)
602: mapped->release();
603:
604: return( ok );
605: }
606:
607: /*
608: */
609:
610: static const char *
611: CompareKey( OSString * key,
612: const IORegistryEntry * table, const OSSymbol * propName )
613: {
614: OSObject * prop;
615: OSData * data;
616: OSString * string;
617: const char * ckey;
618: UInt32 keyLen;
619: const char * names;
620: const char * lastName;
621: bool wild;
622: bool matched;
623: const char * result = 0;
624:
625: if( 0 == (prop = table->getProperty( propName )))
626: return( 0 );
627:
628: if( (data = OSDynamicCast( OSData, prop ))) {
629: names = (const char *) data->getBytesNoCopy();
630: lastName = names + data->getLength();
631:
632: } else if( (string = OSDynamicCast( OSString, prop ))) {
633: names = string->getCStringNoCopy();
634: lastName = names + string->getLength() + 1;
635:
636: } else
637: return( 0 );
638:
639: ckey = key->getCStringNoCopy();
640: keyLen = key->getLength();
641: wild = ('*' == key->getChar( keyLen ));
642:
643: do {
644: // for each name in the property
645: if( wild)
646: matched = (0 == strncmp( ckey, names, keyLen - 1 ));
647: else
648: matched = (keyLen == strlen( names ))
649: && (0 == strncmp( ckey, names, keyLen ));
650:
651: if( matched)
652: result = names;
653:
654: names = names + strlen( names) + 1;
655:
656: } while( (names < lastName) && (false == matched));
657:
658: return( result);
659: }
660:
661:
662: bool IODTCompareNubName( const IORegistryEntry * regEntry,
663: OSString * name, OSString ** matchingName )
664: {
665: const char * result;
666: bool matched;
667:
668: matched = (0 != (result = CompareKey( name, regEntry, gIODTNameKey)))
669: || (0 != (result = CompareKey( name, regEntry, gIODTCompatibleKey)))
670: || (0 != (result = CompareKey( name, regEntry, gIODTTypeKey)))
671: || (0 != (result = CompareKey( name, regEntry, gIODTModelKey)));
672:
673: if( result && matchingName)
674: *matchingName = OSString::withCString( result );
675:
676: return( result != 0 );
677: }
678:
679: bool IODTMatchNubWithKeys( IORegistryEntry * regEntry,
680: const char * keys )
681: {
682: OSObject * obj;
683: bool result = false;
684:
685: obj = OSUnserialize( keys, 0 );
686:
687: if( obj) {
688: result = regEntry->compareNames( obj );
689: obj->release();
690: }
691: #ifdef DEBUG
692: else IOLog("Couldn't unserialize %s\n", keys );
693: #endif
694:
695: return( result );
696: }
697:
698: OSCollectionIterator * IODTFindMatchingEntries( IORegistryEntry * from,
699: IOOptionBits options, const char * keys )
700: {
701: OSSet * result;
702: IORegistryEntry * next;
703: IORegistryIterator * iter;
704: OSCollectionIterator * cIter;
705: bool cmp;
706: bool minus = options & kIODTExclusive;
707:
708: result = OSSet::withCapacity( 3 );
709: if( !result)
710: return( 0);
711:
712: iter = IORegistryIterator::iterateOver( from, gIODTPlane,
713: (options & kIODTRecursive) ? kIORegistryIterateRecursively : 0 );
714: if( iter) {
715: while( (next = iter->getNextObject())) {
716:
717: // Look for existence of a debug property to skip
718: if( next->getProperty("AAPL,ignore"))
719: continue;
720:
721: if( keys) {
722: cmp = IODTMatchNubWithKeys( next, keys );
723: if( (minus && (false == cmp))
724: || ((false == minus) && (false != cmp)) )
725: result->setObject( next);
726: } else
727: result->setObject( next);
728: }
729: iter->release();
730: }
731:
732: cIter = OSCollectionIterator::withCollection( result);
733: result->release();
734:
735: return( cIter);
736: }
737:
738:
739: struct IODTPersistent {
740: IODTCompareAddressCellFunc compareFunc;
741: IODTNVLocationFunc locationFunc;
742: };
743:
744: void IODTSetResolving( IORegistryEntry * regEntry,
745: IODTCompareAddressCellFunc compareFunc,
746: IODTNVLocationFunc locationFunc )
747: {
748: IODTPersistent persist;
749: OSData * prop;
750:
751: persist.compareFunc = compareFunc;
752: persist.locationFunc = locationFunc;
753: prop = OSData::withBytes( &persist, sizeof( persist));
754: if( !prop)
755: return;
756:
757: regEntry->setProperty( gIODTPersistKey, prop);
758: prop->release();
759: }
760:
761: static SInt32 DefaultCompare( UInt32 cellCount, UInt32 left[], UInt32 right[] )
762: {
763: cellCount--;
764: return( left[ cellCount ] - right[ cellCount ] );
765: }
766:
767:
768: void IODTGetCellCounts( IORegistryEntry * regEntry,
769: UInt32 * sizeCount, UInt32 * addressCount)
770: {
771: if( !GetUInt32( regEntry, gIODTSizeCellKey, sizeCount))
772: *sizeCount = 1;
773: if( !GetUInt32( regEntry, gIODTAddressCellKey, addressCount))
774: *addressCount = 2;
775: }
776:
777: // Given addr & len cells from our child, find it in our ranges property, then
778: // look in our parent to resolve the base of the range for us.
779:
780: // Range[]: child-addr our-addr child-len
781: // #cells: child ours child
782:
783: bool IODTResolveAddressCell( IORegistryEntry * regEntry,
784: UInt32 cellsIn[],
785: IOPhysicalAddress * phys, IOPhysicalLength * len )
786: {
787: IORegistryEntry * parent;
788: OSData * prop;
789: // cells in addresses at regEntry
790: UInt32 sizeCells, addressCells;
791: // cells in addresses below regEntry
792: UInt32 childSizeCells, childAddressCells;
793: UInt32 childCells;
794: UInt32 cell[ 5 ], offset = 0, length;
795: UInt32 * range;
796: UInt32 * endRanges;
797: bool ok = true;
798: SInt32 diff;
799:
800: IODTPersistent * persist;
801: IODTCompareAddressCellFunc compare;
802:
803: IODTGetCellCounts( regEntry, &childSizeCells, &childAddressCells );
804: childCells = childAddressCells + childSizeCells;
805:
806: bcopy( cellsIn, cell, 4 * childCells );
807: if( childSizeCells > 1)
808: *len = IOPhysical32( cellsIn[ childAddressCells ],
809: cellsIn[ childAddressCells + 1 ] );
810: else
811: *len = IOPhysical32( 0, cellsIn[ childAddressCells ] );
812:
813: do {
814: prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey ));
815: if( 0 == prop) {
816: /* end of the road */
817: *phys = IOPhysical32( 0, cell[ childAddressCells - 1 ] + offset);
818: break;
819: }
820:
821: parent = regEntry->getParentEntry( gIODTPlane );
822: IODTGetCellCounts( parent, &sizeCells, &addressCells );
823:
824: if( (length = prop->getLength())) {
825: // search
826: range = (UInt32 *) prop->getBytesNoCopy();
827: endRanges = range + (length / 4);
828:
829: prop = (OSData *) regEntry->getProperty( gIODTPersistKey );
830: if( prop) {
831: persist = (IODTPersistent *) prop->getBytesNoCopy();
832: compare = persist->compareFunc;
833: } else
834: compare = DefaultCompare;
835:
836: for( ok = false;
837: range < endRanges;
838: range += (childCells + addressCells) ) {
839:
840: // is cell >= range start?
841: diff = (*compare)( childAddressCells, cell, range );
842: if( diff < 0)
843: continue;
844: // is cell + size <= range end?
845: if( (diff + cell[ childCells - 1 ])
846: > range[ childCells + addressCells - 1 ])
847: continue;
848:
849: offset += diff;
850: ok = true;
851: break;
852: }
853:
854: // Get the physical start of the range from our parent
855: bcopy( range + childAddressCells, cell, 4 * addressCells );
856: bzero( cell + addressCells, 4 * sizeCells );
857:
858: } /* else zero length range => pass thru to parent */
859:
860: regEntry = parent;
861: childSizeCells = sizeCells;
862: childAddressCells = addressCells;
863: childCells = childAddressCells + childSizeCells;
864:
865: } while( ok && regEntry);
866:
867: return( ok);
868: }
869:
870:
871: OSArray * IODTResolveAddressing( IORegistryEntry * regEntry,
872: const char * addressPropertyName,
873: IODeviceMemory * parent )
874: {
875: IORegistryEntry * parentEntry;
876: OSData * addressProperty;
877: UInt32 sizeCells, addressCells, cells;
878: int i, num;
879: UInt32 * reg;
880: IOPhysicalAddress phys;
881: IOPhysicalLength len;
882: OSArray * array;
883: IODeviceMemory * range;
884:
885: parentEntry = regEntry->getParentEntry( gIODTPlane );
886: addressProperty = (OSData *) regEntry->getProperty( addressPropertyName );
887: if( (0 == addressProperty) || (0 == parentEntry))
888: return( 0);
889:
890: IODTGetCellCounts( parentEntry, &sizeCells, &addressCells );
891: if( 0 == sizeCells)
892: return( 0);
893:
894: cells = sizeCells + addressCells;
895: reg = (UInt32 *) addressProperty->getBytesNoCopy();
896: num = addressProperty->getLength() / (4 * cells);
897:
898: array = OSArray::withCapacity( 1 );
899: if( 0 == array)
900: return( 0);
901:
902: for( i = 0; i < num; i++) {
903:
904: if( IODTResolveAddressCell( parentEntry, reg, &phys, &len )) {
905:
906: range = 0;
907: if( parent)
908: range = IODeviceMemory::withSubRange( parent,
909: phys - parent->getPhysicalAddress(), len );
910: if( 0 == range)
911: range = IODeviceMemory::withRange( phys, len );
912: if( range)
913: array->setObject( range );
914: }
915: reg += cells;
916: }
917:
918: regEntry->setProperty( gIODeviceMemoryKey, array);
919: array->release(); /* ??? */
920:
921: return( array);
922: }
923:
924: static void IODTGetNVLocation(
925: IORegistryEntry * parent,
926: IORegistryEntry * regEntry,
927: UInt8 * busNum, UInt8 * deviceNum, UInt8 * functionNum )
928: {
929:
930: OSData * prop;
931: IODTPersistent * persist;
932: UInt32 * cell;
933:
934: prop = (OSData *) parent->getProperty( gIODTPersistKey );
935: if( prop) {
936: persist = (IODTPersistent *) prop->getBytesNoCopy();
937: (*persist->locationFunc)( regEntry, busNum, deviceNum, functionNum );
938:
939: } else {
940: prop = (OSData *) regEntry->getProperty( "reg" );
941: *functionNum = 0;
942: if( prop) {
943: cell = (UInt32 *) prop->getBytesNoCopy();
944: #if 0
945: if( (regHi & 0xf0000000) != 0xf0000000) {
946: *bus = 0x03 & (regHi >> 16);
947: *function = 0x07 & (regHi >> 8);
948: *device = 0x1f & (regHi >> 11);
949: #endif
950: *busNum = 3;
951: *deviceNum = 0x1f & (cell[ 0 ] >> 24);
952: } else {
953: *busNum = 0;
954: *deviceNum = 0;
955: }
956: }
957: }
958:
959: /*
960: * Try to make the same messed up descriptor as Mac OS
961: */
962:
963: IOReturn IODTMakeNVDescriptor( IORegistryEntry * regEntry,
964: IONVRAMDescriptor * hdr )
965: {
966: IORegistryEntry * parent;
967: UInt32 level;
968: UInt32 bridgeDevices;
969: UInt8 busNum;
970: UInt8 deviceNum;
971: UInt8 functionNum;
972:
973: hdr->format = 1;
974: hdr->marker = 0;
975:
976: for(
977: level = 0, bridgeDevices = 0;
978: (parent = regEntry->getParentEntry( gIODTPlane ))
979: && (level < 7);
980: level++ ) {
981:
982: IODTGetNVLocation( parent, regEntry,
983: &busNum, &deviceNum, &functionNum );
984: if( level)
985: bridgeDevices |= ((deviceNum & 0x1f) << ((level - 1) * 5));
986: else {
987: hdr->busNum = busNum;
988: hdr->deviceNum = deviceNum;
989: hdr->functionNum = functionNum;
990: }
991: regEntry = parent;
992: }
993: hdr->bridgeCount = level - 2;
994: hdr->bridgeDevices = bridgeDevices;
995:
996: return( kIOReturnSuccess );
997: }
998:
999: OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber )
1000: {
1001: IORegistryEntry * parent;
1002: OSData * data;
1003: OSData * ret = 0;
1004: UInt32 * bits;
1005: UInt32 i;
1006: char * names;
1007: char * lastName;
1008: UInt32 mask;
1009:
1010: data = (OSData *) regEntry->getProperty("AAPL,slot-name");
1011: if( data)
1012: return( data);
1013: parent = regEntry->getParentEntry( gIODTPlane );
1014: if( !parent)
1015: return( 0 );
1016: data = OSDynamicCast( OSData, parent->getProperty("slot-names"));
1017: if( !data)
1018: return( 0 );
1019: if( data->getLength() <= 4)
1020: return( 0 );
1021:
1022: bits = (UInt32 *) data->getBytesNoCopy();
1023: mask = *bits;
1024: if( (0 == (mask & (1 << deviceNumber))))
1025: return( 0 );
1026:
1027: names = (char *)(bits + 1);
1028: lastName = names + (data->getLength() - 4);
1029:
1030: for( i = 0;
1031: (i <= deviceNumber) && (names < lastName);
1032: i++ ) {
1033:
1034: if( mask & (1 << i)) {
1035: if( i == deviceNumber) {
1036: data = OSData::withBytesNoCopy( names, 1 + strlen( names));
1037: if( data) {
1038: regEntry->setProperty("AAPL,slot-name", data);
1039: ret = data;
1040: data->release();
1041: }
1042: } else
1043: names += 1 + strlen( names);
1044: }
1045: }
1046:
1047: return( ret );
1048: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.