/*
* Copyright (c) 2007-2012 Apple Inc. All rights reserved.
* Copyright (c) 1998-2006 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. 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
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* 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_OSREFERENCE_LICENSE_HEADER_END@
*/
#include <IOKit/IOLib.h>
#include <IOKit/IOService.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/IODeviceTreeSupport.h>
#include <IOKit/IOInterrupts.h>
#include <IOKit/IOInterruptController.h>
#include <IOKit/IOKitDebug.h>
#include <IOKit/IOTimeStamp.h>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define super IOService
OSDefineMetaClassAndAbstractStructors(IOInterruptController, IOService);
OSMetaClassDefineReservedUsedX86(IOInterruptController, 0);
OSMetaClassDefineReservedUsedX86(IOInterruptController, 1);
OSMetaClassDefineReservedUsedX86(IOInterruptController, 2);
OSMetaClassDefineReservedUnused(IOInterruptController, 3);
OSMetaClassDefineReservedUnused(IOInterruptController, 4);
OSMetaClassDefineReservedUnused(IOInterruptController, 5);
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
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 == NULL) {
// Make the IOShareInterruptController instance
vector->sharedController = new IOSharedInterruptController;
if (vector->sharedController == NULL) {
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 = NULL;
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 = NULL;
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 = NULL;
// 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::unregisterInterrupt(IOService *nub, int source)
{
IOInterruptSource *interruptSources;
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
OSData *vectorData;
interruptSources = nub->_interruptSources;
vectorData = interruptSources[source].vectorData;
vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
vector = &vectors[vectorNumber];
// Get the lock for this vector.
IOLockLock(vector->interruptLock);
// Return success if it is not already registered
if (!vector->interruptRegistered) {
IOLockUnlock(vector->interruptLock);
return kIOReturnSuccess;
}
// Soft disable the source.
disableInterrupt(nub, source);
// Turn the source off at hardware.
disableVectorHard(vectorNumber, vector);
// Clear all the storage for the vector except for interruptLock.
vector->interruptActive = 0;
vector->interruptDisabledSoft = 0;
vector->interruptDisabledHard = 0;
vector->interruptRegistered = 0;
vector->nub = NULL;
vector->source = 0;
vector->handler = NULL;
vector->target = NULL;
vector->refCon = NULL;
IOLockUnlock(vector->interruptLock);
return kIOReturnSuccess;
}
IOReturn
IOInterruptController::getInterruptType(IOService *nub, int source,
int *interruptType)
{
IOInterruptSource *interruptSources;
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
OSData *vectorData;
if (interruptType == NULL) {
return kIOReturnBadArgument;
}
interruptSources = nub->_interruptSources;
vectorData = interruptSources[source].vectorData;
vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
vector = &vectors[vectorNumber];
*interruptType = getVectorType(vectorNumber, vector);
return kIOReturnSuccess;
}
IOReturn
IOInterruptController::enableInterrupt(IOService *nub, int source)
{
IOInterruptSource *interruptSources;
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
OSData *vectorData;
interruptSources = nub->_interruptSources;
vectorData = interruptSources[source].vectorData;
vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
vector = &vectors[vectorNumber];
if (vector->interruptDisabledSoft) {
vector->interruptDisabledSoft = 0;
#if !defined(__i386__) && !defined(__x86_64__)
OSMemoryBarrier();
#endif
if (!getPlatform()->atInterruptLevel()) {
while (vector->interruptActive) {
}
}
if (vector->interruptDisabledHard) {
vector->interruptDisabledHard = 0;
// A DSB ISH on ARM is needed to make sure the vector data are
// properly initialized before the MMIO enabling the interrupts
// in hardware. OSMemoryBarrier(), which maps to DMB, is not
// sufficient here as the CPUs are not consumers of the device
// write. Hence, the DMB does not guarantee the CPUs won't see an
// interrupt before it initalizes the vector data properly.
OSSynchronizeIO();
enableVector(vectorNumber, vector);
}
}
return kIOReturnSuccess;
}
IOReturn
IOInterruptController::disableInterrupt(IOService *nub, int source)
{
IOInterruptSource *interruptSources;
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
OSData *vectorData;
interruptSources = nub->_interruptSources;
vectorData = interruptSources[source].vectorData;
vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
vector = &vectors[vectorNumber];
vector->interruptDisabledSoft = 1;
#if !defined(__i386__) && !defined(__x86_64__)
OSMemoryBarrier();
#endif
if (!getPlatform()->atInterruptLevel()) {
while (vector->interruptActive) {
}
}
return kIOReturnSuccess;
}
IOReturn
IOInterruptController::causeInterrupt(IOService *nub, int source)
{
IOInterruptSource *interruptSources;
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
OSData *vectorData;
interruptSources = nub->_interruptSources;
vectorData = interruptSources[source].vectorData;
vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
vector = &vectors[vectorNumber];
causeVector(vectorNumber, vector);
return kIOReturnSuccess;
}
IOInterruptAction
IOInterruptController::getInterruptHandlerAddress(void)
{
return NULL;
}
IOReturn
IOInterruptController::handleInterrupt(void *refCon, IOService *nub,
int source)
{
return kIOReturnInvalid;
}
// Methods to be overridden for simplifed interrupt controller subclasses.
bool
IOInterruptController::vectorCanBeShared(IOInterruptVectorNumber /*vectorNumber*/,
IOInterruptVector */*vector*/)
{
return false;
}
void
IOInterruptController::initVector(IOInterruptVectorNumber /*vectorNumber*/,
IOInterruptVector */*vector*/)
{
}
int
IOInterruptController::getVectorType(IOInterruptVectorNumber /*vectorNumber*/,
IOInterruptVector */*vector*/)
{
return kIOInterruptTypeEdge;
}
void
IOInterruptController::disableVectorHard(IOInterruptVectorNumber /*vectorNumber*/,
IOInterruptVector */*vector*/)
{
}
void
IOInterruptController::enableVector(IOInterruptVectorNumber /*vectorNumber*/,
IOInterruptVector */*vector*/)
{
}
void
IOInterruptController::causeVector(IOInterruptVectorNumber /*vectorNumber*/,
IOInterruptVector */*vector*/)
{
}
void
IOInterruptController::setCPUInterruptProperties(IOService */*service*/)
{
}
void
IOInterruptController::sendIPI(unsigned int /*cpu_id*/, bool /*deferred*/)
{
}
void
IOInterruptController::cancelDeferredIPI(unsigned int /*cpu_id*/)
{
}
void
IOInterruptController::timeStampSpuriousInterrupt(void)
{
uint64_t providerID = 0;
IOService * provider = getProvider();
if (provider) {
providerID = provider->getRegistryEntryID();
}
IOTimeStampConstant(IODBG_INTC(IOINTC_SPURIOUS), providerID);
}
void
IOInterruptController::timeStampInterruptHandlerInternal(bool isStart, IOInterruptVectorNumber vectorNumber, IOInterruptVector *vector)
{
uint64_t providerID = 0;
vm_offset_t unslidHandler = 0;
vm_offset_t unslidTarget = 0;
IOService * provider = getProvider();
if (provider) {
providerID = provider->getRegistryEntryID();
}
if (vector) {
unslidHandler = VM_KERNEL_UNSLIDE((vm_offset_t)vector->handler);
unslidTarget = VM_KERNEL_UNSLIDE_OR_PERM((vm_offset_t)vector->target);
}
if (isStart) {
#if SCHED_HYGIENE_DEBUG
ml_irq_debug_start((uintptr_t)vector->handler, (uintptr_t)vector);
#endif
IOTimeStampStartConstant(IODBG_INTC(IOINTC_HANDLER), (uintptr_t)vectorNumber, (uintptr_t)unslidHandler,
(uintptr_t)unslidTarget, (uintptr_t)providerID);
} else {
IOTimeStampEndConstant(IODBG_INTC(IOINTC_HANDLER), (uintptr_t)vectorNumber, (uintptr_t)unslidHandler,
(uintptr_t)unslidTarget, (uintptr_t)providerID);
#if SCHED_HYGIENE_DEBUG
ml_irq_debug_end();
#endif
}
}
void
IOInterruptController::timeStampInterruptHandlerStart(IOInterruptVectorNumber vectorNumber, IOInterruptVector *vector)
{
timeStampInterruptHandlerInternal(true, vectorNumber, vector);
}
void
IOInterruptController::timeStampInterruptHandlerEnd(IOInterruptVectorNumber vectorNumber, IOInterruptVector *vector)
{
timeStampInterruptHandlerInternal(false, vectorNumber, vector);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#undef super
#define super IOInterruptController
OSDefineMetaClassAndStructors(IOSharedInterruptController, IOInterruptController);
OSMetaClassDefineReservedUnused(IOSharedInterruptController, 0);
OSMetaClassDefineReservedUnused(IOSharedInterruptController, 1);
OSMetaClassDefineReservedUnused(IOSharedInterruptController, 2);
OSMetaClassDefineReservedUnused(IOSharedInterruptController, 3);
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define kIOSharedInterruptControllerDefaultVectors (128)
IOReturn
IOSharedInterruptController::initInterruptController(IOInterruptController *parentController, OSData *parentSource)
{
int cnt, interruptType;
IOReturn error;
if (!super::init()) {
return kIOReturnNoResources;
}
// Set provider to this so enable/disable nub stuff works.
provider = this;
// Allocate the IOInterruptSource so this can act like a nub.
_interruptSources = IONew(IOInterruptSource, 1);
if (_interruptSources == NULL) {
return kIOReturnNoMemory;
}
_numInterruptSources = 1;
// Set up the IOInterruptSource to point at this.
parentController->retain();
parentSource->retain();
_interruptSources[0].interruptController = parentController;
_interruptSources[0].vectorData = parentSource;
sourceIsLevel = false;
error = provider->getInterruptType(0, &interruptType);
if (error == kIOReturnSuccess) {
if (interruptType & kIOInterruptTypeLevel) {
sourceIsLevel = true;
}
}
// Allocate the memory for the vectors
numVectors = kIOSharedInterruptControllerDefaultVectors; // For now a constant number.
vectors = IONewZero(IOInterruptVector, numVectors);
if (vectors == NULL) {
IODelete(_interruptSources, IOInterruptSource, 1);
return kIOReturnNoMemory;
}
// Allocate the lock for the controller.
controllerLock = IOSimpleLockAlloc();
if (controllerLock == NULL) {
return kIOReturnNoResources;
}
// Allocate locks for the vectors.
for (cnt = 0; cnt < numVectors; cnt++) {
vectors[cnt].interruptLock = IOLockAlloc();
if (vectors[cnt].interruptLock == NULL) {
for (cnt = 0; cnt < numVectors; cnt++) {
if (vectors[cnt].interruptLock != NULL) {
IOLockFree(vectors[cnt].interruptLock);
}
}
return kIOReturnNoResources;
}
}
numVectors = 0; // reset the high water mark for used vectors
vectorsRegistered = 0;
vectorsEnabled = 0;
controllerDisabled = 1;
return kIOReturnSuccess;
}
IOReturn
IOSharedInterruptController::registerInterrupt(IOService *nub,
int source,
void *target,
IOInterruptHandler handler,
void *refCon)
{
IOInterruptSource *interruptSources;
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector = NULL;
OSData *vectorData;
IOInterruptState interruptState;
interruptSources = nub->_interruptSources;
// Find a free vector.
vectorNumber = kIOSharedInterruptControllerDefaultVectors;
while (vectorsRegistered != kIOSharedInterruptControllerDefaultVectors) {
for (vectorNumber = 0; vectorNumber < kIOSharedInterruptControllerDefaultVectors; vectorNumber++) {
vector = &vectors[vectorNumber];
// Get the lock for this vector.
IOLockLock(vector->interruptLock);
// Is it unregistered?
if (!vector->interruptRegistered) {
break;
}
// Move along to the next one.
IOLockUnlock(vector->interruptLock);
}
if (vectorNumber != kIOSharedInterruptControllerDefaultVectors) {
break;
}
}
// Could not find a free one, so give up.
if (vectorNumber == kIOSharedInterruptControllerDefaultVectors) {
return kIOReturnNoResources;
}
// Create the vectorData for the IOInterruptSource.
vectorData = OSData::withValue(vectorNumber);
if (vectorData == NULL) {
IOLockUnlock(vector->interruptLock);
return kIOReturnNoMemory;
}
// Fill in the IOInterruptSource with the controller's info.
interruptSources[source].interruptController = this;
interruptSources[source].vectorData = vectorData;
// Fill in vector with the client's info.
vector->handler = handler;
vector->nub = nub;
vector->source = source;
vector->target = target;
vector->refCon = refCon;
// Get the vector ready. It starts off soft disabled.
vector->interruptDisabledSoft = 1;
vector->interruptRegistered = 1;
interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
// Move the high water mark if needed
if (++vectorsRegistered > numVectors) {
numVectors = vectorsRegistered;
}
IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
IOLockUnlock(vector->interruptLock);
return kIOReturnSuccess;
}
IOReturn
IOSharedInterruptController::unregisterInterrupt(IOService *nub,
int source)
{
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
IOInterruptState interruptState;
for (vectorNumber = 0; vectorNumber < kIOSharedInterruptControllerDefaultVectors; vectorNumber++) {
vector = &vectors[vectorNumber];
// Get the lock for this vector.
IOLockLock(vector->interruptLock);
// Return success if it is not already registered
if (!vector->interruptRegistered
|| (vector->nub != nub) || (vector->source != source)) {
IOLockUnlock(vector->interruptLock);
continue;
}
// Soft disable the source and the controller too.
disableInterrupt(nub, source);
// Free vectorData
IOInterruptSource *interruptSources = nub->_interruptSources;
OSSafeReleaseNULL(interruptSources[source].vectorData);
// Clear all the storage for the vector except for interruptLock.
vector->interruptActive = 0;
vector->interruptDisabledSoft = 0;
vector->interruptDisabledHard = 0;
vector->interruptRegistered = 0;
vector->nub = NULL;
vector->source = 0;
vector->handler = NULL;
vector->target = NULL;
vector->refCon = NULL;
interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
vectorsRegistered--;
IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
// Move along to the next one.
IOLockUnlock(vector->interruptLock);
}
// Re-enable the controller if all vectors are enabled.
if (vectorsEnabled == vectorsRegistered) {
controllerDisabled = 0;
provider->enableInterrupt(0);
}
return kIOReturnSuccess;
}
IOReturn
IOSharedInterruptController::getInterruptType(IOService */*nub*/,
int /*source*/,
int *interruptType)
{
return provider->getInterruptType(0, interruptType);
}
IOReturn
IOSharedInterruptController::enableInterrupt(IOService *nub,
int source)
{
IOInterruptSource *interruptSources;
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
OSData *vectorData;
IOInterruptState interruptState;
interruptSources = nub->_interruptSources;
vectorData = interruptSources[source].vectorData;
vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
vector = &vectors[vectorNumber];
interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
if (!vector->interruptDisabledSoft) {
IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
return kIOReturnSuccess;
}
vector->interruptDisabledSoft = 0;
vectorsEnabled++;
IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
if (controllerDisabled && (vectorsEnabled == vectorsRegistered)) {
controllerDisabled = 0;
provider->enableInterrupt(0);
}
return kIOReturnSuccess;
}
IOReturn
IOSharedInterruptController::disableInterrupt(IOService *nub,
int source)
{
IOInterruptSource *interruptSources;
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
OSData *vectorData;
IOInterruptState interruptState;
interruptSources = nub->_interruptSources;
vectorData = interruptSources[source].vectorData;
vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
vector = &vectors[vectorNumber];
interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
if (!vector->interruptDisabledSoft) {
vector->interruptDisabledSoft = 1;
#if !defined(__i386__) && !defined(__x86_64__)
OSMemoryBarrier();
#endif
vectorsEnabled--;
}
IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
if (!getPlatform()->atInterruptLevel()) {
while (vector->interruptActive) {
}
}
return kIOReturnSuccess;
}
IOInterruptAction
IOSharedInterruptController::getInterruptHandlerAddress(void)
{
return OSMemberFunctionCast(IOInterruptAction,
this, &IOSharedInterruptController::handleInterrupt);
}
IOReturn
IOSharedInterruptController::handleInterrupt(void * /*refCon*/,
IOService * nub,
int /*source*/)
{
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
for (vectorNumber = 0; vectorNumber < numVectors; vectorNumber++) {
vector = &vectors[vectorNumber];
vector->interruptActive = 1;
#if !defined(__i386__) && !defined(__x86_64__)
OSMemoryBarrier();
#endif
if (!vector->interruptDisabledSoft) {
// Call the handler if it exists.
if (vector->interruptRegistered) {
bool trace = (gIOKitTrace & kIOTraceInterrupts) ? true : false;
if (trace) {
timeStampInterruptHandlerStart(vectorNumber, vector);
}
// Call handler.
vector->handler(vector->target, vector->refCon, vector->nub, vector->source);
if (trace) {
timeStampInterruptHandlerEnd(vectorNumber, vector);
}
}
}
vector->interruptActive = 0;
}
// if any of the vectors are dissabled, then dissable this controller.
IOSimpleLockLock(controllerLock);
if (vectorsEnabled != vectorsRegistered) {
nub->disableInterrupt(0);
controllerDisabled = 1;
}
IOSimpleLockUnlock(controllerLock);
return kIOReturnSuccess;
}