xnu-1504.9.26.tar.gz

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

diff --git a/iokit/Kernel/IOInterruptController.cpp b/iokit/Kernel/IOInterruptController.cpp
index bd3baa04db7b7bee1065f6d56543537177d2aa28..beedc1a8b6ad8a63fbea67ac7e627206e1123365 100644 (file)
--- a/iokit/Kernel/IOInterruptController.cpp
+++ b/iokit/Kernel/IOInterruptController.cpp
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2008 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@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * Copyright (c) 1999 Apple Computer, Inc.  All rights reserved. 
  */
 /*
  * Copyright (c) 1999 Apple Computer, Inc.  All rights reserved. 


@@ -34,10 +40,10 @@
 #include <IOKit/IOLib.h>
 #include <IOKit/IOService.h>
 #include <IOKit/IOPlatformExpert.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/IOInterrupts.h>
 #include <IOKit/IOInterruptController.h>
 

-

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #define super IOService
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #define super IOService


@@ -59,30 +65,51 @@ 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;
+
+  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.
   IOTakeLock(vector->interruptLock);
   
   vector = &vectors[vectorNumber];
   
   // Get the lock for this vector.
   IOTakeLock(vector->interruptLock);
   

-  // If this vector is already in use, and can be shared,
+  // 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) {
+    IOUnlock(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.
   // register as a shared interrupt.

-  if (vector->interruptRegistered) {
-    if (!vectorCanBeShared(vectorNumber, vector)) {
-      IOUnlock(vector->interruptLock);
-      return kIOReturnNoResources;
-    }
-    
+  if (wasAlreadyRegisterd || shouldBeShared) {

     // If this vector is not already shared, break it out.
     if (vector->sharedController == 0) {
       // Make the IOShareInterruptController instance
     // If this vector is not already shared, break it out.
     if (vector->sharedController == 0) {
       // Make the IOShareInterruptController instance


@@ -92,44 +119,57 @@ IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
         return kIOReturnNoMemory;
       }
       
         return kIOReturnNoMemory;
       }
       

-      // Save the nub and source for the original consumer.
-      originalNub = vector->nub;
-      originalSource = vector->source;
-      
-      // Save the dis/enable state for the original consumer's interrupt.
-      // Then disable the source
-      wasDisabledSoft = vector->interruptDisabledSoft;
-      disableInterrupt(originalNub, originalSource);
+      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.
       
       // Initialize the new shared interrupt controller.

-      error = vector->sharedController->initInterruptController(this,
-                                                                vectorData);
+      error = vector->sharedController->initInterruptController(this, vectorData);

       // If the IOSharedInterruptController could not be initalized,
       // If the IOSharedInterruptController could not be initalized,

-      // put the original consumor's interrupt back to normal and
+      // if needed, put the original consumer's interrupt back to normal and

       // get rid of whats left of the shared controller.
       if (error != kIOReturnSuccess) {
       // get rid of whats left of the shared controller.
       if (error != kIOReturnSuccess) {

-        enableInterrupt(originalNub, originalSource);
+       if (wasAlreadyRegisterd) enableInterrupt(originalNub, originalSource);

         vector->sharedController->release();
         vector->sharedController = 0;
         IOUnlock(vector->interruptLock);
         return error;
       }
       
         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) {
-        enableInterrupt(originalNub, originalSource);
-        vector->sharedController->release();
-        vector->sharedController = 0;
-        IOUnlock(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;
+         IOUnlock(vector->interruptLock);
+         return error;
+       }

       }
       
       // Fill in vector with the shared controller's info.
       }
       
       // Fill in vector with the shared controller's info.


@@ -139,7 +179,21 @@ IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
       vector->target  = vector->sharedController;
       vector->refCon  = 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.
       // Enable the original consumer's interrupt if needed.

+      // originalNub is protected by wasAlreadyRegisterd here (see line 184).

       if (!wasDisabledSoft) originalNub->enableInterrupt(originalSource);
     }
     
       if (!wasDisabledSoft) originalNub->enableInterrupt(originalSource);
     }
     


@@ -171,13 +225,13 @@ IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
 IOReturn IOInterruptController::unregisterInterrupt(IOService *nub, int source)
 {
   IOInterruptSource *interruptSources;
 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.


@@ -214,7 +268,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;
   


@@ -222,7 +276,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);


@@ -233,13 +287,13 @@ 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 = &vectors[vectorNumber];
   
   if (vector->interruptDisabledSoft) {


@@ -250,7 +304,8 @@ IOReturn IOInterruptController::enableInterrupt(IOService *nub, int source)
 #endif
     
     if (!getPlatform()->atInterruptLevel()) {
 #endif
     
     if (!getPlatform()->atInterruptLevel()) {

-      while (vector->interruptActive);
+      while (vector->interruptActive)
+       {}

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


@@ -268,13 +323,13 @@ 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;


@@ -284,7 +339,8 @@ IOReturn IOInterruptController::disableInterrupt(IOService *nub, int source)
 #endif
   
   if (!getPlatform()->atInterruptLevel()) {
 #endif
   
   if (!getPlatform()->atInterruptLevel()) {

-    while (vector->interruptActive);
+    while (vector->interruptActive)
+       {}

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


@@ -296,13 +352,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);


@@ -324,34 +380,34 @@ 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*/)
 {
 }


