![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOFireWireController.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOFireWire|
Return to IOFireWireController.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOFireWire |
1.1 ! root 1: /* ! 2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 24: * ! 25: * HISTORY ! 26: * 27 April 99 wgulland created. ! 27: * ! 28: */ ! 29: ! 30: #include <IOKit/assert.h> ! 31: ! 32: #define DEBUGGING_LEVEL 0 // 1 = low; 2 = high; 3 = extreme ! 33: #define DEBUGLOG kprintf ! 34: ! 35: #include <IOKit/IOWorkLoop.h> ! 36: #include <IOKit/IOTimerEventSource.h> ! 37: #include <IOKit/IOKitKeys.h> ! 38: ! 39: #include <IOKit/firewire/IOFireWireController.h> ! 40: #include <IOKit/firewire/IOFWCommand.h> ! 41: #include <IOKit/firewire/IOFireWireDevice.h> ! 42: #include <IOKit/firewire/IOFWDCLProgram.h> ! 43: #include <IOKit/firewire/IOFWLocalIsochPort.h> ! 44: #include <IOKit/firewire/IOFWAddressSpace.h> ! 45: #include <IOKit/IOBufferMemoryDescriptor.h> ! 46: ! 47: #define kDevicePruneDelay 1000 // 1000 milliseconds ! 48: ! 49: #define FWAddressToID(addr) (addr & 63) ! 50: ! 51: const OSSymbol *gFireWireROM; ! 52: const OSSymbol *gFireWireNodeID; ! 53: const OSSymbol *gFireWireSelfIDs; ! 54: const OSSymbol *gFireWireUnit_Spec_ID; ! 55: const OSSymbol *gFireWireUnit_SW_Version; ! 56: const OSSymbol *gFireWireVendor_ID; ! 57: const OSSymbol *gFireWire_GUID; ! 58: const OSSymbol *gFireWireSpeed; ! 59: ! 60: const IORegistryPlane * IOFireWireController::gIOFireWirePlane = NULL; ! 61: ! 62: enum ReadROMState { ! 63: kReadROMSize, ! 64: kReadingROM ! 65: }; ! 66: ! 67: struct NodeScan { ! 68: IOFireWireController * fControl; ! 69: FWAddress fAddr; ! 70: UInt32 * fBuf; ! 71: UInt32 * fSelfIDs; ! 72: int fNumSelfIDs; ! 73: ReadROMState fState; ! 74: IOFWReadQuadCommand * fCmd; ! 75: UInt32 fROMHdr; ! 76: int fROMSize; ! 77: int fRead; ! 78: }; ! 79: ! 80: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 81: //Utility functions ! 82: ! 83: #define super IOFireWireBus ! 84: ! 85: OSDefineMetaClass( IOFireWireController, IOFireWireBus ) ! 86: OSDefineAbstractStructors(IOFireWireController, IOFireWireBus) ! 87: ! 88: static void doneReset(void *refcon, IOReturn status, IOFireWireBus *bus, IOFWBusCommand *fwCmd) ! 89: { ! 90: fwCmd->release(); ! 91: } ! 92: ! 93: void IOFireWireController::readROMGlue(void *refcon, IOReturn status, ! 94: IOFireWireNub *device, IOFWCommand *fwCmd) ! 95: { ! 96: NodeScan *scan = (NodeScan *)refcon; ! 97: scan->fControl->readDeviceROM(scan, status); ! 98: } ! 99: ! 100: IOReturn IOFireWireController::execCommand(OSObject * obj, void *field0, ! 101: void *field1, void *field2, void *field3) ! 102: { ! 103: // obj is the IOFireWireController, if we need that ! 104: ! 105: IOFWCommand *cmd = (IOFWCommand *)field0; ! 106: //kprintf("Executing command 0x%x\n", cmd); ! 107: return cmd->execute(); ! 108: } ! 109: ! 110: void IOFireWireController::clockTick(OSObject *obj, IOTimerEventSource *src) ! 111: { ! 112: IOFireWireController *me = (IOFireWireController *)obj; ! 113: ! 114: me->pruneDevices(); ! 115: } ! 116: IOWorkLoop * IOFireWireController::createWorkLoop() ! 117: { ! 118: IOWorkLoop * wrkLoop; ! 119: ! 120: wrkLoop = new IOWorkLoop; ! 121: if ( wrkLoop == NULL ) { ! 122: return NULL; ! 123: } ! 124: ! 125: if ( wrkLoop->init() != true ) { ! 126: return NULL; ! 127: } ! 128: ! 129: return wrkLoop; ! 130: } ! 131: ! 132: bool IOFireWireController::init(OSDictionary * dict) ! 133: { ! 134: if(!super::init(dict)) ! 135: return false; ! 136: ! 137: // Create firewire symbols. ! 138: gFireWireROM = OSSymbol::withCString("FireWire Device ROM"); ! 139: gFireWireNodeID = OSSymbol::withCString("FireWire Node ID"); ! 140: gFireWireSelfIDs = OSSymbol::withCString("FireWire Self IDs"); ! 141: gFireWireUnit_Spec_ID = OSSymbol::withCString("Unit_Spec_ID"); ! 142: gFireWireUnit_SW_Version = OSSymbol::withCString("Unit_SW_Version"); ! 143: gFireWireVendor_ID = OSSymbol::withCString("Vendor_ID"); ! 144: gFireWire_GUID = OSSymbol::withCString("GUID"); ! 145: gFireWireSpeed = OSSymbol::withCString("FireWire Speed"); ! 146: ! 147: if(NULL == gIOFireWirePlane) { ! 148: gIOFireWirePlane = IORegistryEntry::makePlane( kIOFireWirePlane ); ! 149: } ! 150: ! 151: fLocalAddresses = OSSet::withCapacity(3); // Local ROM + CSR registers + SBP-2 ORBs ! 152: if(fLocalAddresses) ! 153: fSpaceIterator = OSCollectionIterator::withCollection(fLocalAddresses); ! 154: ! 155: fAllocatedChannels = OSSet::withCapacity(1); // DV channel. ! 156: if(fAllocatedChannels) ! 157: fAllocChannelIterator = OSCollectionIterator::withCollection(fAllocatedChannels); ! 158: ! 159: fLastTrans = kMaxPendingTransfers-1; ! 160: fTransAllocLock = IOLockAlloc(); ! 161: fChannelLock = IOLockAlloc(); ! 162: ! 163: return (gFireWireROM != NULL && gFireWireNodeID != NULL && ! 164: fChannelLock != NULL && fTransAllocLock != NULL && ! 165: gFireWireUnit_Spec_ID != NULL && gFireWireUnit_SW_Version != NULL && ! 166: fLocalAddresses != NULL && fSpaceIterator != NULL && ! 167: fAllocatedChannels != NULL && fAllocChannelIterator != NULL); ! 168: } ! 169: ! 170: bool IOFireWireController::startWorkLoop() ! 171: { ! 172: OSData *rom; ! 173: UInt16 crc16; ! 174: IOReturn status; ! 175: CSRROMEntryID csrROMRootEntryID = kInvalidCSRROMEntryID; ! 176: CSRROMEntryID csrROMEntryID = kInvalidCSRROMEntryID; ! 177: UInt32 immediateEntry; ! 178: ! 179: ! 180: kprintf("Local GUID = 0x%x:0x%x\n", (UInt32)(fUniqueID >> 32), (UInt32)(fUniqueID & 0xffffffff)); ! 181: ! 182: // Build local device ROM ! 183: rom = OSData::withCapacity(20); // smallest possible real ROM ! 184: if(!rom) ! 185: return false; ! 186: ! 187: // Allocate address space for Configuration ROM and fill in Bus Info ! 188: // block. ! 189: fROMHeader[1] = kFWBIBBusName; ! 190: fROMHeader[2] = ! 191: kFWBIBIrmc | kFWBIBCmc | kFWBIBIsc | (8 << kFWBIBMaxRecPhase); ! 192: fROMHeader[3] = fUniqueID >> 32; ! 193: fROMHeader[4] = fUniqueID & 0xffffffff; ! 194: ! 195: crc16 = FWComputeCRC16 (&fROMHeader[1], 4); ! 196: fROMHeader[0] = 0x04040000 | crc16; ! 197: ! 198: rom->appendBytes(fROMHeader, 20); ! 199: setProperty(gFireWireROM, rom); ! 200: rom->release(); // XXX -- svail: added. ! 201: ! 202: // Create root directory in FWIM data.//zzz should we have one for each FWIM or just one??? ! 203: fCSRROMRootDirectory.csrROMEntryData.pParentCSRROMEntryData = NULL; ! 204: fCSRROMRootDirectory.csrROMEntryData.pPrevCSRROMEntryData = NULL; ! 205: fCSRROMRootDirectory.csrROMEntryData.pNextCSRROMEntryData = NULL; ! 206: fCSRROMRootDirectory.csrROMEntryData.entryType = ! 207: kDirectoryCSRROMEntryType; ! 208: //fCSRROMRootDirectory->csrROMEntryData.fwimID = fwimID; ! 209: //fCSRROMRootDirectory.csrROMEntryData.pEntryLocation = NULL; ! 210: fCSRROMRootDirectory.csrROMBasicEntryData.keyValue = 0; ! 211: fCSRROMRootDirectory.pChildCSRROMEntryData = NULL; ! 212: fCSRROMRootDirectory.numChildren = 0; ! 213: ! 214: status = CSRROMGetRootDirectory (&csrROMRootEntryID); ! 215: ! 216: // Set our CSR ROM generation. ! 217: if (status == kIOReturnSuccess) { ! 218: immediateEntry = 0; ! 219: status = CSRROMCreateEntry (csrROMRootEntryID, ! 220: &csrROMEntryID, ! 221: kImmediateCSRROMEntryType, ! 222: kCSRGenerationKey, ! 223: (UInt8 *) &immediateEntry, ! 224: 3); ! 225: } ! 226: ! 227: // Set our module vendor ID. ! 228: if (status == kIOReturnSuccess) { ! 229: immediateEntry = 0x00A040 << 8; ! 230: status = CSRROMCreateEntry (csrROMRootEntryID, ! 231: &csrROMEntryID, ! 232: kImmediateCSRROMEntryType, ! 233: kCSRModuleVendorIDKey, ! 234: (UInt8 *) &immediateEntry, ! 235: 3); ! 236: } ! 237: ! 238: // Set our capabilities. ! 239: if (status == kIOReturnSuccess) { ! 240: immediateEntry = 0x000083C0 << 8;//zzz need real values. ! 241: status = CSRROMCreateEntry (csrROMRootEntryID, ! 242: &csrROMEntryID, ! 243: kImmediateCSRROMEntryType, ! 244: kCSRNodeCapabilitiesKey, ! 245: (UInt8 *) &immediateEntry, ! 246: 3); ! 247: } ! 248: ! 249: // Set our node unique ID. ! 250: if (status == kIOReturnSuccess) { ! 251: status = CSRROMCreateEntry (csrROMRootEntryID, ! 252: &csrROMEntryID, ! 253: kLeafCSRROMEntryType, ! 254: kCSRNodeUniqueIdKey, ! 255: &fUniqueID, ! 256: 8); ! 257: } ! 258: ! 259: // Will instantiate at end (causes a bus reset). ! 260: // Clean up ROM entry references ! 261: if (csrROMRootEntryID != kInvalidCSRROMEntryID) ! 262: FWCSRROMDisposeEntryID (csrROMRootEntryID); ! 263: ! 264: if (csrROMEntryID != kInvalidCSRROMEntryID) ! 265: FWCSRROMDisposeEntryID (csrROMEntryID); ! 266: ! 267: // Create command gate, start probing etc. ! 268: fGate = IOCommandGate::commandGate(this, execCommand); ! 269: if(!fGate) ! 270: return false; ! 271: ! 272: // Create Timer Event source ! 273: fTimer = IOTimerEventSource::timerEventSource(this, clockTick); ! 274: if(!fTimer) ! 275: return false; ! 276: ! 277: fWorkLoop = createWorkLoop(); ! 278: fWorkLoop->addEventSource(fGate); ! 279: fWorkLoop->addEventSource(fTimer); ! 280: ! 281: ! 282: IOFWUpdateROM *reset = new IOFWUpdateROM; ! 283: if(reset) { ! 284: if(reset->initWithController(this, doneReset, NULL)) ! 285: reset->submit(); ! 286: else { ! 287: reset->release(); ! 288: reset = NULL; ! 289: } ! 290: } ! 291: ! 292: return fWorkLoop != NULL && reset != NULL; ! 293: } ! 294: ! 295: IOWorkLoop *IOFireWireController::getWorkLoop() const ! 296: { ! 297: return fWorkLoop; ! 298: } ! 299: ! 300: AsyncPendingTrans *IOFireWireController::allocTrans(bool sleepOK) ! 301: { ! 302: unsigned int i; ! 303: unsigned int tran; ! 304: ! 305: do { ! 306: IOTakeLock(fTransAllocLock); ! 307: tran = fLastTrans; ! 308: for(i=0; i<kMaxPendingTransfers; i++) { ! 309: AsyncPendingTrans *t; ! 310: tran++; ! 311: if(tran >= kMaxPendingTransfers) ! 312: tran = 0; ! 313: t = &fTrans[tran]; ! 314: if(!t->fInUse) { ! 315: t->fHandler = NULL; ! 316: t->fInUse = true; ! 317: t->fTCode = tran; ! 318: fLastTrans = tran; ! 319: IOUnlock(fTransAllocLock); ! 320: return t; ! 321: } ! 322: } ! 323: IOUnlock(fTransAllocLock); ! 324: IOLog("Out of FireWire read request codes!\n"); ! 325: if(!sleepOK) ! 326: break; ! 327: IOSleep(10); ! 328: } while (true); ! 329: return NULL; ! 330: } ! 331: ! 332: void IOFireWireController::freeTrans(AsyncPendingTrans *trans) ! 333: { ! 334: // No lock needed - can't have two users of a tcode. ! 335: trans->fInUse = false; ! 336: } ! 337: ! 338: ! 339: void IOFireWireController::readDeviceROM(NodeScan *scan, IOReturn status) ! 340: { ! 341: bool done = true; ! 342: if(status != kIOReturnSuccess) { ! 343: // If status isn't bus reset, make a dummy registry entry. ! 344: if(status == kIOFireWireBusReset) ! 345: return; ! 346: ! 347: OSDictionary *propTable; ! 348: UInt32 nodeID = FWAddressToID(scan->fAddr.nodeID); ! 349: OSObject * prop; ! 350: propTable = OSDictionary::withCapacity(3); ! 351: prop = OSNumber::withNumber(scan->fAddr.nodeID, 16); ! 352: propTable->setObject(gFireWireNodeID, prop); ! 353: prop->release(); ! 354: ! 355: prop = OSNumber::withNumber((scan->fSelfIDs[0] & kFWSelfID0SP) >> kFWSelfID0SPPhase, 32); ! 356: propTable->setObject(gFireWireSpeed, prop); ! 357: prop->release(); ! 358: ! 359: prop = OSData::withBytes(scan->fSelfIDs, scan->fNumSelfIDs*sizeof(UInt32)); ! 360: propTable->setObject(gFireWireSelfIDs, prop); ! 361: prop->release(); ! 362: ! 363: IORegistryEntry * newPhy; ! 364: newPhy = new IORegistryEntry; ! 365: if(newPhy) { ! 366: if(!newPhy->init(propTable)) { ! 367: newPhy->release(); ! 368: newPhy = NULL; ! 369: } ! 370: } ! 371: fNodes[nodeID] = newPhy; ! 372: if(propTable) ! 373: propTable->release(); ! 374: fNumROMReads--; ! 375: if(fNumROMReads == 0) { ! 376: fTimer->enable(); ! 377: fTimer->setTimeoutMS(kDevicePruneDelay); // One second ! 378: } ! 379: ! 380: if(scan->fBuf) ! 381: IOFree(scan->fBuf, scan->fROMSize); ! 382: scan->fCmd->release(); ! 383: IOFree(scan, sizeof(*scan)); ! 384: return; ! 385: } ! 386: ! 387: if(scan->fState == kReadROMSize) { ! 388: if( ((scan->fROMHdr & kCSRBusInfoBlockLength) >> kCSRBusInfoBlockLengthPhase) == 1) { ! 389: // Minimal ROM ! 390: scan->fROMSize = 4; ! 391: done = true; ! 392: } ! 393: else { ! 394: scan->fROMSize = 4*((scan->fROMHdr & kCSRROMCRCLength) >> kCSRROMCRCLengthPhase) + 4; ! 395: scan->fBuf = (UInt32 *)IOMalloc(scan->fROMSize); ! 396: *scan->fBuf = scan->fROMHdr; ! 397: scan->fRead = 4; ! 398: if(scan->fROMSize > 4) { ! 399: scan->fState = kReadingROM; ! 400: scan->fAddr.addressLo = kCSRROMBaseAddress+4; ! 401: scan->fCmd->reinit(scan->fAddr, scan->fBuf+1, scan->fROMSize/4-1, ! 402: &readROMGlue, scan, true); ! 403: scan->fCmd->execute(); ! 404: done = false; ! 405: } ! 406: else ! 407: done = true; ! 408: } ! 409: } ! 410: if(done) { ! 411: // Check if node exists, if not create it ! 412: #if (DEBUGGING_LEVEL > 0) ! 413: DEBUGLOG("Finished reading ROM for node 0x%x\n", scan->fNodeID); ! 414: #endif ! 415: OSDictionary * propTable = NULL; ! 416: IOFireWireDevice * newDevice = NULL; ! 417: OSData * rom = NULL; ! 418: do { ! 419: CSRNodeUniqueID guid; ! 420: OSIterator *childIterator; ! 421: if(scan->fROMSize >= 20) ! 422: guid = *(CSRNodeUniqueID *)(scan->fBuf+3); ! 423: else ! 424: guid = scan->fROMHdr; // Best we can do. ! 425: if(scan->fROMSize == 4) ! 426: rom = OSData::withBytes(&scan->fROMHdr, 4); ! 427: else ! 428: rom = OSData::withBytes(scan->fBuf, scan->fROMSize); ! 429: childIterator = getClientIterator(); ! 430: if( childIterator) { ! 431: IOFireWireDevice * found; ! 432: while( (found = (IOFireWireDevice *) childIterator->getNextObject())) { ! 433: if(found->fUniqueID == guid) { ! 434: newDevice = found; ! 435: break; ! 436: } ! 437: } ! 438: childIterator->release(); ! 439: } ! 440: ! 441: if(newDevice) { ! 442: // Just update device properties. ! 443: newDevice->setNodeROM(fBusGeneration, scan->fAddr.nodeID, fLocalNodeID, ! 444: rom, scan->fSelfIDs, scan->fNumSelfIDs); ! 445: newDevice->retain(); // match release, since not newly created. ! 446: } ! 447: else { ! 448: OSObject * prop; ! 449: propTable = OSDictionary::withCapacity(6); ! 450: if (!propTable) ! 451: continue; ! 452: ! 453: prop = OSNumber::withNumber(guid, 64); ! 454: propTable->setObject(gFireWire_GUID, prop); ! 455: prop->release(); ! 456: prop = OSNumber::withNumber((scan->fSelfIDs[0] & kFWSelfID0SP) >> kFWSelfID0SPPhase, 32); ! 457: propTable->setObject(gFireWireSpeed, prop); ! 458: prop->release(); ! 459: newDevice = createDeviceNub(propTable); ! 460: if (!newDevice) ! 461: continue; ! 462: propTable->release(); // done with it after init ! 463: propTable = NULL; ! 464: ! 465: if (!newDevice->attach(this)) ! 466: continue; ! 467: newDevice->setNodeROM(fBusGeneration, scan->fAddr.nodeID, fLocalNodeID, ! 468: rom, scan->fSelfIDs, scan->fNumSelfIDs); ! 469: newDevice->registerService(); ! 470: } ! 471: if(fIRMNodeID == scan->fAddr.nodeID) { ! 472: IOFWIsochChannel *found; ! 473: fIRMDevice = newDevice; ! 474: // Tell all active ioschronous channels to re-allocate bandwidth ! 475: IOTakeLock(fChannelLock); ! 476: fAllocChannelIterator->reset(); ! 477: while( (found = (IOFWIsochChannel *) fAllocChannelIterator->getNextObject())) { ! 478: found->handleBusReset(); ! 479: } ! 480: IOUnlock(fChannelLock); ! 481: } ! 482: UInt32 nodeID = FWAddressToID(scan->fAddr.nodeID); ! 483: fNodes[nodeID] = newDevice; ! 484: fNodes[nodeID]->retain(); ! 485: } while (false); ! 486: if (propTable) ! 487: propTable->release(); ! 488: if (newDevice) ! 489: newDevice->release(); ! 490: if (rom) ! 491: rom->release(); ! 492: if(scan->fBuf) ! 493: IOFree(scan->fBuf, scan->fROMSize); ! 494: scan->fCmd->release(); ! 495: IOFree(scan, sizeof(*scan)); ! 496: fNumROMReads--; ! 497: if(fNumROMReads == 0) { ! 498: fTimer->enable(); ! 499: fTimer->setTimeoutMS(kDevicePruneDelay); // One second ! 500: } ! 501: } ! 502: } ! 503: ! 504: ! 505: // ! 506: // Hardware detected a bus reset. ! 507: // At this point we don't know what the hardware addresses are ! 508: void IOFireWireController::processBusReset() ! 509: { ! 510: clock_get_uptime(&fResetTime); // Update even if we're already processing a reset ! 511: ! 512: if(!fInReset) { ! 513: fInReset = true; ! 514: unsigned int i; ! 515: ! 516: fTimer->cancelTimeout(); ! 517: ! 518: // Set all current device nodeIDs to something invalid ! 519: OSIterator *childIterator; ! 520: childIterator = getClientIterator(); ! 521: if( childIterator) { ! 522: IOFireWireDevice * found; ! 523: while( (found = (IOFireWireDevice *) childIterator->getNextObject())) { ! 524: found->setNodeROM(fBusGeneration, kFWBadNodeID, kFWBadNodeID, NULL, NULL, 0); ! 525: } ! 526: childIterator->release(); ! 527: } ! 528: ! 529: ! 530: // Invalidate current topology and speed map ! 531: fBusGeneration++; ! 532: bzero(fSpeedCodes, sizeof(fSpeedCodes)); ! 533: ! 534: // Zap all outstanding async requests ! 535: for(i=0; i<kMaxPendingTransfers; i++) { ! 536: AsyncPendingTrans *t = &fTrans[i]; ! 537: if(t->fInUse) { ! 538: IOFWAsyncCommand * cmd = t->fHandler; ! 539: if(cmd) { ! 540: cmd->gotPacket(this, kFWResponseBusResetError, NULL, 0); ! 541: } ! 542: } ! 543: } ! 544: ! 545: // Clear out the old firewire plane ! 546: if(fNodes[fRootNodeID]) { ! 547: fNodes[fRootNodeID]->detachAll(gIOFireWirePlane); ! 548: } ! 549: for(i=0; i<=fRootNodeID; i++) { ! 550: if(fNodes[i]) { ! 551: fNodes[i]->release(); ! 552: fNodes[i] = NULL; ! 553: } ! 554: } ! 555: } ! 556: } ! 557: ! 558: // ! 559: // SelfID packets received after reset. ! 560: void IOFireWireController::processSelfIDs(UInt32 *IDs, int numIDs, UInt32 *ownIDs, int numOwnIDs) ! 561: { ! 562: OSObject *prop; ! 563: int i; ! 564: UInt32 id; ! 565: UInt32 nodeID; ! 566: UInt16 irmID, ourID; ! 567: ! 568: #if 0 ! 569: for(i=0; i<numIDs; i++) ! 570: IOLog("ID %d: 0x%x <-> 0x%x\n", i, IDs[2*i], ~IDs[2*i+1]); ! 571: ! 572: for(i=0; i<numOwnIDs; i++) ! 573: IOLog("Own ID %d: 0x%x <-> 0x%x\n", i, ownIDs[2*i], ~ownIDs[2*i+1]); ! 574: #endif ! 575: // If not processing a reset, then we should be ! 576: // This can happen if we get two resets in quick succession ! 577: if(!fInReset) ! 578: processBusReset(); ! 579: fInReset = false; ! 580: fNumROMReads = 0; ! 581: ! 582: // Update the registry entry for our local nodeID, ! 583: // which will have been updated by the device driver. ! 584: prop = OSNumber::withNumber(fLocalNodeID, 16); ! 585: setProperty(gFireWireNodeID, prop); ! 586: prop->release(); ! 587: prop = OSNumber::withNumber((ownIDs[0] & kFWSelfID0SP) >> kFWSelfID0SPPhase, 32); ! 588: setProperty(gFireWireSpeed, prop); ! 589: prop->release(); ! 590: ! 591: // Initialize root node to be our node, we'll update it below to be the highest node ID. ! 592: fRootNodeID = ourID = (*ownIDs & kFWPhyPacketPhyID) >> kFWPhyPacketPhyIDPhase; ! 593: ! 594: fNodes[ourID] = this; ! 595: retain(); ! 596: ! 597: // Copy over the selfIDs, checking validity and merging in our selfIDs if they aren't ! 598: // already in the list. ! 599: SInt16 prevID = -1; // Impossible ID. ! 600: UInt32 *idPtr = fSelfIDs; ! 601: for(i=0; i<numIDs; i++) { ! 602: UInt32 id = IDs[2*i]; ! 603: UInt16 currID = (id & kFWPhyPacketPhyID) >> kFWPhyPacketPhyIDPhase; ! 604: ! 605: if(id != ~IDs[2*i+1]) { ! 606: IOLog("Bad SelfID packet %d: 0x%x != 0x%x!\n", i, id, ~IDs[2*i+1]); ! 607: resetBus(); // Could wait a bit in case somebody else spots the bad packet ! 608: return; ! 609: } ! 610: if(currID != prevID) { ! 611: // Check for ownids not in main list ! 612: if(prevID < ourID && currID > ourID) { ! 613: int j; ! 614: fNodeIDs[ourID] = idPtr; ! 615: for(j=0; j<numOwnIDs; j++) ! 616: *idPtr++ = ownIDs[2*j]; ! 617: } ! 618: fNodeIDs[currID] = idPtr; ! 619: prevID = currID; ! 620: if(fRootNodeID < currID) ! 621: fRootNodeID = currID; ! 622: } ! 623: *idPtr++ = id; ! 624: } ! 625: // Check for ownids at end & not in main list ! 626: if(prevID < ourID) { ! 627: int j; ! 628: fNodeIDs[ourID] = idPtr; ! 629: for(j=0; j<numOwnIDs; j++) ! 630: *idPtr++ = ownIDs[2*j]; ! 631: } ! 632: // Stick a known elephant at the end. ! 633: fNodeIDs[fRootNodeID+1] = idPtr; ! 634: ! 635: buildTopology(false); ! 636: ! 637: prop = OSData::withBytes(fNodeIDs[ourID], numOwnIDs*sizeof(UInt32)); ! 638: setProperty(gFireWireSelfIDs, prop); ! 639: prop->release(); ! 640: ! 641: // Ask each device for its GUID. ! 642: // In the completion handler we'll match the new IDs to existing ! 643: // nubs and create new ones. ! 644: #if (DEBUGGING_LEVEL > 0) ! 645: for(i=0; i<numIDs; i++) { ! 646: id = IDs[2*i]; ! 647: if(id != ~IDs[2*i+1]) { ! 648: DEBUGLOG("Bad SelfID: 0x%x <-> 0x%x\n", id, ~IDs[2*i+1]); ! 649: continue; ! 650: } ! 651: DEBUGLOG("SelfID: 0x%x\n", id); ! 652: } ! 653: DEBUGLOG("Our ID: 0x%x\n", *ownIDs); ! 654: #endif ! 655: irmID = 0; ! 656: for(i=0; i<=fRootNodeID; i++) { ! 657: if(i == ourID) ! 658: continue; // Skip ourself! ! 659: id = *fNodeIDs[i]; ! 660: // Get nodeID. ! 661: nodeID = (id & kFWSelfIDPhyID) >> kFWSelfIDPhyIDPhase; ! 662: nodeID |= kFWLocalBusAddress>>kCSRNodeIDPhase; ! 663: ! 664: if((id & (kFWSelfID0C | kFWSelfID0L)) == (kFWSelfID0C | kFWSelfID0L)) { ! 665: kprintf("IRM contender: %x\n", nodeID); ! 666: if(nodeID > irmID) ! 667: irmID = nodeID; ! 668: } ! 669: ! 670: // Read ROM header if link is active (MacOS8 turns link on, why?) ! 671: if(true) { //id & kFWSelfID0L) { ! 672: NodeScan *scan; ! 673: scan = (NodeScan *)IOMalloc(sizeof(*scan)); ! 674: fNumROMReads++; ! 675: ! 676: scan->fControl = this; ! 677: scan->fAddr.nodeID = nodeID; ! 678: scan->fAddr.addressHi = kCSRRegisterSpaceBaseAddressHi; ! 679: scan->fAddr.addressLo = kCSRBIBHeaderAddress; ! 680: scan->fSelfIDs = fNodeIDs[i]; ! 681: scan->fNumSelfIDs = fNodeIDs[i+1] - fNodeIDs[i]; ! 682: scan->fState = kReadROMSize; ! 683: scan->fCmd = new IOFWReadQuadCommand; ! 684: scan->fCmd->initAll(this, NULL, scan->fAddr, &scan->fROMHdr, 1, ! 685: &readROMGlue, scan, true); ! 686: scan->fBuf = NULL; ! 687: scan->fCmd->execute(); ! 688: } ! 689: } ! 690: if(irmID != 0) ! 691: fIRMNodeID = irmID; ! 692: else ! 693: fIRMNodeID = kFWBadNodeID; ! 694: if(fNumROMReads == 0) { ! 695: fTimer->enable(); ! 696: fTimer->setTimeoutMS(kDevicePruneDelay); // One second ! 697: } ! 698: } ! 699: ! 700: void IOFireWireController::buildTopology(bool doFWPlane) ! 701: { ! 702: int i; ! 703: IORegistryEntry *root; ! 704: struct FWNodeScan ! 705: { ! 706: int nodeID; ! 707: int childrenRemaining; ! 708: IORegistryEntry *node; ! 709: }; ! 710: FWNodeScan scanList[kFWMaxNodeHops]; ! 711: FWNodeScan *level; ! 712: root = fNodes[fRootNodeID]; ! 713: level = scanList; ! 714: ! 715: // First build the topology. ! 716: for(i=fRootNodeID; i>=0; i--) { ! 717: UInt32 id0; ! 718: UInt8 speedCode; ! 719: IORegistryEntry *node = fNodes[i]; ! 720: id0 = *fNodeIDs[i]; ! 721: int children = 0; ! 722: UInt32 port; ! 723: port = (id0 & kFWSelfID0P0) >> kFWSelfID0P0Phase; ! 724: if(port == kFWSelfIDPortStatusChild) ! 725: children++; ! 726: port = (id0 & kFWSelfID0P1) >> kFWSelfID0P1Phase; ! 727: if(port == kFWSelfIDPortStatusChild) ! 728: children++; ! 729: port = (id0 & kFWSelfID0P2) >> kFWSelfID0P2Phase; ! 730: if(port == kFWSelfIDPortStatusChild) ! 731: children++; ! 732: ! 733: // Add node to bottom of tree ! 734: level->nodeID = i; ! 735: level->childrenRemaining = children; ! 736: level->node = node; ! 737: ! 738: // Add node's self speed to speedmap ! 739: speedCode = (id0 & kFWSelfID0SP) >> kFWSelfID0SPPhase; ! 740: fSpeedCodes[(kFWMaxNodesPerBus + 1)*i + i] = speedCode; ! 741: ! 742: // Add to parent ! 743: // Compute rest of this node's speed map entries unless it's the root. ! 744: // We only need to compute speeds between this node and all higher node numbers. ! 745: // These speeds will be the minimum of this node's speed and the speed between ! 746: // this node's parent and the other higher numbered nodes. ! 747: if (i != fRootNodeID) { ! 748: int parentNodeNum, scanNodeNum; ! 749: parentNodeNum = (level-1)->nodeID; ! 750: if(doFWPlane) ! 751: node->attachToParent((level-1)->node, gIOFireWirePlane); ! 752: for (scanNodeNum = i + 1; scanNodeNum <= fRootNodeID; scanNodeNum++) { ! 753: UInt8 scanSpeedCode; ! 754: // Get speed code between parent and scan node. ! 755: scanSpeedCode = ! 756: fSpeedCodes[(kFWMaxNodesPerBus + 1)*parentNodeNum + scanNodeNum]; ! 757: ! 758: // Set speed map entry to minimum of scan speed and node's speed. ! 759: if (speedCode < scanSpeedCode) ! 760: scanSpeedCode = speedCode; ! 761: fSpeedCodes[(kFWMaxNodesPerBus + 1)*i + scanNodeNum] = scanSpeedCode; ! 762: fSpeedCodes[(kFWMaxNodesPerBus + 1)*scanNodeNum + i] = scanSpeedCode; ! 763: } ! 764: } ! 765: // Find next child port. ! 766: if (i > 0) { ! 767: while (level->childrenRemaining == 0) { ! 768: // Go up one level in tree. ! 769: level--; ! 770: ! 771: // One less child to scan. ! 772: level->childrenRemaining--; ! 773: } ! 774: // Go down one level in tree. ! 775: level++; ! 776: } ! 777: } ! 778: ! 779: ! 780: if(doFWPlane) { ! 781: IOLog("FireWire Speed map:\n"); ! 782: for(i=0; i <= fRootNodeID; i++) { ! 783: int j; ! 784: for(j=0; j <= fRootNodeID; j++) { ! 785: IOLog("%d ", fSpeedCodes[(kFWMaxNodesPerBus + 1)*i + j]); ! 786: } ! 787: IOLog("\n"); ! 788: } ! 789: } ! 790: // Finally attach the full topology into the IOKit registry ! 791: if(doFWPlane) ! 792: root->attachToParent(IORegistryEntry::getRegistryRoot(), gIOFireWirePlane); ! 793: } ! 794: ! 795: void IOFireWireController::pruneDevices() ! 796: { ! 797: OSIterator *childIterator; ! 798: childIterator = getClientIterator(); ! 799: if( childIterator) { ! 800: IOFireWireDevice * found; ! 801: while( (found = (IOFireWireDevice *) childIterator->getNextObject())) { ! 802: if(found->fNodeID == kFWBadNodeID) { ! 803: found->terminate(); ! 804: } ! 805: } ! 806: childIterator->release(); ! 807: } ! 808: ! 809: buildTopology(true); ! 810: } ! 811: ! 812: //////////////////////////////////////////////////////////////////////////////// ! 813: // ! 814: // processWriteRequest ! 815: // ! 816: // process quad and block writes. ! 817: // ! 818: void IOFireWireController::processWriteRequest(UInt16 sourceID, UInt32 tLabel, ! 819: UInt32 *hdr, void *buf, int len) ! 820: { ! 821: UInt32 ret = kFWResponseAddressError; ! 822: FWAddress addr((hdr[1] & kFWAsynchDestinationOffsetHigh) >> kFWAsynchDestinationOffsetHighPhase, hdr[2]); ! 823: IOFWAddressSpace * found; ! 824: fSpaceIterator->reset(); ! 825: while( (found = (IOFWAddressSpace *) fSpaceIterator->getNextObject())) { ! 826: ret = found->doWrite(sourceID, addr, len, buf, false); ! 827: if(ret != kFWResponseAddressError) ! 828: break; ! 829: } ! 830: asyncWriteResponse(sourceID, FWSpeed(sourceID), tLabel, ret, addr.addressHi); ! 831: } ! 832: ! 833: //////////////////////////////////////////////////////////////////////////////// ! 834: // ! 835: // processLockRequest ! 836: // ! 837: // process 32 and 64 bit locks. ! 838: // ! 839: void IOFireWireController::processLockRequest(UInt16 sourceID, UInt32 tLabel, ! 840: UInt32 *hdr, void *buf, int len) ! 841: { ! 842: UInt32 oldVal[2]; ! 843: UInt32 ret = kFWResponseAddressError; ! 844: bool ok; ! 845: int size; ! 846: int i; ! 847: int type = (hdr[3] & kFWAsynchExtendedTCode) >> kFWAsynchExtendedTCodePhase; ! 848: FWAddress addr((hdr[1] & kFWAsynchDestinationOffsetHigh) >> kFWAsynchDestinationOffsetHighPhase, hdr[2]); ! 849: IOFWAddressSpace * found; ! 850: IOMemoryDescriptor *desc = NULL; ! 851: IOByteCount offset; ! 852: ! 853: ! 854: size = len/8; // Depends on type, but right for 'compare and swap' ! 855: ! 856: fSpaceIterator->reset(); ! 857: while( (found = (IOFWAddressSpace *) fSpaceIterator->getNextObject())) { ! 858: ret = found->doRead(sourceID, addr, size*4, &desc, &offset, true); ! 859: if(ret != kFWResponseAddressError) ! 860: break; ! 861: } ! 862: if(NULL != desc) { ! 863: desc->readBytes(offset,oldVal, size*4); ! 864: switch (type) { ! 865: case kFWExtendedTCodeCompareSwap: ! 866: ok = true; ! 867: for(i=0; i<size; i++) ! 868: ok = ok && oldVal[i] == ((UInt32 *)buf)[i]; ! 869: if(ok) ! 870: ret = found->doWrite(sourceID, addr, size*4, (UInt32 *)buf+size, true); ! 871: break; ! 872: ! 873: default: ! 874: ret = kFWResponseTypeError; ! 875: } ! 876: asyncLockResponse(sourceID, FWSpeed(sourceID), tLabel, ret, type, oldVal, size*4); ! 877: } ! 878: else { ! 879: oldVal[0] = 0xdeadbabe; ! 880: asyncLockResponse(sourceID, FWSpeed(sourceID), tLabel, ret, type, oldVal, 4); ! 881: } ! 882: } ! 883: ! 884: //////////////////////////////////////////////////////////////////////////////// ! 885: // ! 886: // processRcvPacket ! 887: // ! 888: // Dispatch received Async packet based on tCode. ! 889: // ! 890: void IOFireWireController::processRcvPacket(UInt32 *data, int size) ! 891: { ! 892: #if 0 ! 893: int i; ! 894: kprintf("Received packet 0x%x size %d\n", data, size); ! 895: for(i=0; i<size; i++) { ! 896: kprintf("0x%x ", data[i]); ! 897: } ! 898: kprintf("\n"); ! 899: #endif ! 900: UInt32 tCode, tLabel; ! 901: UInt32 quad0; ! 902: UInt16 sourceID; ! 903: ! 904: // Get first quad. ! 905: quad0 = *data; ! 906: ! 907: tCode = (quad0 & kFWPacketTCode) >> kFWPacketTCodePhase; ! 908: tLabel = (quad0 & kFWAsynchTLabel) >> kFWAsynchTLabelPhase; ! 909: sourceID = (data[1] & kFWAsynchSourceID) >> kFWAsynchSourceIDPhase; ! 910: ! 911: // Dispatch processing based on tCode. ! 912: switch (tCode) ! 913: { ! 914: case kFWTCodeWriteQuadlet : ! 915: #if (DEBUGGING_LEVEL > 0) ! 916: DEBUGLOG("WriteQuadlet: addr 0x%x:0x%x\n", ! 917: (data[1] & kFWAsynchDestinationOffsetHigh) >> kFWAsynchDestinationOffsetHighPhase, data[2]); ! 918: #endif ! 919: processWriteRequest(sourceID, tLabel, data, &data[3], 4); ! 920: break; ! 921: ! 922: case kFWTCodeWriteBlock : ! 923: #if (DEBUGGING_LEVEL > 0) ! 924: DEBUGLOG("WriteBlock: addr 0x%x:0x%x\n", ! 925: (data[1] & kFWAsynchDestinationOffsetHigh) >> kFWAsynchDestinationOffsetHighPhase, data[2]); ! 926: #endif ! 927: processWriteRequest(sourceID, tLabel, data, &data[4], ! 928: (data[3] & kFWAsynchDataLength) >> kFWAsynchDataLengthPhase); ! 929: break; ! 930: ! 931: case kFWTCodeWriteResponse : ! 932: if(fTrans[tLabel].fInUse) { ! 933: IOFWAsyncCommand * cmd = fTrans[tLabel].fHandler; ! 934: cmd->gotPacket(this, ! 935: (data[1] & kFWAsynchRCode)>>kFWAsynchRCodePhase, 0, 0); ! 936: } ! 937: else { ! 938: #if (DEBUGGING_LEVEL > 0) ! 939: DEBUGLOG("WriteResponse: label %d isn't in use!!\n", tLabel); ! 940: #endif ! 941: } ! 942: break; ! 943: ! 944: case kFWTCodeReadQuadlet : ! 945: #if (DEBUGGING_LEVEL > 0) ! 946: DEBUGLOG("ReadQuadlet: addr 0x%x:0x%x\n", ! 947: (data[1] & kFWAsynchDestinationOffsetHigh) >> kFWAsynchDestinationOffsetHighPhase, data[2]); ! 948: #endif ! 949: { ! 950: // Rather inefficiently search for a matching address space ! 951: UInt32 ret = kFWResponseAddressError; ! 952: FWAddress addr((data[1] & kFWAsynchDestinationOffsetHigh) >> kFWAsynchDestinationOffsetHighPhase, data[2]); ! 953: IOFWAddressSpace * found; ! 954: IOMemoryDescriptor *buf = NULL; ! 955: IOByteCount offset; ! 956: fSpaceIterator->reset(); ! 957: while( (found = (IOFWAddressSpace *) fSpaceIterator->getNextObject())) { ! 958: ret = found->doRead(sourceID, addr, 4, &buf, &offset, false); ! 959: if(ret != kFWResponseAddressError) ! 960: break; ! 961: } ! 962: if(NULL != buf) { ! 963: IOByteCount lengthOfSegment; ! 964: asyncReadQuadResponse(sourceID, FWSpeed(sourceID), tLabel, ret, ! 965: *(UInt32 *)buf->getVirtualSegment(offset, &lengthOfSegment)); ! 966: } ! 967: else { ! 968: asyncReadQuadResponse(sourceID, FWSpeed(sourceID), ! 969: tLabel, ret, 0xdeadbeef); ! 970: } ! 971: } ! 972: break; ! 973: ! 974: case kFWTCodeReadBlock : ! 975: #if (DEBUGGING_LEVEL > 0) ! 976: DEBUGLOG("ReadBlock: addr 0x%x:0x%x len %d\n", ! 977: (data[1] & kFWAsynchDestinationOffsetHigh) >> kFWAsynchDestinationOffsetHighPhase, data[2], ! 978: (data[3] & kFWAsynchDataLength) >> kFWAsynchDataLengthPhase); ! 979: #endif ! 980: { ! 981: // Rather inefficiently search for a matching address space ! 982: IOReturn ret = kFWResponseAddressError; ! 983: int length = (data[3] & kFWAsynchDataLength) >> kFWAsynchDataLengthPhase ; ! 984: FWAddress addr((data[1] & kFWAsynchDestinationOffsetHigh) >> ! 985: kFWAsynchDestinationOffsetHighPhase, data[2]); ! 986: IOFWAddressSpace * found; ! 987: IOMemoryDescriptor *buf = NULL; ! 988: IOByteCount offset; ! 989: fSpaceIterator->reset(); ! 990: while( (found = (IOFWAddressSpace *) fSpaceIterator->getNextObject())) { ! 991: ret = found->doRead(sourceID, addr, length, &buf, &offset, false); ! 992: if(ret != kFWResponseAddressError) ! 993: break; ! 994: } ! 995: if(NULL != buf) { ! 996: asyncReadResponse(sourceID, FWSpeed(sourceID), ! 997: tLabel, ret, buf, offset, length); ! 998: } ! 999: else { ! 1000: UInt32 bad = 0xcafebabe; ! 1001: asyncReadResponse(sourceID, FWSpeed(sourceID), ! 1002: tLabel, ret, &bad, 4); ! 1003: } ! 1004: } ! 1005: break; ! 1006: ! 1007: case kFWTCodeReadQuadletResponse : ! 1008: if(fTrans[tLabel].fInUse) { ! 1009: IOFWAsyncCommand * cmd = fTrans[tLabel].fHandler; ! 1010: cmd->gotPacket(this, (data[1] & kFWAsynchRCode)>>kFWAsynchRCodePhase, ! 1011: (UInt8*)(data+3), 4); ! 1012: } ! 1013: else { ! 1014: #if (DEBUGGING_LEVEL > 0) ! 1015: DEBUGLOG("ReadQuadletResponse: label %d isn't in use!!\n", tLabel); ! 1016: #endif ! 1017: } ! 1018: break; ! 1019: ! 1020: case kFWTCodeReadBlockResponse : ! 1021: case kFWTCodeLockResponse : ! 1022: if(fTrans[tLabel].fInUse) { ! 1023: IOFWAsyncCommand * cmd = fTrans[tLabel].fHandler; ! 1024: cmd->gotPacket(this, (data[1] & kFWAsynchRCode)>>kFWAsynchRCodePhase, ! 1025: (UInt8*)(data+4), (data[3] & kFWAsynchDataLength)>>kFWAsynchDataLengthPhase); ! 1026: } ! 1027: else { ! 1028: #if (DEBUGGING_LEVEL > 0) ! 1029: DEBUGLOG("ReadBlock/LockResponse: label %d isn't in use!!\n", tLabel); ! 1030: #endif ! 1031: } ! 1032: break; ! 1033: ! 1034: case kFWTCodeLock : ! 1035: #if (DEBUGGING_LEVEL > 0) ! 1036: DEBUGLOG("Lock type %d: addr 0x%x:0x%x\n", ! 1037: (data[3] & kFWAsynchExtendedTCode) >> kFWAsynchExtendedTCodePhase, ! 1038: (data[1] & kFWAsynchDestinationOffsetHigh) >> kFWAsynchDestinationOffsetHighPhase, ! 1039: data[2]); ! 1040: #endif ! 1041: processLockRequest(sourceID, tLabel, data, &data[4], ! 1042: (data[3] & kFWAsynchDataLength) >> kFWAsynchDataLengthPhase); ! 1043: ! 1044: break; ! 1045: ! 1046: case kFWTCodeIsochronousBlock : ! 1047: #if (DEBUGGING_LEVEL > 0) ! 1048: DEBUGLOG("Async Stream Packet\n"); ! 1049: #endif ! 1050: break; ! 1051: ! 1052: default : ! 1053: #if (DEBUGGING_LEVEL > 0) ! 1054: DEBUGLOG("Unexpected tcode in Asyncrecv: %d\n", tCode); ! 1055: #endif ! 1056: break; ! 1057: } ! 1058: } ! 1059: ! 1060: IOReturn IOFireWireController::allocAddress(IOFWAddressSpace *space) ! 1061: { ! 1062: /* ! 1063: * Lots of scope for optimizations here, perhaps building a hash table for ! 1064: * addresses etc. ! 1065: * Drivers may want to override this if their hardware can match addresses ! 1066: * without CPU intervention. ! 1067: */ ! 1068: if(!fLocalAddresses->setObject(space)) ! 1069: return kIOReturnNoMemory; ! 1070: else ! 1071: return kIOReturnSuccess; ! 1072: } ! 1073: ! 1074: void IOFireWireController::freeAddress(IOFWAddressSpace *space) ! 1075: { ! 1076: fLocalAddresses->removeObject(space); ! 1077: } ! 1078: ! 1079: void IOFireWireController::addAllocatedChannel(IOFWIsochChannel *channel) ! 1080: { ! 1081: IOTakeLock(fChannelLock); ! 1082: fAllocatedChannels->setObject(channel); ! 1083: IOUnlock(fChannelLock); ! 1084: } ! 1085: ! 1086: void IOFireWireController::removeAllocatedChannel(IOFWIsochChannel *channel) ! 1087: { ! 1088: IOTakeLock(fChannelLock); ! 1089: fAllocatedChannels->removeObject(channel); ! 1090: IOUnlock(fChannelLock); ! 1091: } ! 1092: ! 1093: ! 1094: IOFireWireDevice * IOFireWireController::nodeIDtoDevice(UInt16 nodeID) ! 1095: { ! 1096: OSIterator *childIterator; ! 1097: IOFireWireDevice * found = NULL; ! 1098: ! 1099: childIterator = getClientIterator(); ! 1100: ! 1101: if( childIterator) { ! 1102: while( (found = (IOFireWireDevice *) childIterator->getNextObject())) { ! 1103: if(found->fNodeID == nodeID) ! 1104: break; ! 1105: } ! 1106: childIterator->release(); ! 1107: } ! 1108: return found; ! 1109: } ! 1110: ! 1111: IOFireWireDevice *IOFireWireController::createDeviceNub(OSDictionary *propTable) ! 1112: { ! 1113: IOFireWireDevice *newDevice; ! 1114: newDevice = new IOFireWireDevice; ! 1115: ! 1116: if (!newDevice) ! 1117: return NULL; ! 1118: if(!newDevice->init(propTable)) { ! 1119: newDevice->release(); ! 1120: return NULL; ! 1121: } ! 1122: return newDevice; ! 1123: } ! 1124: ! 1125: IOFWIsochChannel *IOFireWireController::createIsochChannel( ! 1126: bool doIRM, UInt32 bandwidth, IOFWSpeed prefSpeed, ! 1127: FWIsochChannelForceStopNotificationProc stopProc, void *stopRefCon) ! 1128: { ! 1129: IOFWIsochChannel *channel; ! 1130: ! 1131: channel = new IOFWIsochChannel; ! 1132: if(!channel) ! 1133: return NULL; ! 1134: ! 1135: if(!channel->init(this, doIRM, bandwidth, prefSpeed, stopProc, stopRefCon)) { ! 1136: channel->release(); ! 1137: channel = NULL; ! 1138: } ! 1139: return channel; ! 1140: } ! 1141: ! 1142: IOFWIsochPort *IOFireWireController::createLocalIsochPort(bool talking, ! 1143: DCLCommandStruct *opcodes, DCLTaskInfo *info, ! 1144: UInt32 startEvent, UInt32 startState, UInt32 startMask) ! 1145: { ! 1146: IOFWLocalIsochPort *port; ! 1147: IODCLProgram *program; ! 1148: ! 1149: program = createDCLProgram(talking, opcodes, info, startEvent, startState, startMask); ! 1150: if(!program) ! 1151: return NULL; ! 1152: ! 1153: port = new IOFWLocalIsochPort; ! 1154: if(!port) { ! 1155: program->release(); ! 1156: return NULL; ! 1157: } ! 1158: ! 1159: if(!port->init(program, this)) { ! 1160: port->release(); ! 1161: port = NULL; ! 1162: } ! 1163: ! 1164: return port; ! 1165: } ! 1166: ! 1167: // How big (as a power of two) can packets sent to/received from the node be? ! 1168: int IOFireWireController::maxPackLog(bool forSend, UInt16 nodeAddress) const ! 1169: { ! 1170: return 9+FWSpeed(nodeAddress); ! 1171: } ! 1172: ! 1173: // How big (as a power of two) can packets sent from A to B be? ! 1174: int IOFireWireController::maxPackLog(UInt16 nodeA, UInt16 nodeB) const ! 1175: { ! 1176: return 9+FWSpeed(nodeA, nodeB); ! 1177: } ! 1178:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.