xnu-2050.18.24.tar.gz

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

diff --git a/iokit/Kernel/IODeviceTreeSupport.cpp b/iokit/Kernel/IODeviceTreeSupport.cpp
index 3c75dceb2d8b693a8576a3250812443c7afec551..4ee53e5668203b8e239fc9334f82a16324d215cd 100644 (file)
--- a/iokit/Kernel/IODeviceTreeSupport.cpp
+++ b/iokit/Kernel/IODeviceTreeSupport.cpp
@@ -1,31 +1,29 @@
 /*
 /*

- * Copyright (c) 1998-2000 Apple Computer, 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) 1998 Apple Computer, Inc.  All rights reserved. 
- *
- * HISTORY
- * 23 Nov 98 sdouglas, created from IODeviceTreeBus.m, & MacOS exp mgr.
- * 05 Apr 99 sdouglas, add interrupt mapping.
- *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 
 #include <IOKit/IODeviceTreeSupport.h>
  */
 
 #include <IOKit/IODeviceTreeSupport.h>


@@ -37,13 +35,16 @@
 #include <IOKit/IOLib.h>
 #include <IOKit/IOKitKeys.h>
 
 #include <IOKit/IOLib.h>
 #include <IOKit/IOKitKeys.h>
 

-#include <DeviceTree.h>
+#include <pexpert/device_tree.h>
+
+#include <machine/machine_routines.h>
+

 extern "C" {
 extern "C" {

-       #include <machine/machine_routines.h>
-       void DTInit( void * data );

 
 

-       int IODTGetLoaderInfo( char *key, void **infoAddr, int *infosize );
-       void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize );
+int IODTGetLoaderInfo( const char *key, void **infoAddr, int *infosize );
+void IODTFreeLoaderInfo( const char *key, void *infoAddr, int infoSize );
+int IODTGetDefault(const char *key, void *infoAddr, unsigned int infoSize );
+

 }
 
 #include <IOKit/assert.h>
 }
 
 #include <IOKit/assert.h>


@@ -74,29 +75,29 @@ const OSSymbol *    gIODTInterruptCellKey;
 const OSSymbol *       gIODTInterruptParentKey;
 const OSSymbol *       gIODTNWInterruptMappingKey;
 
 const OSSymbol *       gIODTInterruptParentKey;
 const OSSymbol *       gIODTNWInterruptMappingKey;
 

+OSDictionary   *       gIODTSharedInterrupts;

 
 static IORegistryEntry * MakeReferenceTable( DTEntry dtEntry, bool copy );
 static void AddPHandle( IORegistryEntry * regEntry );
 static void FreePhysicalMemory( vm_offset_t * range );
 
 static IORegistryEntry * MakeReferenceTable( DTEntry dtEntry, bool copy );
 static void AddPHandle( IORegistryEntry * regEntry );
 static void FreePhysicalMemory( vm_offset_t * range );