@@ -371,6 +427,8 @@ OSMetaClassDefineReservedUnused(IOSharedInterruptController, 3);
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 

+#define kIOSharedInterruptControllerDefaultVectors (128)
+

 IOReturn IOSharedInterruptController::initInterruptController(IOInterruptController *parentController, OSData *parentSource)
 {
   int      cnt, interruptType;
 IOReturn IOSharedInterruptController::initInterruptController(IOInterruptController *parentController, OSData *parentSource)
 {
   int      cnt, interruptType;


@@ -388,6 +446,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;
   


@@ -399,7 +459,7 @@ IOReturn IOSharedInterruptController::initInterruptController(IOInterruptControl
   }
   
   // Allocate the memory for the vectors
   }
   
   // Allocate the memory for the vectors

-  numVectors = 8; // For now a constant number.
+  numVectors = kIOSharedInterruptControllerDefaultVectors; // For now a constant number.

   vectors = (IOInterruptVector *)IOMalloc(numVectors * sizeof(IOInterruptVector));
   if (vectors == NULL) {
     IOFree(_interruptSources, sizeof(IOInterruptSource));
   vectors = (IOInterruptVector *)IOMalloc(numVectors * sizeof(IOInterruptVector));
   if (vectors == NULL) {
     IOFree(_interruptSources, sizeof(IOInterruptSource));


@@ -423,6 +483,7 @@ IOReturn IOSharedInterruptController::initInterruptController(IOInterruptControl
     }
   }
   
     }
   }
   

+  numVectors = 0; // reset the high water mark for used vectors

   vectorsRegistered = 0;
   vectorsEnabled = 0;
   controllerDisabled = 1;
   vectorsRegistered = 0;
   vectorsEnabled = 0;
   controllerDisabled = 1;


@@ -437,7 +498,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;


