IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
void *target,
IOInterruptHandler handler,
void *refCon)
{
IOInterruptSource *interruptSources;
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
int wasDisabledSoft;
IOReturn error;
OSData *vectorData;
IOOptionBits options;
bool canBeShared, shouldBeShared, wasAlreadyRegisterd;
IOService *originalNub = NULL; // Protected by wasAlreadyRegisterd
int originalSource = 0; // Protected by wasAlreadyRegisterd
interruptSources = nub->_interruptSources;
vectorData = interruptSources[source].vectorData;
vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
vector = &vectors[vectorNumber];
// Get the lock for this vector.
IOLockLock(vector->interruptLock);
// Check if the interrupt source can/should be shared.
canBeShared = vectorCanBeShared(vectorNumber, vector);
IODTGetInterruptOptions(nub, source, &options);
#if defined(__i386__) || defined(__x86_64__)
int interruptType;
if (OSDynamicCast(IOPlatformDevice, getProvider()) &&
(getInterruptType(nub, source, &interruptType) == kIOReturnSuccess) &&
(kIOInterruptTypeLevel & interruptType))
{
options |= kIODTInterruptShared;
}
#endif
shouldBeShared = canBeShared && (options & kIODTInterruptShared);
wasAlreadyRegisterd = vector->interruptRegistered;
// If the vector is registered and can not be shared return error.
if (wasAlreadyRegisterd && !canBeShared) {
IOLockUnlock(vector->interruptLock);
return kIOReturnNoResources;
}
// If this vector is already in use, and can be shared (implied),
// or it is not registered and should be shared,
// register as a shared interrupt.
if (wasAlreadyRegisterd || shouldBeShared) {
// If this vector is not already shared, break it out.
if (vector->sharedController == 0) {
// Make the IOShareInterruptController instance
vector->sharedController = new IOSharedInterruptController;
if (vector->sharedController == 0) {
IOLockUnlock(vector->interruptLock);
return kIOReturnNoMemory;
}
if (wasAlreadyRegisterd) {
// Save the nub and source for the original consumer.
originalNub = vector->nub;
originalSource = vector->source;
// Physically disable the interrupt, but mark it as being enabled in the hardware.
// The interruptDisabledSoft now indicates the driver's request for enablement.
disableVectorHard(vectorNumber, vector);
vector->interruptDisabledHard = 0;
}
// Initialize the new shared interrupt controller.
error = vector->sharedController->initInterruptController(this, vectorData);
// If the IOSharedInterruptController could not be initalized,
// if needed, put the original consumer's interrupt back to normal and
// get rid of whats left of the shared controller.
if (error != kIOReturnSuccess) {
if (wasAlreadyRegisterd) enableInterrupt(originalNub, originalSource);
vector->sharedController->release();
vector->sharedController = 0;
IOLockUnlock(vector->interruptLock);
return error;
}
// If there was an original consumer try to register it on the shared controller.
if (wasAlreadyRegisterd) {
error = vector->sharedController->registerInterrupt(originalNub,
originalSource,
vector->target,
vector->handler,
vector->refCon);
// If the original consumer could not be moved to the shared controller,
// put the original consumor's interrupt back to normal and
// get rid of whats left of the shared controller.
if (error != kIOReturnSuccess) {
// Save the driver's interrupt enablement state.
wasDisabledSoft = vector->interruptDisabledSoft;
// Make the interrupt really hard disabled.
vector->interruptDisabledSoft = 1;
vector->interruptDisabledHard = 1;
// Enable the original consumer's interrupt if needed.
if (!wasDisabledSoft) originalNub->enableInterrupt(originalSource);
enableInterrupt(originalNub, originalSource);
vector->sharedController->release();
vector->sharedController = 0;
IOLockUnlock(vector->interruptLock);
return error;
}
}
// Fill in vector with the shared controller's info.
vector->handler = (IOInterruptHandler)vector->sharedController->getInterruptHandlerAddress();
vector->nub = vector->sharedController;
vector->source = 0;
vector->target = vector->sharedController;
vector->refCon = 0;
// If the interrupt was already registered,
// save the driver's interrupt enablement state.
if (wasAlreadyRegisterd) wasDisabledSoft = vector->interruptDisabledSoft;
else wasDisabledSoft = true;
// Do any specific initalization for this vector if it has not yet been used.
if (!wasAlreadyRegisterd) initVector(vectorNumber, vector);
// Make the interrupt really hard disabled.
vector->interruptDisabledSoft = 1;
vector->interruptDisabledHard = 1;
vector->interruptRegistered = 1;
// Enable the original consumer's interrupt if needed.
// originalNub is protected by wasAlreadyRegisterd here (see line 184).
if (!wasDisabledSoft) originalNub->enableInterrupt(originalSource);
}
error = vector->sharedController->registerInterrupt(nub, source, target,
handler, refCon);
IOLockUnlock(vector->interruptLock);
return error;
}
// Fill in vector with the client's info.
vector->handler = handler;
vector->nub = nub;
vector->source = source;
vector->target = target;
vector->refCon = refCon;
// Do any specific initalization for this vector.
initVector(vectorNumber, vector);
// Get the vector ready. It starts hard disabled.
vector->interruptDisabledHard = 1;
vector->interruptDisabledSoft = 1;
vector->interruptRegistered = 1;
IOLockUnlock(vector->interruptLock);
return kIOReturnSuccess;
}
IORegistryEntry *
IODeviceTreeAlloc( void * dtTop )
{
IORegistryEntry * parent;
IORegistryEntry * child;
IORegistryIterator * regIter;
DTEntryIterator iter;
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 );
gIODTNameKey = OSSymbol::withCStringNoCopy( "name" );
gIODTUnitKey = OSSymbol::withCStringNoCopy( "AAPL,unit-string" );
gIODTCompatibleKey = OSSymbol::withCStringNoCopy( "compatible" );
gIODTTypeKey = OSSymbol::withCStringNoCopy( "device_type" );
gIODTModelKey = OSSymbol::withCStringNoCopy( "model" );
gIODTSizeCellKey = OSSymbol::withCStringNoCopy( "#size-cells" );
gIODTAddressCellKey = OSSymbol::withCStringNoCopy( "#address-cells" );
gIODTRangeKey = OSSymbol::withCStringNoCopy( "ranges" );
gIODTPersistKey = OSSymbol::withCStringNoCopy( "IODTPersist" );
assert( gIODTPlane && gIODTCompatibleKey
&& gIODTTypeKey && gIODTModelKey
&& gIODTSizeCellKey && gIODTAddressCellKey && gIODTRangeKey
&& gIODTPersistKey );
gIODTDefaultInterruptController
= OSSymbol::withCStringNoCopy("IOPrimaryInterruptController");
gIODTNWInterruptMappingKey
= OSSymbol::withCStringNoCopy("IONWInterrupts");
gIODTAAPLInterruptsKey
= OSSymbol::withCStringNoCopy("AAPL,interrupts");
gIODTPHandleKey
= OSSymbol::withCStringNoCopy("AAPL,phandle");
gIODTInterruptParentKey
= OSSymbol::withCStringNoCopy("interrupt-parent");
gIODTPHandles = OSArray::withCapacity( 1 );
gIODTPHandleMap = OSArray::withCapacity( 1 );
gIODTInterruptCellKey
= OSSymbol::withCStringNoCopy("#interrupt-cells");
assert( gIODTDefaultInterruptController && gIODTNWInterruptMappingKey
&& gIODTAAPLInterruptsKey
&& gIODTPHandleKey && gIODTInterruptParentKey
&& gIODTPHandles && gIODTPHandleMap
&& gIODTInterruptCellKey
);
freeDT = (kSuccess == DTLookupEntry( 0, "/chosen/memory-map", &mapEntry ))
&& (kSuccess == DTGetProperty( mapEntry,
"DeviceTree", (void **) &dtMap, &propSize ))
&& ((2 * sizeof(uint32_t)) == propSize);
parent = MakeReferenceTable( (DTEntry)dtTop, freeDT );
stack = OSArray::withObjects( (const OSObject **) &parent, 1, 10 );
DTCreateEntryIterator( (DTEntry)dtTop, &iter );
do {
parent = (IORegistryEntry *)stack->getObject( stack->getCount() - 1);
//parent->release();
stack->removeObject( stack->getCount() - 1);
while( kSuccess == DTIterateEntries( iter, &dtChild) ) {
child = MakeReferenceTable( dtChild, freeDT );
child->attachToParent( parent, gIODTPlane);
AddPHandle( child );
if( kSuccess == DTEnterEntry( iter, dtChild)) {
stack->setObject( parent);
parent = child;
}
// only registry holds retain
child->release();
}
} while( stack->getCount()
&& (kSuccess == DTExitEntry( iter, &dtChild)));
stack->release();
DTDisposeEntryIterator( iter);
// parent is now root of the created tree
// make root name first compatible entry (purely cosmetic)
if( (prop = (OSData *) parent->getProperty( gIODTCompatibleKey))) {
parent->setName( parent->getName(), gIODTPlane );
parent->setName( (const char *) prop->getBytesNoCopy() );
}
// attach tree to meta root
parent->attachToParent( IORegistryEntry::getRegistryRoot(), gIODTPlane);
parent->release();
if( freeDT ) {
// free original device tree
DTInit(0);
IODTFreeLoaderInfo( "DeviceTree",
(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 && allInts && gIODTSharedInterrupts );
if( regIter && allInts && gIODTSharedInterrupts ) {
while( (child = regIter->getNextObject())) {
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 );
return( parent);
}
