X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/9bccf70c0258c7cac2dcb80011b2a964d884c552..c7d2c2c6ee645e10cbccdd01c6191873ec77239d:/iokit/Kernel/IODeviceTreeSupport.cpp diff --git a/iokit/Kernel/IODeviceTreeSupport.cpp b/iokit/Kernel/IODeviceTreeSupport.cpp index 6d9eb7f61..965670f37 100644 --- a/iokit/Kernel/IODeviceTreeSupport.cpp +++ b/iokit/Kernel/IODeviceTreeSupport.cpp @@ -1,31 +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@ - */ -/* - * Copyright (c) 1998 Apple Computer, Inc. All rights reserved. - * - * HISTORY - * 23 Nov 98 sdouglas, created from IODeviceTreeBus.m, & MacOS exp mgr. - * 05 Apr 99 sdouglas, add interrupt mapping. - * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ #include @@ -37,13 +35,16 @@ #include #include -#include +#include + +#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 @@ -60,6 +61,7 @@ const OSSymbol * gIODTUnitKey; const OSSymbol * gIODTCompatibleKey; const OSSymbol * gIODTTypeKey; const OSSymbol * gIODTModelKey; +const OSSymbol * gIODTTargetTypeKey; const OSSymbol * gIODTSizeCellKey; const OSSymbol * gIODTAddressCellKey; @@ -74,29 +76,29 @@ const OSSymbol * gIODTInterruptCellKey; const OSSymbol * gIODTInterruptParentKey; const OSSymbol * gIODTNWInterruptMappingKey; +OSDictionary * gIODTSharedInterrupts; static IORegistryEntry * MakeReferenceTable( DTEntry dtEntry, bool copy ); static void AddPHandle( IORegistryEntry * regEntry ); static void FreePhysicalMemory( vm_offset_t * range ); +static bool IODTMapInterruptsSharing( IORegistryEntry * regEntry, OSDictionary * allInts ); IORegistryEntry * IODeviceTreeAlloc( void * dtTop ) { - IORegistryEntry *parent; - IORegistryEntry *child; - IORegistryIterator *regIter; + IORegistryEntry * parent; + IORegistryEntry * child; + IORegistryIterator * regIter; DTEntryIterator iter; - DTEntry dtChild; - DTEntry mapEntry; - OSArray *stack; - OSData *prop; - OSObject *obj; - vm_offset_t *dtMap; - int propSize; - bool intMap; - bool freeDT; - - IOLog("IODeviceTreeSupport "); + DTEntry dtChild; + DTEntry mapEntry; + OSArray * stack; + OSData * prop; + OSDictionary * allInts; + vm_offset_t * dtMap; + unsigned int propSize; + bool intMap; + bool freeDT; gIODTPlane = IORegistryEntry::makePlane( kIODeviceTreePlane ); @@ -105,6 +107,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" ); @@ -144,11 +147,11 @@ IODeviceTreeAlloc( void * dtTop ) 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 ); + stack = OSArray::withObjects( (const OSObject **) &parent, 1, 10 ); DTCreateEntryIterator( (DTEntry)dtTop, &iter ); do { @@ -193,51 +196,60 @@ IODeviceTreeAlloc( void * dtTop ) // free original device tree DTInit(0); IODTFreeLoaderInfo( "DeviceTree", - (void *)dtMap[0], round_page(dtMap[1]) ); + (void *)dtMap[0], (int) round_page(dtMap[1]) ); } // adjust tree + + gIODTSharedInterrupts = OSDictionary::withCapacity(4); + allInts = OSDictionary::withCapacity(4); intMap = false; regIter = IORegistryIterator::iterateOver( gIODTPlane, kIORegistryIterateRecursively ); - assert( regIter ); - if( regIter) { + assert( regIter && allInts && gIODTSharedInterrupts ); + if( regIter && allInts && gIODTSharedInterrupts ) { while( (child = regIter->getNextObject())) { - IODTMapInterrupts( child ); + IODTMapInterruptsSharing( child, allInts ); 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"); + } + regIter->release(); + } - if( (obj = child->getProperty( "driver,AAPL,MacOS,PowerPC"))) { +#if IODTSUPPORTDEBUG + parent->setProperty("allInts", allInts); + parent->setProperty("sharedInts", gIODTSharedInterrupts); - if( (0 == (prop = (OSData *)child->getProperty( gIODTTypeKey ))) - || (strcmp( "display", (char *) prop->getBytesNoCopy())) ) { - child->removeProperty( "driver,AAPL,MacOS,PowerPC"); - } - } - } + regIter = IORegistryIterator::iterateOver( gIODTPlane, + kIORegistryIterateRecursively ); + if (regIter) { + while( (child = regIter->getNextObject())) { + OSArray * + array = OSDynamicCast(OSArray, child->getProperty( gIOInterruptSpecifiersKey )); + for( UInt32 i = 0; array && (i < array->getCount()); i++) + { + IOOptionBits options; + IOReturn ret = IODTGetInterruptOptions( child, i, &options ); + if( (ret != kIOReturnSuccess) || options) + IOLog("%s[%ld] %ld (%x)\n", child->getName(), i, options, ret); + } + } regIter->release(); } +#endif + + allInts->release(); if( intMap) // set a key in the root to indicate we found NW interrupt mapping parent->setProperty( gIODTNWInterruptMappingKey, (OSObject *) gIODTNWInterruptMappingKey ); - IOLog("done\n"); - return( parent); } -int IODTGetLoaderInfo( char *key, void **infoAddr, int *infoSize ) +int IODTGetLoaderInfo( const char *key, void **infoAddr, int *infoSize ) { IORegistryEntry *chosen; OSData *propObj; @@ -256,13 +268,13 @@ int IODTGetLoaderInfo( char *key, void **infoAddr, int *infoSize ) propPtr = (unsigned int *)propObj->getBytesNoCopy(); if ( propPtr == 0 ) return -1; - *infoAddr = (void *)propPtr[0] ; - *infoSize = (int) propPtr[1]; + *infoAddr = (void *)(uintptr_t) (propPtr[0]); + *infoSize = (int) (propPtr[1]); return 0; } -void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize ) +void IODTFreeLoaderInfo( const char *key, void *infoAddr, int infoSize ) { vm_offset_t range[2]; IORegistryEntry *chosen; @@ -279,6 +291,26 @@ void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize ) } } +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; @@ -299,7 +331,7 @@ MakeReferenceTable( DTEntry dtEntry, bool copy ) const OSSymbol *sym; DTPropertyIterator dtIter; void *prop; - int propSize; + unsigned int propSize; char *name; char location[ 32 ]; bool noLocation = true; @@ -344,17 +376,17 @@ 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 ); } } @@ -406,15 +438,21 @@ static bool GetUInt32( IORegistryEntry * regEntry, const OSSymbol * name, return( false ); } -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; @@ -433,7 +471,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; @@ -452,8 +490,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; @@ -465,12 +503,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; @@ -491,7 +529,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, @@ -500,7 +538,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; @@ -568,19 +606,58 @@ UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec, return( ok ? original_icells : 0 ); } -bool IODTMapInterrupts( IORegistryEntry * regEntry ) +IOReturn IODTGetInterruptOptions( IORegistryEntry * regEntry, int source, IOOptionBits * options ) { - IORegistryEntry *parent; - OSData *local; - OSData *local2; - UInt32 *localBits; - UInt32 *localEnd; - OSData *map; - OSArray *mapped; - const OSSymbol *controller; - OSArray *controllers; - UInt32 skip = 1; - bool ok, nw; + OSArray * controllers; + OSArray * specifiers; + OSArray * shared; + OSObject * spec; + OSObject * oneSpec; + + *options = 0; + + controllers = OSDynamicCast(OSArray, regEntry->getProperty(gIOInterruptControllersKey)); + specifiers = OSDynamicCast(OSArray, regEntry->getProperty(gIOInterruptSpecifiersKey)); + + if( !controllers || !specifiers) + return (kIOReturnNoInterrupt); + + shared = (OSArray *) gIODTSharedInterrupts->getObject( + (const OSSymbol *) controllers->getObject(source) ); + if (!shared) + return (kIOReturnSuccess); + + spec = specifiers->getObject(source); + if (!spec) + return (kIOReturnNoInterrupt); + + for (unsigned int i = 0; + (oneSpec = shared->getObject(i)) + && (!oneSpec->isEqualTo(spec)); + i++ ) {} + + if (oneSpec) + *options = kIODTInterruptShared; + + return (kIOReturnSuccess); +} + +static bool IODTMapInterruptsSharing( IORegistryEntry * regEntry, OSDictionary * allInts ) +{ + IORegistryEntry * parent; + OSData * local; + OSData * local2; + UInt32 * localBits; + UInt32 * localEnd; + IOItemCount index; + OSData * map; + OSObject * oneMap; + OSArray * mapped; + OSArray * controllerInts; + const OSSymbol * controller = 0; + OSArray * controllers; + UInt32 skip = 1; + bool ok, nw; nw = (0 == (local = OSDynamicCast( OSData, regEntry->getProperty( gIODTAAPLInterruptsKey)))); @@ -598,7 +675,8 @@ bool IODTMapInterrupts( IORegistryEntry * regEntry ) } 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 ); @@ -606,23 +684,63 @@ bool IODTMapInterrupts( IORegistryEntry * regEntry ) 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 ); + + if (allInts) + { + controllerInts = (OSArray *) allInts->getObject( controller ); + if (controllerInts) + { + for (unsigned int i = 0; (oneMap = controllerInts->getObject(i)); i++) + { + if (map->isEqualTo(oneMap)) + { + controllerInts = (OSArray *) gIODTSharedInterrupts->getObject( controller ); + if (controllerInts) + controllerInts->setObject(map); + else + { + controllerInts = OSArray::withObjects( (const OSObject **) &map, 1, 4 ); + if (controllerInts) + { + gIODTSharedInterrupts->setObject( controller, controllerInts ); + controllerInts->release(); + } + } + break; + } + } + if (!oneMap) + controllerInts->setObject(map); + } + else + { + controllerInts = OSArray::withObjects( (const OSObject **) &map, 1, 16 ); + if (controllerInts) + { + allInts->setObject( controller, controllerInts ); + controllerInts->release(); + } + } + } + map->release(); - controllers->setObject( (OSObject *) controller ); controller->release(); } while( localBits < localEnd); @@ -643,6 +761,11 @@ bool IODTMapInterrupts( IORegistryEntry * regEntry ) return( ok ); } +bool IODTMapInterrupts( IORegistryEntry * regEntry ) +{ + return( IODTMapInterruptsSharing( regEntry, 0 )); +} + /* */ @@ -655,6 +778,7 @@ CompareKey( OSString * key, OSString *string; const char *ckey; UInt32 keyLen; + UInt32 nlen; const char *names; const char *lastName; bool wild; @@ -679,16 +803,16 @@ CompareKey( OSString * key, do { // for each name in the property + nlen = strnlen(names, lastName - names); if( wild) - matched = (0 == strncmp( ckey, names, keyLen - 1 )); + matched = ((nlen >= (keyLen - 1)) && (0 == strncmp(ckey, names, keyLen - 1))); else - matched = (keyLen == strlen( names )) - && (0 == strncmp( ckey, names, keyLen )); + matched = (keyLen == nlen) && (0 == strncmp(ckey, names, keyLen)); if( matched) result = names; - names = names + strlen( names) + 1; + names = names + nlen + 1; } while( (names < lastName) && (false == matched)); @@ -725,7 +849,7 @@ bool IODTMatchNubWithKeys( IORegistryEntry * regEntry, result = regEntry->compareNames( obj ); obj->release(); } -#ifdef DEBUG +#if DEBUG else IOLog("Couldn't unserialize %s\n", keys ); #endif @@ -776,7 +900,7 @@ OSCollectionIterator * IODTFindMatchingEntries( IORegistryEntry * from, } cIter = OSCollectionIterator::withCollection( result); - result->release(); + if (result) result->release(); return( cIter); } @@ -796,21 +920,49 @@ void IODTSetResolving( IORegistryEntry * regEntry, persist.compareFunc = compareFunc; persist.locationFunc = locationFunc; - prop = OSData::withBytes( &persist, sizeof( persist)); + prop = OSData::withBytes( &persist, sizeof(persist)); if( !prop) return; + prop->setSerializable(false); regEntry->setProperty( gIODTPersistKey, prop); prop->release(); return; } +#if 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 { + UInt64 sum = cells[numCells - 1] + offset; + cells[numCells - 1] = (UInt32)sum; + if (sum > UINT32_MAX) { + cells[numCells - 2] += (UInt32)(sum >> 32); + } + } +} + +static IOPhysicalAddress CellsValue( UInt32 numCells, UInt32 *cells) +{ + if (numCells == 1) { + return IOPhysical32( 0, cells[0] ); + } else { + return IOPhysical32( cells[numCells - 2], cells[numCells - 1] ); + } +} void IODTGetCellCounts( IORegistryEntry * regEntry, UInt32 * sizeCount, UInt32 * addressCount) @@ -830,7 +982,7 @@ void IODTGetCellCounts( IORegistryEntry * regEntry, bool IODTResolveAddressCell( IORegistryEntry * regEntry, UInt32 cellsIn[], - IOPhysicalAddress * phys, IOPhysicalLength * len ) + IOPhysicalAddress * phys, IOPhysicalLength * lenOut ) { IORegistryEntry *parent; OSData *prop; @@ -839,11 +991,16 @@ bool IODTResolveAddressCell( IORegistryEntry * regEntry, // cells in addresses below regEntry UInt32 childSizeCells, childAddressCells; UInt32 childCells; - UInt32 cell[ 5 ], offset = 0, length; + UInt32 cell[ 8 ], propLen; + UInt64 offset = 0; + UInt32 endCell[ 8 ]; UInt32 *range; + UInt32 *lookRange; + UInt32 *startRange; UInt32 *endRanges; bool ok = true; - SInt32 diff; + SInt64 diff, diff2, endDiff; + UInt64 len, rangeLen; IODTPersistent *persist; IODTCompareAddressCellFunc compare; @@ -851,67 +1008,111 @@ bool IODTResolveAddressCell( IORegistryEntry * regEntry, 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); - do { + 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); + *phys = CellsValue( childAddressCells, cell ); + *phys += offset; break; } parent = regEntry->getParentEntry( gIODTPlane ); IODTGetCellCounts( parent, &sizeCells, &addressCells ); - if( (length = prop->getLength())) { + if( (propLen = prop->getLength())) { // search - range = (UInt32 *) prop->getBytesNoCopy(); - endRanges = range + (length / 4); + startRange = (UInt32 *) prop->getBytesNoCopy(); + range = startRange; + endRanges = range + (propLen / sizeof(UInt32)); prop = (OSData *) regEntry->getProperty( gIODTPersistKey ); if( prop) { persist = (IODTPersistent *) prop->getBytesNoCopy(); compare = persist->compareFunc; - } else + } else if (addressCells == childAddressCells) { compare = DefaultCompare; + } else { + panic("There is no mixed comparison function yet..."); + } for( ok = false; - range < endRanges; - range += (childCells + addressCells) ) { + range < endRanges; + range += (childCells + addressCells) ) { - // is cell >= range start? + // is cell start within range? diff = (*compare)( childAddressCells, cell, range ); - if( diff < 0) - continue; - - // is cell + size <= range end? - if( (diff + cell[ childCells - 1 ]) - > range[ childCells + addressCells - 1 ]) + + 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; - ok = true; 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 ); + bcopy( range + childAddressCells, cell, sizeof(UInt32) * addressCells ); + bzero( cell + addressCells, sizeof(UInt32) * sizeCells ); } /* else zero length range => pass thru to parent */ - regEntry = parent; - childSizeCells = sizeCells; - childAddressCells = addressCells; - childCells = childAddressCells + childSizeCells; - - } while( ok && regEntry); + regEntry = parent; + childSizeCells = sizeCells; + childAddressCells = addressCells; + childCells = childAddressCells + childSizeCells; + } + while( ok && regEntry); return( ok); } @@ -953,7 +1154,7 @@ OSArray * IODTResolveAddressing( IORegistryEntry * regEntry, range = 0; if( parent) range = IODeviceMemory::withSubRange( parent, - phys - parent->getPhysicalAddress(), len ); + phys - parent->getPhysicalSegment(0, 0, kIOMemoryMapperNone), len ); if( 0 == range) range = IODeviceMemory::withRange( phys, len ); if( range) @@ -1041,6 +1242,7 @@ OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber ) OSData *ret = 0; UInt32 *bits; UInt32 i; + size_t nlen; char *names; char *lastName; UInt32 mask; @@ -1068,17 +1270,23 @@ OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber ) 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, 1 + strlen( names)); + data = OSData::withBytesNoCopy(names, nlen); if( data) { regEntry->setProperty("AAPL,slot-name", data); ret = data; data->release(); } } else - names += 1 + strlen( names); + names += nlen; } } return( ret ); } + +extern "C" IOReturn IONDRVLibrariesInitialize( IOService * provider ) +{ + return( kIOReturnUnsupported ); +}