xnu-4570.31.3.tar.gz

[apple/xnu.git] / iokit / Kernel / IOInterruptController.cpp

diff --git a/iokit/Kernel/IOInterruptController.cpp b/iokit/Kernel/IOInterruptController.cpp
index 2c8304e333fd73afc7773d2ec93ed23116782401..81f07dcabf6a7a7253743d739e5b576dcb774569 100644 (file)
--- a/iokit/Kernel/IOInterruptController.cpp
+++ b/iokit/Kernel/IOInterruptController.cpp
@@ -1,42 +1,40 @@
 /*
 /*

- * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2007-2012 Apple 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,
  * 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) 1999 Apple Computer, Inc.  All rights reserved. 
- *
- *  DRI: Josh de Cesare
- *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 
  */
 

-
-#if __ppc__
-#include <ppc/proc_reg.h> 
-#endif
-

 #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/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>

 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */


@@ -60,33 +58,44 @@ IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
                                                  void *refCon)
 {
   IOInterruptSource *interruptSources;
                                                  void *refCon)
 {
   IOInterruptSource *interruptSources;

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   IOInterruptVector *vector;

-  long              wasDisabledSoft;
+  int               wasDisabledSoft;

   IOReturn          error;
   OSData            *vectorData;
   IOReturn          error;
   OSData            *vectorData;

-  IOService         *originalNub;
-  int               originalSource;

   IOOptionBits      options;
   bool              canBeShared, shouldBeShared, wasAlreadyRegisterd;
   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;
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;

-  vectorNumber = *(long *)vectorData->getBytesNoCopy();
+  vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();

   vector = &vectors[vectorNumber];
   
   // Get the lock for this vector.
   vector = &vectors[vectorNumber];
   
   // Get the lock for this vector.

-  IOTakeLock(vector->interruptLock);
+  IOLockLock(vector->interruptLock);

   
   // Check if the interrupt source can/should be shared.
   canBeShared = vectorCanBeShared(vectorNumber, vector);
   IODTGetInterruptOptions(nub, source, &options);
   
   // 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) {
   shouldBeShared = canBeShared && (options & kIODTInterruptShared);
   wasAlreadyRegisterd = vector->interruptRegistered;
   
   // If the vector is registered and can not be shared return error.
   if (wasAlreadyRegisterd && !canBeShared) {

-    IOUnlock(vector->interruptLock);
+    IOLockUnlock(vector->interruptLock);

     return kIOReturnNoResources;
   }
   
     return kIOReturnNoResources;
   }
   


@@ -99,7 +108,7 @@ IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
       // Make the IOShareInterruptController instance
       vector->sharedController = new IOSharedInterruptController;
       if (vector->sharedController == 0) {
       // Make the IOShareInterruptController instance
       vector->sharedController = new IOSharedInterruptController;
       if (vector->sharedController == 0) {

-        IOUnlock(vector->interruptLock);
+        IOLockUnlock(vector->interruptLock);

         return kIOReturnNoMemory;
       }
       
         return kIOReturnNoMemory;
       }
       


@@ -123,7 +132,7 @@ IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
        if (wasAlreadyRegisterd) enableInterrupt(originalNub, originalSource);
         vector->sharedController->release();
         vector->sharedController = 0;
        if (wasAlreadyRegisterd) enableInterrupt(originalNub, originalSource);
         vector->sharedController->release();
         vector->sharedController = 0;

-        IOUnlock(vector->interruptLock);
+        IOLockUnlock(vector->interruptLock);

         return error;
       }
       
         return error;
       }
       


@@ -151,7 +160,7 @@ IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
          
          vector->sharedController->release();
          vector->sharedController = 0;
          
          vector->sharedController->release();
          vector->sharedController = 0;

-         IOUnlock(vector->interruptLock);
+         IOLockUnlock(vector->interruptLock);

          return error;
        }
       }
          return error;
        }
       }