+static bool IODTMapInterruptsSharing( IORegistryEntry * regEntry, OSDictionary * allInts );

 
 IORegistryEntry *
 IODeviceTreeAlloc( void * dtTop )
 {
 
 IORegistryEntry *
 IODeviceTreeAlloc( void * dtTop )
 {

-    IORegistryEntry    *parent;
-    IORegistryEntry            *child;
-    IORegistryIterator *regIter;
+    IORegistryEntry *          parent;
+    IORegistryEntry *          child;
+    IORegistryIterator *       regIter;

     DTEntryIterator            iter;
     DTEntryIterator            iter;

-    DTEntry                            dtChild;
-    DTEntry                            mapEntry;
-    OSArray                            *stack;
-    OSData                             *prop;
-    OSObject                   *obj;
-    vm_offset_t                        *dtMap;
-    int                                        propSize;
-    bool                               intMap;
-    bool                               freeDT;
-
-    IOLog("IODeviceTreeSupport ");
+    DTEntry                    dtChild;
+    DTEntry                    mapEntry;
+    OSArray *                  stack;
+    OSData *                   prop;
+    OSDictionary *             allInts;
+    vm_offset_t *              dtMap;
+    unsigned int               propSize;
+    bool                       intMap;
+    bool                       freeDT;

 
     gIODTPlane = IORegistryEntry::makePlane( kIODeviceTreePlane );
 
 
     gIODTPlane = IORegistryEntry::makePlane( kIODeviceTreePlane );
 


@@ -144,16 +145,16 @@ IODeviceTreeAlloc( void * dtTop )
     freeDT = (kSuccess == DTLookupEntry( 0, "/chosen/memory-map", &mapEntry ))
          && (kSuccess == DTGetProperty( mapEntry,
                 "DeviceTree", (void **) &dtMap, &propSize ))
     freeDT = (kSuccess == DTLookupEntry( 0, "/chosen/memory-map", &mapEntry ))
          && (kSuccess == DTGetProperty( mapEntry,
                 "DeviceTree", (void **) &dtMap, &propSize ))

-         && ((2 * sizeof( vm_offset_t)) == propSize);
+         && ((2 * sizeof(uint32_t)) == propSize);

 
     parent = MakeReferenceTable( (DTEntry)dtTop, freeDT );
 
 
     parent = MakeReferenceTable( (DTEntry)dtTop, freeDT );
 

-    stack = OSArray::withObjects( & (const OSObject *) parent, 1, 10 );
+    stack = OSArray::withObjects( (const OSObject **) &parent, 1, 10 );

     DTCreateEntryIterator( (DTEntry)dtTop, &iter );
 
     do {
         parent = (IORegistryEntry *)stack->getObject( stack->getCount() - 1);
     DTCreateEntryIterator( (DTEntry)dtTop, &iter );
 
     do {
         parent = (IORegistryEntry *)stack->getObject( stack->getCount() - 1);

-               //parent->release();
+        //parent->release();

         stack->removeObject( stack->getCount() - 1);
 
         while( kSuccess == DTIterateEntries( iter, &dtChild) ) {
         stack->removeObject( stack->getCount() - 1);
 
         while( kSuccess == DTIterateEntries( iter, &dtChild) ) {


@@ -161,14 +162,14 @@ IODeviceTreeAlloc( void * dtTop )
             child = MakeReferenceTable( dtChild, freeDT );
             child->attachToParent( parent, gIODTPlane);
 
             child = MakeReferenceTable( dtChild, freeDT );
             child->attachToParent( parent, gIODTPlane);
 

-                       AddPHandle( child );
+            AddPHandle( child );

 
             if( kSuccess == DTEnterEntry( iter, dtChild)) {
                 stack->setObject( parent);
                 parent = child;
             }
 
             if( kSuccess == DTEnterEntry( iter, dtChild)) {
                 stack->setObject( parent);
                 parent = child;
             }

-               // only registry holds retain
-               child->release();
+            // only registry holds retain
+            child->release();

         }
 
     } while( stack->getCount()
         }
 
     } while( stack->getCount()


@@ -181,8 +182,8 @@ IODeviceTreeAlloc( void * dtTop )
 
     // make root name first compatible entry (purely cosmetic)
     if( (prop = (OSData *) parent->getProperty( gIODTCompatibleKey))) {
 
     // make root name first compatible entry (purely cosmetic)
     if( (prop = (OSData *) parent->getProperty( gIODTCompatibleKey))) {

-               parent->setName( parent->getName(), gIODTPlane );
-               parent->setName( (const char *) prop->getBytesNoCopy() );
+        parent->setName( parent->getName(), gIODTPlane );
+        parent->setName( (const char *) prop->getBytesNoCopy() );

     }
 
     // attach tree to meta root
     }
 
     // attach tree to meta root


@@ -190,55 +191,63 @@ IODeviceTreeAlloc( void * dtTop )
     parent->release();
 
     if( freeDT ) {
     parent->release();
 
     if( freeDT ) {

-               // free original device tree
+        // free original device tree

         DTInit(0);
         IODTFreeLoaderInfo( "DeviceTree",
         DTInit(0);
         IODTFreeLoaderInfo( "DeviceTree",

-                       (void *)dtMap[0], round_page(dtMap[1]) );
+                           (void *)dtMap[0], (int) round_page(dtMap[1]) );

     }
 
     // adjust tree
     }
 
     // adjust tree

+
+    gIODTSharedInterrupts = OSDictionary::withCapacity(4);
+    allInts = OSDictionary::withCapacity(4);

     intMap = false;
     regIter = IORegistryIterator::iterateOver( gIODTPlane,
                                                kIORegistryIterateRecursively );
     intMap = false;
     regIter = IORegistryIterator::iterateOver( gIODTPlane,
                                                kIORegistryIterateRecursively );

-    assert( regIter );
-    if( regIter) {
-               while( (child = regIter->getNextObject())) {
-                       IODTMapInterrupts( child );
-                       if( !intMap && child->getProperty( gIODTInterruptParentKey))
-                               intMap = true;
-       
-                       // Look for a "driver,AAPL,MacOSX,PowerPC" property.
-                       if( (obj = child->getProperty( "driver,AAPL,MacOSX,PowerPC"))) {
-                               gIOCatalogue->addExtensionsFromArchive((OSData *)obj);
-       
-                               child->removeProperty( "driver,AAPL,MacOSX,PowerPC");
-                       }
-       
-                       // some gross pruning
-                       child->removeProperty( "lanLib,AAPL,MacOS,PowerPC");
-       
-                       if( (obj = child->getProperty( "driver,AAPL,MacOS,PowerPC"))) {
-       
-                               if( (0 == (prop = (OSData *)child->getProperty( gIODTTypeKey )))
-                                       || (strcmp( "display", (char *) prop->getBytesNoCopy())) ) {
-                                       child->removeProperty( "driver,AAPL,MacOS,PowerPC");
-                               }
-                       }
-               }
-               regIter->release();
+    assert( regIter && allInts && gIODTSharedInterrupts );
+    if( regIter && allInts && gIODTSharedInterrupts ) {
+        while( (child = regIter->getNextObject())) {
+            IODTMapInterruptsSharing( child, allInts );
+            if( !intMap && child->getProperty( gIODTInterruptParentKey))
+                intMap = true;
+
+        }
+        regIter->release();

     }
 
     }
 

-    if( intMap)
-               // set a key in the root to indicate we found NW interrupt mapping
-               parent->setProperty( gIODTNWInterruptMappingKey,
-                       (OSObject *) gIODTNWInterruptMappingKey );
+#if IODTSUPPORTDEBUG
+    parent->setProperty("allInts", allInts);
+    parent->setProperty("sharedInts", gIODTSharedInterrupts);
+
+    regIter = IORegistryIterator::iterateOver( gIODTPlane,
+                                               kIORegistryIterateRecursively );
+    if (regIter) {
+        while( (child = regIter->getNextObject())) {
+           OSArray *
+           array = OSDynamicCast(OSArray, child->getProperty( gIOInterruptSpecifiersKey ));
+           for( UInt32 i = 0; array && (i < array->getCount()); i++)
+           {
+               IOOptionBits options;
+               IOReturn ret = IODTGetInterruptOptions( child, i, &options );
+               if( (ret != kIOReturnSuccess) || options)
+                   IOLog("%s[%ld] %ld (%x)\n", child->getName(), i, options, ret);
+           }
+       }
+        regIter->release();
+    }
+#endif

 
 

-    IOLog("done\n");
+    allInts->release();
+
+    if( intMap)
+        // set a key in the root to indicate we found NW interrupt mapping
+        parent->setProperty( gIODTNWInterruptMappingKey,
+                (OSObject *) gIODTNWInterruptMappingKey );

 
     return( parent);
 }
 
 
     return( parent);
 }
 

-int IODTGetLoaderInfo( char *key, void **infoAddr, int *infoSize )
+int IODTGetLoaderInfo( const char *key, void **infoAddr, int *infoSize )

 {
     IORegistryEntry            *chosen;
     OSData                             *propObj;
 {
     IORegistryEntry            *chosen;
     OSData                             *propObj;


@@ -263,7 +272,7 @@ int IODTGetLoaderInfo( char *key, void **infoAddr, int *infoSize )
     return 0;
 }
 
     return 0;
 }
 

-void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize )
+void IODTFreeLoaderInfo( const char *key, void *infoAddr, int infoSize )

 {
     vm_offset_t                        range[2];
     IORegistryEntry            *chosen;
 {
     vm_offset_t                        range[2];
     IORegistryEntry            *chosen;


@@ -280,6 +289,26 @@ void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize )
     }
 }
 
     }
 }
 

