xnu-792.13.8.tar.gz

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

diff --git a/iokit/Kernel/IODeviceTreeSupport.cpp b/iokit/Kernel/IODeviceTreeSupport.cpp
index 6d9eb7f61404961bfea72c241ad97490ab1be543..40deb93fa9c9b70e7a9d96b403035d2e6833fc71 100644 (file)
--- a/iokit/Kernel/IODeviceTreeSupport.cpp
+++ b/iokit/Kernel/IODeviceTreeSupport.cpp
@@ -1,31 +1,31 @@
 /*
  * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
  *
 /*
  * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_LICENSE_OSREFERENCE_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 Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE 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. 
+ * This file contains Original Code and/or Modifications of Original Code 
+ * as defined in and that are subject to the Apple Public Source License 
+ * Version 2.0 (the 'License'). You may not use this file except in 
+ * compliance with the License.  The rights granted to you under the 
+ * License may not be used to create, or enable the creation or 
+ * redistribution of, unlawful or unlicensed copies of an Apple operating 
+ * system, or to circumvent, violate, or enable the circumvention or 
+ * violation of, any terms of an Apple operating system software license 
+ * agreement.
+ *
+ * Please obtain a copy of the License at 
+ * http://www.opensource.apple.com/apsl/ and read it before using this 
+ * file.

  *
  *

- * HISTORY
- * 23 Nov 98 sdouglas, created from IODeviceTreeBus.m, & MacOS exp mgr.
- * 05 Apr 99 sdouglas, add interrupt mapping.
+ * The Original Code and all software distributed under the License are 
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * Please see the License for the specific language governing rights and 
+ * limitations under the License.

  *
  *

+ * @APPLE_LICENSE_OSREFERENCE_HEADER_END@

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


@@ -37,7 +37,8 @@
 #include <IOKit/IOLib.h>
 #include <IOKit/IOKitKeys.h>
 
 #include <IOKit/IOLib.h>
 #include <IOKit/IOKitKeys.h>
 

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

 extern "C" {
     #include <machine/machine_routines.h>
     void DTInit( void * data );
 extern "C" {
     #include <machine/machine_routines.h>
     void DTInit( void * data );


@@ -74,29 +75,30 @@ 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;
+    OSObject *                 obj;
+    OSDictionary *             allInts;
+    vm_offset_t *              dtMap;
+    int                                propSize;
+    bool                       intMap;
+    bool                       freeDT;

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


@@ -148,7 +150,7 @@ IODeviceTreeAlloc( void * dtTop )
 
     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 {
     DTCreateEntryIterator( (DTEntry)dtTop, &iter );
 
     do {


@@ -193,17 +195,20 @@ IODeviceTreeAlloc( void * dtTop )
         // free original device tree
         DTInit(0);
         IODTFreeLoaderInfo( "DeviceTree",
         // free original device tree
         DTInit(0);
         IODTFreeLoaderInfo( "DeviceTree",

-                       (void *)dtMap[0], round_page(dtMap[1]) );
+                       (void *)dtMap[0], round_page_32(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;
 


@@ -227,13 +232,35 @@ IODeviceTreeAlloc( void * dtTop )
         regIter->release();
     }
 
         regIter->release();
     }
 

+#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
+
+    allInts->release();
+

     if( intMap)
         // set a key in the root to indicate we found NW interrupt mapping
         parent->setProperty( gIODTNWInterruptMappingKey,
                 (OSObject *) gIODTNWInterruptMappingKey );
 
     if( intMap)
         // set a key in the root to indicate we found NW interrupt mapping
         parent->setProperty( gIODTNWInterruptMappingKey,
                 (OSObject *) gIODTNWInterruptMappingKey );
 

-    IOLog("done\n");
-

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


@@ -283,7 +310,11 @@ static void FreePhysicalMemory( vm_offset_t * range )
 {
     vm_offset_t        virt;
 
 {
     vm_offset_t        virt;
 

+#if defined (__i386__)
+    virt = ml_boot_ptovirt( range[0] );
+#else

     virt = ml_static_ptovirt( range[0] );
     virt = ml_static_ptovirt( range[0] );

+#endif

     if( virt) {
         ml_static_mfree( virt, range[1] );
     }
     if( virt) {
         ml_static_mfree( virt, range[1] );
     }


@@ -568,19 +599,57 @@ 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;
+    OSData *           map;
+    OSObject *         oneMap;
+    OSArray *          mapped;
+    OSArray *          controllerInts;
+    const OSSymbol *   controller;
+    OSArray *          controllers;
+    UInt32             skip = 1;
+    bool               ok, nw;

 
     nw = (0 == (local = OSDynamicCast( OSData,
         regEntry->getProperty( gIODTAAPLInterruptsKey))));
 
     nw = (0 == (local = OSDynamicCast( OSData,
         regEntry->getProperty( gIODTAAPLInterruptsKey))));


@@ -621,8 +690,47 @@ bool IODTMapInterrupts( IORegistryEntry * regEntry )
 
         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);


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

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

 /*
  */
 
 /*
  */
 


