![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to BMacEnet.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / network / drvPPCBMac|
Return to BMacEnet.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / network / drvPPCBMac |
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) 1998-1999 by Apple Computer, Inc., All rights reserved. ! 24: * ! 25: * Hardware independent (relatively) code for the BMac Ethernet Controller ! 26: * ! 27: * HISTORY ! 28: * ! 29: * dd-mmm-yy ! 30: * Created. ! 31: * ! 32: * Dec 10, 1998 jliu ! 33: * Converted to IOKit/C++. ! 34: */ ! 35: ! 36: #include "BMacEnet.h" ! 37: #include "BMacEnetPrivate.h" ! 38: ! 39: #include <IOKit/IORegistryEntry.h> ! 40: #include <IOKit/IODeviceTreeSupport.h> ! 41: #include <IOKit/platform/AppleMacIODevice.h> ! 42: #include <IOKit/assert.h> ! 43: ! 44: // #define DEBUG_JOE 1 ! 45: ! 46: //------------------------------------------------------------------------ ! 47: ! 48: #define super IOEthernetController ! 49: ! 50: OSDefineMetaClassAndStructors( BMacEnet, IOEthernetController ) ! 51: ! 52: //------------------------------------------------------------------------ ! 53: ! 54: #define PROVIDER_DEV 0 ! 55: #define PROVIDER_DMA_TX 1 ! 56: #define PROVIDER_DMA_RX 2 ! 57: ! 58: /* ! 59: * Public Instance Methods ! 60: */ ! 61: ! 62: /*------------------------------------------------------------------------- ! 63: * ! 64: * ! 65: * ! 66: *-------------------------------------------------------------------------*/ ! 67: ! 68: bool BMacEnet::init(OSDictionary * properties = 0) ! 69: { ! 70: /* ! 71: * Initialize my ivars. ! 72: */ ! 73: networkInterface = 0; ! 74: transmitQueue = 0; ! 75: debugQueue = 0; ! 76: debugger = 0; ! 77: rxIntSrc = 0; ! 78: txDebuggerPkt = 0; ! 79: phyId = 0xff; ! 80: phyMIIDelay = MII_DEFAULT_DELAY; ! 81: sromAddressBits = 6; ! 82: enetAddressOffset = 20; ! 83: phyStatusPrev = 0; ! 84: ready = false; ! 85: debugClient = false; ! 86: debugTxPoll = false; ! 87: netifClient = false; ! 88: isPromiscuous = false; ! 89: multicastEnabled = false; ! 90: ! 91: if (!super::init(properties)) ! 92: return false; ! 93: ! 94: /* ! 95: * Clear the mbuf rings. ! 96: */ ! 97: for (int i = 0; i < TX_RING_LENGTH; i++) ! 98: txMbuf[i] = 0; ! 99: for (int i = 0; i < RX_RING_LENGTH; i++) ! 100: rxMbuf[i] = 0; ! 101: ! 102: /* ! 103: * Clear the memory map objects. ! 104: */ ! 105: for (int i = 0; i < MEMORY_MAP_COUNT; i++) ! 106: maps[i] = 0; ! 107: ! 108: return true; ! 109: } ! 110: ! 111: bool BMacEnet::start(IOService * provider) ! 112: { ! 113: AppleMacIODevice *nub = OSDynamicCast(AppleMacIODevice, provider); ! 114: IOInterruptEventSource *intES; ! 115: ! 116: if (!nub || !super::start(provider)) ! 117: return false; ! 118: ! 119: transmitQueue = OSDynamicCast(IOOQGateFIFOQueue, getOutputQueue()); ! 120: if (!transmitQueue) { ! 121: IOLog("BMac: output queue initialization failed\n"); ! 122: return false; ! 123: } ! 124: transmitQueue->retain(); ! 125: ! 126: // Allocate debug queue. This stores packets retired from the TX ring ! 127: // by the polling routine. We cannot call freePacket() or m_free() within ! 128: // the debugger context. ! 129: // ! 130: // The capacity of the queue is set at maximum to prevent the queue from ! 131: // calling m_free() due to over-capacity. But we don't expect the size ! 132: // of the queue to grow too large. ! 133: // ! 134: debugQueue = IOPacketQueue::withCapacity((UInt) -1); ! 135: if (!debugQueue) ! 136: return false; ! 137: ! 138: // Allocate a IOMBufDBDMAMemoryCursor instance. Currently, the maximum ! 139: // number of segments is set to 2. The maximum length for each segment ! 140: // is set to the maximum ethernet frame size (plus padding). ! 141: ! 142: mbufCursor = IOMBufBigMemoryCursor::withSpecification(NETWORK_BUFSIZE, 2); ! 143: if (!mbufCursor) { ! 144: IOLog("Ethernet(BMac): IOMBufDBDMAMemoryCursor allocation failure\n"); ! 145: return false; ! 146: } ! 147: ! 148: // ! 149: // Our provider is the nub representing the BMacEnet hardware ! 150: // controller. We will query it for our resource information. ! 151: // ! 152: ! 153: for (int i = 0; i < MEMORY_MAP_HEATHROW_INDEX; i++) { ! 154: IOMemoryMap * map; ! 155: ! 156: map = provider->mapDeviceMemoryWithIndex(i); ! 157: if (!map) ! 158: return false; ! 159: #ifdef DEBUG_JOE ! 160: IOLog("map %d: Phys:%08x Virt:%08x len:%d\n", ! 161: i, ! 162: (unsigned) map->getPhysicalAddress(), ! 163: (unsigned) map->getVirtualAddress(), ! 164: (unsigned) map->getLength()); ! 165: #endif DEBUG_JOE ! 166: ! 167: switch (i) { ! 168: case MEMORY_MAP_ENET_INDEX: ! 169: ioBaseEnet = (IOPPCAddress) map->getVirtualAddress(); ! 170: break; ! 171: ! 172: case MEMORY_MAP_TXDMA_INDEX: ! 173: ioBaseEnetTxDMA = (IODBDMAChannelRegisters *) ! 174: map->getVirtualAddress(); ! 175: break; ! 176: ! 177: case MEMORY_MAP_RXDMA_INDEX: ! 178: ioBaseEnetRxDMA = (IODBDMAChannelRegisters *) ! 179: map->getVirtualAddress(); ! 180: break; ! 181: } ! 182: ! 183: maps[i] = map; ! 184: } ! 185: ! 186: #ifdef DEBUG_JOE ! 187: IOLog("ioBaseEnet: 0x%08x\n", ioBaseEnet); ! 188: IOLog("ioBaseEnetTxDMA: 0x%08x\n", ioBaseEnetTxDMA); ! 189: IOLog("ioBaseEnetRxDMA: 0x%08x\n", ioBaseEnetRxDMA); ! 190: #endif DEBUG_JOE ! 191: ! 192: // ! 193: // We need to get the I/O address for the Heathrow controller. ! 194: // We ask the provider (bmac) for its device tree parent. ! 195: // ! 196: IOService *heathrow; ! 197: if (!(heathrow = OSDynamicCast(IOService, ! 198: provider->getParentEntry( gIODTPlane )))) ! 199: return false; ! 200: ! 201: // Check whether the hardware is susceptible to the broken unicast ! 202: // filter problem. ! 203: // ! 204: OSData * devIDData; ! 205: devIDData = OSDynamicCast(OSData, heathrow->getProperty("device-id")); ! 206: ! 207: if (devIDData) { ! 208: useUnicastFilter = ( *((UInt32 *) devIDData->getBytesNoCopy()) == ! 209: 0x10 ); ! 210: if (useUnicastFilter) ! 211: IOLog("%s: Enabling workaround for broken unicast filter\n", ! 212: getName()); ! 213: } ! 214: ! 215: IOMemoryMap * map = heathrow->mapDeviceMemoryWithIndex(0); ! 216: if (map) ! 217: { ! 218: #ifdef DEBUG_JOE ! 219: IOLog("Heathrow: Phys:%08x Virt:%08x len:%d\n", ! 220: (unsigned) map->getPhysicalAddress(), ! 221: (unsigned) map->getVirtualAddress(), ! 222: (unsigned) map->getLength()); ! 223: #endif DEBUG_JOE ! 224: ioBaseHeathrow = (IOPPCAddress) map->getVirtualAddress(); ! 225: ! 226: maps[MEMORY_MAP_HEATHROW_INDEX] = map; ! 227: } ! 228: else { ! 229: return false; ! 230: } ! 231: ! 232: // ! 233: // Get a reference to the IOWorkLoop in our superclass. ! 234: // ! 235: IOWorkLoop * myWorkLoop = getWorkLoop(); ! 236: assert(myWorkLoop); ! 237: ! 238: // ! 239: // Allocate three IOInterruptEventSources. ! 240: // ! 241: rxIntSrc = IOInterruptEventSource::interruptEventSource ! 242: (this, ! 243: (IOInterruptEventAction) &BMacEnet::interruptOccurredForSource, ! 244: provider, PROVIDER_DMA_RX); ! 245: if (!rxIntSrc ! 246: || (myWorkLoop->addEventSource(rxIntSrc) != kIOReturnSuccess)) { ! 247: IOLog("Ethernet(BMac): rxIntSrc init failure\n"); ! 248: return false; ! 249: } ! 250: ! 251: intES = IOInterruptEventSource::interruptEventSource ! 252: (this, ! 253: (IOInterruptEventAction) &BMacEnet::interruptOccurredForSource, ! 254: provider, PROVIDER_DMA_TX); ! 255: if (intES) { ! 256: bool res = (myWorkLoop->addEventSource(intES) != kIOReturnSuccess); ! 257: intES->release(); ! 258: if (res) { ! 259: IOLog("Ethernet(BMac): PROVIDER_DMA_TX add failure\n"); ! 260: return false; ! 261: } ! 262: } ! 263: else { ! 264: IOLog("Mace: PROVIDER_DMA_TX init failure\n"); ! 265: return false; ! 266: } ! 267: ! 268: intES = IOInterruptEventSource::interruptEventSource ! 269: (this, ! 270: (IOInterruptEventAction) &BMacEnet::interruptOccurredForSource, ! 271: provider, PROVIDER_DEV); ! 272: if (intES) { ! 273: bool res = (myWorkLoop->addEventSource(intES) != kIOReturnSuccess); ! 274: intES->release(); ! 275: if (res) { ! 276: IOLog("Ethernet(BMac): PROVIDER_DEV add failure\n"); ! 277: return false; ! 278: } ! 279: } ! 280: else { ! 281: IOLog("Ethernet(BMac): PROVIDER_DEV init failure\n"); ! 282: return false; ! 283: } ! 284: ! 285: timerSrc = IOTimerEventSource::timerEventSource ! 286: (this, (IOTimerEventSource::Action) &BMacEnet::timeoutOccurred); ! 287: if (!timerSrc ! 288: || (myWorkLoop->addEventSource(timerSrc) != kIOReturnSuccess)) { ! 289: IOLog("Ethernet(BMac): timerSrc init failure\n"); ! 290: return false; ! 291: } ! 292: ! 293: MGETHDR(txDebuggerPkt, M_DONTWAIT, MT_DATA); ! 294: if (!txDebuggerPkt) { ! 295: IOLog("Ethernet(BMac): Couldn't allocate KDB buffer\n"); ! 296: return false; ! 297: } ! 298: ! 299: #if 0 ! 300: // Enable the interrupt event sources. The hardware interrupts ! 301: // sources remain disabled until _resetAndEnable(true) is called. ! 302: // ! 303: // myWorkLoop->enableAllInterrupts(); ! 304: #endif ! 305: ! 306: // ! 307: // Perform a hardware reset. ! 308: // ! 309: if ( !_resetAndEnable(false) ) ! 310: { ! 311: return false; ! 312: } ! 313: ! 314: // ! 315: // Cache my MAC address. ! 316: // ! 317: getHardwareAddress(&myAddress); ! 318: ! 319: // ! 320: // Allocate memory for ring buffers. ! 321: // ! 322: if (_allocateMemory() == false) ! 323: { ! 324: return false; ! 325: } ! 326: ! 327: // ! 328: // Attach a kernel debugger client. ! 329: // ! 330: attachDebuggerClient(&debugger); ! 331: ! 332: // ! 333: // Attach an IOEthernetInterface client. ! 334: // ! 335: if (!attachNetworkInterface((IONetworkInterface **) &networkInterface)) ! 336: return false; ! 337: ! 338: return true; ! 339: } ! 340: ! 341: /*------------------------------------------------------------------------- ! 342: * ! 343: * ! 344: * ! 345: *-------------------------------------------------------------------------*/ ! 346: ! 347: void BMacEnet::free() ! 348: { ! 349: UInt i; ! 350: ! 351: _resetAndEnable(false); ! 352: ! 353: if (debugger) ! 354: debugger->release(); ! 355: ! 356: if (getWorkLoop()) ! 357: getWorkLoop()->disableAllEventSources(); ! 358: ! 359: if (timerSrc) ! 360: timerSrc->release(); ! 361: ! 362: if (rxIntSrc) ! 363: rxIntSrc->release(); ! 364: ! 365: if (txDebuggerPkt) ! 366: freePacket(txDebuggerPkt); ! 367: ! 368: if (transmitQueue) ! 369: transmitQueue->release(); ! 370: ! 371: if (debugQueue) ! 372: debugQueue->release(); ! 373: ! 374: if (networkInterface) ! 375: networkInterface->release(); ! 376: ! 377: if (mbufCursor) ! 378: mbufCursor->release(); ! 379: ! 380: for (i = 0; i < rxMaxCommand; i++) ! 381: if (rxMbuf[i]) freePacket(rxMbuf[i]); ! 382: ! 383: for (i = 0; i < txMaxCommand; i++) ! 384: if (txMbuf[i]) freePacket(txMbuf[i]); ! 385: ! 386: for (i = 0; i < MEMORY_MAP_COUNT; i++) ! 387: if (maps[i]) maps[i]->release(); ! 388: ! 389: if (dmaMemory.ptr) ! 390: { ! 391: IOFree(dmaMemory.ptrReal, dmaMemory.sizeReal); ! 392: dmaMemory.ptr = 0; ! 393: } ! 394: ! 395: super::free(); ! 396: } ! 397: ! 398: /*------------------------------------------------------------------------- ! 399: * ! 400: * ! 401: * ! 402: *-------------------------------------------------------------------------*/ ! 403: ! 404: void BMacEnet::interruptOccurredForSource(IOInterruptEventSource *src, ! 405: int /*count*/) ! 406: { ! 407: bool doFlushQueue = false; ! 408: bool doService = false; ! 409: ! 410: reserveDebuggerLock(); ! 411: ! 412: statReg = ReadBigMacRegister( ioBaseEnet, kSTAT ); ! 413: ! 414: if (src == rxIntSrc) { ! 415: KERNEL_DEBUG(DBG_BMAC_RXIRQ | DBG_FUNC_START, 0, 0, 0, 0, 0 ); ! 416: doFlushQueue = _receiveInterruptOccurred(); ! 417: KERNEL_DEBUG(DBG_BMAC_RXIRQ | DBG_FUNC_END, 0, 0, 0, 0, 0 ); ! 418: } ! 419: else { ! 420: /* ! 421: * On the transmit side, we use the chipset interrupt. Using the ! 422: * transmit DMA interrupt (or having multiple transmit DMA entries) ! 423: * would allows us to send the next frame to the chipset prior the ! 424: * transmit fifo going empty. ! 425: * However, this aggrevates a BMac chipset bug where the next frame going ! 426: * out gets corrupted (first two bytes lost) if the chipset had to retry ! 427: * the previous frame. ! 428: */ ! 429: txWDInterrupts++; ! 430: KERNEL_DEBUG(DBG_BMAC_TXIRQ | DBG_FUNC_START, 0, 0, 0, 0, 0 ); ! 431: doService = _transmitInterruptOccurred(); ! 432: KERNEL_DEBUG(DBG_BMAC_TXIRQ | DBG_FUNC_END, 0, 0, 0, 0, 0 ); ! 433: } ! 434: ! 435: releaseDebuggerLock(); ! 436: ! 437: /* ! 438: * Submit all received packets queued up by _receiveInterruptOccurred() ! 439: * to the network stack. The up call is performed without holding the ! 440: * debugger lock. ! 441: */ ! 442: if (doFlushQueue) ! 443: networkInterface->flushInputQueue(); ! 444: ! 445: /* ! 446: * Unstall the output queue if some space was made available. ! 447: */ ! 448: if (doService && netifClient) ! 449: transmitQueue->service(); ! 450: } ! 451: ! 452: /*------------------------------------------------------------------------- ! 453: * ! 454: * ! 455: * ! 456: *-------------------------------------------------------------------------*/ ! 457: ! 458: UInt32 BMacEnet::outputPacket(struct mbuf * pkt) ! 459: { ! 460: u_int32_t i; ! 461: UInt32 ret = kIOOQReturnSuccess; ! 462: ! 463: KERNEL_DEBUG(DBG_BMAC_TXQUEUE | DBG_FUNC_NONE, (int) pkt, ! 464: (int) pkt->m_pkthdr.len, 0, 0, 0 ); ! 465: ! 466: /* ! 467: * Hold the debugger lock so the debugger can't interrupt us ! 468: */ ! 469: reserveDebuggerLock(); ! 470: ! 471: do ! 472: { ! 473: /* ! 474: * Preliminary sanity checks ! 475: */ ! 476: assert(pkt && netifClient); ! 477: ! 478: #if 0 ! 479: /* ! 480: * Remove any completed packets from the Tx ring ! 481: */ ! 482: if ( chipId >= kCHIPID_PaddingtonXmitStreaming ) ! 483: { ! 484: _transmitInterruptOccurred(); ! 485: } ! 486: #endif ! 487: ! 488: i = txCommandTail + 1; ! 489: if ( i >= txMaxCommand ) i = 0; ! 490: if ( i == txCommandHead ) ! 491: { ! 492: /* ! 493: * Ring buffer is full. Disable the dequeueing process. ! 494: * We reenable it when an entry is made available by the ! 495: * transmit interrupt handler, or if a timeout occurs. ! 496: */ ! 497: ret = kIOOQReturnStall; ! 498: continue; ! 499: } ! 500: ! 501: /* ! 502: * If there is space on the Tx ring, add the packet directly to the ! 503: * ring. ! 504: */ ! 505: _transmitPacket(pkt); ! 506: } ! 507: while ( 0 ); ! 508: ! 509: releaseDebuggerLock(); ! 510: ! 511: return ret; ! 512: } ! 513: ! 514: /*------------------------------------------------------------------------- ! 515: * ! 516: * ! 517: * ! 518: *-------------------------------------------------------------------------*/ ! 519: ! 520: bool BMacEnet::_resetAndEnable(bool enable) ! 521: { ! 522: bool ret = true; ! 523: ! 524: // reserveDebuggerLock(); ! 525: ! 526: ready = false; ! 527: ! 528: if (timerSrc) timerSrc->cancelTimeout(); ! 529: ! 530: _disableAdapterInterrupts(); ! 531: if (getWorkLoop()) getWorkLoop()->disableAllInterrupts(); ! 532: ! 533: _resetChip(); ! 534: ! 535: while (enable) ! 536: { ! 537: if (!_initRxRing() || !_initTxRing()) ! 538: { ! 539: ret = false; ! 540: break; ! 541: } ! 542: ! 543: if ( phyId != 0xff ) ! 544: { ! 545: miiInitializePHY(phyId); ! 546: } ! 547: ! 548: if (_initChip() == false) ! 549: { ! 550: ret = false; ! 551: break; ! 552: } ! 553: ! 554: _startChip(); ! 555: ! 556: timerSrc->setTimeoutMS(WATCHDOG_TIMER_MS); ! 557: ! 558: if (getWorkLoop()) getWorkLoop()->enableAllInterrupts(); ! 559: _enableAdapterInterrupts(); ! 560: ! 561: ready = true; ! 562: ! 563: _sendDummyPacket(); ! 564: ! 565: break; ! 566: } ! 567: ! 568: // releaseDebuggerLock(); ! 569: ! 570: return ret; ! 571: } ! 572: ! 573: /*------------------------------------------------------------------------- ! 574: * Called by IOEthernetInterface client to enable the controller. ! 575: * This method is always called while running on the default workloop ! 576: * thread. ! 577: *-------------------------------------------------------------------------*/ ! 578: ! 579: IOReturn BMacEnet::enable(IONetworkInterface * netif) ! 580: { ! 581: IONetworkParameter * param; ! 582: ! 583: // If an interface client has previously enabled us, ! 584: // and we know there can only be one interface client ! 585: // for this driver, then simply return true. ! 586: // ! 587: if (netifClient) { ! 588: IOLog("EtherNet(BMac): already enabled\n"); ! 589: return kIOReturnSuccess; ! 590: } ! 591: ! 592: // Grab a pointer to the statistics structure in the interface. ! 593: // ! 594: param = netif->getParameter(kIONetworkStatsKey); ! 595: if (!param || !(netStats = (IONetworkStats *) param->getBuffer())) ! 596: { ! 597: IOLog("EtherNet(BMac): invalid network statistics\n"); ! 598: return kIOReturnError; ! 599: } ! 600: ! 601: if ((ready == false) && !_resetAndEnable(true)) ! 602: return kIOReturnIOError; ! 603: ! 604: // Record the interface as an active client. ! 605: // ! 606: netifClient = true; ! 607: ! 608: // Start our IOOutputQueue object. ! 609: // ! 610: transmitQueue->setCapacity(TRANSMIT_QUEUE_SIZE); ! 611: transmitQueue->start(); ! 612: ! 613: return kIOReturnSuccess; ! 614: } ! 615: ! 616: /*------------------------------------------------------------------------- ! 617: * Called by IOEthernetInterface client to disable the controller. ! 618: * This method is always called while running on the default workloop ! 619: * thread. ! 620: *-------------------------------------------------------------------------*/ ! 621: ! 622: IOReturn BMacEnet::disable(IONetworkInterface * /*netif*/) ! 623: { ! 624: // If we have no active clients, then disable the controller. ! 625: // ! 626: if (debugClient == false) ! 627: _resetAndEnable(false); ! 628: ! 629: // Disable our IOOutputQueue object. This will prevent the ! 630: // outputPacket() method from being called. ! 631: // ! 632: transmitQueue->stop(); ! 633: ! 634: // Flush all packets currently in the output queue. ! 635: // ! 636: transmitQueue->setCapacity(0); ! 637: transmitQueue->flush(); ! 638: ! 639: netifClient = false; ! 640: ! 641: return kIOReturnSuccess; ! 642: } ! 643: ! 644: /*------------------------------------------------------------------------- ! 645: * This method is called by our debugger client to bring up the controller ! 646: * just before the controller is registered as the debugger device. The ! 647: * debugger client is attached in response to the attachDebuggerClient() ! 648: * call. ! 649: * ! 650: * This method is always called while running on the default workloop ! 651: * thread. ! 652: *-------------------------------------------------------------------------*/ ! 653: ! 654: IOReturn BMacEnet::handleDebuggerOpen(IOKernelDebugger * /*debugger*/) ! 655: { ! 656: // Enable hardware and make it ready to support the debugger client. ! 657: // ! 658: if ((ready == false) && !_resetAndEnable(true)) ! 659: return kIOReturnIOError; ! 660: ! 661: // Record the debugger as an active client of ours. ! 662: // ! 663: debugClient = true; ! 664: ! 665: // Returning true will allow the kdp registration to continue. ! 666: // If we return false, then we will not be registered as the ! 667: // debugger device, and the attachDebuggerClient() call will ! 668: // return NULL. ! 669: // ! 670: return kIOReturnSuccess; ! 671: } ! 672: ! 673: /*------------------------------------------------------------------------- ! 674: * This method is called by our debugger client to stop the controller. ! 675: * The debugger will call this method when we issue a detachDebuggerClient(). ! 676: * ! 677: * This method is always called while running on the default workloop ! 678: * thread. ! 679: *-------------------------------------------------------------------------*/ ! 680: ! 681: IOReturn BMacEnet::handleDebuggerClose(IOKernelDebugger * /*debugger*/) ! 682: { ! 683: debugClient = false; ! 684: ! 685: // If we have no active clients, then disable the controller. ! 686: // ! 687: if (netifClient == false) ! 688: _resetAndEnable(false); ! 689: ! 690: return kIOReturnSuccess; ! 691: } ! 692: ! 693: /*------------------------------------------------------------------------- ! 694: * ! 695: * ! 696: * ! 697: *-------------------------------------------------------------------------*/ ! 698: ! 699: void BMacEnet::timeoutOccurred(IOTimerEventSource * /*timer*/) ! 700: { ! 701: u_int32_t dmaStatus; ! 702: u_int16_t phyStatus; ! 703: u_int16_t linkStatus; ! 704: u_int16_t phyStatusChange; ! 705: bool fullDuplex = false; ! 706: bool doFlushQueue = false; ! 707: bool doService = false; ! 708: ! 709: // IOLog("Ethernet(BMac): watchdog timer\n"); ! 710: ! 711: reserveDebuggerLock(); ! 712: ! 713: /* ! 714: * Check for DMA shutdown on receive channel ! 715: */ ! 716: dmaStatus = IOGetDBDMAChannelStatus( ioBaseEnetRxDMA ); ! 717: if ( !(dmaStatus & kdbdmaActive) ) ! 718: { ! 719: #if 0 ! 720: IOLog( "Ethernet(BMac): Timeout check - RxHead = %d RxTail = %d\n", ! 721: rxCommandHead, rxCommandTail); ! 722: ! 723: IOLog( "Ethernet(BMac): Rx Commands = %08x(p) Rx DMA Ptr = %08x(p)\n\r", rxDMACommandsPhys, IOGetDBDMACommandPtr(ioBaseEnetRxDMA) ); ! 724: [self _dumpDesc:(void *)rxDMACommands Size:rxMaxCommand * sizeof(enet_dma_cmd_t)]; ! 725: #endif ! 726: ! 727: doFlushQueue = _receiveInterruptOccurred(); ! 728: } ! 729: ! 730: /* ! 731: * If there are pending entries on the Tx ring ! 732: */ ! 733: if ( txCommandHead != txCommandTail ) ! 734: { ! 735: /* ! 736: * If we did not service the Tx ring during the last timeout interval, ! 737: * then force servicing of the Tx ring ! 738: */ ! 739: if ( txWDInterrupts == 0 ) ! 740: { ! 741: if ( txWDCount++ > 0 ) ! 742: { ! 743: if (_transmitInterruptOccurred() == false) ! 744: { ! 745: #if 0 ! 746: IOLog( "Ethernet(BMac): Timeout check - TxHead = %d TxTail = %d\n", ! 747: txCommandHead, txCommandTail); ! 748: #endif ! 749: _restartTransmitter(); ! 750: } ! 751: doService = true; ! 752: } ! 753: } ! 754: else ! 755: { ! 756: txWDInterrupts = 0; ! 757: txWDCount = 0; ! 758: } ! 759: } ! 760: else ! 761: { ! 762: txWDInterrupts = 0; ! 763: txWDCount = 0; ! 764: } ! 765: ! 766: if ( phyId != 0xff ) ! 767: { ! 768: if ( miiReadWord(&phyStatus, MII_STATUS, phyId) == true ) ! 769: { ! 770: phyStatusChange = (phyStatusPrev ^ phyStatus) & ! 771: (MII_STATUS_LINK_STATUS | MII_STATUS_NEGOTIATION_COMPLETE); ! 772: if ( phyStatusChange ) ! 773: { ! 774: if ( (phyStatus & MII_STATUS_LINK_STATUS) && ! 775: (phyStatus & MII_STATUS_NEGOTIATION_COMPLETE ) ) ! 776: { ! 777: if ( (phyType & MII_ST10040_MASK) == MII_ST10040_ID ) ! 778: { ! 779: miiReadWord(&linkStatus, MII_ST10040_CHIPST, phyId); ! 780: ! 781: fullDuplex = (linkStatus & MII_ST10040_CHIPST_DUPLEX) ? true : false; ! 782: ! 783: IOLog( "Ethernet(BMac): Link is up at %sMb - %s Duplex\n\r", ! 784: (linkStatus & MII_ST10040_CHIPST_SPEED) ? "100" : "10", ! 785: (fullDuplex) ? "Full" : "Half" ); ! 786: } ! 787: else if ( (phyType & MII_DP83843_MASK) == MII_DP83843_ID ) ! 788: { ! 789: miiReadWord(&linkStatus, MII_DP83843_PHYSTS, phyId); ! 790: ! 791: fullDuplex = (linkStatus & MII_DP83843_PHYSTS_DUPLEX) ? true : false; ! 792: ! 793: IOLog( "Ethernet(BMac): Link is up at %sMb - %s Duplex\n\r", ! 794: (linkStatus & MII_DP83843_PHYSTS_SPEED10) ? "10" : "100", ! 795: (fullDuplex) ? "Full" : "Half" ); ! 796: } ! 797: else ! 798: { ! 799: fullDuplex = false ; ! 800: IOLog( "Ethernet(BMac): Link is up\n\r" ); ! 801: } ! 802: ! 803: if ( fullDuplex != isFullDuplex ) ! 804: { ! 805: _setDuplexMode(fullDuplex); ! 806: } ! 807: } ! 808: else ! 809: { ! 810: IOLog( "Ethernet(BMac): Link is down.\n\r" ); ! 811: } ! 812: phyStatusPrev = phyStatus; ! 813: } ! 814: } ! 815: } ! 816: ! 817: // Clean-up after the debugger if the debugger was active. ! 818: // ! 819: if (debugTxPoll) ! 820: { ! 821: debugQueue->flush(); ! 822: debugTxPoll = false; ! 823: releaseDebuggerLock(); ! 824: doService = true; ! 825: } ! 826: else ! 827: { ! 828: releaseDebuggerLock(); ! 829: } ! 830: ! 831: /* ! 832: * Submit all received packets queued up by _receiveInterruptOccurred() ! 833: * to the network stack. The up call is performed without holding the ! 834: * debugger lock. ! 835: */ ! 836: if (doFlushQueue) ! 837: { ! 838: networkInterface->flushInputQueue(); ! 839: } ! 840: ! 841: /* ! 842: * Make sure the output queue is not stalled. ! 843: */ ! 844: if (doService && netifClient) ! 845: { ! 846: transmitQueue->service(); ! 847: } ! 848: ! 849: /* ! 850: * Restart the watchdog timer ! 851: */ ! 852: timerSrc->setTimeoutMS(WATCHDOG_TIMER_MS); ! 853: } ! 854: ! 855: /*------------------------------------------------------------------------- ! 856: * ! 857: * ! 858: * ! 859: *-------------------------------------------------------------------------*/ ! 860: ! 861: const char * BMacEnet::getVendorString() const ! 862: { ! 863: return ("Apple"); ! 864: } ! 865: ! 866: const char * BMacEnet::getModelString() const ! 867: { ! 868: return ("BMac"); ! 869: } ! 870: ! 871: const char * BMacEnet::getRevisionString() const ! 872: { ! 873: return (""); ! 874: } ! 875: ! 876: /*------------------------------------------------------------------------- ! 877: * ! 878: * ! 879: * ! 880: *-------------------------------------------------------------------------*/ ! 881: ! 882: IOReturn BMacEnet::setPromiscuousMode(IOEnetPromiscuousMode mode) ! 883: { ! 884: u_int16_t rxCFGVal; ! 885: ! 886: reserveDebuggerLock(); ! 887: ! 888: /* ! 889: * Turn off the receiver and wait for the chipset to acknowledge ! 890: */ ! 891: rxCFGVal = ReadBigMacRegister(ioBaseEnet, kRXCFG); ! 892: WriteBigMacRegister(ioBaseEnet, kRXCFG, rxCFGVal & ~kRxMACEnable ); ! 893: while( ReadBigMacRegister(ioBaseEnet, kRXCFG) & kRxMACEnable ) ! 894: ; ! 895: ! 896: /* ! 897: * Set or reset promiscuous mode and restore receiver state ! 898: */ ! 899: if (mode == kIOEnetPromiscuousModeOff) { ! 900: rxCFGVal &= ~kRxPromiscEnable; ! 901: isPromiscuous = false; ! 902: } ! 903: else { ! 904: rxCFGVal |= kRxPromiscEnable; ! 905: isPromiscuous = true; ! 906: } ! 907: ! 908: WriteBigMacRegister( ioBaseEnet, kRXCFG, rxCFGVal ); ! 909: ! 910: releaseDebuggerLock(); ! 911: ! 912: return kIOReturnSuccess; ! 913: } ! 914: ! 915: IOReturn BMacEnet::setMulticastMode(IOEnetMulticastMode mode) ! 916: { ! 917: multicastEnabled = (mode == kIOEnetMulticastModeOff) ? false : true; ! 918: ! 919: return kIOReturnSuccess; ! 920: } ! 921: ! 922: IOReturn BMacEnet::setMulticastList(enet_addr_t *addrs, UInt count) ! 923: { ! 924: reserveDebuggerLock(); ! 925: _resetHashTableMask(); ! 926: for (UInt i = 0; i < count; i++) { ! 927: _addToHashTableMask(addrs->ea_byte); ! 928: addrs++; ! 929: } ! 930: _updateBMacHashTableMask(); ! 931: releaseDebuggerLock(); ! 932: return kIOReturnSuccess; ! 933: } ! 934: ! 935: /* ! 936: * Kernel Debugger Support ! 937: */ ! 938: void BMacEnet::sendPacket(void *pkt, unsigned int pkt_len) ! 939: { ! 940: _sendPacket(pkt, pkt_len); ! 941: } ! 942: ! 943: void BMacEnet::receivePacket(void *pkt, unsigned int *pkt_len, ! 944: unsigned int timeout) ! 945: { ! 946: _receivePacket(pkt, pkt_len, timeout); ! 947: } ! 948: ! 949: /* ! 950: * Allocate a WorkLoop serialized output queue object. ! 951: */ ! 952: IOOutputQueue * BMacEnet::allocateOutputQueue() ! 953: { ! 954: return IOOQGateFIFOQueue::withTarget( this, ! 955: getWorkLoop(), ! 956: TRANSMIT_QUEUE_SIZE ); ! 957: } ! 958: ! 959: #ifdef PM_SUPPORT ! 960: /* ! 961: * Power management methods. ! 962: */ ! 963: - (IOReturn)getPowerState:(PMPowerState *)state_p ! 964: { ! 965: return kIOReturnUnsupported; ! 966: } ! 967: ! 968: - (IOReturn)setPowerState:(PMPowerState)state ! 969: { ! 970: if (state == PM_OFF) { ! 971: resetAndEnabled = NO; ! 972: [self _resetChip]; ! 973: return kIOReturnSuccess; ! 974: } ! 975: return kIOReturnUnsupported; ! 976: } ! 977: ! 978: - (IOReturn)getPowerManagement:(PMPowerManagementState *)state_p ! 979: { ! 980: return kIOReturnUnsupported; ! 981: } ! 982: ! 983: - (IOReturn)setPowerManagement:(PMPowerManagementState)state ! 984: { ! 985: return kIOReturnUnsupported; ! 986: } ! 987: #endif PM_SUPPORT
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.