+int IODTGetDefault(const char *key, void *infoAddr, unsigned int infoSize )
+{
+    IORegistryEntry            *defaults;
+    OSData                     *defaultObj;
+    unsigned int               defaultSize;
+
+    defaults = IORegistryEntry::fromPath( "/defaults", gIODTPlane );
+    if ( defaults == 0 ) return -1;
+
+    defaultObj = OSDynamicCast( OSData, defaults->getProperty(key) );
+    if ( defaultObj == 0 ) return -1;
+
+    defaultSize = defaultObj->getLength();
+    if ( defaultSize > infoSize) return -1;
+
+    memcpy( infoAddr, defaultObj->getBytesNoCopy(), defaultSize );
+
+    return 0;
+}
+

 static void FreePhysicalMemory( vm_offset_t * range )
 {
     vm_offset_t        virt;
 static void FreePhysicalMemory( vm_offset_t * range )
 {
     vm_offset_t        virt;


@@ -300,7 +329,7 @@ MakeReferenceTable( DTEntry dtEntry, bool copy )
     const OSSymbol             *sym;
     DTPropertyIterator dtIter;
     void                               *prop;
     const OSSymbol             *sym;
     DTPropertyIterator dtIter;
     void                               *prop;

-    int                                        propSize;
+    unsigned int               propSize;

     char                               *name;
     char                               location[ 32 ];
     bool                               noLocation = true;
     char                               *name;
     char                               location[ 32 ];
     bool                               noLocation = true;


@@ -308,57 +337,58 @@ MakeReferenceTable( DTEntry dtEntry, bool copy )
     regEntry = new IOService;
 
     if( regEntry && (false == regEntry->init())) {
     regEntry = new IOService;
 
     if( regEntry && (false == regEntry->init())) {

-               regEntry->release();
-               regEntry = 0;
+        regEntry->release();
+        regEntry = 0;

     }
 
     if( regEntry &&
     }
 
     if( regEntry &&

-               (kSuccess == DTCreatePropertyIterator( dtEntry, &dtIter))) {
+      (kSuccess == DTCreatePropertyIterator( dtEntry, &dtIter))) {

 
         propTable = regEntry->getPropertyTable();
 
 
         propTable = regEntry->getPropertyTable();
 

-               while( kSuccess == DTIterateProperties( dtIter, &name)) {
-       
-                       if(  kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize ))
-                               continue;
-       
-                       if( copy) {
-                               nameKey = OSSymbol::withCString(name);
-                               data = OSData::withBytes(prop, propSize);
-                       } else {
-                               nameKey = OSSymbol::withCStringNoCopy(name);
-                               data = OSData::withBytesNoCopy(prop, propSize);
-                       }
-                       assert( nameKey && data );
-       
-                       propTable->setObject( nameKey, data);
-                       data->release();
-                       nameKey->release();
-       
-                       if( nameKey == gIODTNameKey ) {
-                               if( copy)
-                                       sym = OSSymbol::withCString( (const char *) prop);
-                               else
-                                       sym = OSSymbol::withCStringNoCopy( (const char *) prop);
-                               regEntry->setName( sym );
-                               sym->release();
-                       } else if( nameKey == gIODTUnitKey ) {
-                               // all OF strings are null terminated... except this one
-                               if( propSize >= (int) sizeof( location))
-                                       propSize = sizeof( location) - 1;
-                               strncpy( location, (const char *) prop, propSize );
-                               location[ propSize ] = 0;
-                               regEntry->setLocation( location );
-                               propTable->removeObject( gIODTUnitKey );
-                               noLocation = false;
-               
-                       } else if( noLocation && (0 == strcmp( name, "reg"))) {
-                               // default location - override later
-                               sprintf( location, "%lX", *((UInt32 *) prop) );
-                               regEntry->setLocation( location );
-                       }
-               }
-               DTDisposePropertyIterator( dtIter);
+        while( kSuccess == DTIterateProperties( dtIter, &name)) {
+
+            if(  kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize ))
+                continue;
+
+            if( copy) {
+                nameKey = OSSymbol::withCString(name);
+                data = OSData::withBytes(prop, propSize);
+            } else {
+                nameKey = OSSymbol::withCStringNoCopy(name);
+                data = OSData::withBytesNoCopy(prop, propSize);
+            }
+            assert( nameKey && data );
+
+            propTable->setObject( nameKey, data);
+            data->release();
+            nameKey->release();
+
+            if( nameKey == gIODTNameKey ) {
+                if( copy)
+                    sym = OSSymbol::withCString( (const char *) prop);
+                else
+                    sym = OSSymbol::withCStringNoCopy( (const char *) prop);
+                regEntry->setName( sym );
+                sym->release();
+
+            } else if( nameKey == gIODTUnitKey ) {
+                // all OF strings are null terminated... except this one
+                if( propSize >= (int) sizeof(location))
+                    propSize = sizeof(location) - 1;
+                strncpy( location, (const char *) prop, propSize );
+                location[ propSize ] = 0;
+                regEntry->setLocation( location );
+                propTable->removeObject( gIODTUnitKey );
+                noLocation = false;
+    
+            } else if(noLocation && (!strncmp(name, "reg", sizeof("reg")))) {
+                // default location - override later
+                snprintf(location, sizeof(location), "%X", *((uint32_t *) prop));
+                regEntry->setLocation( location );
+            }
+        }
+        DTDisposePropertyIterator( dtIter);

     }
 
     return( regEntry);
     }
 
     return( regEntry);


@@ -369,10 +399,10 @@ static void AddPHandle( IORegistryEntry * regEntry )
     OSData *   data;
 
     if( regEntry->getProperty( gIODTInterruptCellKey)
     OSData *   data;
 
     if( regEntry->getProperty( gIODTInterruptCellKey)

-       && (data = OSDynamicCast( OSData, regEntry->getProperty( gIODTPHandleKey )))) {
-               // a possible interrupt-parent
-               gIODTPHandles->setObject( data );
-               gIODTPHandleMap->setObject( regEntry );
+      && (data = OSDynamicCast( OSData, regEntry->getProperty( gIODTPHandleKey )))) {
+        // a possible interrupt-parent
+        gIODTPHandles->setObject( data );
+        gIODTPHandleMap->setObject( regEntry );

     }
 }
 
     }
 }
 


@@ -383,10 +413,10 @@ static IORegistryEntry * FindPHandle( UInt32 phandle )
     int                                i;
 
     for( i = 0; (data = (OSData *)gIODTPHandles->getObject( i )); i++ ) {
     int                                i;
 
     for( i = 0; (data = (OSData *)gIODTPHandles->getObject( i )); i++ ) {

-               if( phandle == *((UInt32 *)data->getBytesNoCopy())) {
-                       regEntry = (IORegistryEntry *)
-                       gIODTPHandleMap->getObject( i );
-                       break;
+        if( phandle == *((UInt32 *)data->getBytesNoCopy())) {
+            regEntry = (IORegistryEntry *)
+            gIODTPHandleMap->getObject( i );
+            break;

         }
     }
 
         }
     }
 


@@ -399,25 +429,31 @@ static bool GetUInt32( IORegistryEntry * regEntry, const OSSymbol * name,
     OSData     *data;
 
     if( (data = OSDynamicCast( OSData, regEntry->getProperty( name )))
     OSData     *data;
 
     if( (data = OSDynamicCast( OSData, regEntry->getProperty( name )))

-               && (4 == data->getLength())) {
+      && (4 == data->getLength())) {

         *value = *((UInt32 *) data->getBytesNoCopy());
         *value = *((UInt32 *) data->getBytesNoCopy());

-               return( true );
+        return( true );

     } else
     } else

-               return( false );
+        return( false );

 }
 
 }
 

-IORegistryEntry * IODTFindInterruptParent( IORegistryEntry * regEntry )
+static IORegistryEntry * IODTFindInterruptParent( IORegistryEntry * regEntry, IOItemCount index )

 {
     IORegistryEntry *  parent;
     UInt32             phandle;
 {
     IORegistryEntry *  parent;
     UInt32             phandle;

-
-    if( GetUInt32( regEntry, gIODTInterruptParentKey, &phandle))
-               parent = FindPHandle( phandle );
-
-    else if( 0 == regEntry->getProperty( "interrupt-controller"))
-               parent = regEntry->getParentEntry( gIODTPlane);
+    OSData         *   data;
+    unsigned int       len;
+
+    if( (data = OSDynamicCast( OSData, regEntry->getProperty( gIODTInterruptParentKey )))
+      && (sizeof(UInt32) <= (len = data->getLength()))) {
+       if (((index + 1) * sizeof(UInt32)) > len)
+           index = 0;
+       phandle = ((UInt32 *) data->getBytesNoCopy())[index];
+       parent = FindPHandle( phandle );
+
+    } else if( 0 == regEntry->getProperty( "interrupt-controller"))
+        parent = regEntry->getParentEntry( gIODTPlane);

     else
     else

-               parent = 0;
+        parent = 0;

 
     return( parent );
 }
 
     return( parent );
 }


@@ -425,18 +461,18 @@ IORegistryEntry * IODTFindInterruptParent( IORegistryEntry * regEntry )
 const OSSymbol * IODTInterruptControllerName( IORegistryEntry * regEntry )
 {
     const OSSymbol     *sym;
 const OSSymbol * IODTInterruptControllerName( IORegistryEntry * regEntry )
 {
     const OSSymbol     *sym;

-    UInt32                     phandle;
-    bool                       ok;
-    char                       buf[48];
+    UInt32             phandle;
+    bool               ok;
+    char               buf[48];

 
     ok = GetUInt32( regEntry, gIODTPHandleKey, &phandle);
     assert( ok );
 
     if( ok) {
 
     ok = GetUInt32( regEntry, gIODTPHandleKey, &phandle);
     assert( ok );
 
     if( ok) {

-        sprintf( buf, "IOInterruptController%08lX", phandle);
+        snprintf(buf, sizeof(buf), "IOInterruptController%08X", (uint32_t)phandle);

         sym = OSSymbol::withCString( buf );
     } else
         sym = OSSymbol::withCString( buf );
     } else

-               sym = 0;
+        sym = 0;

 
     return( sym );
 }
 
     return( sym );
 }


