xnu-3248.30.4.tar.gz

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

diff --git a/iokit/Kernel/IODeviceTreeSupport.cpp b/iokit/Kernel/IODeviceTreeSupport.cpp
index c18268a3c15f51898840945965d6755bf674fb86..965670f373a9bbe132264421a7b64aef93efd1c4 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>


@@ -39,12 +37,14 @@
 
 #include <pexpert/device_tree.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>


@@ -61,6 +61,7 @@ const OSSymbol *      gIODTUnitKey;
 const OSSymbol *       gIODTCompatibleKey;
 const OSSymbol *       gIODTTypeKey;
 const OSSymbol *       gIODTModelKey;
 const OSSymbol *       gIODTCompatibleKey;
 const OSSymbol *       gIODTTypeKey;
 const OSSymbol *       gIODTModelKey;

+const OSSymbol *       gIODTTargetTypeKey;

 
 const OSSymbol *       gIODTSizeCellKey;
 const OSSymbol *       gIODTAddressCellKey;
 
 const OSSymbol *       gIODTSizeCellKey;
 const OSSymbol *       gIODTAddressCellKey;


@@ -75,27 +76,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;
+    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 );
 


@@ -104,6 +107,7 @@ IODeviceTreeAlloc( void * dtTop )
     gIODTCompatibleKey         = OSSymbol::withCStringNoCopy( "compatible" );
     gIODTTypeKey               = OSSymbol::withCStringNoCopy( "device_type" );
     gIODTModelKey              = OSSymbol::withCStringNoCopy( "model" );
     gIODTCompatibleKey         = OSSymbol::withCStringNoCopy( "compatible" );
     gIODTTypeKey               = OSSymbol::withCStringNoCopy( "device_type" );
     gIODTModelKey              = OSSymbol::withCStringNoCopy( "model" );

+    gIODTTargetTypeKey         = OSSymbol::withCStringNoCopy( "target-type" );

     gIODTSizeCellKey   = OSSymbol::withCStringNoCopy( "#size-cells" );
     gIODTAddressCellKey = OSSymbol::withCStringNoCopy( "#address-cells" );
     gIODTRangeKey              = OSSymbol::withCStringNoCopy( "ranges" );
     gIODTSizeCellKey   = OSSymbol::withCStringNoCopy( "#size-cells" );
     gIODTAddressCellKey = OSSymbol::withCStringNoCopy( "#address-cells" );
     gIODTRangeKey              = OSSymbol::withCStringNoCopy( "ranges" );


@@ -143,7 +147,7 @@ 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 );
 