@@ -177,12 +186,13 @@ IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
       vector->interruptRegistered   = 1;
       
       // Enable the original consumer's interrupt if needed.
       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);
       if (!wasDisabledSoft) originalNub->enableInterrupt(originalSource);
     }
     
     error = vector->sharedController->registerInterrupt(nub, source, target,
                                                         handler, refCon);

-    IOUnlock(vector->interruptLock);
+    IOLockUnlock(vector->interruptLock);

     return error;
   }
   
     return error;
   }
   


@@ -201,28 +211,28 @@ IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
   vector->interruptDisabledSoft = 1;
   vector->interruptRegistered   = 1;
   
   vector->interruptDisabledSoft = 1;
   vector->interruptRegistered   = 1;
   

-  IOUnlock(vector->interruptLock);
+  IOLockUnlock(vector->interruptLock);

   return kIOReturnSuccess;
 }
 
 IOReturn IOInterruptController::unregisterInterrupt(IOService *nub, int source)
 {
   IOInterruptSource *interruptSources;
   return kIOReturnSuccess;
 }
 
 IOReturn IOInterruptController::unregisterInterrupt(IOService *nub, int source)
 {
   IOInterruptSource *interruptSources;

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   OSData            *vectorData;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;
   IOInterruptVector *vector;
   OSData            *vectorData;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;

-  vectorNumber = *(long *)vectorData->getBytesNoCopy();
+  vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();

   vector = &vectors[vectorNumber];
   
   // Get the lock for this vector.
   vector = &vectors[vectorNumber];
   
   // Get the lock for this vector.

-  IOTakeLock(vector->interruptLock);
+  IOLockLock(vector->interruptLock);

   
   // Return success if it is not already registered
   if (!vector->interruptRegistered) {
   
   // Return success if it is not already registered
   if (!vector->interruptRegistered) {

-    IOUnlock(vector->interruptLock);
+    IOLockUnlock(vector->interruptLock);

     return kIOReturnSuccess;
   }
   
     return kIOReturnSuccess;
   }
   


@@ -243,7 +253,7 @@ IOReturn IOInterruptController::unregisterInterrupt(IOService *nub, int source)
   vector->target = 0;
   vector->refCon = 0;
   
   vector->target = 0;
   vector->refCon = 0;
   

-  IOUnlock(vector->interruptLock);
+  IOLockUnlock(vector->interruptLock);

   return kIOReturnSuccess;
 }
 
   return kIOReturnSuccess;
 }
 