@@ -452,8 +488,8 @@ static void IODTGetICellCounts( IORegistryEntry * regEntry,
         *aCellCount = 0;
 }
 
         *aCellCount = 0;
 }
 

-UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec,
-                               OSData ** spec, const OSSymbol ** controller )
+static UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec, UInt32 index,
+                                   OSData ** spec, const OSSymbol ** controller )

 {
     IORegistryEntry *parent = 0;
     OSData                     *data;
 {
     IORegistryEntry *parent = 0;
     OSData                     *data;


@@ -465,77 +501,76 @@ UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec,
     UInt32                     i, original_icells;
     bool                       cmp, ok = false;
 
     UInt32                     i, original_icells;
     bool                       cmp, ok = false;
 

-
-    parent = IODTFindInterruptParent( regEntry );    
+    parent = IODTFindInterruptParent( regEntry, index );    

     IODTGetICellCounts( parent, &icells, &acells );
     addrCmp = 0;
     if( acells) {
     IODTGetICellCounts( parent, &icells, &acells );
     addrCmp = 0;
     if( acells) {

-               data = OSDynamicCast( OSData, regEntry->getProperty( "reg" ));
-               if( data && (data->getLength() >= (acells * sizeof( UInt32))))
-               addrCmp = (UInt32 *) data->getBytesNoCopy();
+        data = OSDynamicCast( OSData, regEntry->getProperty( "reg" ));
+        if( data && (data->getLength() >= (acells * sizeof(UInt32))))
+            addrCmp = (UInt32 *) data->getBytesNoCopy();

     }
     original_icells = icells;
     regEntry = parent;
     
     }
     original_icells = icells;
     regEntry = parent;
     

-       do {
+    do {

 #if IODTSUPPORTDEBUG
 #if IODTSUPPORTDEBUG

-               kprintf ("IODTMapOneInterrupt: current regEntry name %s\n", regEntry->getName());
-               kprintf ("acells - icells: ");
-               for (i = 0; i < acells; i++) kprintf ("0x%08X ", addrCmp[i]);
-               kprintf ("- ");
-               for (i = 0; i < icells; i++) kprintf ("0x%08X ", intSpec[i]);
-               kprintf ("\n");
+        kprintf ("IODTMapOneInterrupt: current regEntry name %s\n", regEntry->getName());
+        kprintf ("acells - icells: ");
+        for (i = 0; i < acells; i++) kprintf ("0x%08X ", addrCmp[i]);
+        kprintf ("- ");
+        for (i = 0; i < icells; i++) kprintf ("0x%08X ", intSpec[i]);
+        kprintf ("\n");

 #endif
 
 #endif
 

-               if( parent && (data = OSDynamicCast( OSData,
-                       regEntry->getProperty( "interrupt-controller")))) {
-               // found a controller - don't want to follow cascaded controllers
+        if( parent && (data = OSDynamicCast( OSData,
+            regEntry->getProperty( "interrupt-controller")))) {
+            // found a controller - don't want to follow cascaded controllers

             parent = 0;
             *spec = OSData::withBytesNoCopy( (void *) intSpec,
             parent = 0;
             *spec = OSData::withBytesNoCopy( (void *) intSpec,

-                                            icells * sizeof( UInt32));
+                                            icells * sizeof(UInt32));

             *controller = IODTInterruptControllerName( regEntry );
             *controller = IODTInterruptControllerName( regEntry );

-               ok = (*spec && *controller);
-               } else if( parent && (data = OSDynamicCast( OSData,
-                       regEntry->getProperty( "interrupt-map")))) {
+            ok = (*spec && *controller);
+        } else if( parent && (data = OSDynamicCast( OSData,
+                    regEntry->getProperty( "interrupt-map")))) {

             // interrupt-map
             map = (UInt32 *) data->getBytesNoCopy();
             endMap = map + (data->getLength() / sizeof(UInt32));
             data = OSDynamicCast( OSData, regEntry->getProperty( "interrupt-map-mask" ));
             // interrupt-map
             map = (UInt32 *) data->getBytesNoCopy();
             endMap = map + (data->getLength() / sizeof(UInt32));
             data = OSDynamicCast( OSData, regEntry->getProperty( "interrupt-map-mask" ));

-            if( data && (data->getLength() >= ((acells + icells) * sizeof( UInt32))))
+            if( data && (data->getLength() >= ((acells + icells) * sizeof(UInt32))))

                 maskCmp = (UInt32 *) data->getBytesNoCopy();
                 maskCmp = (UInt32 *) data->getBytesNoCopy();

-                       else
-                               maskCmp = 0;
+            else
+                maskCmp = 0;

 
 #if IODTSUPPORTDEBUG
 
 #if IODTSUPPORTDEBUG

-                       if (maskCmp) {
-                               kprintf ("        maskCmp: ");
-                               for (i = 0; i < acells + icells; i++) {
-                                       if (i == acells)
-                                               kprintf ("- ");
-                                       kprintf ("0x%08X ", maskCmp[i]);
-                               }
-                               kprintf ("\n");
-                               kprintf ("         masked: ");
-                               for (i = 0; i < acells + icells; i++) {
-                                       if (i == acells)
-                                               kprintf ("- ");
-                                       kprintf ("0x%08X ", ((i < acells) ? addrCmp[i] : intSpec[i-acells]) & maskCmp[i]);
-                               }
-                               kprintf ("\n");
-                       } else
-                               kprintf ("no maskCmp\n");
+            if (maskCmp) {
+                kprintf ("        maskCmp: ");
+                for (i = 0; i < acells + icells; i++) {
+                    if (i == acells)
+                        kprintf ("- ");
+                    kprintf ("0x%08X ", maskCmp[i]);
+                }
+                kprintf ("\n");
+                kprintf ("         masked: ");
+                for (i = 0; i < acells + icells; i++) {
+                    if (i == acells)
+                        kprintf ("- ");
+                    kprintf ("0x%08X ", ((i < acells) ? addrCmp[i] : intSpec[i-acells]) & maskCmp[i]);
+                }
+                kprintf ("\n");
+            } else
+                kprintf ("no maskCmp\n");

 #endif
 #endif

-                       do {
+            do {

 #if IODTSUPPORTDEBUG
 #if IODTSUPPORTDEBUG

-                               kprintf ("            map: ");
-                               for (i = 0; i < acells + icells; i++) {
-                                       if (i == acells)
-                                               kprintf ("- ");
-                                       kprintf ("0x%08X ", map[i]);
-                               }
-                               kprintf ("\n");
+                kprintf ("            map: ");
+                for (i = 0; i < acells + icells; i++) {
+                    if (i == acells)
+                        kprintf ("- ");
+                    kprintf ("0x%08X ", map[i]);
+                }
+                kprintf ("\n");

 #endif
 #endif

-                               for( i = 0, cmp = true; cmp && (i < (acells + icells)); i++) {
+                for( i = 0, cmp = true; cmp && (i < (acells + icells)); i++) {

                     cell = (i < acells) ? addrCmp[i] : intSpec[ i - acells ];
                     if( maskCmp)
                         cell &= maskCmp[i];
                     cell = (i < acells) ? addrCmp[i] : intSpec[ i - acells ];
                     if( maskCmp)
                         cell &= maskCmp[i];


@@ -546,59 +581,100 @@ UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec,
                 if( 0 == (parent = FindPHandle( *(map++) )))
                     unexpected(break);
 
                 if( 0 == (parent = FindPHandle( *(map++) )))
                     unexpected(break);
 

-                               IODTGetICellCounts( parent, &picells, &pacells );
+                IODTGetICellCounts( parent, &picells, &pacells );

                 if( cmp) {
                     addrCmp = map;
                     intSpec = map + pacells;
                     regEntry = parent;
                 if( cmp) {
                     addrCmp = map;
                     intSpec = map + pacells;
                     regEntry = parent;

-                               } else {
+                } else {

                     map += pacells + picells;
                     map += pacells + picells;

-                               }
+                }

             } while( !cmp && (map < endMap) );
             if (!cmp)
             } while( !cmp && (map < endMap) );
             if (!cmp)

-               parent = 0;
-               } 
+                parent = 0;
+        } 

 
 

-               if( parent) {
+        if( parent) {

             IODTGetICellCounts( parent, &icells, &acells );
             IODTGetICellCounts( parent, &icells, &acells );

-               regEntry = parent;
-               }
-       } while( parent);
+            regEntry = parent;
+        }
+
+    } while( parent);

 
     return( ok ? original_icells : 0 );
 }
 
 
     return( ok ? original_icells : 0 );
 }
 

-bool IODTMapInterrupts( IORegistryEntry * regEntry )
+IOReturn IODTGetInterruptOptions( IORegistryEntry * regEntry, int source, IOOptionBits * options )

 {
 {

-    IORegistryEntry *parent;
-    OSData                     *local;
-    OSData                     *local2;
-    UInt32                     *localBits;
-    UInt32                     *localEnd;
-    OSData                     *map;
-    OSArray                    *mapped;
-    const OSSymbol     *controller;
-    OSArray                    *controllers;
-    UInt32                     skip = 1;
-    bool                       ok, nw;
+    OSArray *  controllers;
+    OSArray *  specifiers;
+    OSArray *  shared;
+    OSObject * spec;
+    OSObject * oneSpec;
+
+    *options = 0;
+
+    controllers = OSDynamicCast(OSArray, regEntry->getProperty(gIOInterruptControllersKey));
+    specifiers  = OSDynamicCast(OSArray, regEntry->getProperty(gIOInterruptSpecifiersKey));
+
+    if( !controllers || !specifiers)
+        return (kIOReturnNoInterrupt);
+    
+    shared = (OSArray *) gIODTSharedInterrupts->getObject(
+                        (const OSSymbol *) controllers->getObject(source) );
+    if (!shared)
+        return (kIOReturnSuccess);
+
+    spec = specifiers->getObject(source);
+    if (!spec)
+        return (kIOReturnNoInterrupt);
+
+    for (unsigned int i = 0;
+            (oneSpec = shared->getObject(i))
+            && (!oneSpec->isEqualTo(spec));
+            i++ )      {}
+
+    if (oneSpec)
+        *options = kIODTInterruptShared;
+
+    return (kIOReturnSuccess);
+}
+
+static bool IODTMapInterruptsSharing( IORegistryEntry * regEntry, OSDictionary * allInts )
+{
+    IORegistryEntry *  parent;
+    OSData *           local;
+    OSData *           local2;
+    UInt32 *           localBits;
+    UInt32 *           localEnd;
+    IOItemCount                index;
+    OSData *           map;
+    OSObject *         oneMap;
+    OSArray *          mapped;
+    OSArray *          controllerInts;
+    const OSSymbol *   controller = 0;
+    OSArray *          controllers;
+    UInt32             skip = 1;
+    bool               ok, nw;

 
     nw = (0 == (local = OSDynamicCast( OSData,
 
     nw = (0 == (local = OSDynamicCast( OSData,

-               regEntry->getProperty( gIODTAAPLInterruptsKey))));
+        regEntry->getProperty( gIODTAAPLInterruptsKey))));

     if( nw && (0 == (local = OSDynamicCast( OSData,
     if( nw && (0 == (local = OSDynamicCast( OSData,

-               regEntry->getProperty( "interrupts")))))
-               return( true );         // nothing to see here
+        regEntry->getProperty( "interrupts")))))
+        return( true );                // nothing to see here

 
     if( nw && (parent = regEntry->getParentEntry( gIODTPlane))) {
 
     if( nw && (parent = regEntry->getParentEntry( gIODTPlane))) {

-               // check for bridges on old world
-               if( (local2 = OSDynamicCast( OSData,
-                       parent->getProperty( gIODTAAPLInterruptsKey)))) {
-               local = local2;
-               nw = false;
-               }
+        // check for bridges on old world
+        if( (local2 = OSDynamicCast( OSData,
+                parent->getProperty( gIODTAAPLInterruptsKey)))) {
+            local = local2;
+            nw = false;
+        }

     }
 
     localBits = (UInt32 *) local->getBytesNoCopy();
     }
 
     localBits = (UInt32 *) local->getBytesNoCopy();

-    localEnd = localBits + (local->getLength() / sizeof( UInt32));
+    localEnd = localBits + (local->getLength() / sizeof(UInt32));
+    index = 0;

     mapped = OSArray::withCapacity( 1 );
     controllers = OSArray::withCapacity( 1 );
 
     mapped = OSArray::withCapacity( 1 );
     controllers = OSArray::withCapacity( 1 );
 


@@ -606,23 +682,63 @@ bool IODTMapInterrupts( IORegistryEntry * regEntry )
 
     if( ok) do {
         if( nw) {
 
     if( ok) do {
         if( nw) {

-            skip = IODTMapOneInterrupt( regEntry, localBits, &map, &controller );
+            skip = IODTMapOneInterrupt( regEntry, localBits, index, &map, &controller );

             if( 0 == skip) {
                 IOLog("%s: error mapping interrupt[%d]\n",
             if( 0 == skip) {
                 IOLog("%s: error mapping interrupt[%d]\n",

-                                       regEntry->getName(), mapped->getCount());
+                        regEntry->getName(), mapped->getCount());

                 break;
             }
         } else {
                 break;
             }
         } else {

-            map = OSData::withData( local, mapped->getCount() * sizeof( UInt32),
-                               sizeof( UInt32));
+            map = OSData::withData( local, mapped->getCount() * sizeof(UInt32),
+                               sizeof(UInt32));

             controller = gIODTDefaultInterruptController;
             controller->retain();
         }
 
             controller = gIODTDefaultInterruptController;
             controller->retain();
         }
 

+       index++;

         localBits += skip;
         mapped->setObject( map );
         localBits += skip;
         mapped->setObject( map );

+        controllers->setObject( controller );
+
+        if (allInts)
+        {
+            controllerInts = (OSArray *) allInts->getObject( controller );
+            if (controllerInts)
+           {
+                for (unsigned int i = 0; (oneMap = controllerInts->getObject(i)); i++)
+                {
+                    if (map->isEqualTo(oneMap))
+                    {
+                        controllerInts = (OSArray *) gIODTSharedInterrupts->getObject( controller );
+                        if (controllerInts)
+                            controllerInts->setObject(map);
+                        else
+                        {
+                            controllerInts = OSArray::withObjects( (const OSObject **) &map, 1, 4 );
+                            if (controllerInts)
+                            {
+                                gIODTSharedInterrupts->setObject( controller, controllerInts );
+                                controllerInts->release();
+                            }
+                        }
+                        break;
+                    }
+                }
+               if (!oneMap)
+                    controllerInts->setObject(map);
+            }
+            else
+            {
+                controllerInts = OSArray::withObjects( (const OSObject **) &map, 1, 16 );
+                if (controllerInts)
+                {
+                    allInts->setObject( controller, controllerInts );
+                    controllerInts->release();
+                }
+            }
+        }
+

         map->release();
         map->release();

-        controllers->setObject( (OSObject *) controller );

         controller->release();
 
     } while( localBits < localEnd);
         controller->release();
 
     } while( localBits < localEnd);


@@ -630,7 +746,7 @@ bool IODTMapInterrupts( IORegistryEntry * regEntry )
     ok &= (localBits == localEnd);
 
     if( ok ) {
     ok &= (localBits == localEnd);
 
     if( ok ) {

-               // store results
+        // store results

         ok  = regEntry->setProperty( gIOInterruptControllersKey, controllers);
         ok &= regEntry->setProperty( gIOInterruptSpecifiersKey, mapped);
     }
         ok  = regEntry->setProperty( gIOInterruptControllersKey, controllers);
         ok &= regEntry->setProperty( gIOInterruptSpecifiersKey, mapped);
     }


@@ -643,6 +759,11 @@ bool IODTMapInterrupts( IORegistryEntry * regEntry )
     return( ok );
 }
 
     return( ok );
 }
 

+bool IODTMapInterrupts( IORegistryEntry * regEntry )
+{
+    return( IODTMapInterruptsSharing( regEntry, 0 ));
+}
+

 /*
  */
 
 /*
  */
 


@@ -725,8 +846,8 @@ bool IODTMatchNubWithKeys( IORegistryEntry * regEntry,
         result = regEntry->compareNames( obj );
                obj->release();
     }
         result = regEntry->compareNames( obj );
                obj->release();
     }

-#ifdef DEBUG
-       else IOLog("Couldn't unserialize %s\n", keys );
+#if DEBUG
+    else IOLog("Couldn't unserialize %s\n", keys );

 #endif
 
     return( result );
 #endif
 
     return( result );


@@ -746,6 +867,7 @@ OSCollectionIterator * IODTFindMatchingEntries( IORegistryEntry * from,
     iter = IORegistryIterator::iterateOver( from, gIODTPlane,
                (options & kIODTRecursive) ? kIORegistryIterateRecursively : 0 );
     if( iter) {
     iter = IORegistryIterator::iterateOver( from, gIODTPlane,
                (options & kIODTRecursive) ? kIORegistryIterateRecursively : 0 );
     if( iter) {

+

         do {
 
             if( result)
         do {
 
             if( result)


@@ -759,17 +881,18 @@ OSCollectionIterator * IODTFindMatchingEntries( IORegistryEntry * from,
     
                 // Look for existence of a debug property to skip
                 if( next->getProperty("AAPL,ignore"))
     
                 // Look for existence of a debug property to skip
                 if( next->getProperty("AAPL,ignore"))

-                                    continue;
+                    continue;

     
     

-                    if( keys) {
+                if( keys) {

                     cmp = IODTMatchNubWithKeys( next, keys );
                     if( (minus && (false == cmp))
                             || ((false == minus) && (false != cmp)) )
                         result->setObject( next);
                     cmp = IODTMatchNubWithKeys( next, keys );
                     if( (minus && (false == cmp))
                             || ((false == minus) && (false != cmp)) )
                         result->setObject( next);

-                    } else
+                } else

                     result->setObject( next);
             }
         } while( !iter->isValid());
                     result->setObject( next);
             }
         } while( !iter->isValid());

+

         iter->release();
     }
 
         iter->release();
     }
 


@@ -794,10 +917,11 @@ void IODTSetResolving( IORegistryEntry *  regEntry,
 
     persist.compareFunc = compareFunc;
     persist.locationFunc = locationFunc;
 
     persist.compareFunc = compareFunc;
     persist.locationFunc = locationFunc;

-    prop = OSData::withBytes( &persist, sizeof( persist));
+    prop = OSData::withBytes( &persist, sizeof(persist));

     if( !prop)
     if( !prop)

-               return;
+        return;

 
 

+    prop->setSerializable(false);

     regEntry->setProperty( gIODTPersistKey, prop);
     prop->release();
     return;
     regEntry->setProperty( gIODTPersistKey, prop);
     prop->release();
     return;


@@ -805,11 +929,10 @@ void IODTSetResolving( IORegistryEntry *  regEntry,
 
 static SInt32 DefaultCompare( UInt32 cellCount, UInt32 left[], UInt32 right[] )
 {
 
 static SInt32 DefaultCompare( UInt32 cellCount, UInt32 left[], UInt32 right[] )
 {

-    cellCount--;
-    return( left[ cellCount ] - right[ cellCount ] );
+       cellCount--;
+       return( left[ cellCount ] - right[ cellCount ] ); 

 }
 
 }
 

-

 void IODTGetCellCounts( IORegistryEntry * regEntry,
                            UInt32 * sizeCount, UInt32 * addressCount)
 {
 void IODTGetCellCounts( IORegistryEntry * regEntry,
                            UInt32 * sizeCount, UInt32 * addressCount)
 {


@@ -817,7 +940,7 @@ void IODTGetCellCounts( IORegistryEntry * regEntry,
         *sizeCount = 1;
     if( !GetUInt32( regEntry, gIODTAddressCellKey, addressCount))
         *addressCount = 2;
         *sizeCount = 1;
     if( !GetUInt32( regEntry, gIODTAddressCellKey, addressCount))
         *addressCount = 2;

-       return;
+    return;

 }
 
 // Given addr & len cells from our child, find it in our ranges property, then
 }
 
 // Given addr & len cells from our child, find it in our ranges property, then


@@ -830,86 +953,153 @@ bool IODTResolveAddressCell( IORegistryEntry * regEntry,
                              UInt32 cellsIn[],
                              IOPhysicalAddress * phys, IOPhysicalLength * len )
 {
                              UInt32 cellsIn[],
                              IOPhysicalAddress * phys, IOPhysicalLength * len )
 {

-    IORegistryEntry            *parent;
-    OSData                             *prop;
+    IORegistryEntry    *parent;
+    OSData             *prop;

     // cells in addresses at regEntry
     // cells in addresses at regEntry

-    UInt32                             sizeCells, addressCells;
+    UInt32             sizeCells, addressCells;

     // cells in addresses below regEntry
     // cells in addresses below regEntry

-    UInt32                             childSizeCells, childAddressCells;
-    UInt32                             childCells;
-    UInt32                             cell[ 5 ], offset = 0, length;
-    UInt32                             *range;
-    UInt32                             *endRanges;
-    bool                               ok = true;
-    SInt32                             diff;
-
-    IODTPersistent                             *persist;
+    UInt32             childSizeCells, childAddressCells;
+    UInt32             childCells;
+    UInt32             cell[ 8 ], length;
+    UInt64             offset = 0;
+    UInt32             endCell[ 8 ];
+    UInt32             *range;
+    UInt32             *lookRange;
+    UInt32             *startRange;
+    UInt32             *endRanges;
+    bool               ok = true;
+    SInt64             diff, diff2, endDiff;
+
+    IODTPersistent     *persist;

     IODTCompareAddressCellFunc compare;
 
     IODTGetCellCounts( regEntry, &childSizeCells, &childAddressCells );
     childCells = childAddressCells + childSizeCells;
 
     IODTCompareAddressCellFunc compare;
 
     IODTGetCellCounts( regEntry, &childSizeCells, &childAddressCells );
     childCells = childAddressCells + childSizeCells;
 

-    bcopy( cellsIn, cell, 4 * childCells );
+    if (childCells > sizeof(cell)/sizeof(cell[0]))
+        panic("IODTResolveAddressCell: Invalid device tree (%u,%u)", (uint32_t)childAddressCells, (uint32_t)childSizeCells);
+
+    bcopy( cellsIn, cell, sizeof(UInt32) * childCells );

     if( childSizeCells > 1)
     if( childSizeCells > 1)

-        *len = IOPhysical32( cellsIn[ childAddressCells ],
-                       cellsIn[ childAddressCells + 1 ] );
+        *len = IOPhysical32( cellsIn[ childAddressCells + 1],
+                             cellsIn[ childAddressCells] );

     else
         *len = IOPhysical32( 0, cellsIn[ childAddressCells ] );
 
     else
         *len = IOPhysical32( 0, cellsIn[ childAddressCells ] );
 

-    do {
-        prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey ));
-        if( 0 == prop) {
-               /* end of the road */
-            *phys = IOPhysical32( 0,  cell[ childAddressCells - 1 ] + offset);
-            break;
-        }
-
-        parent = regEntry->getParentEntry( gIODTPlane );
-               IODTGetCellCounts( parent, &sizeCells, &addressCells );
+    do
+    {
+       prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey ));
+       if( 0 == prop) {
+            /* end of the road */
+           if (childAddressCells == 2)  {
+                *phys = IOPhysical32( cell[ childAddressCells - 1 ], cell [ childAddressCells - 2 ]);
+           } else  {
+               *phys = IOPhysical32( 0, cell[ childAddressCells - 1 ]);
+           }
+            *phys += offset;
+           break;
+       }
+
+       parent = regEntry->getParentEntry( gIODTPlane );
+       IODTGetCellCounts( parent, &sizeCells, &addressCells );
+
+       if( (length = prop->getLength())) {
+           // search
+           startRange = (UInt32 *) prop->getBytesNoCopy();
+           range = startRange;
+           endRanges = range + (length / sizeof(UInt32));
+
+           prop = (OSData *) regEntry->getProperty( gIODTPersistKey );
+           if( prop) {
+               persist = (IODTPersistent *) prop->getBytesNoCopy();
+               compare = persist->compareFunc;
+           } else if (addressCells == childAddressCells) {
+               compare = DefaultCompare;
+           } else {
+               panic("There is no mixed comparison function yet...");
+           }
+
+           for( ok = false;
+                range < endRanges;
+                range += (childCells + addressCells) ) {
+
+               // is cell start within range?
+               diff = (*compare)( childAddressCells, cell, range );
+
+        if (childAddressCells > sizeof(endCell)/sizeof(endCell[0]))
+            panic("IODTResolveAddressCell: Invalid device tree (%u)", (uint32_t)childAddressCells);
+
+               bcopy(range, endCell, childAddressCells * sizeof(UInt32));
+
+               if (childAddressCells == 2) {
+                       uint64_t sum = endCell[childAddressCells - 2] + IOPhysical32(range[childCells + addressCells - 1], range[childCells + addressCells - 2]);
+                       endCell[childAddressCells - 2] = (uint32_t)(sum & 0x00000000FFFFFFFFULL);
+                       if (sum > UINT32_MAX) {
+                               endCell[childAddressCells - 1] += (uint32_t)((sum & 0xFFFFFFFF00000000ULL) >> 32);
+                       }
+               } else {
+                       endCell[childAddressCells - 1] += range[childCells + addressCells - 1];
+               }

 
 

-        if( (length = prop->getLength())) {
-            // search
-            range = (UInt32 *) prop->getBytesNoCopy();
-            endRanges = range + (length / 4);
+               diff2 = (*compare)( childAddressCells, cell, endCell );

 
 

-            prop = (OSData *) regEntry->getProperty( gIODTPersistKey );
-            if( prop) {
-                persist = (IODTPersistent *) prop->getBytesNoCopy();
-                compare = persist->compareFunc;
-            } else
-                compare = DefaultCompare;
+               if ((diff < 0) || (diff2 >= 0))
+                   continue;

 
 

-            for( ok = false;
-                 range < endRanges;
-                 range += (childCells + addressCells) ) {
+               ok = (0 == cell[childCells - 1]);
+               if (!ok)
+               {
+                   // search for cell end
+                   bcopy(cell, endCell, childAddressCells * sizeof(UInt32));

 
 

-                // is cell >= range start?
-                diff = (*compare)( childAddressCells, cell, range );
-                if( diff < 0)
-                    continue;
-                    
-                // is cell + size <= range end?
-                if( (diff + cell[ childCells - 1 ])
-                        > range[ childCells + addressCells - 1 ])
-                    continue;
+                   if (childSizeCells == 2) {
+                       uint64_t sum;
+                        sum = endCell[childAddressCells - 2] + IOPhysical32(cell[childCells - 1], cell[childCells - 2]) - 1;
+                       endCell[childAddressCells - 2] = (uint32_t)(sum & 0x00000000FFFFFFFFULL);
+                       if (sum > UINT32_MAX) {
+                               endCell[childAddressCells - 1] += (uint32_t)((sum & 0xFFFFFFFF00000000ULL) >> 32);
+                       }
+                   } else {
+                        endCell[childAddressCells - 1] += cell[childCells - 1] - 1;
+                   }
+                   lookRange = startRange;
+                   for( ;
+                        lookRange < endRanges;
+                        lookRange += (childCells + addressCells) )
+                    {
+                       // is cell >= range start?
+                       endDiff = (*compare)( childAddressCells, endCell, lookRange );
+                       if( endDiff < 0)
+                           continue;
+                       if ((endDiff - cell[childCells - 1] + 1 + lookRange[childAddressCells + addressCells - 1])
+                           == (diff + range[childAddressCells + addressCells - 1]))
+                       {
+                           ok = true;
+                           break;
+                       }
+                   }
+                   if (!ok)
+                       continue;
+               }
+               offset += diff;
+               break;
+           }

 
 

-                offset += diff;
-                ok = true;
-                break;
-            }
+        if (addressCells + sizeCells > sizeof(cell)/sizeof(cell[0]))
+            panic("IODTResolveAddressCell: Invalid device tree (%u, %u)", (uint32_t)addressCells, (uint32_t)sizeCells);

 
 

-            // Get the physical start of the range from our parent
-            bcopy( range + childAddressCells, cell, 4 * addressCells );
-            bzero( cell + addressCells, 4 * sizeCells );
+           // Get the physical start of the range from our parent
+           bcopy( range + childAddressCells, cell, sizeof(UInt32) * addressCells );
+           bzero( cell + addressCells, sizeof(UInt32) * sizeCells );

 
 

-        } /* else zero length range => pass thru to parent */
+       } /* else zero length range => pass thru to parent */

 
 

-       regEntry                        = parent;
+       regEntry                = parent;

        childSizeCells          = sizeCells;
        childAddressCells       = addressCells;
        childSizeCells          = sizeCells;
        childAddressCells       = addressCells;

-       childCells                      = childAddressCells + childSizeCells;
-
-    } while( ok && regEntry);
+       childCells              = childAddressCells + childSizeCells;
+    }
+    while( ok && regEntry);

 
     return( ok);
 }
 
     return( ok);
 }