@@ -192,39 +196,50 @@ IODeviceTreeAlloc( void * dtTop )
         // free original device tree
         DTInit(0);
         IODTFreeLoaderInfo( "DeviceTree",
         // free original device tree
         DTInit(0);
         IODTFreeLoaderInfo( "DeviceTree",

-                       (void *)dtMap[0], round_page_32(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) {
+    assert( regIter && allInts && gIODTSharedInterrupts );
+    if( regIter && allInts && gIODTSharedInterrupts ) {

         while( (child = regIter->getNextObject())) {
         while( (child = regIter->getNextObject())) {

-            IODTMapInterrupts( child );
+            IODTMapInterruptsSharing( child, allInts );

             if( !intMap && child->getProperty( gIODTInterruptParentKey))
                 intMap = true;
 
             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");
+        }
+        regIter->release();
+    }

 
 

-            if( (obj = child->getProperty( "driver,AAPL,MacOS,PowerPC"))) {
+#if IODTSUPPORTDEBUG
+    parent->setProperty("allInts", allInts);
+    parent->setProperty("sharedInts", gIODTSharedInterrupts);

 
 

-                if( (0 == (prop = (OSData *)child->getProperty( gIODTTypeKey )))
-                  || (strcmp( "display", (char *) prop->getBytesNoCopy())) ) {
-                    child->removeProperty( "driver,AAPL,MacOS,PowerPC");
-                }
-            }
-        }
+    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();
     }
         regIter->release();
     }

+#endif
+
+    allInts->release();

 
     if( intMap)
         // set a key in the root to indicate we found NW interrupt mapping
 
     if( intMap)
         // set a key in the root to indicate we found NW interrupt mapping


@@ -234,7 +249,7 @@ IODeviceTreeAlloc( void * dtTop )
     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;


@@ -253,13 +268,13 @@ int IODTGetLoaderInfo( char *key, void **infoAddr, int *infoSize )
     propPtr = (unsigned int *)propObj->getBytesNoCopy();
     if ( propPtr == 0 ) return -1;
 
     propPtr = (unsigned int *)propObj->getBytesNoCopy();
     if ( propPtr == 0 ) return -1;
 

-    *infoAddr = (void *)propPtr[0] ;
-    *infoSize = (int)   propPtr[1]; 
+    *infoAddr = (void *)(uintptr_t) (propPtr[0]);
+    *infoSize = (int)               (propPtr[1]);

 
     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;


@@ -276,6 +291,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;


@@ -296,7 +331,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;


@@ -341,17 +376,17 @@ MakeReferenceTable( DTEntry dtEntry, bool copy )
 
             } else if( nameKey == gIODTUnitKey ) {
                 // all OF strings are null terminated... except this one
 
             } else if( nameKey == gIODTUnitKey ) {
                 // all OF strings are null terminated... except this one

-                if( propSize >= (int) sizeof( location))
-                    propSize = sizeof( location) - 1;
+                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;
     
                 strncpy( location, (const char *) prop, propSize );
                 location[ propSize ] = 0;
                 regEntry->setLocation( location );
                 propTable->removeObject( gIODTUnitKey );
                 noLocation = false;
     

-            } else if( noLocation && (0 == strcmp( name, "reg"))) {
+            } else if(noLocation && (!strncmp(name, "reg", sizeof("reg")))) {

                 // default location - override later
                 // default location - override later

-                sprintf( location, "%lX", *((UInt32 *) prop) );
+                snprintf(location, sizeof(location), "%X", *((uint32_t *) prop));

                 regEntry->setLocation( location );
             }
         }
                 regEntry->setLocation( location );
             }
         }


@@ -403,15 +438,21 @@ static bool GetUInt32( IORegistryEntry * regEntry, const OSSymbol * name,
         return( false );
 }
 
         return( false );
 }
 

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

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

+    OSData         *   data;
+    unsigned int       len;

 
 

-    if( GetUInt32( regEntry, gIODTInterruptParentKey, &phandle))
-        parent = FindPHandle( phandle );
+    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"))
+    } else if( 0 == regEntry->getProperty( "interrupt-controller"))

         parent = regEntry->getParentEntry( gIODTPlane);
     else
         parent = 0;
         parent = regEntry->getParentEntry( gIODTPlane);
     else
         parent = 0;


