iokit/Kernel/IODeviceTreeSupport.cpp

   1 /*
   2  * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #include <IOKit/IODeviceTreeSupport.h>
  30 #include <libkern/c++/OSContainers.h>
  31 #include <IOKit/IODeviceMemory.h>
  32 #include <IOKit/IOService.h>
  33 #include <IOKit/IOCatalogue.h>
  34
  35 #include <IOKit/IOLib.h>
  36 #include <IOKit/IOKitKeys.h>
  37
  38 #include <pexpert/device_tree.h>
  39
  40 #if __arm64__
  41 typedef UInt64  dtptr_t;
  42 #else
  43 typedef UInt32  dtptr_t;
  44 #endif
  45
  46 #include <machine/machine_routines.h>
  47
  48 extern "C" {
  49
  50 int IODTGetLoaderInfo( const char *key, void **infoAddr, int *infosize );
  51 void IODTFreeLoaderInfo( const char *key, void *infoAddr, int infoSize );
  52 int IODTGetDefault(const char *key, void *infoAddr, unsigned int infoSize );
  53
  54 }
  55
  56 #include <IOKit/assert.h>
  57
  58 #define IODTSUPPORTDEBUG 0
  59
  60 const IORegistryPlane * gIODTPlane;
  61
  62 static OSArray *    gIODTPHandles;
  63 static OSArray *    gIODTPHandleMap;
  64 static OSData  *    gIODTResolvers;
  65
  66 const OSSymbol *        gIODTNameKey;
  67 const OSSymbol *        gIODTUnitKey;
  68 const OSSymbol *        gIODTCompatibleKey;
  69 const OSSymbol *        gIODTTypeKey;
  70 const OSSymbol *        gIODTModelKey;
  71 const OSSymbol *        gIODTTargetTypeKey;
  72
  73 const OSSymbol *        gIODTSizeCellKey;
  74 const OSSymbol *        gIODTAddressCellKey;
  75 const OSSymbol *        gIODTRangeKey;
  76
  77 const OSSymbol *        gIODTPersistKey;
  78
  79 const OSSymbol *        gIODTDefaultInterruptController;
  80 const OSSymbol *        gIODTAAPLInterruptsKey;
  81 const OSSymbol *        gIODTPHandleKey;
  82 const OSSymbol *        gIODTInterruptCellKey;
  83 const OSSymbol *        gIODTInterruptParentKey;
  84 const OSSymbol *        gIODTNWInterruptMappingKey;
  85
  86 OSDictionary   *        gIODTSharedInterrupts;
  87
  88 static IOLock  *    gIODTResolversLock;
  89
  90 static IORegistryEntry * MakeReferenceTable( DTEntry dtEntry, bool copy );
  91 static void AddPHandle( IORegistryEntry * regEntry );
  92 static void FreePhysicalMemory( vm_offset_t * range );
  93 static bool IODTMapInterruptsSharing( IORegistryEntry * regEntry, OSDictionary * allInts );
  94
  95 IORegistryEntry *
  96 IODeviceTreeAlloc( void * dtTop )
  97 {
  98     IORegistryEntry *           parent;
  99     IORegistryEntry *           child;
 100     IORegistryIterator *        regIter;
 101     OpaqueDTEntryIterator       iter;
 102     DTEntry                     dtChild;
 103     DTEntry                     mapEntry;
 104     OSArray *                   stack;
 105     OSData *                    prop;
 106     OSDictionary *              allInts;
 107     vm_offset_t *               dtMap;
 108     unsigned int                propSize;
 109     bool                        intMap;
 110     bool                        freeDT;
 111
 112     gIODTPlane = IORegistryEntry::makePlane( kIODeviceTreePlane );
 113
 114     gIODTNameKey                = OSSymbol::withCStringNoCopy( "name" );
 115     gIODTUnitKey                = OSSymbol::withCStringNoCopy( "AAPL,unit-string" );
 116     gIODTCompatibleKey  = OSSymbol::withCStringNoCopy( "compatible" );
 117     gIODTTypeKey                = OSSymbol::withCStringNoCopy( "device_type" );
 118     gIODTModelKey               = OSSymbol::withCStringNoCopy( "model" );
 119     gIODTTargetTypeKey          = OSSymbol::withCStringNoCopy( "target-type" );
 120     gIODTSizeCellKey    = OSSymbol::withCStringNoCopy( "#size-cells" );
 121     gIODTAddressCellKey = OSSymbol::withCStringNoCopy( "#address-cells" );
 122     gIODTRangeKey               = OSSymbol::withCStringNoCopy( "ranges" );
 123     gIODTPersistKey             = OSSymbol::withCStringNoCopy( "IODTPersist" );
 124
 125     assert(    gIODTPlane && gIODTCompatibleKey
 126             && gIODTTypeKey && gIODTModelKey
 127             && gIODTSizeCellKey && gIODTAddressCellKey && gIODTRangeKey
 128             && gIODTPersistKey );
 129
 130     gIODTDefaultInterruptController
 131                 = OSSymbol::withCStringNoCopy("IOPrimaryInterruptController");
 132     gIODTNWInterruptMappingKey
 133                 = OSSymbol::withCStringNoCopy("IONWInterrupts");
 134
 135     gIODTAAPLInterruptsKey
 136                 = OSSymbol::withCStringNoCopy("AAPL,interrupts");
 137     gIODTPHandleKey
 138                 = OSSymbol::withCStringNoCopy("AAPL,phandle");
 139
 140     gIODTInterruptParentKey
 141                 = OSSymbol::withCStringNoCopy("interrupt-parent");
 142
 143     gIODTPHandles       = OSArray::withCapacity( 1 );
 144     gIODTPHandleMap     = OSArray::withCapacity( 1 );
 145     gIODTResolvers  = OSData::withCapacity(16);
 146
 147     gIODTResolversLock = IOLockAlloc();
 148
 149     gIODTInterruptCellKey
 150                 = OSSymbol::withCStringNoCopy("#interrupt-cells");
 151
 152     assert(    gIODTDefaultInterruptController && gIODTNWInterruptMappingKey
 153             && gIODTAAPLInterruptsKey
 154             && gIODTPHandleKey && gIODTInterruptParentKey
 155             && gIODTPHandles && gIODTPHandleMap && gIODTResolvers && gIODTResolversLock
 156             && gIODTInterruptCellKey
 157          );
 158
 159     freeDT = (kSuccess == DTLookupEntry( 0, "/chosen/memory-map", &mapEntry ))
 160           && (kSuccess == DTGetProperty( mapEntry,
 161                 "DeviceTree", (void **) &dtMap, &propSize ))
 162           && ((2 * sizeof(uint32_t)) == propSize);
 163
 164     parent = MakeReferenceTable( (DTEntry)dtTop, freeDT );
 165
 166     stack = OSArray::withObjects( (const OSObject **) &parent, 1, 10 );
 167     DTInitEntryIterator( (DTEntry)dtTop, &iter );
 168
 169     do {
 170         parent = (IORegistryEntry *)stack->getObject( stack->getCount() - 1);
 171         //parent->release();
 172         stack->removeObject( stack->getCount() - 1);
 173
 174         while( kSuccess == DTIterateEntries( &iter, &dtChild) ) {
 175
 176             child = MakeReferenceTable( dtChild, freeDT );
 177             child->attachToParent( parent, gIODTPlane);
 178
 179             AddPHandle( child );
 180
 181             if( kSuccess == DTEnterEntry( &iter, dtChild)) {
 182                 stack->setObject( parent);
 183                 parent = child;
 184             }
 185             // only registry holds retain
 186             child->release();
 187         }
 188
 189     } while( stack->getCount()
 190                 && (kSuccess == DTExitEntry( &iter, &dtChild)));
 191
 192     stack->release();
 193     assert(kSuccess != DTExitEntry(&iter, &dtChild));
 194
 195     // parent is now root of the created tree
 196
 197     // make root name first compatible entry (purely cosmetic)
 198     if( (prop = (OSData *) parent->getProperty( gIODTCompatibleKey))) {
 199         parent->setName( parent->getName(), gIODTPlane );
 200         parent->setName( (const char *) prop->getBytesNoCopy() );
 201     }
 202
 203     // attach tree to meta root
 204     parent->attachToParent( IORegistryEntry::getRegistryRoot(), gIODTPlane);
 205     parent->release();
 206
 207     if( freeDT ) {
 208         // free original device tree
 209         DTInit(0);
 210         IODTFreeLoaderInfo( "DeviceTree",
 211                             (void *)dtMap[0], (int) round_page(dtMap[1]) );
 212     }
 213
 214     // adjust tree
 215
 216     gIODTSharedInterrupts = OSDictionary::withCapacity(4);
 217     allInts = OSDictionary::withCapacity(4);
 218     intMap = false;
 219     regIter = IORegistryIterator::iterateOver( gIODTPlane,
 220                                                 kIORegistryIterateRecursively );
 221     assert( regIter && allInts && gIODTSharedInterrupts );
 222     if( regIter && allInts && gIODTSharedInterrupts ) {
 223         while( (child = regIter->getNextObject())) {
 224             IODTMapInterruptsSharing( child, allInts );
 225             if( !intMap && child->getProperty( gIODTInterruptParentKey))
 226                 intMap = true;
 227
 228         }
 229         regIter->release();
 230     }
 231
 232 #if IODTSUPPORTDEBUG
 233     parent->setProperty("allInts", allInts);
 234     parent->setProperty("sharedInts", gIODTSharedInterrupts);
 235
 236     regIter = IORegistryIterator::iterateOver( gIODTPlane,
 237                                                 kIORegistryIterateRecursively );
 238     if (regIter) {
 239         while( (child = regIter->getNextObject())) {
 240             OSArray *
 241             array = OSDynamicCast(OSArray, child->getProperty( gIOInterruptSpecifiersKey ));
 242             for( UInt32 i = 0; array && (i < array->getCount()); i++)
 243             {
 244                 IOOptionBits options;
 245                 IOReturn ret = IODTGetInterruptOptions( child, i, &options );
 246                 if( (ret != kIOReturnSuccess) || options)
 247                     IOLog("%s[%ld] %ld (%x)\n", child->getName(), i, options, ret);
 248             }
 249         }
 250         regIter->release();
 251     }
 252 #endif
 253
 254     allInts->release();
 255
 256     if( intMap)
 257         // set a key in the root to indicate we found NW interrupt mapping
 258         parent->setProperty( gIODTNWInterruptMappingKey,
 259                 (OSObject *) gIODTNWInterruptMappingKey );
 260
 261     return( parent);
 262 }
 263
 264 int IODTGetLoaderInfo( const char *key, void **infoAddr, int *infoSize )
 265 {
 266     IORegistryEntry             *chosen;
 267     OSData                              *propObj;
 268     dtptr_t                             *propPtr;
 269     unsigned int                propSize;
 270     int ret = -1;
 271
 272     chosen = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane );
 273     if ( chosen == 0 ) return -1;
 274
 275     propObj = OSDynamicCast( OSData, chosen->getProperty(key) );
 276     if ( propObj == 0 ) goto cleanup;
 277
 278     propSize = propObj->getLength();
 279     if ( propSize != (2 * sizeof(dtptr_t)) ) goto cleanup;
 280
 281     propPtr = (dtptr_t *)propObj->getBytesNoCopy();
 282     if ( propPtr == 0 ) goto cleanup;
 283
 284     *infoAddr = (void *)(uintptr_t) (propPtr[0]);
 285     *infoSize = (int)               (propPtr[1]);
 286
 287     ret = 0;
 288
 289 cleanup:
 290     chosen->release();
 291
 292     return ret;
 293 }
 294
 295 void IODTFreeLoaderInfo( const char *key, void *infoAddr, int infoSize )
 296 {
 297     vm_offset_t                 range[2];
 298     IORegistryEntry             *chosen;
 299
 300     range[0] = (vm_offset_t)infoAddr;
 301     range[1] = (vm_offset_t)infoSize;
 302     FreePhysicalMemory( range );
 303
 304     if ( key != 0 ) {
 305         chosen = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane );
 306         if ( chosen != 0 ) {
 307             chosen->removeProperty(key);
 308             chosen->release();
 309         }
 310     }
 311 }
 312
 313 int IODTGetDefault(const char *key, void *infoAddr, unsigned int infoSize )
 314 {
 315     IORegistryEntry             *defaults;
 316     OSData                      *defaultObj;
 317     unsigned int                defaultSize;
 318
 319     defaults = IORegistryEntry::fromPath( "/defaults", gIODTPlane );
 320     if ( defaults == 0 ) return -1;
 321
 322     defaultObj = OSDynamicCast( OSData, defaults->getProperty(key) );
 323     if ( defaultObj == 0 ) return -1;
 324
 325     defaultSize = defaultObj->getLength();
 326     if ( defaultSize > infoSize) return -1;
 327
 328     memcpy( infoAddr, defaultObj->getBytesNoCopy(), defaultSize );
 329
 330     return 0;
 331 }
 332
 333 static void FreePhysicalMemory( vm_offset_t * range )
 334 {
 335     vm_offset_t virt;
 336
 337     virt = ml_static_ptovirt( range[0] );
 338     if( virt) {
 339         ml_static_mfree( virt, range[1] );
 340     }
 341 }
 342
 343 static IORegistryEntry *
 344 MakeReferenceTable( DTEntry dtEntry, bool copy )
 345 {
 346     IORegistryEntry             *regEntry;
 347     OSDictionary                *propTable;
 348     const OSSymbol              *nameKey;
 349     OSData                              *data;
 350     const OSSymbol              *sym;
 351     OpaqueDTPropertyIterator    dtIter;
 352     void                                *prop;
 353     unsigned int                propSize;
 354     char                                *name;
 355     char                                location[ 32 ];
 356     bool                                noLocation = true;
 357     bool                                kernelOnly;
 358
 359     regEntry = new IOService;
 360
 361     if( regEntry && (false == regEntry->init())) {
 362         regEntry->release();
 363         regEntry = 0;
 364     }
 365
 366     if( regEntry &&
 367       (kSuccess == DTInitPropertyIterator( dtEntry, &dtIter))) {
 368
 369         kernelOnly = (kSuccess == DTGetProperty(dtEntry, "kernel-only", &prop, &propSize));
 370         propTable = regEntry->getPropertyTable();
 371
 372         while( kSuccess == DTIterateProperties( &dtIter, &name)) {
 373
 374             if(  kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize ))
 375                 continue;
 376
 377             if( copy) {
 378                 nameKey = OSSymbol::withCString(name);
 379                 data = OSData::withBytes(prop, propSize);
 380             } else {
 381                 nameKey = OSSymbol::withCStringNoCopy(name);
 382                 data = OSData::withBytesNoCopy(prop, propSize);
 383             }
 384             assert( nameKey && data );
 385
 386             if (kernelOnly)
 387                 data->setSerializable(false);
 388
 389             propTable->setObject( nameKey, data);
 390             data->release();
 391             nameKey->release();
 392
 393             if( nameKey == gIODTNameKey ) {
 394                 if( copy)
 395                     sym = OSSymbol::withCString( (const char *) prop);
 396                 else
 397                     sym = OSSymbol::withCStringNoCopy( (const char *) prop);
 398                 regEntry->setName( sym );
 399                 sym->release();
 400
 401             } else if( nameKey == gIODTUnitKey ) {
 402                 // all OF strings are null terminated... except this one
 403                 if( propSize >= (int) sizeof(location))
 404                     propSize = sizeof(location) - 1;
 405                 strncpy( location, (const char *) prop, propSize );
 406                 location[ propSize ] = 0;
 407                 regEntry->setLocation( location );
 408                 propTable->removeObject( gIODTUnitKey );
 409                 noLocation = false;
 410
 411             } else if(noLocation && (!strncmp(name, "reg", sizeof("reg")))) {
 412                 // default location - override later
 413                 snprintf(location, sizeof(location), "%X", *((uint32_t *) prop));
 414                 regEntry->setLocation( location );
 415             }
 416         }
 417     }
 418
 419     return( regEntry);
 420 }
 421
 422 static void AddPHandle( IORegistryEntry * regEntry )
 423 {
 424     OSData *    data;
 425
 426     if( regEntry->getProperty( gIODTInterruptCellKey)
 427       && (data = OSDynamicCast( OSData, regEntry->getProperty( gIODTPHandleKey )))) {
 428         // a possible interrupt-parent
 429         gIODTPHandles->setObject( data );
 430         gIODTPHandleMap->setObject( regEntry );
 431     }
 432 }
 433
 434 static IORegistryEntry * FindPHandle( UInt32 phandle )
 435 {
 436     OSData                      *data;
 437     IORegistryEntry *regEntry = 0;
 438     int                         i;
 439
 440     for( i = 0; (data = (OSData *)gIODTPHandles->getObject( i )); i++ ) {
 441         if( phandle == *((UInt32 *)data->getBytesNoCopy())) {
 442             regEntry = (IORegistryEntry *)
 443             gIODTPHandleMap->getObject( i );
 444             break;
 445         }
 446     }
 447
 448     return( regEntry );
 449 }
 450
 451 static bool GetUInt32( IORegistryEntry * regEntry, const OSSymbol * name,
 452                         UInt32 * value )
 453 {
 454     OSObject * obj;
 455     OSData   * data;
 456     bool       result;
 457
 458     if (!(obj = regEntry->copyProperty(name))) return (false);
 459
 460     result = ((data = OSDynamicCast(OSData, obj)) && (sizeof(UInt32) == data->getLength()));
 461     if (result) *value = *((UInt32 *) data->getBytesNoCopy());
 462
 463     obj->release();
 464     return(result);
 465 }
 466
 467 static IORegistryEntry * IODTFindInterruptParent( IORegistryEntry * regEntry, IOItemCount index )
 468 {
 469     IORegistryEntry *   parent;
 470     UInt32              phandle;
 471     OSData          *   data;
 472     unsigned int        len;
 473
 474     if( (data = OSDynamicCast( OSData, regEntry->getProperty( gIODTInterruptParentKey )))
 475       && (sizeof(UInt32) <= (len = data->getLength()))) {
 476         if (((index + 1) * sizeof(UInt32)) > len)
 477             index = 0;
 478         phandle = ((UInt32 *) data->getBytesNoCopy())[index];
 479         parent = FindPHandle( phandle );
 480
 481     } else if( 0 == regEntry->getProperty( "interrupt-controller"))
 482         parent = regEntry->getParentEntry( gIODTPlane);
 483     else
 484         parent = 0;
 485
 486     return( parent );
 487 }
 488
 489 const OSSymbol * IODTInterruptControllerName( IORegistryEntry * regEntry )
 490 {
 491     const OSSymbol      *sym;
 492     UInt32              phandle;
 493     bool                ok;
 494     char                buf[48];
 495
 496     ok = GetUInt32( regEntry, gIODTPHandleKey, &phandle);
 497     assert( ok );
 498
 499     if( ok) {
 500         snprintf(buf, sizeof(buf), "IOInterruptController%08X", (uint32_t)phandle);
 501         sym = OSSymbol::withCString( buf );
 502     } else
 503         sym = 0;
 504
 505     return( sym );
 506 }
 507
 508 #define unexpected(a) { kprintf("unexpected %s:%d\n", __FILE__, __LINE__); a; }
 509
 510 static void IODTGetICellCounts( IORegistryEntry * regEntry,
 511                             UInt32 * iCellCount, UInt32 * aCellCount)
 512 {
 513     if( !GetUInt32( regEntry, gIODTInterruptCellKey, iCellCount))
 514         unexpected( *iCellCount = 1 );
 515     if( !GetUInt32( regEntry, gIODTAddressCellKey, aCellCount))
 516         *aCellCount = 0;
 517 }
 518
 519 static UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec, UInt32 index,
 520                                     OSData ** spec, const OSSymbol ** controller )
 521 {
 522     IORegistryEntry *parent = 0;
 523     OSData                      *data;
 524     UInt32                      *addrCmp;
 525     UInt32                      *maskCmp;
 526     UInt32                      *map;
 527     UInt32                      *endMap;
 528     UInt32                      acells, icells, pacells, picells, cell;
 529     UInt32                      i, original_icells;
 530     bool                        cmp, ok = false;
 531
 532     parent = IODTFindInterruptParent( regEntry, index );
 533     IODTGetICellCounts( parent, &icells, &acells );
 534     addrCmp = 0;
 535     if( acells) {
 536         data = OSDynamicCast( OSData, regEntry->getProperty( "reg" ));
 537         if( data && (data->getLength() >= (acells * sizeof(UInt32))))
 538             addrCmp = (UInt32 *) data->getBytesNoCopy();
 539     }
 540     original_icells = icells;
 541     regEntry = parent;
 542
 543     do {
 544 #if IODTSUPPORTDEBUG
 545         kprintf ("IODTMapOneInterrupt: current regEntry name %s\n", regEntry->getName());
 546         kprintf ("acells - icells: ");
 547         for (i = 0; i < acells; i++) kprintf ("0x%08X ", addrCmp[i]);
 548         kprintf ("- ");
 549         for (i = 0; i < icells; i++) kprintf ("0x%08X ", intSpec[i]);
 550         kprintf ("\n");
 551 #endif
 552
 553         if( parent && (data = OSDynamicCast( OSData,
 554             regEntry->getProperty( "interrupt-controller")))) {
 555             // found a controller - don't want to follow cascaded controllers
 556             parent = 0;
 557             *spec = OSData::withBytesNoCopy( (void *) intSpec,
 558                                             icells * sizeof(UInt32));
 559             *controller = IODTInterruptControllerName( regEntry );
 560             ok = (*spec && *controller);
 561         } else if( parent && (data = OSDynamicCast( OSData,
 562                     regEntry->getProperty( "interrupt-map")))) {
 563             // interrupt-map
 564             map = (UInt32 *) data->getBytesNoCopy();
 565             endMap = map + (data->getLength() / sizeof(UInt32));
 566             data = OSDynamicCast( OSData, regEntry->getProperty( "interrupt-map-mask" ));
 567             if( data && (data->getLength() >= ((acells + icells) * sizeof(UInt32))))
 568                 maskCmp = (UInt32 *) data->getBytesNoCopy();
 569             else
 570                 maskCmp = 0;
 571
 572 #if IODTSUPPORTDEBUG
 573             if (maskCmp) {
 574                 kprintf ("        maskCmp: ");
 575                 for (i = 0; i < acells + icells; i++) {
 576                     if (i == acells)
 577                         kprintf ("- ");
 578                     kprintf ("0x%08X ", maskCmp[i]);
 579                 }
 580                 kprintf ("\n");
 581                 kprintf ("         masked: ");
 582                 for (i = 0; i < acells + icells; i++) {
 583                     if (i == acells)
 584                         kprintf ("- ");
 585                     kprintf ("0x%08X ", ((i < acells) ? addrCmp[i] : intSpec[i-acells]) & maskCmp[i]);
 586                 }
 587                 kprintf ("\n");
 588             } else
 589                 kprintf ("no maskCmp\n");
 590 #endif
 591             do {
 592 #if IODTSUPPORTDEBUG
 593                 kprintf ("            map: ");
 594                 for (i = 0; i < acells + icells; i++) {
 595                     if (i == acells)
 596                         kprintf ("- ");
 597                     kprintf ("0x%08X ", map[i]);
 598                 }
 599                 kprintf ("\n");
 600 #endif
 601                 for( i = 0, cmp = true; cmp && (i < (acells + icells)); i++) {
 602                     cell = (i < acells) ? addrCmp[i] : intSpec[ i - acells ];
 603                     if( maskCmp)
 604                         cell &= maskCmp[i];
 605                     cmp = (cell == map[i]);
 606                 }
 607
 608                 map += acells + icells;
 609                 if( 0 == (parent = FindPHandle( *(map++) )))
 610                     unexpected(break);
 611
 612                 IODTGetICellCounts( parent, &picells, &pacells );
 613                 if( cmp) {
 614                     addrCmp = map;
 615                     intSpec = map + pacells;
 616                     regEntry = parent;
 617                 } else {
 618                     map += pacells + picells;
 619                 }
 620             } while( !cmp && (map < endMap) );
 621             if (!cmp)
 622                 parent = 0;
 623         }
 624
 625         if( parent) {
 626             IODTGetICellCounts( parent, &icells, &acells );
 627             regEntry = parent;
 628         }
 629
 630     } while( parent);
 631
 632     return( ok ? original_icells : 0 );
 633 }
 634
 635 IOReturn IODTGetInterruptOptions( IORegistryEntry * regEntry, int source, IOOptionBits * options )
 636 {
 637     OSArray *   controllers;
 638     OSArray *   specifiers;
 639     OSArray *   shared;
 640     OSObject *  spec;
 641     OSObject *  oneSpec;
 642
 643     *options = 0;
 644
 645     controllers = OSDynamicCast(OSArray, regEntry->getProperty(gIOInterruptControllersKey));
 646     specifiers  = OSDynamicCast(OSArray, regEntry->getProperty(gIOInterruptSpecifiersKey));
 647
 648     if( !controllers || !specifiers)
 649         return (kIOReturnNoInterrupt);
 650
 651     shared = (OSArray *) gIODTSharedInterrupts->getObject(
 652                         (const OSSymbol *) controllers->getObject(source) );
 653     if (!shared)
 654         return (kIOReturnSuccess);
 655
 656     spec = specifiers->getObject(source);
 657     if (!spec)
 658         return (kIOReturnNoInterrupt);
 659
 660     for (unsigned int i = 0;
 661             (oneSpec = shared->getObject(i))
 662             && (!oneSpec->isEqualTo(spec));
 663             i++ )       {}
 664
 665     if (oneSpec)
 666         *options = kIODTInterruptShared;
 667
 668     return (kIOReturnSuccess);
 669 }
 670
 671 static bool IODTMapInterruptsSharing( IORegistryEntry * regEntry, OSDictionary * allInts )
 672 {
 673     IORegistryEntry *   parent;
 674     OSData *            local;
 675     OSData *            local2;
 676     UInt32 *            localBits;
 677     UInt32 *            localEnd;
 678     IOItemCount         index;
 679     OSData *            map;
 680     OSObject *          oneMap;
 681     OSArray *           mapped;
 682     OSArray *           controllerInts;
 683     const OSSymbol *    controller = 0;
 684     OSArray *           controllers;
 685     UInt32              skip = 1;
 686     bool                ok, nw;
 687
 688     nw = (0 == (local = OSDynamicCast( OSData,
 689         regEntry->getProperty( gIODTAAPLInterruptsKey))));
 690     if( nw && (0 == (local = OSDynamicCast( OSData,
 691         regEntry->getProperty( "interrupts")))))
 692         return( true );         // nothing to see here
 693
 694     if( nw && (parent = regEntry->getParentEntry( gIODTPlane))) {
 695         // check for bridges on old world
 696         if( (local2 = OSDynamicCast( OSData,
 697                 parent->getProperty( gIODTAAPLInterruptsKey)))) {
 698             local = local2;
 699             nw = false;
 700         }
 701     }
 702
 703     localBits = (UInt32 *) local->getBytesNoCopy();
 704     localEnd = localBits + (local->getLength() / sizeof(UInt32));
 705     index = 0;
 706     mapped = OSArray::withCapacity( 1 );
 707     controllers = OSArray::withCapacity( 1 );
 708
 709     ok = (mapped && controllers);
 710
 711     if( ok) do {
 712         if( nw) {
 713             skip = IODTMapOneInterrupt( regEntry, localBits, index, &map, &controller );
 714             if( 0 == skip) {
 715                 IOLog("%s: error mapping interrupt[%d]\n",
 716                         regEntry->getName(), mapped->getCount());
 717                 break;
 718             }
 719         } else {
 720             map = OSData::withData( local, mapped->getCount() * sizeof(UInt32),
 721                                 sizeof(UInt32));
 722             controller = gIODTDefaultInterruptController;
 723             controller->retain();
 724         }
 725
 726         index++;
 727         localBits += skip;
 728         mapped->setObject( map );
 729         controllers->setObject( controller );
 730
 731         if (allInts)
 732         {
 733             controllerInts = (OSArray *) allInts->getObject( controller );
 734             if (controllerInts)
 735             {
 736                 for (unsigned int i = 0; (oneMap = controllerInts->getObject(i)); i++)
 737                 {
 738                     if (map->isEqualTo(oneMap))
 739                     {
 740                         controllerInts = (OSArray *) gIODTSharedInterrupts->getObject( controller );
 741                         if (controllerInts)
 742                             controllerInts->setObject(map);
 743                         else
 744                         {
 745                             controllerInts = OSArray::withObjects( (const OSObject **) &map, 1, 4 );
 746                             if (controllerInts)
 747                             {
 748                                 gIODTSharedInterrupts->setObject( controller, controllerInts );
 749                                 controllerInts->release();
 750                             }
 751                         }
 752                         break;
 753                     }
 754                 }
 755                 if (!oneMap)
 756                     controllerInts->setObject(map);
 757             }
 758             else
 759             {
 760                 controllerInts = OSArray::withObjects( (const OSObject **) &map, 1, 16 );
 761                 if (controllerInts)
 762                 {
 763                     allInts->setObject( controller, controllerInts );
 764                     controllerInts->release();
 765                 }
 766             }
 767         }
 768
 769         map->release();
 770         controller->release();
 771
 772     } while( localBits < localEnd);
 773
 774     ok &= (localBits == localEnd);
 775
 776     if( ok ) {
 777         // store results
 778         ok  = regEntry->setProperty( gIOInterruptControllersKey, controllers);
 779         ok &= regEntry->setProperty( gIOInterruptSpecifiersKey, mapped);
 780     }
 781
 782     if( controllers)
 783         controllers->release();
 784     if( mapped)
 785         mapped->release();
 786
 787     return( ok );
 788 }
 789
 790 bool IODTMapInterrupts( IORegistryEntry * regEntry )
 791 {
 792     return( IODTMapInterruptsSharing( regEntry, 0 ));
 793 }
 794
 795 /*
 796  */
 797
 798 static bool
 799 CompareKey( OSString * key,
 800                 const IORegistryEntry * table, const OSSymbol * propName,
 801                 OSString ** matchingName )
 802 {
 803     OSObject            *prop;
 804     OSData                      *data;
 805     OSString            *string;
 806     const char          *ckey;
 807     UInt32                      keyLen;
 808     UInt32          nlen;
 809     const char          *names;
 810     const char          *lastName;
 811     bool                        wild;
 812     bool                        matched;
 813     const char          *result = 0;
 814
 815     if( 0 == (prop = table->copyProperty( propName ))) return( 0 );
 816
 817     if( (data = OSDynamicCast( OSData, prop ))) {
 818         names = (const char *) data->getBytesNoCopy();
 819         lastName = names + data->getLength();
 820     } else if( (string = OSDynamicCast( OSString, prop ))) {
 821         names = string->getCStringNoCopy();
 822         lastName = names + string->getLength() + 1;
 823     } else names = 0;
 824
 825         if (names) {
 826                 ckey = key->getCStringNoCopy();
 827                 keyLen = key->getLength();
 828                 wild = ('*' == key->getChar( keyLen - 1 ));
 829
 830                 do {
 831                         // for each name in the property
 832                         nlen = strnlen(names, lastName - names);
 833                         if( wild)
 834                                 matched = ((nlen >= (keyLen - 1)) && (0 == strncmp(ckey, names, keyLen - 1)));
 835                         else
 836                                 matched = (keyLen == nlen) && (0 == strncmp(ckey, names, keyLen));
 837
 838                         if( matched)
 839                                 result = names;
 840
 841                         names = names + nlen + 1;
 842
 843                 } while( (names < lastName) && (false == matched));
 844         }
 845
 846     if (result && matchingName) *matchingName = OSString::withCString( result );
 847
 848         if (prop) prop->release();
 849
 850     return (result != 0);
 851 }
 852
 853
 854 bool IODTCompareNubName( const IORegistryEntry * regEntry,
 855                          OSString * name, OSString ** matchingName )
 856 {
 857     bool matched;
 858
 859     matched = CompareKey( name, regEntry, gIODTNameKey,       matchingName)
 860                    || CompareKey( name, regEntry, gIODTCompatibleKey, matchingName)
 861                    || CompareKey( name, regEntry, gIODTTypeKey,       matchingName)
 862                    || CompareKey( name, regEntry, gIODTModelKey,      matchingName);
 863
 864     return (matched);
 865 }
 866
 867 bool IODTMatchNubWithKeys( IORegistryEntry * regEntry,
 868                                     const char * keys )
 869 {
 870     OSObject    *obj;
 871     bool                result = false;
 872
 873     obj = OSUnserialize( keys, 0 );
 874
 875     if( obj) {
 876         result = regEntry->compareNames( obj );
 877                 obj->release();
 878     }
 879 #if DEBUG
 880     else IOLog("Couldn't unserialize %s\n", keys );
 881 #endif
 882
 883     return( result );
 884 }
 885
 886 OSCollectionIterator * IODTFindMatchingEntries( IORegistryEntry * from,
 887                         IOOptionBits options, const char * keys )
 888 {
 889     OSSet                                       *result = 0;
 890     IORegistryEntry                     *next;
 891     IORegistryIterator          *iter;
 892     OSCollectionIterator        *cIter;
 893     bool                                        cmp;
 894     bool                                        minus = options & kIODTExclusive;
 895
 896
 897     iter = IORegistryIterator::iterateOver( from, gIODTPlane,
 898                 (options & kIODTRecursive) ? kIORegistryIterateRecursively : 0 );
 899     if( iter) {
 900
 901         do {
 902
 903             if( result)
 904                 result->release();
 905             result = OSSet::withCapacity( 3 );
 906             if( !result)
 907                 break;
 908
 909             iter->reset();
 910             while( (next = iter->getNextObject())) {
 911
 912                 // Look for existence of a debug property to skip
 913                 if( next->getProperty("AAPL,ignore"))
 914                     continue;
 915
 916                 if( keys) {
 917                     cmp = IODTMatchNubWithKeys( next, keys );
 918                     if( (minus && (false == cmp))
 919                             || ((false == minus) && (false != cmp)) )
 920                         result->setObject( next);
 921                 } else
 922                     result->setObject( next);
 923             }
 924         } while( !iter->isValid());
 925
 926         iter->release();
 927     }
 928
 929     cIter = OSCollectionIterator::withCollection( result);
 930     if (result) result->release();
 931
 932     return( cIter);
 933 }
 934
 935
 936 struct IODTPersistent {
 937     IODTCompareAddressCellFunc  compareFunc;
 938 };
 939
 940 void IODTSetResolving( IORegistryEntry *        regEntry,
 941                 IODTCompareAddressCellFunc      compareFunc,
 942                 IODTNVLocationFunc              locationFunc __unused )
 943 {
 944     IODTPersistent       persist;
 945     IODTPersistent * entry;
 946     OSNumber       * num;
 947     unsigned int     index, count;
 948
 949     IOLockLock(gIODTResolversLock);
 950
 951     count = (gIODTResolvers->getLength() / sizeof(IODTPersistent));
 952     entry = (typeof(entry)) gIODTResolvers->getBytesNoCopy();
 953     for (index = 0; index < count; index++)
 954     {
 955         if (compareFunc == entry->compareFunc) break;
 956         entry++;
 957     }
 958     if (index == count)
 959     {
 960         persist.compareFunc = compareFunc;
 961         if (!gIODTResolvers->appendBytes(&persist, sizeof(IODTPersistent))) panic("IODTSetResolving");
 962     }
 963
 964     IOLockUnlock(gIODTResolversLock);
 965
 966     num = OSNumber::withNumber(index, 32);
 967     regEntry->setProperty(gIODTPersistKey, num);
 968     OSSafeReleaseNULL(num);
 969
 970     return;
 971 }
 972
 973 #if  defined(__arm64__)
 974 static SInt64 DefaultCompare( UInt32 cellCount, UInt32 left[], UInt32 right[] )
 975 {
 976     SInt64 diff = 0;
 977
 978     if (cellCount == 2) {
 979         diff = IOPhysical32(left[1], left[0]) - IOPhysical32(right[1], right[0]);
 980     } else if (cellCount == 1) {
 981         diff = ( left[0] - right[0] );
 982     } else {
 983         panic("DefaultCompare only knows how to handle 1 or 2 cells.");
 984     }
 985
 986     return diff;
 987 }
 988 #elif defined(__arm__) || defined(__i386__) || defined(__x86_64__)
 989 static SInt32 DefaultCompare( UInt32 cellCount, UInt32 left[], UInt32 right[] )
 990 {
 991         cellCount--;
 992         return( left[ cellCount ] - right[ cellCount ] );
 993 }
 994 #else
 995 #error Unknown architecture.
 996 #endif
 997
 998 static void AddLengthToCells( UInt32 numCells, UInt32 *cells, UInt64 offset)
 999 {
1000     if (numCells == 1)
1001     {
1002         cells[0] += (UInt32)offset;
1003     }
1004     else {
1005 #if defined(__arm64__) || defined(__arm__)
1006         UInt64 sum = cells[numCells - 2] + offset;
1007         cells[numCells - 2] = (UInt32)sum;
1008         if (sum > UINT32_MAX) {
1009             cells[numCells - 1] += (UInt32)(sum >> 32);
1010         }
1011 #else
1012         UInt64 sum = cells[numCells - 1] + offset;
1013         cells[numCells - 1] = (UInt32)sum;
1014         if (sum > UINT32_MAX) {
1015             cells[numCells - 2] += (UInt32)(sum >> 32);
1016         }
1017 #endif
1018     }
1019 }
1020
1021 static IOPhysicalAddress CellsValue( UInt32 numCells, UInt32 *cells)
1022 {
1023     if (numCells == 1) {
1024         return IOPhysical32( 0, cells[0] );
1025     } else {
1026 #if defined(__arm64__) || defined(arm)
1027         return IOPhysical32( cells[numCells - 1], cells[numCells - 2] );
1028 #else
1029         return IOPhysical32( cells[numCells - 2], cells[numCells - 1] );
1030 #endif
1031     }
1032 }
1033
1034 void IODTGetCellCounts( IORegistryEntry * regEntry,
1035                             UInt32 * sizeCount, UInt32 * addressCount)
1036 {
1037     if( !GetUInt32( regEntry, gIODTSizeCellKey, sizeCount))
1038         *sizeCount = 1;
1039     if( !GetUInt32( regEntry, gIODTAddressCellKey, addressCount))
1040         *addressCount = 2;
1041     return;
1042 }
1043
1044 // Given addr & len cells from our child, find it in our ranges property, then
1045 // look in our parent to resolve the base of the range for us.
1046
1047 // Range[]: child-addr  our-addr  child-len
1048 // #cells:    child       ours     child
1049
1050 bool IODTResolveAddressCell( IORegistryEntry * startEntry,
1051                              UInt32 cellsIn[],
1052                              IOPhysicalAddress * phys, IOPhysicalLength * lenOut )
1053 {
1054     IORegistryEntry     * parent;
1055     IORegistryEntry * regEntry;
1056     OSData          * prop;
1057         OSNumber    * num;
1058         unsigned int  index, count;
1059     // cells in addresses at regEntry
1060     UInt32              sizeCells, addressCells;
1061     // cells in addresses below regEntry
1062     UInt32              childSizeCells, childAddressCells;
1063     UInt32              childCells;
1064     UInt32              cell[ 8 ], propLen;
1065     UInt64              offset = 0;
1066     UInt32              endCell[ 8 ];
1067     UInt32              *range;
1068     UInt32              *lookRange;
1069     UInt32              *startRange;
1070     UInt32              *endRanges;
1071     bool                ok = true;
1072     SInt64              diff, diff2, endDiff;
1073     UInt64              len, rangeLen;
1074
1075     IODTPersistent      *persist;
1076     IODTCompareAddressCellFunc  compare;
1077
1078     regEntry = startEntry;
1079     IODTGetCellCounts( regEntry, &childSizeCells, &childAddressCells );
1080     childCells = childAddressCells + childSizeCells;
1081
1082     if (childCells > sizeof(cell)/sizeof(cell[0]))
1083         panic("IODTResolveAddressCell: Invalid device tree (%u,%u)", (uint32_t)childAddressCells, (uint32_t)childSizeCells);
1084
1085     bcopy( cellsIn, cell, sizeof(UInt32) * childCells );
1086     *lenOut = CellsValue( childSizeCells, cellsIn + childAddressCells );
1087
1088     do
1089     {
1090         prop = OSDynamicCast( OSData, regEntry->getProperty( gIODTRangeKey ));
1091         if( 0 == prop) {
1092             /* end of the road */
1093             *phys = CellsValue( childAddressCells, cell );
1094             *phys += offset;
1095             if (regEntry != startEntry) regEntry->release();
1096             break;
1097         }
1098
1099         parent = regEntry->copyParentEntry( gIODTPlane );
1100         IODTGetCellCounts( parent, &sizeCells, &addressCells );
1101
1102         if( (propLen = prop->getLength())) {
1103             // search
1104             startRange = (UInt32 *) prop->getBytesNoCopy();
1105             range = startRange;
1106             endRanges = range + (propLen / sizeof(UInt32));
1107
1108             compare = NULL;
1109             num = OSDynamicCast(OSNumber, regEntry->getProperty(gIODTPersistKey));
1110             if (num)
1111             {
1112                 IOLockLock(gIODTResolversLock);
1113                 index = num->unsigned32BitValue();
1114                 count = gIODTResolvers->getLength() / sizeof(IODTPersistent);
1115                 if (index < count)
1116                 {
1117                     persist = ((IODTPersistent *) gIODTResolvers->getBytesNoCopy()) + index;
1118                     compare = persist->compareFunc;
1119                 }
1120                 IOLockUnlock(gIODTResolversLock);
1121             }
1122
1123             if (!compare && (addressCells == childAddressCells)) {
1124                 compare = DefaultCompare;
1125             }
1126             if (!compare) {
1127                 panic("There is no mixed comparison function yet...");
1128             }
1129
1130             for( ok = false;
1131                     range < endRanges;
1132                     range += (childCells + addressCells) ) {
1133
1134                 // is cell start within range?
1135                 diff = (*compare)( childAddressCells, cell, range );
1136
1137                 if (childAddressCells > sizeof(endCell)/sizeof(endCell[0]))
1138                     panic("IODTResolveAddressCell: Invalid device tree (%u)", (uint32_t)childAddressCells);
1139
1140                 bcopy(range, endCell, childAddressCells * sizeof(UInt32));
1141
1142                 rangeLen = CellsValue(childSizeCells, range + childAddressCells + addressCells);
1143                 AddLengthToCells(childAddressCells, endCell, rangeLen);
1144
1145                 diff2 = (*compare)( childAddressCells, cell, endCell );
1146
1147                 // if start of cell < start of range, or end of range >= start of cell, skip
1148                 if ((diff < 0) || (diff2 >= 0))
1149                     continue;
1150
1151                 len = CellsValue(childSizeCells, cell + childAddressCells);
1152                 ok = (0 == len);
1153
1154                 if (!ok)
1155                 {
1156                     // search for cell end
1157                     bcopy(cell, endCell, childAddressCells * sizeof(UInt32));
1158
1159                     AddLengthToCells(childAddressCells, endCell, len - 1);
1160
1161                     for( lookRange = startRange;
1162                             lookRange < endRanges;
1163                             lookRange += (childCells + addressCells) )
1164                     {
1165                         // make sure end of cell >= range start
1166                         endDiff = (*compare)( childAddressCells, endCell, lookRange );
1167                         if( endDiff < 0)
1168                             continue;
1169
1170                         UInt64 rangeStart = CellsValue(addressCells, range + childAddressCells);
1171                         UInt64 lookRangeStart = CellsValue(addressCells, lookRange + childAddressCells);
1172                         if ((endDiff - len + 1 + lookRangeStart) == (diff + rangeStart))
1173                         {
1174                             ok = true;
1175                             break;
1176                         }
1177                     }
1178                     if (!ok)
1179                         continue;
1180                 }
1181                 offset += diff;
1182                 break;
1183             }
1184
1185             if (addressCells + sizeCells > sizeof(cell)/sizeof(cell[0]))
1186                 panic("IODTResolveAddressCell: Invalid device tree (%u, %u)", (uint32_t)addressCells, (uint32_t)sizeCells);
1187
1188             // Get the physical start of the range from our parent
1189             bcopy( range + childAddressCells, cell, sizeof(UInt32) * addressCells );
1190             bzero( cell + addressCells, sizeof(UInt32) * sizeCells );
1191
1192         } /* else zero length range => pass thru to parent */
1193
1194         if (regEntry != startEntry) regEntry->release();
1195         regEntry                = parent;
1196         childSizeCells          = sizeCells;
1197         childAddressCells       = addressCells;
1198         childCells              = childAddressCells + childSizeCells;
1199     }
1200     while( ok && regEntry);
1201
1202     return( ok);
1203 }
1204
1205
1206 OSArray * IODTResolveAddressing( IORegistryEntry * regEntry,
1207                         const char * addressPropertyName,
1208                         IODeviceMemory * parent )
1209 {
1210     IORegistryEntry             *parentEntry;
1211     OSData                              *addressProperty;
1212     UInt32                              sizeCells, addressCells, cells;
1213     int                                 i, num;
1214     UInt32                              *reg;
1215     IOPhysicalAddress   phys;
1216     IOPhysicalLength    len;
1217     OSArray                             *array;
1218     IODeviceMemory              *range;
1219
1220     array = 0;
1221     do
1222     {
1223         parentEntry = regEntry->copyParentEntry( gIODTPlane );
1224         addressProperty = (OSData *) regEntry->getProperty( addressPropertyName );
1225         if( (0 == addressProperty) || (0 == parentEntry)) break;
1226
1227         IODTGetCellCounts( parentEntry, &sizeCells, &addressCells );
1228         if( 0 == sizeCells) break;
1229
1230         cells = sizeCells + addressCells;
1231         reg = (UInt32 *) addressProperty->getBytesNoCopy();
1232         num = addressProperty->getLength() / (4 * cells);
1233
1234         array = OSArray::withCapacity( 1 );
1235         if( 0 == array) break;
1236
1237         for( i = 0; i < num; i++) {
1238             if( IODTResolveAddressCell( parentEntry, reg, &phys, &len )) {
1239                 range = 0;
1240                 if( parent)
1241                     range = IODeviceMemory::withSubRange( parent,
1242                             phys - parent->getPhysicalSegment(0, 0, kIOMemoryMapperNone), len );
1243                 if( 0 == range)
1244                     range = IODeviceMemory::withRange( phys, len );
1245                 if( range)
1246                     array->setObject( range );
1247             }
1248             reg += cells;
1249         }
1250
1251         regEntry->setProperty( gIODeviceMemoryKey, array);
1252         array->release();       /* ??? */
1253     }
1254     while (false);
1255
1256     OSSafeReleaseNULL(parentEntry);
1257
1258     return (array);
1259 }
1260
1261 OSData * IODTFindSlotName( IORegistryEntry * regEntry, UInt32 deviceNumber )
1262 {
1263     IORegistryEntry             *parent;
1264     OSData                              *data;
1265     OSData                              *ret = 0;
1266     UInt32                              *bits;
1267     UInt32                              i;
1268     size_t              nlen;
1269     char                                *names;
1270     char                                *lastName;
1271     UInt32                              mask;
1272
1273     data = (OSData *) regEntry->getProperty("AAPL,slot-name");
1274     if (data) return (data);
1275
1276     do
1277     {
1278         parent = regEntry->copyParentEntry( gIODTPlane );
1279         if (!parent) break;
1280
1281         data = OSDynamicCast( OSData, parent->getProperty("slot-names"));
1282         if (!data) break;
1283         if (data->getLength() <= 4) break;
1284
1285         bits = (UInt32 *) data->getBytesNoCopy();
1286         mask = *bits;
1287         if ((0 == (mask & (1 << deviceNumber)))) break;
1288
1289         names = (char *)(bits + 1);
1290         lastName = names + (data->getLength() - 4);
1291
1292         for( i = 0; (i <= deviceNumber) && (names < lastName); i++ ) {
1293
1294             if( mask & (1 << i)) {
1295                 nlen = 1 + strnlen(names, lastName - names);
1296                 if( i == deviceNumber) {
1297                     data = OSData::withBytesNoCopy(names, nlen);
1298                     if( data) {
1299                         regEntry->setProperty("AAPL,slot-name", data);
1300                         ret = data;
1301                         data->release();
1302                     }
1303                 } else
1304                     names += nlen;
1305             }
1306         }
1307     }
1308     while (false);
1309
1310     OSSafeReleaseNULL(parent);
1311
1312     return( ret );
1313 }
1314
1315 extern "C" IOReturn IONDRVLibrariesInitialize( IOService * provider )
1316 {
1317     return( kIOReturnUnsupported );
1318 }