@@ -932,11 +1122,11 @@ OSArray * IODTResolveAddressing( IORegistryEntry * regEntry,
     parentEntry = regEntry->getParentEntry( gIODTPlane );
     addressProperty = (OSData *) regEntry->getProperty( addressPropertyName );
     if( (0 == addressProperty) || (0 == parentEntry))
     parentEntry = regEntry->getParentEntry( gIODTPlane );
     addressProperty = (OSData *) regEntry->getProperty( addressPropertyName );
     if( (0 == addressProperty) || (0 == parentEntry))

-               return( 0);
+        return( 0);

 
     IODTGetCellCounts( parentEntry, &sizeCells, &addressCells );
     if( 0 == sizeCells)
 
     IODTGetCellCounts( parentEntry, &sizeCells, &addressCells );
     if( 0 == sizeCells)

-               return( 0);
+        return( 0);

 
     cells = sizeCells + addressCells;
     reg = (UInt32 *) addressProperty->getBytesNoCopy();
 
     cells = sizeCells + addressCells;
     reg = (UInt32 *) addressProperty->getBytesNoCopy();


@@ -944,20 +1134,20 @@ OSArray * IODTResolveAddressing( IORegistryEntry * regEntry,
 
     array = OSArray::withCapacity( 1 );
     if( 0 == array)
 
     array = OSArray::withCapacity( 1 );
     if( 0 == array)

-               return( 0);
+        return( 0);

 
     for( i = 0; i < num; i++) {
 
     for( i = 0; i < num; i++) {

-               if( IODTResolveAddressCell( parentEntry, reg, &phys, &len )) {
-                       range = 0;
-                       if( parent)
-                               range = IODeviceMemory::withSubRange( parent,
-                                       phys - parent->getPhysicalAddress(), len );
-                       if( 0 == range)
-                               range = IODeviceMemory::withRange( phys, len );
-                       if( range)
-                               array->setObject( range );
-               }
-               reg += cells;
+        if( IODTResolveAddressCell( parentEntry, reg, &phys, &len )) {
+            range = 0;
+            if( parent)
+                range = IODeviceMemory::withSubRange( parent,
+                        phys - parent->getPhysicalSegment(0, 0, kIOMemoryMapperNone), len );
+            if( 0 == range)
+                range = IODeviceMemory::withRange( phys, len );
+            if( range)
+                array->setObject( range );
+        }
+        reg += cells;

     }
 
     regEntry->setProperty( gIODeviceMemoryKey, array);
     }
 
     regEntry->setProperty( gIODeviceMemoryKey, array);


@@ -979,7 +1169,7 @@ static void IODTGetNVLocation(
     prop = (OSData *) parent->getProperty( gIODTPersistKey );
     if( prop) {
         persist = (IODTPersistent *) prop->getBytesNoCopy();
     prop = (OSData *) parent->getProperty( gIODTPersistKey );
     if( prop) {
         persist = (IODTPersistent *) prop->getBytesNoCopy();

-               (*persist->locationFunc)( regEntry, busNum, deviceNum, functionNum );
+        (*persist->locationFunc)( regEntry, busNum, deviceNum, functionNum );

     } else {
         prop = (OSData *) regEntry->getProperty( "reg" );
         *functionNum   = 0;
     } else {
         prop = (OSData *) regEntry->getProperty( "reg" );
         *functionNum   = 0;


@@ -990,7 +1180,7 @@ static void IODTGetNVLocation(
         } else {
             *busNum    = 0;
             *deviceNum         = 0;
         } else {
             *busNum    = 0;
             *deviceNum         = 0;

-               }
+        }

     }
     return;
 }
     }
     return;
 }