@@ -430,7 +471,7 @@ const OSSymbol * IODTInterruptControllerName( IORegistryEntry * regEntry )
     assert( ok );
 
     if( ok) {
     assert( ok );
 
     if( ok) {

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

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


@@ -449,8 +490,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;


@@ -462,12 +503,12 @@ 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) {
         data = OSDynamicCast( OSData, regEntry->getProperty( "reg" ));
     IODTGetICellCounts( parent, &icells, &acells );
     addrCmp = 0;
     if( acells) {
         data = OSDynamicCast( OSData, regEntry->getProperty( "reg" ));

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

             addrCmp = (UInt32 *) data->getBytesNoCopy();
     }
     original_icells = icells;
             addrCmp = (UInt32 *) data->getBytesNoCopy();
     }
     original_icells = icells;


@@ -488,7 +529,7 @@ UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec,
             // found a controller - don't want to follow cascaded controllers
             parent = 0;
             *spec = OSData::withBytesNoCopy( (void *) intSpec,
             // found a controller - don't want to follow cascaded controllers
             parent = 0;
             *spec = OSData::withBytesNoCopy( (void *) intSpec,

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

             *controller = IODTInterruptControllerName( regEntry );
             ok = (*spec && *controller);
         } else if( parent && (data = OSDynamicCast( OSData,
             *controller = IODTInterruptControllerName( regEntry );
             ok = (*spec && *controller);
         } else if( parent && (data = OSDynamicCast( OSData,


@@ -497,7 +538,7 @@ UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec,
             map = (UInt32 *) data->getBytesNoCopy();
             endMap = map + (data->getLength() / sizeof(UInt32));
             data = OSDynamicCast( OSData, regEntry->getProperty( "interrupt-map-mask" ));
             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();
             else
                 maskCmp = 0;
                 maskCmp = (UInt32 *) data->getBytesNoCopy();
             else
                 maskCmp = 0;


@@ -565,19 +606,58 @@ UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec,
     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,
         regEntry->getProperty( gIODTAAPLInterruptsKey))));
 
     nw = (0 == (local = OSDynamicCast( OSData,
         regEntry->getProperty( gIODTAAPLInterruptsKey))));


@@ -595,7 +675,8 @@ bool IODTMapInterrupts( IORegistryEntry * regEntry )
     }
 
     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 );
 


@@ -603,23 +684,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",
                         regEntry->getName(), mapped->getCount());
                 break;
             }
         } else {
             if( 0 == skip) {
                 IOLog("%s: error mapping interrupt[%d]\n",
                         regEntry->getName(), mapped->getCount());
                 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);


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

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

 /*
  */
 
 /*
  */
 


@@ -652,6 +778,7 @@ CompareKey( OSString * key,
     OSString           *string;
     const char         *ckey;
     UInt32                     keyLen;
     OSString           *string;
     const char         *ckey;
     UInt32                     keyLen;

+    UInt32          nlen;

     const char         *names;
     const char         *lastName;
     bool                       wild;
     const char         *names;
     const char         *lastName;
     bool                       wild;


@@ -676,16 +803,16 @@ CompareKey( OSString * key,
 
     do {
         // for each name in the property
 
     do {
         // for each name in the property

+        nlen = strnlen(names, lastName - names);

         if( wild)
         if( wild)

-            matched = (0 == strncmp( ckey, names, keyLen - 1 ));
+            matched = ((nlen >= (keyLen - 1)) && (0 == strncmp(ckey, names, keyLen - 1)));

         else
         else

-            matched = (keyLen == strlen( names ))
-                    && (0 == strncmp( ckey, names, keyLen ));
+            matched = (keyLen == nlen) && (0 == strncmp(ckey, names, keyLen));

 
         if( matched)
             result = names;
 
 
         if( matched)
             result = names;
 

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

 
     } while( (names < lastName) && (false == matched));
 
 
     } while( (names < lastName) && (false == matched));
 


@@ -722,7 +849,7 @@ bool IODTMatchNubWithKeys( IORegistryEntry * regEntry,
         result = regEntry->compareNames( obj );
                obj->release();
     }
         result = regEntry->compareNames( obj );
                obj->release();
     }

-#ifdef DEBUG
+#if DEBUG

     else IOLog("Couldn't unserialize %s\n", keys );
 #endif
 
     else IOLog("Couldn't unserialize %s\n", keys );
 #endif
 


@@ -773,7 +900,7 @@ OSCollectionIterator * IODTFindMatchingEntries( IORegistryEntry * from,
     }
 
     cIter = OSCollectionIterator::withCollection( result);
     }
 
     cIter = OSCollectionIterator::withCollection( result);

-    result->release();
+    if (result) result->release();

 
     return( cIter);
 }
 
     return( cIter);
 }


@@ -793,21 +920,49 @@ 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)
         return;
 
     if( !prop)
         return;
 

+    prop->setSerializable(false);

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

+#if   defined(__arm__) || defined(__i386__) || defined(__x86_64__)

 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 ] ); 

 }
 }

+#else
+#error Unknown architecture.
+#endif

 
 

+static void AddLengthToCells( UInt32 numCells, UInt32 *cells, UInt64 offset)
+{
+    if (numCells == 1)
+    {
+        cells[0] += (UInt32)offset;
+    }
+    else {
+        UInt64 sum = cells[numCells - 1] + offset;
+        cells[numCells - 1] = (UInt32)sum;
+        if (sum > UINT32_MAX) {
+            cells[numCells - 2] += (UInt32)(sum >> 32);
+        }
+    }
+}
+
+static IOPhysicalAddress CellsValue( UInt32 numCells, UInt32 *cells)
+{
+    if (numCells == 1) {
+        return IOPhysical32( 0, cells[0] );
+    } else {
+        return IOPhysical32( cells[numCells - 2], cells[numCells - 1] );
+    }
+}

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