@@ -811,7 +924,6 @@ static SInt32 DefaultCompare( UInt32 cellCount, UInt32 left[], UInt32 right[] )
     return( left[ cellCount ] - right[ cellCount ] );
 }
 
     return( left[ cellCount ] - right[ cellCount ] );
 }
 

-

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


@@ -840,10 +952,13 @@ bool IODTResolveAddressCell( IORegistryEntry * regEntry,
     UInt32             childSizeCells, childAddressCells;
     UInt32             childCells;
     UInt32             cell[ 5 ], offset = 0, length;
     UInt32             childSizeCells, childAddressCells;
     UInt32             childCells;
     UInt32             cell[ 5 ], offset = 0, length;

+    UInt32             endCell[ 5 ];

     UInt32             *range;
     UInt32             *range;

+    UInt32             *lookRange;
+    UInt32             *startRange;

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

-    SInt32             diff;
+    SInt32             diff, endDiff;

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


@@ -858,60 +973,81 @@ bool IODTResolveAddressCell( IORegistryEntry * regEntry,
     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 );
-
-        if( (length = prop->getLength())) {
-            // search
-            range = (UInt32 *) prop->getBytesNoCopy();
-            endRanges = range + (length / 4);
-
-            prop = (OSData *) regEntry->getProperty( gIODTPersistKey );
-            if( prop) {
-                persist = (IODTPersistent *) prop->getBytesNoCopy();
-                compare = persist->compareFunc;
-            } else
-                compare = DefaultCompare;
-
-            for( ok = false;
-                 range < endRanges;
-                 range += (childCells + addressCells) ) {
-
-                // 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;
-
-                offset += diff;
-                ok = true;
-                break;
-            }
-
-            // Get the physical start of the range from our parent
-            bcopy( range + childAddressCells, cell, 4 * addressCells );
-            bzero( cell + addressCells, 4 * sizeCells );
-
-        } /* else zero length range => pass thru to parent */
+    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 );
+
+       if( (length = prop->getLength())) {
+           // search
+           startRange = (UInt32 *) prop->getBytesNoCopy();
+           range = startRange;
+           endRanges = range + (length / 4);
+
+           prop = (OSData *) regEntry->getProperty( gIODTPersistKey );
+           if( prop) {
+               persist = (IODTPersistent *) prop->getBytesNoCopy();
+               compare = persist->compareFunc;
+           } else
+               compare = DefaultCompare;
+
+           for( ok = false;
+                range < endRanges;
+                range += (childCells + addressCells) ) {
+
+               // is cell start >= range start?
+               diff = (*compare)( childAddressCells, cell, range );
+               if( diff < 0)
+                   continue;
+
+               ok = (0 == cell[childCells - 1]);
+               if (!ok)
+               {
+                   // search for cell end
+                   bcopy(cell, endCell, childAddressCells * sizeof(UInt32));
+                   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;
+           }
+
+           // Get the physical start of the range from our parent
+           bcopy( range + childAddressCells, cell, 4 * addressCells );
+           bzero( cell + addressCells, 4 * sizeCells );
+
+       } /* else zero length range => pass thru to parent */

 
        regEntry                = parent;
        childSizeCells          = sizeCells;
        childAddressCells       = addressCells;
        childCells              = childAddressCells + childSizeCells;
 
        regEntry                = parent;
        childSizeCells          = sizeCells;
        childAddressCells       = addressCells;
        childCells              = childAddressCells + childSizeCells;

-
-    } while( ok && regEntry);
+    }
+    while( ok && regEntry);

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


@@ -1082,3 +1218,8 @@ OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber )
 
     return( ret );
 }
 
     return( ret );
 }

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