@@ -1017,14 +1207,14 @@ IOReturn IODTMakeNVDescriptor( IORegistryEntry * regEntry,
 
         IODTGetNVLocation( parent, regEntry,
                        &busNum, &deviceNum, &functionNum );
 
         IODTGetNVLocation( parent, regEntry,
                        &busNum, &deviceNum, &functionNum );

-               if( level)
-                       bridgeDevices |= ((deviceNum & 0x1f) << ((level - 1) * 5));
-               else {
+        if( level)
+            bridgeDevices |= ((deviceNum & 0x1f) << ((level - 1) * 5));
+        else {

             hdr->busNum        = busNum;
             hdr->deviceNum     = deviceNum;
             hdr->functionNum   = functionNum;
             hdr->busNum        = busNum;
             hdr->deviceNum     = deviceNum;
             hdr->functionNum   = functionNum;

-               }
-               regEntry = parent;
+        }
+        regEntry = parent;

     }
     hdr->bridgeCount   = level - 2;
     hdr->bridgeDevices         = bridgeDevices;
     }
     hdr->bridgeCount   = level - 2;
     hdr->bridgeDevices         = bridgeDevices;


@@ -1045,38 +1235,43 @@ OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber )
 
     data = (OSData *) regEntry->getProperty("AAPL,slot-name");
     if( data)
 
     data = (OSData *) regEntry->getProperty("AAPL,slot-name");
     if( data)