@@ -251,7 +261,7 @@ IOReturn IOInterruptController::getInterruptType(IOService *nub, int source,
                                                 int *interruptType)
 {
   IOInterruptSource *interruptSources;
                                                 int *interruptType)
 {
   IOInterruptSource *interruptSources;

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   OSData            *vectorData;
   
   IOInterruptVector *vector;
   OSData            *vectorData;
   


@@ -259,7 +269,7 @@ IOReturn IOInterruptController::getInterruptType(IOService *nub, int source,
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;

-  vectorNumber = *(long *)vectorData->getBytesNoCopy();
+  vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();

   vector = &vectors[vectorNumber];
   
   *interruptType = getVectorType(vectorNumber, vector);
   vector = &vectors[vectorNumber];
   
   *interruptType = getVectorType(vectorNumber, vector);


@@ -270,27 +280,24 @@ IOReturn IOInterruptController::getInterruptType(IOService *nub, int source,
 IOReturn IOInterruptController::enableInterrupt(IOService *nub, int source)
 {
   IOInterruptSource *interruptSources;
 IOReturn IOInterruptController::enableInterrupt(IOService *nub, int source)
 {
   IOInterruptSource *interruptSources;

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   OSData            *vectorData;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;
   IOInterruptVector *vector;
   OSData            *vectorData;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;

-  vectorNumber = *(long *)vectorData->getBytesNoCopy();
+  vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();

   vector = &vectors[vectorNumber];
   
   if (vector->interruptDisabledSoft) {
     vector->interruptDisabledSoft = 0;
   vector = &vectors[vectorNumber];
   
   if (vector->interruptDisabledSoft) {
     vector->interruptDisabledSoft = 0;

-#if __ppc__
-    sync();
-    isync();
+#if !defined(__i386__) && !defined(__x86_64__)
+    OSMemoryBarrier();

 #endif
 #endif

-    
+

     if (!getPlatform()->atInterruptLevel()) {
     if (!getPlatform()->atInterruptLevel()) {

-      while (vector->interruptActive);
-#if __ppc__
-      isync();
-#endif
+      while (vector->interruptActive)
+       {}

     }
     if (vector->interruptDisabledHard) {
       vector->interruptDisabledHard = 0;
     }
     if (vector->interruptDisabledHard) {
       vector->interruptDisabledHard = 0;


@@ -305,26 +312,23 @@ IOReturn IOInterruptController::enableInterrupt(IOService *nub, int source)
 IOReturn IOInterruptController::disableInterrupt(IOService *nub, int source)
 {
   IOInterruptSource *interruptSources;
 IOReturn IOInterruptController::disableInterrupt(IOService *nub, int source)
 {
   IOInterruptSource *interruptSources;

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   OSData            *vectorData;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;
   IOInterruptVector *vector;
   OSData            *vectorData;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;

-  vectorNumber = *(long *)vectorData->getBytesNoCopy();
+  vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();

   vector = &vectors[vectorNumber];
   
   vector->interruptDisabledSoft = 1;
   vector = &vectors[vectorNumber];
   
   vector->interruptDisabledSoft = 1;

-#if __ppc__
-  sync();
-  isync();
+#if !defined(__i386__) && !defined(__x86_64__)
+  OSMemoryBarrier();

 #endif
   
   if (!getPlatform()->atInterruptLevel()) {
 #endif
   
   if (!getPlatform()->atInterruptLevel()) {

-    while (vector->interruptActive);
-#if __ppc__
-    isync();
-#endif
+    while (vector->interruptActive)
+       {}

   }
   
   return kIOReturnSuccess;
   }
   
   return kIOReturnSuccess;


@@ -333,13 +337,13 @@ IOReturn IOInterruptController::disableInterrupt(IOService *nub, int source)
 IOReturn IOInterruptController::causeInterrupt(IOService *nub, int source)
 {
   IOInterruptSource *interruptSources;
 IOReturn IOInterruptController::causeInterrupt(IOService *nub, int source)
 {
   IOInterruptSource *interruptSources;

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   OSData            *vectorData;
 
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;
   IOInterruptVector *vector;
   OSData            *vectorData;
 
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;

-  vectorNumber = *(long *)vectorData->getBytesNoCopy();
+  vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();

   vector = &vectors[vectorNumber];
   
   causeVector(vectorNumber, vector);
   vector = &vectors[vectorNumber];
   
   causeVector(vectorNumber, vector);


@@ -361,38 +365,86 @@ IOReturn IOInterruptController::handleInterrupt(void *refCon, IOService *nub,
 
 // Methods to be overridden for simplifed interrupt controller subclasses.
 
 
 // Methods to be overridden for simplifed interrupt controller subclasses.
 

-bool IOInterruptController::vectorCanBeShared(long /*vectorNumber*/,
+bool IOInterruptController::vectorCanBeShared(IOInterruptVectorNumber /*vectorNumber*/,

                                              IOInterruptVector */*vector*/)
 {
   return false;
 }
 
                                              IOInterruptVector */*vector*/)
 {
   return false;
 }
 

-void IOInterruptController::initVector(long /*vectorNumber*/,
+void IOInterruptController::initVector(IOInterruptVectorNumber /*vectorNumber*/,

                                       IOInterruptVector */*vector*/)
 {
 }
 
                                       IOInterruptVector */*vector*/)
 {
 }
 

-int IOInterruptController::getVectorType(long /*vectorNumber*/,
+int IOInterruptController::getVectorType(IOInterruptVectorNumber /*vectorNumber*/,

                                          IOInterruptVector */*vector*/)
 {
   return kIOInterruptTypeEdge;
 }
 
                                          IOInterruptVector */*vector*/)
 {
   return kIOInterruptTypeEdge;
 }
 

-void IOInterruptController::disableVectorHard(long /*vectorNumber*/,
+void IOInterruptController::disableVectorHard(IOInterruptVectorNumber /*vectorNumber*/,

                                              IOInterruptVector */*vector*/)
 {
 }
 
                                              IOInterruptVector */*vector*/)
 {
 }
 

-void IOInterruptController::enableVector(long /*vectorNumber*/,
+void IOInterruptController::enableVector(IOInterruptVectorNumber /*vectorNumber*/,

                                         IOInterruptVector */*vector*/)
 {
 }
 
                                         IOInterruptVector */*vector*/)
 {
 }
 

-void IOInterruptController::causeVector(long /*vectorNumber*/,
+void IOInterruptController::causeVector(IOInterruptVectorNumber /*vectorNumber*/,

                                        IOInterruptVector */*vector*/)
 {
 }
 
                                        IOInterruptVector */*vector*/)
 {
 }
 

+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) {
+    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);
+  }
+}
+
+void IOInterruptController::timeStampInterruptHandlerStart(IOInterruptVectorNumber vectorNumber, IOInterruptVector *vector)
+{
+  timeStampInterruptHandlerInternal(true, vectorNumber, vector);
+}
+
+void IOInterruptController::timeStampInterruptHandlerEnd(IOInterruptVectorNumber vectorNumber, IOInterruptVector *vector)
+{
+  timeStampInterruptHandlerInternal(false, vectorNumber, vector);
+}

 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 


@@ -414,6 +466,8 @@ IOReturn IOSharedInterruptController::initInterruptController(IOInterruptControl
 {
   int      cnt, interruptType;
   IOReturn error;
 {
   int      cnt, interruptType;
   IOReturn error;

+
+  reserved = NULL;

   
   if (!super::init())
     return kIOReturnNoResources;
   
   if (!super::init())
     return kIOReturnNoResources;


@@ -427,6 +481,8 @@ IOReturn IOSharedInterruptController::initInterruptController(IOInterruptControl
   _numInterruptSources = 1;
   
   // Set up the IOInterruptSource to point at this.
   _numInterruptSources = 1;
   
   // Set up the IOInterruptSource to point at this.

+  parentController->retain();
+  parentSource->retain();

   _interruptSources[0].interruptController = parentController;
   _interruptSources[0].vectorData = parentSource;
   
   _interruptSources[0].interruptController = parentController;
   _interruptSources[0].vectorData = parentSource;
   


@@ -477,7 +533,7 @@ IOReturn IOSharedInterruptController::registerInterrupt(IOService *nub,
                                                        void *refCon)
 {
   IOInterruptSource *interruptSources;
                                                        void *refCon)
 {
   IOInterruptSource *interruptSources;

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector = 0;
   OSData            *vectorData;
   IOInterruptState  interruptState;
   IOInterruptVector *vector = 0;
   OSData            *vectorData;
   IOInterruptState  interruptState;


@@ -491,13 +547,13 @@ IOReturn IOSharedInterruptController::registerInterrupt(IOService *nub,
       vector = &vectors[vectorNumber];
       
       // Get the lock for this vector.
       vector = &vectors[vectorNumber];
       
       // Get the lock for this vector.

-      IOTakeLock(vector->interruptLock);
+      IOLockLock(vector->interruptLock);

       
       // Is it unregistered?
       if (!vector->interruptRegistered) break;
       
       // Move along to the next one.
       
       // Is it unregistered?
       if (!vector->interruptRegistered) break;
       
       // Move along to the next one.

-      IOUnlock(vector->interruptLock);
+      IOLockUnlock(vector->interruptLock);

     }
     
     if (vectorNumber != kIOSharedInterruptControllerDefaultVectors) break;
     }
     
     if (vectorNumber != kIOSharedInterruptControllerDefaultVectors) break;


@@ -511,6 +567,7 @@ IOReturn IOSharedInterruptController::registerInterrupt(IOService *nub,
   // Create the vectorData for the IOInterruptSource.
   vectorData = OSData::withBytes(&vectorNumber, sizeof(vectorNumber));
   if (vectorData == 0) {
   // Create the vectorData for the IOInterruptSource.
   vectorData = OSData::withBytes(&vectorNumber, sizeof(vectorNumber));
   if (vectorData == 0) {

+    IOLockUnlock(vector->interruptLock);

     return kIOReturnNoMemory;
   }
   
     return kIOReturnNoMemory;
   }
   


@@ -534,59 +591,58 @@ IOReturn IOSharedInterruptController::registerInterrupt(IOService *nub,
   if (++vectorsRegistered > numVectors) numVectors = vectorsRegistered;
   IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
   
   if (++vectorsRegistered > numVectors) numVectors = vectorsRegistered;
   IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
   

-  IOUnlock(vector->interruptLock);
+  IOLockUnlock(vector->interruptLock);

   return kIOReturnSuccess;
 }
 
 IOReturn IOSharedInterruptController::unregisterInterrupt(IOService *nub,
                                                          int source)
 {
   return kIOReturnSuccess;
 }
 
 IOReturn IOSharedInterruptController::unregisterInterrupt(IOService *nub,
                                                          int source)
 {

-  IOInterruptSource *interruptSources;
-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   IOInterruptVector *vector;

-  OSData            *vectorData;

   IOInterruptState  interruptState;
   IOInterruptState  interruptState;

-  
-  interruptSources = nub->_interruptSources;
-  vectorData = interruptSources[source].vectorData;
-  vectorNumber = *(long *)vectorData->getBytesNoCopy();
-  vector = &vectors[vectorNumber];
-  
-  // Get the lock for this vector.
-  IOTakeLock(vector->interruptLock);
-  
-  // Return success if it is not already registered
-  if (!vector->interruptRegistered) {
-    IOUnlock(vector->interruptLock);
-    return kIOReturnSuccess;
+
+  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);
+
+    // Clear all the storage for the vector except for interruptLock.
+    vector->interruptActive = 0;
+    vector->interruptDisabledSoft = 0;
+    vector->interruptDisabledHard = 0;
+    vector->interruptRegistered = 0;
+    vector->nub = 0;
+    vector->source = 0;
+    vector->handler = 0;
+    vector->target = 0;
+    vector->refCon = 0;
+
+    interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
+    vectorsRegistered--;
+    IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
+
+    // Move along to the next one.
+    IOLockUnlock(vector->interruptLock);

   }
   }

-  
-  // Soft disable the source and the controller too.
-  disableInterrupt(nub, source);
-  
-  // Clear all the storage for the vector except for interruptLock.
-  vector->interruptActive = 0;
-  vector->interruptDisabledSoft = 0;
-  vector->interruptDisabledHard = 0;
-  vector->interruptRegistered = 0;
-  vector->nub = 0;
-  vector->source = 0;
-  vector->handler = 0;
-  vector->target = 0;
-  vector->refCon = 0;
-  
-  interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
-  vectorsRegistered--;
-  IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
-  
-  IOUnlock(vector->interruptLock);
-  
+

   // Re-enable the controller if all vectors are enabled.
   if (vectorsEnabled == vectorsRegistered) {
     controllerDisabled = 0;
     provider->enableInterrupt(0);
   }
   // Re-enable the controller if all vectors are enabled.
   if (vectorsEnabled == vectorsRegistered) {
     controllerDisabled = 0;
     provider->enableInterrupt(0);
   }

-  
+

   return kIOReturnSuccess;
 }
 
   return kIOReturnSuccess;
 }
 


@@ -601,14 +657,14 @@ IOReturn IOSharedInterruptController::enableInterrupt(IOService *nub,
                                                      int source)
 {
   IOInterruptSource *interruptSources;
                                                      int source)
 {
   IOInterruptSource *interruptSources;

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   OSData            *vectorData;
   IOInterruptState  interruptState;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;
   IOInterruptVector *vector;
   OSData            *vectorData;
   IOInterruptState  interruptState;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;

-  vectorNumber = *(long *)vectorData->getBytesNoCopy();
+  vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();

   vector = &vectors[vectorNumber];
   
   interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
   vector = &vectors[vectorNumber];
   
   interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);


@@ -633,32 +689,30 @@ IOReturn IOSharedInterruptController::disableInterrupt(IOService *nub,
                                                       int source)
 {
   IOInterruptSource *interruptSources;
                                                       int source)
 {
   IOInterruptSource *interruptSources;

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   OSData            *vectorData;
   IOInterruptState  interruptState;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;
   IOInterruptVector *vector;
   OSData            *vectorData;
   IOInterruptState  interruptState;
   
   interruptSources = nub->_interruptSources;
   vectorData = interruptSources[source].vectorData;

-  vectorNumber = *(long *)vectorData->getBytesNoCopy();
+  vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();

   vector = &vectors[vectorNumber];
   
   interruptState = IOSimpleLockLockDisableInterrupt(controllerLock); 
   if (!vector->interruptDisabledSoft) {
     vector->interruptDisabledSoft = 1;
   vector = &vectors[vectorNumber];
   
   interruptState = IOSimpleLockLockDisableInterrupt(controllerLock); 
   if (!vector->interruptDisabledSoft) {
     vector->interruptDisabledSoft = 1;

-#if __ppc__
-    sync();
-    isync();
+#if !defined(__i386__) && !defined(__x86_64__)
+    OSMemoryBarrier();

 #endif
 #endif

+

     vectorsEnabled--;
   }
   IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
   
   if (!getPlatform()->atInterruptLevel()) {
     vectorsEnabled--;
   }
   IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
   
   if (!getPlatform()->atInterruptLevel()) {

-    while (vector->interruptActive);
-#if __ppc__
-    isync();
-#endif
+    while (vector->interruptActive)
+       {}

   }
   
   return kIOReturnSuccess;
   }
   
   return kIOReturnSuccess;


@@ -674,26 +728,32 @@ IOReturn IOSharedInterruptController::handleInterrupt(void * /*refCon*/,
                                                      IOService * nub,
                                                      int /*source*/)
 {
                                                      IOService * nub,
                                                      int /*source*/)
 {

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   
   for (vectorNumber = 0; vectorNumber < numVectors; vectorNumber++) {
     vector = &vectors[vectorNumber];
     
     vector->interruptActive = 1;
   IOInterruptVector *vector;
   
   for (vectorNumber = 0; vectorNumber < numVectors; vectorNumber++) {
     vector = &vectors[vectorNumber];
     
     vector->interruptActive = 1;

-#if __ppc__
-    sync();
-    isync();
+#if !defined(__i386__) && !defined(__x86_64__)
+    OSMemoryBarrier();

 #endif
 #endif

+

     if (!vector->interruptDisabledSoft) {
     if (!vector->interruptDisabledSoft) {

-#if __ppc__
-      isync();
-#endif
-      
+

       // Call the handler if it exists.
       if (vector->interruptRegistered) {
       // Call the handler if it exists.
       if (vector->interruptRegistered) {

-       vector->handler(vector->target, vector->refCon,
-                       vector->nub, vector->source);
+
+        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);

       }
     }
     
       }
     }