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; }
IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source, void *target, IOInterruptHandler handler, void *refCon) { IOInterruptSource *interruptSources; long vectorNumber; IOInterruptVector *vector; long wasDisabledSoft; IOReturn error; OSData *vectorData; IOService *originalNub; int originalSource; interruptSources = nub->_interruptSources; vectorData = interruptSources[source].vectorData; vectorNumber = *(long *)vectorData->getBytesNoCopy(); vector = &vectors[vectorNumber]; // Get the lock for this vector. IOTakeLock(vector->interruptLock); // If this vector is already in use, and can be shared, // register as a shared interrupt. if (vector->interruptRegistered) { if (!vectorCanBeShared(vectorNumber, vector)) { IOUnlock(vector->interruptLock); return kIOReturnNoResources; } // 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) { IOUnlock(vector->interruptLock); return kIOReturnNoMemory; } // Save the nub and source for the original consumer. originalNub = vector->nub; originalSource = vector->source; // Physically disable the interrupt, but mark it as being enables 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, // put the original consumor's interrupt back to normal and // get rid of whats left of the shared controller. if (error != kIOReturnSuccess) { enableInterrupt(originalNub, originalSource); vector->sharedController->release(); vector->sharedController = 0; IOUnlock(vector->interruptLock); return error; } // Try to register the original consumer on the shared controller. 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; IOUnlock(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; // 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); } error = vector->sharedController->registerInterrupt(nub, source, target, handler, refCon); IOUnlock(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; IOUnlock(vector->interruptLock); return kIOReturnSuccess; }