-               return( data);
+        return( data);

     parent = regEntry->getParentEntry( gIODTPlane );
     if( !parent)
     parent = regEntry->getParentEntry( gIODTPlane );
     if( !parent)

-               return( 0 );
+        return( 0 );

     data = OSDynamicCast( OSData, parent->getProperty("slot-names"));
     if( !data)
     data = OSDynamicCast( OSData, parent->getProperty("slot-names"));
     if( !data)

-               return( 0 );
+        return( 0 );

     if( data->getLength() <= 4)
     if( data->getLength() <= 4)

-               return( 0 );
+        return( 0 );

 
     bits = (UInt32 *) data->getBytesNoCopy();
     mask = *bits;
     if( (0 == (mask & (1 << deviceNumber))))
 
     bits = (UInt32 *) data->getBytesNoCopy();
     mask = *bits;
     if( (0 == (mask & (1 << deviceNumber))))

-               return( 0 );
+        return( 0 );

 
     names = (char *)(bits + 1);
     lastName = names + (data->getLength() - 4);
 
     for( i = 0; (i <= deviceNumber) && (names < lastName); i++ ) {
 
 
     names = (char *)(bits + 1);
     lastName = names + (data->getLength() - 4);
 
     for( i = 0; (i <= deviceNumber) && (names < lastName); i++ ) {
 

-               if( mask & (1 << i)) {
+        if( mask & (1 << i)) {

             if( i == deviceNumber) {
             if( i == deviceNumber) {

-                               data = OSData::withBytesNoCopy( names, 1 + strlen( names));
-                               if( data) {
-                                       regEntry->setProperty("AAPL,slot-name", data);
-                                       ret = data;
-                                       data->release();
-                               }
+                data = OSData::withBytesNoCopy( names, 1 + strlen( names));
+                if( data) {
+                    regEntry->setProperty("AAPL,slot-name", data);
+                    ret = data;
+                    data->release();
+                }

             } else
             } else

-                               names += 1 + strlen( names);
+                names += 1 + strlen( names);

         }
     }
 
     return( ret );
 }
         }
     }
 
     return( ret );
 }

+
+extern "C" IOReturn IONDRVLibrariesInitialize( IOService * provider )
+{
+    return( kIOReturnUnsupported );
+}