/*
* Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
- *
- * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
* 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. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
+ * 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.
+ *
+ * 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
* 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.
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
#include <IOKit/IODeviceTreeSupport.h>
#include <IOKit/IOLib.h>
#include <IOKit/IOKitKeys.h>
-#include <DeviceTree.h>
+#include <pexpert/device_tree.h>
+
extern "C" {
#include <machine/machine_routines.h>
void DTInit( void * data );
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;
+ OSObject * obj;
+ OSDictionary * allInts;
+ vm_offset_t * dtMap;
+ int propSize;
+ bool intMap;
+ bool freeDT;
gIODTPlane = IORegistryEntry::makePlane( kIODeviceTreePlane );
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 {
// free original device tree
DTInit(0);
IODTFreeLoaderInfo( "DeviceTree",
- (void *)dtMap[0], round_page(dtMap[1]) );
+ (void *)dtMap[0], round_page_32(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;
regIter->release();
}
+#if IODTSUPPORTDEBUG
+ parent->setProperty("allInts", allInts);
+ parent->setProperty("sharedInts", gIODTSharedInterrupts);
+
+ 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);
}
{
vm_offset_t virt;
+#if defined (__i386__)
+ virt = ml_boot_ptovirt( range[0] );
+#else
virt = ml_static_ptovirt( range[0] );
+#endif
if( virt) {
ml_static_mfree( virt, range[1] );
}
return( ok ? original_icells : 0 );
}
-bool IODTMapInterrupts( IORegistryEntry * regEntry )
+IOReturn IODTGetInterruptOptions( IORegistryEntry * regEntry, int source, IOOptionBits * options )
+{
+ 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;
- OSData *map;
- OSArray *mapped;
- const OSSymbol *controller;
- OSArray *controllers;
- UInt32 skip = 1;
- bool ok, nw;
+ IORegistryEntry * parent;
+ OSData * local;
+ OSData * local2;
+ UInt32 * localBits;
+ UInt32 * localEnd;
+ OSData * map;
+ OSObject * oneMap;
+ OSArray * mapped;
+ OSArray * controllerInts;
+ const OSSymbol * controller;
+ OSArray * controllers;
+ UInt32 skip = 1;
+ bool ok, nw;
nw = (0 == (local = OSDynamicCast( OSData,
regEntry->getProperty( gIODTAAPLInterruptsKey))));
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);
return( ok );
}
+bool IODTMapInterrupts( IORegistryEntry * regEntry )
+{
+ return( IODTMapInterruptsSharing( regEntry, 0 ));
+}
+
/*
*/
return( left[ cellCount ] - right[ cellCount ] );
}
-
void IODTGetCellCounts( IORegistryEntry * regEntry,
UInt32 * sizeCount, UInt32 * addressCount)
{
UInt32 childSizeCells, childAddressCells;
UInt32 childCells;
UInt32 cell[ 5 ], offset = 0, length;
+ UInt32 endCell[ 5 ];
UInt32 *range;
+ UInt32 *lookRange;
+ UInt32 *startRange;
UInt32 *endRanges;
bool ok = true;
- SInt32 diff;
+ SInt32 diff, endDiff;
IODTPersistent *persist;
IODTCompareAddressCellFunc compare;
else
*len = IOPhysical32( 0, cellsIn[ childAddressCells ] );
- do {
- prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey ));
- if( 0 == prop) {
- /* end of the road */
- *phys = IOPhysical32( 0, cell[ childAddressCells - 1 ] + offset);
- break;
- }
-
- parent = regEntry->getParentEntry( gIODTPlane );
- IODTGetCellCounts( parent, &sizeCells, &addressCells );
-
- if( (length = prop->getLength())) {
- // search
- range = (UInt32 *) prop->getBytesNoCopy();
- 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 >= range start?
- diff = (*compare)( childAddressCells, cell, range );
- if( diff < 0)
- continue;
-
- // is cell + size <= range end?
- if( (diff + cell[ childCells - 1 ])
- > range[ childCells + addressCells - 1 ])
- continue;
-
- offset += diff;
- ok = true;
- break;
- }
-
- // Get the physical start of the range from our parent
- bcopy( range + childAddressCells, cell, 4 * addressCells );
- bzero( cell + addressCells, 4 * sizeCells );
-
- } /* else zero length range => pass thru to parent */
+ do
+ {
+ prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey ));
+ if( 0 == prop) {
+ /* end of the road */
+ *phys = IOPhysical32( 0, cell[ childAddressCells - 1 ] + offset);
+ break;
+ }
+
+ 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)
+ {
+ // 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;
+ }
+ offset += diff;
+ break;
+ }
+
+ // Get the physical start of the range from our parent
+ bcopy( range + childAddressCells, cell, 4 * addressCells );
+ bzero( cell + addressCells, 4 * sizeCells );
+
+ } /* else zero length range => pass thru to parent */
regEntry = parent;
childSizeCells = sizeCells;
childAddressCells = addressCells;
childCells = childAddressCells + childSizeCells;
-
- } while( ok && regEntry);
+ }
+ while( ok && regEntry);
return( ok);
}
return( ret );
}
+
+extern "C" IOReturn IONDRVLibrariesInitialize( IOService * provider )
+{
+ return( kIOReturnUnsupported );
+}
projects / apple / xnu.git / blobdiff