@@ -827,7 +982,7 @@ void IODTGetCellCounts( IORegistryEntry * regEntry,
 
 bool IODTResolveAddressCell( IORegistryEntry * regEntry,
                              UInt32 cellsIn[],
 
 bool IODTResolveAddressCell( IORegistryEntry * regEntry,
                              UInt32 cellsIn[],

-                             IOPhysicalAddress * phys, IOPhysicalLength * len )
+                             IOPhysicalAddress * phys, IOPhysicalLength * lenOut )

 {
     IORegistryEntry    *parent;
     OSData             *prop;
 {
     IORegistryEntry    *parent;
     OSData             *prop;


@@ -836,11 +991,16 @@ bool IODTResolveAddressCell( IORegistryEntry * regEntry,
     // cells in addresses below regEntry
     UInt32             childSizeCells, childAddressCells;
     UInt32             childCells;
     // cells in addresses below regEntry
     UInt32             childSizeCells, childAddressCells;
     UInt32             childCells;

-    UInt32             cell[ 5 ], offset = 0, length;
+    UInt32             cell[ 8 ], propLen;
+    UInt64             offset = 0;
+    UInt32             endCell[ 8 ];

     UInt32             *range;
     UInt32             *range;

+    UInt32             *lookRange;
+    UInt32             *startRange;

     UInt32             *endRanges;
     bool               ok = true;
     UInt32             *endRanges;
     bool               ok = true;

-    SInt32             diff;
+    SInt64             diff, diff2, endDiff;
+    UInt64             len, rangeLen;

 
     IODTPersistent     *persist;
     IODTCompareAddressCellFunc compare;
 
     IODTPersistent     *persist;
     IODTCompareAddressCellFunc compare;


@@ -848,67 +1008,111 @@ bool IODTResolveAddressCell( IORegistryEntry * regEntry,
     IODTGetCellCounts( regEntry, &childSizeCells, &childAddressCells );
     childCells = childAddressCells + childSizeCells;
 
     IODTGetCellCounts( regEntry, &childSizeCells, &childAddressCells );
     childCells = childAddressCells + childSizeCells;
 

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

 
 

-    do {
+    bcopy( cellsIn, cell, sizeof(UInt32) * childCells );
+    *lenOut = CellsValue( childSizeCells, cellsIn + childAddressCells );
+
+    do
+    {

         prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey ));
         if( 0 == prop) {
             /* end of the road */
         prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey ));
         if( 0 == prop) {
             /* end of the road */

-            *phys = IOPhysical32( 0,  cell[ childAddressCells - 1 ] + offset);
+            *phys = CellsValue( childAddressCells, cell );
+            *phys += offset;

             break;
         }
 
         parent = regEntry->getParentEntry( gIODTPlane );
         IODTGetCellCounts( parent, &sizeCells, &addressCells );
 
             break;
         }
 
         parent = regEntry->getParentEntry( gIODTPlane );
         IODTGetCellCounts( parent, &sizeCells, &addressCells );
 

-        if( (length = prop->getLength())) {
+        if( (propLen = prop->getLength())) {

             // search
             // search

-            range = (UInt32 *) prop->getBytesNoCopy();
-            endRanges = range + (length / 4);
+            startRange = (UInt32 *) prop->getBytesNoCopy();
+            range = startRange;
+            endRanges = range + (propLen / sizeof(UInt32));

 
             prop = (OSData *) regEntry->getProperty( gIODTPersistKey );
             if( prop) {
                 persist = (IODTPersistent *) prop->getBytesNoCopy();
                 compare = persist->compareFunc;
 
             prop = (OSData *) regEntry->getProperty( gIODTPersistKey );
             if( prop) {
                 persist = (IODTPersistent *) prop->getBytesNoCopy();
                 compare = persist->compareFunc;

-            } else
+            } else if (addressCells == childAddressCells) {

                 compare = DefaultCompare;
                 compare = DefaultCompare;

+            } else {
+                panic("There is no mixed comparison function yet...");
+            }

 
             for( ok = false;
 
             for( ok = false;

-                 range < endRanges;
-                 range += (childCells + addressCells) ) {
+                    range < endRanges;
+                    range += (childCells + addressCells) ) {

 
 

-                // is cell >= range start?
+                // is cell start within range?

                 diff = (*compare)( childAddressCells, cell, range );
                 diff = (*compare)( childAddressCells, cell, range );

-                if( diff < 0)
-                    continue;
-                    
-                // is cell + size <= range end?
-                if( (diff + cell[ childCells - 1 ])
-                        > range[ childCells + addressCells - 1 ])
+
+                if (childAddressCells > sizeof(endCell)/sizeof(endCell[0]))
+                    panic("IODTResolveAddressCell: Invalid device tree (%u)", (uint32_t)childAddressCells);
+
+                bcopy(range, endCell, childAddressCells * sizeof(UInt32));
+
+                rangeLen = CellsValue(childSizeCells, range + childAddressCells + addressCells);
+                AddLengthToCells(childAddressCells, endCell, rangeLen);
+
+                diff2 = (*compare)( childAddressCells, cell, endCell );
+
+                // if start of cell < start of range, or end of range >= start of cell, skip
+                if ((diff < 0) || (diff2 >= 0))

                     continue;
 
                     continue;
 

+                len = CellsValue(childSizeCells, cell + childAddressCells);
+                ok = (0 == len);
+
+                if (!ok)
+                {
+                    // search for cell end
+                    bcopy(cell, endCell, childAddressCells * sizeof(UInt32));
+
+                    AddLengthToCells(childAddressCells, endCell, len - 1);
+
+                    for( lookRange = startRange;
+                            lookRange < endRanges;
+                            lookRange += (childCells + addressCells) )
+                    {
+                        // make sure end of cell >= range start
+                        endDiff = (*compare)( childAddressCells, endCell, lookRange );
+                        if( endDiff < 0)
+                            continue;
+
+                        UInt64 rangeStart = CellsValue(addressCells, range + childAddressCells);
+                        UInt64 lookRangeStart = CellsValue(addressCells, lookRange + childAddressCells);
+                        if ((endDiff - len + 1 + lookRangeStart) == (diff + rangeStart))
+                        {
+                            ok = true;
+                            break;
+                        }
+                    }
+                    if (!ok)
+                        continue;
+                }

                 offset += diff;
                 offset += diff;

-                ok = true;

                 break;
             }
 
                 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
             // Get the physical start of the range from our parent

-            bcopy( range + childAddressCells, cell, 4 * addressCells );
-            bzero( cell + addressCells, 4 * sizeCells );
+            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;
-       childSizeCells          = sizeCells;
-       childAddressCells       = addressCells;
-       childCells              = childAddressCells + childSizeCells;
-
-    } while( ok && regEntry);
+        regEntry               = parent;
+        childSizeCells         = sizeCells;
+        childAddressCells      = addressCells;
+        childCells             = childAddressCells + childSizeCells;
+    }
+    while( ok && regEntry);

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


@@ -950,7 +1154,7 @@ OSArray * IODTResolveAddressing( IORegistryEntry * regEntry,
             range = 0;
             if( parent)
                 range = IODeviceMemory::withSubRange( parent,
             range = 0;
             if( parent)
                 range = IODeviceMemory::withSubRange( parent,

-                        phys - parent->getPhysicalAddress(), len );
+                        phys - parent->getPhysicalSegment(0, 0, kIOMemoryMapperNone), len );

             if( 0 == range)
                 range = IODeviceMemory::withRange( phys, len );
             if( range)
             if( 0 == range)
                 range = IODeviceMemory::withRange( phys, len );
             if( range)


@@ -1038,6 +1242,7 @@ OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber )
     OSData                             *ret = 0;
     UInt32                             *bits;
     UInt32                             i;
     OSData                             *ret = 0;
     UInt32                             *bits;
     UInt32                             i;

+    size_t              nlen;

     char                               *names;
     char                               *lastName;
     UInt32                             mask;
     char                               *names;
     char                               *lastName;
     UInt32                             mask;


@@ -1065,17 +1270,23 @@ OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber )
     for( i = 0; (i <= deviceNumber) && (names < lastName); i++ ) {
 
         if( mask & (1 << i)) {
     for( i = 0; (i <= deviceNumber) && (names < lastName); i++ ) {
 
         if( mask & (1 << i)) {

+            nlen = 1 + strnlen(names, lastName - names);

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

-                data = OSData::withBytesNoCopy( names, 1 + strlen( names));
+                data = OSData::withBytesNoCopy(names, nlen);

                 if( data) {
                     regEntry->setProperty("AAPL,slot-name", data);
                     ret = data;
                     data->release();
                 }
             } else
                 if( data) {
                     regEntry->setProperty("AAPL,slot-name", data);
                     ret = data;
                     data->release();
                 }
             } else

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

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

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