@@ -445,9 +506,9 @@ IOReturn IOSharedInterruptController::registerInterrupt(IOService *nub,
   interruptSources = nub->_interruptSources;
   
   // Find a free vector.
   interruptSources = nub->_interruptSources;
   
   // Find a free vector.

-  vectorNumber = numVectors;
-  while (vectorsRegistered != numVectors) {
-    for (vectorNumber = 0; vectorNumber < numVectors; vectorNumber++) {
+  vectorNumber = kIOSharedInterruptControllerDefaultVectors;
+  while (vectorsRegistered != kIOSharedInterruptControllerDefaultVectors) {
+    for (vectorNumber = 0; vectorNumber < kIOSharedInterruptControllerDefaultVectors; vectorNumber++) {

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


@@ -460,11 +521,11 @@ IOReturn IOSharedInterruptController::registerInterrupt(IOService *nub,
       IOUnlock(vector->interruptLock);
     }
     
       IOUnlock(vector->interruptLock);
     }
     

-    if (vectorNumber != numVectors) break;
+    if (vectorNumber != kIOSharedInterruptControllerDefaultVectors) break;

   }
   
   // Could not find a free one, so give up.
   }
   
   // Could not find a free one, so give up.

-  if (vectorNumber == numVectors) {
+  if (vectorNumber == kIOSharedInterruptControllerDefaultVectors) {

     return kIOReturnNoResources;
   }
   
     return kIOReturnNoResources;
   }
   


@@ -485,12 +546,13 @@ IOReturn IOSharedInterruptController::registerInterrupt(IOService *nub,
   vector->target  = target;
   vector->refCon  = refCon;
   
   vector->target  = target;
   vector->refCon  = refCon;
   

-  // Get the vector ready.  It start soft disabled.
+  // Get the vector ready.  It starts off soft disabled.

   vector->interruptDisabledSoft = 1;
   vector->interruptRegistered   = 1;
   
   interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
   vector->interruptDisabledSoft = 1;
   vector->interruptRegistered   = 1;
   
   interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);

-  vectorsRegistered++;
+  // Move the high water mark if needed
+  if (++vectorsRegistered > numVectors) numVectors = vectorsRegistered;

   IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
   
   IOUnlock(vector->interruptLock);
   IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
   
   IOUnlock(vector->interruptLock);


@@ -500,45 +562,51 @@ IOReturn IOSharedInterruptController::registerInterrupt(IOService *nub,
 IOReturn IOSharedInterruptController::unregisterInterrupt(IOService *nub,
                                                          int source)
 {
 IOReturn IOSharedInterruptController::unregisterInterrupt(IOService *nub,
                                                          int source)
 {

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

   IOInterruptVector *vector;
   IOInterruptVector *vector;

-  OSData            *vectorData;
-  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) {
+  IOInterruptState  interruptState;
+
+  for (vectorNumber = 0; vectorNumber < kIOSharedInterruptControllerDefaultVectors; vectorNumber++) {
+    vector = &vectors[vectorNumber];
+
+    // Get the lock for this vector.
+    IOTakeLock(vector->interruptLock);
+
+    // Return success if it is not already registered
+    if (!vector->interruptRegistered
+     || (vector->nub != nub) || (vector->source != source)) {
+        IOUnlock(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.

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

-    return kIOReturnSuccess;

   }
   }

-  
-  // Soft disable the source.
-  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);
+  }
+

   return kIOReturnSuccess;
 }
 
   return kIOReturnSuccess;
 }
 


@@ -553,14 +621,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);


@@ -585,14 +653,14 @@ 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); 
   vector = &vectors[vectorNumber];
   
   interruptState = IOSimpleLockLockDisableInterrupt(controllerLock); 


@@ -607,7 +675,8 @@ IOReturn IOSharedInterruptController::disableInterrupt(IOService *nub,
   IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
   
   if (!getPlatform()->atInterruptLevel()) {
   IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
   
   if (!getPlatform()->atInterruptLevel()) {

-    while (vector->interruptActive);
+    while (vector->interruptActive)
+       {}

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


@@ -618,14 +687,15 @@ IOReturn IOSharedInterruptController::disableInterrupt(IOService *nub,
 
 IOInterruptAction IOSharedInterruptController::getInterruptHandlerAddress(void)
 {
 
 IOInterruptAction IOSharedInterruptController::getInterruptHandlerAddress(void)
 {

-    return (IOInterruptAction)&IOSharedInterruptController::handleInterrupt;
+    return OSMemberFunctionCast(IOInterruptAction,
+                       this, &IOSharedInterruptController::handleInterrupt);

 }
 
 IOReturn IOSharedInterruptController::handleInterrupt(void * /*refCon*/,
                                                      IOService * nub,
                                                      int /*source*/)
 {
 }
 
 IOReturn IOSharedInterruptController::handleInterrupt(void * /*refCon*/,
                                                      IOService * nub,
                                                      int /*source*/)
 {

-  long              vectorNumber;
+  IOInterruptVectorNumber vectorNumber;

   IOInterruptVector *vector;
   
   for (vectorNumber = 0; vectorNumber < numVectors; vectorNumber++) {
   IOInterruptVector *vector;
   
   for (vectorNumber = 0; vectorNumber < numVectors; vectorNumber++) {