X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/378393581903b274cb7a4d18e0d978071a6b592d..b226f5e54a60dc81db17b1260381d7dbfea3cdf1:/iokit/Kernel/IODeviceTreeSupport.cpp diff --git a/iokit/Kernel/IODeviceTreeSupport.cpp b/iokit/Kernel/IODeviceTreeSupport.cpp index a238b773c..1a3b426d8 100644 --- a/iokit/Kernel/IODeviceTreeSupport.cpp +++ b/iokit/Kernel/IODeviceTreeSupport.cpp @@ -1,23 +1,29 @@ /* - * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * 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. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * 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 OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * 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@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ #include @@ -31,12 +37,20 @@ #include +#if __arm64__ +typedef UInt64 dtptr_t; +#else +typedef UInt32 dtptr_t; +#endif + +#include + extern "C" { - #include - void DTInit( void * data ); - int IODTGetLoaderInfo( char *key, void **infoAddr, int *infosize ); - void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize ); +int IODTGetLoaderInfo( const char *key, void **infoAddr, int *infosize ); +void IODTFreeLoaderInfo( const char *key, void *infoAddr, int infoSize ); +int IODTGetDefault(const char *key, void *infoAddr, unsigned int infoSize ); + } #include @@ -45,14 +59,16 @@ extern "C" { const IORegistryPlane * gIODTPlane; -static OSArray * gIODTPHandles; -static OSArray * gIODTPHandleMap; +static OSArray * gIODTPHandles; +static OSArray * gIODTPHandleMap; +static OSData * gIODTResolvers; const OSSymbol * gIODTNameKey; const OSSymbol * gIODTUnitKey; const OSSymbol * gIODTCompatibleKey; const OSSymbol * gIODTTypeKey; const OSSymbol * gIODTModelKey; +const OSSymbol * gIODTTargetTypeKey; const OSSymbol * gIODTSizeCellKey; const OSSymbol * gIODTAddressCellKey; @@ -69,6 +85,8 @@ const OSSymbol * gIODTNWInterruptMappingKey; OSDictionary * gIODTSharedInterrupts; +static IOLock * gIODTResolversLock; + static IORegistryEntry * MakeReferenceTable( DTEntry dtEntry, bool copy ); static void AddPHandle( IORegistryEntry * regEntry ); static void FreePhysicalMemory( vm_offset_t * range ); @@ -80,15 +98,14 @@ IODeviceTreeAlloc( void * dtTop ) IORegistryEntry * parent; IORegistryEntry * child; IORegistryIterator * regIter; - DTEntryIterator iter; + OpaqueDTEntryIterator iter; DTEntry dtChild; DTEntry mapEntry; OSArray * stack; OSData * prop; - OSObject * obj; OSDictionary * allInts; vm_offset_t * dtMap; - int propSize; + unsigned int propSize; bool intMap; bool freeDT; @@ -99,6 +116,7 @@ IODeviceTreeAlloc( void * dtTop ) gIODTCompatibleKey = OSSymbol::withCStringNoCopy( "compatible" ); gIODTTypeKey = OSSymbol::withCStringNoCopy( "device_type" ); gIODTModelKey = OSSymbol::withCStringNoCopy( "model" ); + gIODTTargetTypeKey = OSSymbol::withCStringNoCopy( "target-type" ); gIODTSizeCellKey = OSSymbol::withCStringNoCopy( "#size-cells" ); gIODTAddressCellKey = OSSymbol::withCStringNoCopy( "#address-cells" ); gIODTRangeKey = OSSymbol::withCStringNoCopy( "ranges" ); @@ -124,6 +142,9 @@ IODeviceTreeAlloc( void * dtTop ) gIODTPHandles = OSArray::withCapacity( 1 ); gIODTPHandleMap = OSArray::withCapacity( 1 ); + gIODTResolvers = OSData::withCapacity(16); + + gIODTResolversLock = IOLockAlloc(); gIODTInterruptCellKey = OSSymbol::withCStringNoCopy("#interrupt-cells"); @@ -131,33 +152,33 @@ IODeviceTreeAlloc( void * dtTop ) assert( gIODTDefaultInterruptController && gIODTNWInterruptMappingKey && gIODTAAPLInterruptsKey && gIODTPHandleKey && gIODTInterruptParentKey - && gIODTPHandles && gIODTPHandleMap + && gIODTPHandles && gIODTPHandleMap && gIODTResolvers && gIODTResolversLock && gIODTInterruptCellKey ); freeDT = (kSuccess == DTLookupEntry( 0, "/chosen/memory-map", &mapEntry )) && (kSuccess == DTGetProperty( mapEntry, "DeviceTree", (void **) &dtMap, &propSize )) - && ((2 * sizeof( vm_offset_t)) == propSize); + && ((2 * sizeof(uint32_t)) == propSize); parent = MakeReferenceTable( (DTEntry)dtTop, freeDT ); stack = OSArray::withObjects( (const OSObject **) &parent, 1, 10 ); - DTCreateEntryIterator( (DTEntry)dtTop, &iter ); + DTInitEntryIterator( (DTEntry)dtTop, &iter ); do { parent = (IORegistryEntry *)stack->getObject( stack->getCount() - 1); //parent->release(); stack->removeObject( stack->getCount() - 1); - while( kSuccess == DTIterateEntries( iter, &dtChild) ) { + while( kSuccess == DTIterateEntries( &iter, &dtChild) ) { child = MakeReferenceTable( dtChild, freeDT ); child->attachToParent( parent, gIODTPlane); AddPHandle( child ); - if( kSuccess == DTEnterEntry( iter, dtChild)) { + if( kSuccess == DTEnterEntry( &iter, dtChild)) { stack->setObject( parent); parent = child; } @@ -166,10 +187,10 @@ IODeviceTreeAlloc( void * dtTop ) } } while( stack->getCount() - && (kSuccess == DTExitEntry( iter, &dtChild))); + && (kSuccess == DTExitEntry( &iter, &dtChild))); stack->release(); - DTDisposeEntryIterator( iter); + assert(kSuccess != DTExitEntry(&iter, &dtChild)); // parent is now root of the created tree @@ -187,7 +208,7 @@ IODeviceTreeAlloc( void * dtTop ) // free original device tree DTInit(0); IODTFreeLoaderInfo( "DeviceTree", - (void *)dtMap[0], round_page_32(dtMap[1]) ); + (void *)dtMap[0], (int) round_page(dtMap[1]) ); } // adjust tree @@ -204,22 +225,6 @@ IODeviceTreeAlloc( void * dtTop ) if( !intMap && child->getProperty( gIODTInterruptParentKey)) intMap = true; - // Look for a "driver,AAPL,MacOSX,PowerPC" property. - if( (obj = child->getProperty( "driver,AAPL,MacOSX,PowerPC"))) { - gIOCatalogue->addExtensionsFromArchive((OSData *)obj); - child->removeProperty( "driver,AAPL,MacOSX,PowerPC"); - } - - // some gross pruning - child->removeProperty( "lanLib,AAPL,MacOS,PowerPC"); - - if( (obj = child->getProperty( "driver,AAPL,MacOS,PowerPC"))) { - - if( (0 == (prop = (OSData *)child->getProperty( gIODTTypeKey ))) - || (strcmp( "display", (char *) prop->getBytesNoCopy())) ) { - child->removeProperty( "driver,AAPL,MacOS,PowerPC"); - } - } } regIter->release(); } @@ -256,32 +261,38 @@ IODeviceTreeAlloc( void * dtTop ) return( parent); } -int IODTGetLoaderInfo( char *key, void **infoAddr, int *infoSize ) +int IODTGetLoaderInfo( const char *key, void **infoAddr, int *infoSize ) { IORegistryEntry *chosen; OSData *propObj; - unsigned int *propPtr; + dtptr_t *propPtr; unsigned int propSize; + int ret = -1; chosen = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane ); if ( chosen == 0 ) return -1; propObj = OSDynamicCast( OSData, chosen->getProperty(key) ); - if ( propObj == 0 ) return -1; + if ( propObj == 0 ) goto cleanup; propSize = propObj->getLength(); - if ( propSize != (2 * sizeof(UInt32)) ) return -1; + if ( propSize != (2 * sizeof(dtptr_t)) ) goto cleanup; - propPtr = (unsigned int *)propObj->getBytesNoCopy(); - if ( propPtr == 0 ) return -1; + propPtr = (dtptr_t *)propObj->getBytesNoCopy(); + if ( propPtr == 0 ) goto cleanup; - *infoAddr = (void *)propPtr[0] ; - *infoSize = (int) propPtr[1]; + *infoAddr = (void *)(uintptr_t) (propPtr[0]); + *infoSize = (int) (propPtr[1]); - return 0; + ret = 0; + +cleanup: + chosen->release(); + + return ret; } -void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize ) +void IODTFreeLoaderInfo( const char *key, void *infoAddr, int infoSize ) { vm_offset_t range[2]; IORegistryEntry *chosen; @@ -294,10 +305,31 @@ void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize ) chosen = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane ); if ( chosen != 0 ) { chosen->removeProperty(key); + chosen->release(); } } } +int IODTGetDefault(const char *key, void *infoAddr, unsigned int infoSize ) +{ + IORegistryEntry *defaults; + OSData *defaultObj; + unsigned int defaultSize; + + defaults = IORegistryEntry::fromPath( "/defaults", gIODTPlane ); + if ( defaults == 0 ) return -1; + + defaultObj = OSDynamicCast( OSData, defaults->getProperty(key) ); + if ( defaultObj == 0 ) return -1; + + defaultSize = defaultObj->getLength(); + if ( defaultSize > infoSize) return -1; + + memcpy( infoAddr, defaultObj->getBytesNoCopy(), defaultSize ); + + return 0; +} + static void FreePhysicalMemory( vm_offset_t * range ) { vm_offset_t virt; @@ -316,12 +348,13 @@ MakeReferenceTable( DTEntry dtEntry, bool copy ) const OSSymbol *nameKey; OSData *data; const OSSymbol *sym; - DTPropertyIterator dtIter; + OpaqueDTPropertyIterator dtIter; void *prop; - int propSize; + unsigned int propSize; char *name; char location[ 32 ]; bool noLocation = true; + bool kernelOnly; regEntry = new IOService; @@ -331,11 +364,12 @@ MakeReferenceTable( DTEntry dtEntry, bool copy ) } if( regEntry && - (kSuccess == DTCreatePropertyIterator( dtEntry, &dtIter))) { + (kSuccess == DTInitPropertyIterator( dtEntry, &dtIter))) { + kernelOnly = (kSuccess == DTGetProperty(dtEntry, "kernel-only", &prop, &propSize)); propTable = regEntry->getPropertyTable(); - while( kSuccess == DTIterateProperties( dtIter, &name)) { + while( kSuccess == DTIterateProperties( &dtIter, &name)) { if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize )) continue; @@ -349,6 +383,9 @@ MakeReferenceTable( DTEntry dtEntry, bool copy ) } assert( nameKey && data ); + if (kernelOnly) + data->setSerializable(false); + propTable->setObject( nameKey, data); data->release(); nameKey->release(); @@ -363,21 +400,20 @@ MakeReferenceTable( DTEntry dtEntry, bool copy ) } else if( nameKey == gIODTUnitKey ) { // all OF strings are null terminated... except this one - if( propSize >= (int) sizeof( location)) - propSize = sizeof( location) - 1; + if( propSize >= (int) sizeof(location)) + propSize = sizeof(location) - 1; strncpy( location, (const char *) prop, propSize ); location[ propSize ] = 0; regEntry->setLocation( location ); propTable->removeObject( gIODTUnitKey ); noLocation = false; - } else if( noLocation && (0 == strcmp( name, "reg"))) { + } else if(noLocation && (!strncmp(name, "reg", sizeof("reg")))) { // default location - override later - sprintf( location, "%lX", *((UInt32 *) prop) ); + snprintf(location, sizeof(location), "%X", *((uint32_t *) prop)); regEntry->setLocation( location ); } } - DTDisposePropertyIterator( dtIter); } return( regEntry); @@ -415,25 +451,34 @@ static IORegistryEntry * FindPHandle( UInt32 phandle ) static bool GetUInt32( IORegistryEntry * regEntry, const OSSymbol * name, UInt32 * value ) { - OSData *data; + OSObject * obj; + OSData * data; + bool result; - if( (data = OSDynamicCast( OSData, regEntry->getProperty( name ))) - && (4 == data->getLength())) { - *value = *((UInt32 *) data->getBytesNoCopy()); - return( true ); - } else - return( false ); + if (!(obj = regEntry->copyProperty(name))) return (false); + + result = ((data = OSDynamicCast(OSData, obj)) && (sizeof(UInt32) == data->getLength())); + if (result) *value = *((UInt32 *) data->getBytesNoCopy()); + + obj->release(); + return(result); } -IORegistryEntry * IODTFindInterruptParent( IORegistryEntry * regEntry ) +static IORegistryEntry * IODTFindInterruptParent( IORegistryEntry * regEntry, IOItemCount index ) { IORegistryEntry * parent; UInt32 phandle; + OSData * data; + unsigned int len; - if( GetUInt32( regEntry, gIODTInterruptParentKey, &phandle)) - parent = FindPHandle( phandle ); + if( (data = OSDynamicCast( OSData, regEntry->getProperty( gIODTInterruptParentKey ))) + && (sizeof(UInt32) <= (len = data->getLength()))) { + if (((index + 1) * sizeof(UInt32)) > len) + index = 0; + phandle = ((UInt32 *) data->getBytesNoCopy())[index]; + parent = FindPHandle( phandle ); - else if( 0 == regEntry->getProperty( "interrupt-controller")) + } else if( 0 == regEntry->getProperty( "interrupt-controller")) parent = regEntry->getParentEntry( gIODTPlane); else parent = 0; @@ -452,7 +497,7 @@ const OSSymbol * IODTInterruptControllerName( IORegistryEntry * regEntry ) assert( ok ); if( ok) { - sprintf( buf, "IOInterruptController%08lX", phandle); + snprintf(buf, sizeof(buf), "IOInterruptController%08X", (uint32_t)phandle); sym = OSSymbol::withCString( buf ); } else sym = 0; @@ -471,8 +516,8 @@ static void IODTGetICellCounts( IORegistryEntry * regEntry, *aCellCount = 0; } -UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec, - OSData ** spec, const OSSymbol ** controller ) +static UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec, UInt32 index, + OSData ** spec, const OSSymbol ** controller ) { IORegistryEntry *parent = 0; OSData *data; @@ -484,12 +529,12 @@ UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec, UInt32 i, original_icells; bool cmp, ok = false; - parent = IODTFindInterruptParent( regEntry ); + parent = IODTFindInterruptParent( regEntry, index ); IODTGetICellCounts( parent, &icells, &acells ); addrCmp = 0; if( acells) { data = OSDynamicCast( OSData, regEntry->getProperty( "reg" )); - if( data && (data->getLength() >= (acells * sizeof( UInt32)))) + if( data && (data->getLength() >= (acells * sizeof(UInt32)))) addrCmp = (UInt32 *) data->getBytesNoCopy(); } original_icells = icells; @@ -510,7 +555,7 @@ UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec, // found a controller - don't want to follow cascaded controllers parent = 0; *spec = OSData::withBytesNoCopy( (void *) intSpec, - icells * sizeof( UInt32)); + icells * sizeof(UInt32)); *controller = IODTInterruptControllerName( regEntry ); ok = (*spec && *controller); } else if( parent && (data = OSDynamicCast( OSData, @@ -519,7 +564,7 @@ UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec, map = (UInt32 *) data->getBytesNoCopy(); endMap = map + (data->getLength() / sizeof(UInt32)); data = OSDynamicCast( OSData, regEntry->getProperty( "interrupt-map-mask" )); - if( data && (data->getLength() >= ((acells + icells) * sizeof( UInt32)))) + if( data && (data->getLength() >= ((acells + icells) * sizeof(UInt32)))) maskCmp = (UInt32 *) data->getBytesNoCopy(); else maskCmp = 0; @@ -630,11 +675,12 @@ static bool IODTMapInterruptsSharing( IORegistryEntry * regEntry, OSDictionary * OSData * local2; UInt32 * localBits; UInt32 * localEnd; + IOItemCount index; OSData * map; OSObject * oneMap; OSArray * mapped; OSArray * controllerInts; - const OSSymbol * controller; + const OSSymbol * controller = 0; OSArray * controllers; UInt32 skip = 1; bool ok, nw; @@ -655,7 +701,8 @@ static bool IODTMapInterruptsSharing( IORegistryEntry * regEntry, OSDictionary * } localBits = (UInt32 *) local->getBytesNoCopy(); - localEnd = localBits + (local->getLength() / sizeof( UInt32)); + localEnd = localBits + (local->getLength() / sizeof(UInt32)); + index = 0; mapped = OSArray::withCapacity( 1 ); controllers = OSArray::withCapacity( 1 ); @@ -663,19 +710,20 @@ static bool IODTMapInterruptsSharing( IORegistryEntry * regEntry, OSDictionary * if( ok) do { if( nw) { - skip = IODTMapOneInterrupt( regEntry, localBits, &map, &controller ); + skip = IODTMapOneInterrupt( regEntry, localBits, index, &map, &controller ); if( 0 == skip) { IOLog("%s: error mapping interrupt[%d]\n", regEntry->getName(), mapped->getCount()); break; } } else { - map = OSData::withData( local, mapped->getCount() * sizeof( UInt32), - sizeof( UInt32)); + map = OSData::withData( local, mapped->getCount() * sizeof(UInt32), + sizeof(UInt32)); controller = gIODTDefaultInterruptController; controller->retain(); } + index++; localBits += skip; mapped->setObject( map ); controllers->setObject( controller ); @@ -747,23 +795,24 @@ bool IODTMapInterrupts( IORegistryEntry * regEntry ) /* */ -static const char * +static bool CompareKey( OSString * key, - const IORegistryEntry * table, const OSSymbol * propName ) + const IORegistryEntry * table, const OSSymbol * propName, + OSString ** matchingName ) { OSObject *prop; OSData *data; OSString *string; const char *ckey; UInt32 keyLen; + UInt32 nlen; const char *names; const char *lastName; bool wild; bool matched; const char *result = 0; - if( 0 == (prop = table->getProperty( propName ))) - return( 0 ); + if( 0 == (prop = table->copyProperty( propName ))) return( 0 ); if( (data = OSDynamicCast( OSData, prop ))) { names = (const char *) data->getBytesNoCopy(); @@ -771,47 +820,48 @@ CompareKey( OSString * key, } else if( (string = OSDynamicCast( OSString, prop ))) { names = string->getCStringNoCopy(); lastName = names + string->getLength() + 1; - } else - return( 0 ); + } else names = 0; - ckey = key->getCStringNoCopy(); - keyLen = key->getLength(); - wild = ('*' == key->getChar( keyLen - 1 )); + if (names) { + ckey = key->getCStringNoCopy(); + keyLen = key->getLength(); + wild = ('*' == key->getChar( keyLen - 1 )); - do { - // for each name in the property - if( wild) - matched = (0 == strncmp( ckey, names, keyLen - 1 )); - else - matched = (keyLen == strlen( names )) - && (0 == strncmp( ckey, names, keyLen )); + do { + // for each name in the property + nlen = strnlen(names, lastName - names); + if( wild) + matched = ((nlen >= (keyLen - 1)) && (0 == strncmp(ckey, names, keyLen - 1))); + else + matched = (keyLen == nlen) && (0 == strncmp(ckey, names, keyLen)); - if( matched) - result = names; + if( matched) + result = names; - names = names + strlen( names) + 1; + names = names + nlen + 1; - } while( (names < lastName) && (false == matched)); + } while( (names < lastName) && (false == matched)); + } + + if (result && matchingName) *matchingName = OSString::withCString( result ); + + if (prop) prop->release(); - return( result); + return (result != 0); } bool IODTCompareNubName( const IORegistryEntry * regEntry, OSString * name, OSString ** matchingName ) { - const char *result; - bool matched; - - matched = (0 != (result = CompareKey( name, regEntry, gIODTNameKey))) - || (0 != (result = CompareKey( name, regEntry, gIODTCompatibleKey))) - || (0 != (result = CompareKey( name, regEntry, gIODTTypeKey))) - || (0 != (result = CompareKey( name, regEntry, gIODTModelKey))); + bool matched; - if( result && matchingName) - *matchingName = OSString::withCString( result ); + matched = CompareKey( name, regEntry, gIODTNameKey, matchingName) + || CompareKey( name, regEntry, gIODTCompatibleKey, matchingName) + || CompareKey( name, regEntry, gIODTTypeKey, matchingName) + || CompareKey( name, regEntry, gIODTModelKey, matchingName); - return( result != 0 ); + return (matched); } bool IODTMatchNubWithKeys( IORegistryEntry * regEntry, @@ -826,7 +876,7 @@ bool IODTMatchNubWithKeys( IORegistryEntry * regEntry, result = regEntry->compareNames( obj ); obj->release(); } -#ifdef DEBUG +#if DEBUG else IOLog("Couldn't unserialize %s\n", keys ); #endif @@ -877,7 +927,7 @@ OSCollectionIterator * IODTFindMatchingEntries( IORegistryEntry * from, } cIter = OSCollectionIterator::withCollection( result); - result->release(); + if (result) result->release(); return( cIter); } @@ -885,31 +935,100 @@ OSCollectionIterator * IODTFindMatchingEntries( IORegistryEntry * from, struct IODTPersistent { IODTCompareAddressCellFunc compareFunc; - IODTNVLocationFunc locationFunc; }; void IODTSetResolving( IORegistryEntry * regEntry, IODTCompareAddressCellFunc compareFunc, - IODTNVLocationFunc locationFunc ) + IODTNVLocationFunc locationFunc __unused ) { - IODTPersistent persist; - OSData *prop; + IODTPersistent persist; + IODTPersistent * entry; + OSNumber * num; + unsigned int index, count; - persist.compareFunc = compareFunc; - persist.locationFunc = locationFunc; - prop = OSData::withBytes( &persist, sizeof( persist)); - if( !prop) - return; + IOLockLock(gIODTResolversLock); + + count = (gIODTResolvers->getLength() / sizeof(IODTPersistent)); + entry = (typeof(entry)) gIODTResolvers->getBytesNoCopy(); + for (index = 0; index < count; index++) + { + if (compareFunc == entry->compareFunc) break; + entry++; + } + if (index == count) + { + persist.compareFunc = compareFunc; + if (!gIODTResolvers->appendBytes(&persist, sizeof(IODTPersistent))) panic("IODTSetResolving"); + } + + IOLockUnlock(gIODTResolversLock); + + num = OSNumber::withNumber(index, 32); + regEntry->setProperty(gIODTPersistKey, num); + OSSafeReleaseNULL(num); - regEntry->setProperty( gIODTPersistKey, prop); - prop->release(); return; } +#if defined(__arm64__) +static SInt64 DefaultCompare( UInt32 cellCount, UInt32 left[], UInt32 right[] ) +{ + SInt64 diff = 0; + + if (cellCount == 2) { + diff = IOPhysical32(left[1], left[0]) - IOPhysical32(right[1], right[0]); + } else if (cellCount == 1) { + diff = ( left[0] - right[0] ); + } else { + panic("DefaultCompare only knows how to handle 1 or 2 cells."); + } + + return diff; +} +#elif defined(__arm__) || defined(__i386__) || defined(__x86_64__) static SInt32 DefaultCompare( UInt32 cellCount, UInt32 left[], UInt32 right[] ) { - cellCount--; - return( left[ cellCount ] - right[ cellCount ] ); + cellCount--; + return( left[ cellCount ] - right[ cellCount ] ); +} +#else +#error Unknown architecture. +#endif + +static void AddLengthToCells( UInt32 numCells, UInt32 *cells, UInt64 offset) +{ + if (numCells == 1) + { + cells[0] += (UInt32)offset; + } + else { +#if defined(__arm64__) || defined(__arm__) + UInt64 sum = cells[numCells - 2] + offset; + cells[numCells - 2] = (UInt32)sum; + if (sum > UINT32_MAX) { + cells[numCells - 1] += (UInt32)(sum >> 32); + } +#else + UInt64 sum = cells[numCells - 1] + offset; + cells[numCells - 1] = (UInt32)sum; + if (sum > UINT32_MAX) { + cells[numCells - 2] += (UInt32)(sum >> 32); + } +#endif + } +} + +static IOPhysicalAddress CellsValue( UInt32 numCells, UInt32 *cells) +{ + if (numCells == 1) { + return IOPhysical32( 0, cells[0] ); + } else { +#if defined(__arm64__) || defined(arm) + return IOPhysical32( cells[numCells - 1], cells[numCells - 2] ); +#else + return IOPhysical32( cells[numCells - 2], cells[numCells - 1] ); +#endif + } } void IODTGetCellCounts( IORegistryEntry * regEntry, @@ -928,112 +1047,155 @@ void IODTGetCellCounts( IORegistryEntry * regEntry, // Range[]: child-addr our-addr child-len // #cells: child ours child -bool IODTResolveAddressCell( IORegistryEntry * regEntry, +bool IODTResolveAddressCell( IORegistryEntry * startEntry, UInt32 cellsIn[], - IOPhysicalAddress * phys, IOPhysicalLength * len ) + IOPhysicalAddress * phys, IOPhysicalLength * lenOut ) { - IORegistryEntry *parent; - OSData *prop; + IORegistryEntry * parent; + IORegistryEntry * regEntry; + OSData * prop; + OSNumber * num; + unsigned int index, count; // cells in addresses at regEntry UInt32 sizeCells, addressCells; // cells in addresses below regEntry UInt32 childSizeCells, childAddressCells; UInt32 childCells; - UInt32 cell[ 5 ], offset = 0, length; - UInt32 endCell[ 5 ]; + UInt32 cell[ 8 ], propLen; + UInt64 offset = 0; + UInt32 endCell[ 8 ]; UInt32 *range; UInt32 *lookRange; UInt32 *startRange; UInt32 *endRanges; bool ok = true; - SInt32 diff, endDiff; + SInt64 diff, diff2, endDiff; + UInt64 len, rangeLen; IODTPersistent *persist; IODTCompareAddressCellFunc compare; + regEntry = startEntry; IODTGetCellCounts( regEntry, &childSizeCells, &childAddressCells ); childCells = childAddressCells + childSizeCells; - bcopy( cellsIn, cell, 4 * childCells ); - if( childSizeCells > 1) - *len = IOPhysical32( cellsIn[ childAddressCells ], - cellsIn[ childAddressCells + 1 ] ); - else - *len = IOPhysical32( 0, cellsIn[ childAddressCells ] ); + if (childCells > sizeof(cell)/sizeof(cell[0])) + panic("IODTResolveAddressCell: Invalid device tree (%u,%u)", (uint32_t)childAddressCells, (uint32_t)childSizeCells); + + bcopy( cellsIn, cell, sizeof(UInt32) * childCells ); + *lenOut = CellsValue( childSizeCells, cellsIn + childAddressCells ); do { - prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey )); - if( 0 == prop) { - /* end of the road */ - *phys = IOPhysical32( 0, cell[ childAddressCells - 1 ] + offset); - break; - } + prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey )); + if( 0 == prop) { + /* end of the road */ + *phys = CellsValue( childAddressCells, cell ); + *phys += offset; + if (regEntry != startEntry) regEntry->release(); + break; + } + + parent = regEntry->copyParentEntry( gIODTPlane ); + IODTGetCellCounts( parent, &sizeCells, &addressCells ); - parent = regEntry->getParentEntry( gIODTPlane ); - IODTGetCellCounts( parent, &sizeCells, &addressCells ); - - if( (length = prop->getLength())) { - // search - startRange = (UInt32 *) prop->getBytesNoCopy(); - range = startRange; - endRanges = range + (length / 4); - - prop = (OSData *) regEntry->getProperty( gIODTPersistKey ); - if( prop) { - persist = (IODTPersistent *) prop->getBytesNoCopy(); - compare = persist->compareFunc; - } else - compare = DefaultCompare; - - for( ok = false; - range < endRanges; - range += (childCells + addressCells) ) { - - // is cell start >= range start? - diff = (*compare)( childAddressCells, cell, range ); - if( diff < 0) - continue; - - ok = (0 == cell[childCells - 1]); - if (!ok) + if( (propLen = prop->getLength())) { + // search + startRange = (UInt32 *) prop->getBytesNoCopy(); + range = startRange; + endRanges = range + (propLen / sizeof(UInt32)); + + compare = NULL; + num = OSDynamicCast(OSNumber, regEntry->getProperty(gIODTPersistKey)); + if (num) + { + IOLockLock(gIODTResolversLock); + index = num->unsigned32BitValue(); + count = gIODTResolvers->getLength() / sizeof(IODTPersistent); + if (index < count) { - // search for cell end - bcopy(cell, endCell, childAddressCells * sizeof(UInt32)); - endCell[childAddressCells - 1] += cell[childCells - 1] - 1; - lookRange = startRange; - for( ; - lookRange < endRanges; - lookRange += (childCells + addressCells) ) - { - // is cell >= range start? - endDiff = (*compare)( childAddressCells, endCell, lookRange ); - if( endDiff < 0) - continue; - if ((endDiff - cell[childCells - 1] + 1 + lookRange[childAddressCells + addressCells - 1]) - == (diff + range[childAddressCells + addressCells - 1])) - { - ok = true; - break; - } - } - if (!ok) - continue; + persist = ((IODTPersistent *) gIODTResolvers->getBytesNoCopy()) + index; + compare = persist->compareFunc; } - offset += diff; - break; + IOLockUnlock(gIODTResolversLock); + } + + if (!compare && (addressCells == childAddressCells)) { + compare = DefaultCompare; } + if (!compare) { + panic("There is no mixed comparison function yet..."); + } + + for( ok = false; + range < endRanges; + range += (childCells + addressCells) ) { + + // is cell start within range? + diff = (*compare)( childAddressCells, cell, range ); + + if (childAddressCells > sizeof(endCell)/sizeof(endCell[0])) + panic("IODTResolveAddressCell: Invalid device tree (%u)", (uint32_t)childAddressCells); + + bcopy(range, endCell, childAddressCells * sizeof(UInt32)); + + rangeLen = CellsValue(childSizeCells, range + childAddressCells + addressCells); + AddLengthToCells(childAddressCells, endCell, rangeLen); + + diff2 = (*compare)( childAddressCells, cell, endCell ); + + // if start of cell < start of range, or end of range >= start of cell, skip + if ((diff < 0) || (diff2 >= 0)) + continue; + + len = CellsValue(childSizeCells, cell + childAddressCells); + ok = (0 == len); + + if (!ok) + { + // search for cell end + bcopy(cell, endCell, childAddressCells * sizeof(UInt32)); + + AddLengthToCells(childAddressCells, endCell, len - 1); + + for( lookRange = startRange; + lookRange < endRanges; + lookRange += (childCells + addressCells) ) + { + // make sure end of cell >= range start + endDiff = (*compare)( childAddressCells, endCell, lookRange ); + if( endDiff < 0) + continue; + + UInt64 rangeStart = CellsValue(addressCells, range + childAddressCells); + UInt64 lookRangeStart = CellsValue(addressCells, lookRange + childAddressCells); + if ((endDiff - len + 1 + lookRangeStart) == (diff + rangeStart)) + { + ok = true; + break; + } + } + if (!ok) + continue; + } + offset += diff; + break; + } + + if (addressCells + sizeCells > sizeof(cell)/sizeof(cell[0])) + panic("IODTResolveAddressCell: Invalid device tree (%u, %u)", (uint32_t)addressCells, (uint32_t)sizeCells); - // Get the physical start of the range from our parent - bcopy( range + childAddressCells, cell, 4 * addressCells ); - bzero( cell + addressCells, 4 * sizeCells ); + // Get the physical start of the range from our parent + bcopy( range + childAddressCells, cell, sizeof(UInt32) * addressCells ); + bzero( cell + addressCells, sizeof(UInt32) * sizeCells ); - } /* else zero length range => pass thru to parent */ + } /* else zero length range => pass thru to parent */ - regEntry = parent; - childSizeCells = sizeCells; - childAddressCells = addressCells; - childCells = childAddressCells + childSizeCells; + if (regEntry != startEntry) regEntry->release(); + regEntry = parent; + childSizeCells = sizeCells; + childAddressCells = addressCells; + childCells = childAddressCells + childSizeCells; } while( ok && regEntry); @@ -1055,107 +1217,45 @@ OSArray * IODTResolveAddressing( IORegistryEntry * regEntry, OSArray *array; IODeviceMemory *range; - parentEntry = regEntry->getParentEntry( gIODTPlane ); - addressProperty = (OSData *) regEntry->getProperty( addressPropertyName ); - if( (0 == addressProperty) || (0 == parentEntry)) - return( 0); - - IODTGetCellCounts( parentEntry, &sizeCells, &addressCells ); - if( 0 == sizeCells) - return( 0); - - cells = sizeCells + addressCells; - reg = (UInt32 *) addressProperty->getBytesNoCopy(); - num = addressProperty->getLength() / (4 * cells); - - array = OSArray::withCapacity( 1 ); - if( 0 == array) - return( 0); - - for( i = 0; i < num; i++) { - if( IODTResolveAddressCell( parentEntry, reg, &phys, &len )) { - range = 0; - if( parent) - range = IODeviceMemory::withSubRange( parent, - phys - parent->getPhysicalAddress(), len ); - if( 0 == range) - range = IODeviceMemory::withRange( phys, len ); - if( range) - array->setObject( range ); + array = 0; + do + { + parentEntry = regEntry->copyParentEntry( gIODTPlane ); + addressProperty = (OSData *) regEntry->getProperty( addressPropertyName ); + if( (0 == addressProperty) || (0 == parentEntry)) break; + + IODTGetCellCounts( parentEntry, &sizeCells, &addressCells ); + if( 0 == sizeCells) break; + + cells = sizeCells + addressCells; + reg = (UInt32 *) addressProperty->getBytesNoCopy(); + num = addressProperty->getLength() / (4 * cells); + + array = OSArray::withCapacity( 1 ); + if( 0 == array) break; + + for( i = 0; i < num; i++) { + if( IODTResolveAddressCell( parentEntry, reg, &phys, &len )) { + range = 0; + if( parent) + range = IODeviceMemory::withSubRange( parent, + phys - parent->getPhysicalSegment(0, 0, kIOMemoryMapperNone), len ); + if( 0 == range) + range = IODeviceMemory::withRange( phys, len ); + if( range) + array->setObject( range ); + } + reg += cells; } - reg += cells; - } - - regEntry->setProperty( gIODeviceMemoryKey, array); - array->release(); /* ??? */ - - return( array); -} - -static void IODTGetNVLocation( - IORegistryEntry * parent, - IORegistryEntry * regEntry, - UInt8 * busNum, UInt8 * deviceNum, UInt8 * functionNum ) -{ - - OSData *prop; - IODTPersistent *persist; - UInt32 *cell; - prop = (OSData *) parent->getProperty( gIODTPersistKey ); - if( prop) { - persist = (IODTPersistent *) prop->getBytesNoCopy(); - (*persist->locationFunc)( regEntry, busNum, deviceNum, functionNum ); - } else { - prop = (OSData *) regEntry->getProperty( "reg" ); - *functionNum = 0; - if( prop) { - cell = (UInt32 *) prop->getBytesNoCopy(); - *busNum = 3; - *deviceNum = 0x1f & (cell[ 0 ] >> 24); - } else { - *busNum = 0; - *deviceNum = 0; - } + regEntry->setProperty( gIODeviceMemoryKey, array); + array->release(); /* ??? */ } - return; -} + while (false); -/* - * Try to make the same messed up descriptor as Mac OS - */ - -IOReturn IODTMakeNVDescriptor( IORegistryEntry * regEntry, - IONVRAMDescriptor * hdr ) -{ - IORegistryEntry *parent; - UInt32 level; - UInt32 bridgeDevices; - UInt8 busNum; - UInt8 deviceNum; - UInt8 functionNum; - - hdr->format = 1; - hdr->marker = 0; - - for(level = 0, bridgeDevices = 0; - (parent = regEntry->getParentEntry( gIODTPlane )) && (level < 7); level++ ) { - - IODTGetNVLocation( parent, regEntry, - &busNum, &deviceNum, &functionNum ); - if( level) - bridgeDevices |= ((deviceNum & 0x1f) << ((level - 1) * 5)); - else { - hdr->busNum = busNum; - hdr->deviceNum = deviceNum; - hdr->functionNum = functionNum; - } - regEntry = parent; - } - hdr->bridgeCount = level - 2; - hdr->bridgeDevices = bridgeDevices; + OSSafeReleaseNULL(parentEntry); - return( kIOReturnSuccess ); + return (array); } OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber ) @@ -1165,44 +1265,49 @@ OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber ) OSData *ret = 0; UInt32 *bits; UInt32 i; + size_t nlen; char *names; char *lastName; UInt32 mask; data = (OSData *) regEntry->getProperty("AAPL,slot-name"); - if( data) - return( data); - parent = regEntry->getParentEntry( gIODTPlane ); - if( !parent) - return( 0 ); - data = OSDynamicCast( OSData, parent->getProperty("slot-names")); - if( !data) - return( 0 ); - if( data->getLength() <= 4) - return( 0 ); - - bits = (UInt32 *) data->getBytesNoCopy(); - mask = *bits; - if( (0 == (mask & (1 << deviceNumber)))) - return( 0 ); - - names = (char *)(bits + 1); - lastName = names + (data->getLength() - 4); - - for( i = 0; (i <= deviceNumber) && (names < lastName); i++ ) { - - if( mask & (1 << i)) { - if( i == deviceNumber) { - data = OSData::withBytesNoCopy( names, 1 + strlen( names)); - if( data) { - regEntry->setProperty("AAPL,slot-name", data); - ret = data; - data->release(); - } - } else - names += 1 + strlen( names); + if (data) return (data); + + do + { + parent = regEntry->copyParentEntry( gIODTPlane ); + if (!parent) break; + + data = OSDynamicCast( OSData, parent->getProperty("slot-names")); + if (!data) break; + if (data->getLength() <= 4) break; + + bits = (UInt32 *) data->getBytesNoCopy(); + mask = *bits; + if ((0 == (mask & (1 << deviceNumber)))) break; + + names = (char *)(bits + 1); + lastName = names + (data->getLength() - 4); + + for( i = 0; (i <= deviceNumber) && (names < lastName); i++ ) { + + if( mask & (1 << i)) { + nlen = 1 + strnlen(names, lastName - names); + if( i == deviceNumber) { + data = OSData::withBytesNoCopy(names, nlen); + if( data) { + regEntry->setProperty("AAPL,slot-name", data); + ret = data; + data->release(); + } + } else + names += nlen; + } } } + while (false); + + OSSafeReleaseNULL(parent); return( ret ); }