![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to MaceEnet.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 / drvMaceEnet|
Return to MaceEnet.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / network / drvMaceEnet |
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) 1995-1996 NeXT Software, Inc.
24: *
25: * Hardware independent (relatively) code for the Mace Ethernet Controller
26: *
27: * HISTORY
28: *
29: * dd-mmm-yy
30: * Created.
31: *
32: */
33:
34: #include <IOKit/assert.h>
35: #include <IOKit/platform/AppleMacIODevice.h>
36: #include "MaceEnetPrivate.h"
37:
38: //------------------------------------------------------------------------
39:
40: #define super IOEthernetController
41:
42: OSDefineMetaClassAndStructors( MaceEnet, IOEthernetController )
43:
44: //------------------------------------------------------------------------
45:
46: #define PROVIDER_DEV 0
47: #define PROVIDER_DMA_TX 1
48: #define PROVIDER_DMA_RX 2
49:
50: /*
51: * Public Instance Methods
52: */
53:
54: bool MaceEnet::init(OSDictionary * properties)
55: {
56: if (!super::init(properties))
57: return false;
58:
59: isPromiscuous = false;
60: multicastEnabled = false;
61: ready = false;
62: debugClient = false;
63: debugTxPoll = false;
64: netifClient = false;
65:
66: return true;
67: }
68:
69: MaceEnet * MaceEnet::probe(IOService * /*provider*/,
70: unsigned int * /*score*/,
71: unsigned int * /*specificity*/)
72: {
73: #ifdef OLD_CODE
74: extern int kdp_flag;
75:
76: /*
77: * If bootargs: kdp bit 0 using in-kernel mace driver for early debugging,
78: * Don't probe this driver.
79: */
80: if( kdp_flag & 1)
81: {
82: return 0;
83: }
84: #endif
85:
86: return this;
87: }
88:
89: bool MaceEnet::start(IOService * provider)
90: {
91: AppleMacIODevice *nub = OSDynamicCast(AppleMacIODevice, provider);
92:
93: if (!nub || !super::start(provider))
94: return false;
95:
96: transmitQueue = OSDynamicCast(IOOQGateFIFOQueue, getOutputQueue());
97: if (!transmitQueue)
98: {
99: IOLog("Mace: output queue initialization failed\n");
100: return false;
101: }
102: transmitQueue->retain();
103:
104: // Allocate debug queue. This stores packets retired from the TX ring
105: // by the polling routine. We cannot call freePacket() or m_free() within
106: // the debugger context.
107: //
108: // The capacity of the queue is set at maximum to prevent the queue from
109: // calling m_free() due to over-capacity. But we don't expect the size
110: // of the queue to grow too large.
111: //
112: debugQueue = IOPacketQueue::withCapacity((UInt) -1);
113: if (!debugQueue)
114: return false;
115:
116: // Allocate a IOMBufDBDMAMemoryCursor instance. Currently, the maximum
117: // number of segments is set to 2. The maximum length for each segment
118: // is set to the maximum ethernet frame size (plus padding).
119:
120: mbufCursor = IOMBufBigMemoryCursor::withSpecification(NETWORK_BUFSIZE, 2);
121: if (!mbufCursor)
122: {
123: IOLog("Mace: IOMBufMemoryCursor allocation failed\n");
124: return false;
125: }
126:
127: //
128: // Our provider is the nub representing the MaceEnet hardware
129: // controller. We will query it for our resource information.
130: //
131:
132: for (int i = 0; i < MEMORY_MAP_COUNT; i++) {
133: IOMemoryMap * map;
134:
135: map = provider->mapDeviceMemoryWithIndex(i);
136: if (!map)
137: return false;
138:
139: #ifdef DEBUG_XXX
140: IOLog("map %d: Phys:%08x Virt:%08x len:%d\n",
141: i,
142: (UInt) map->getPhysicalAddress(),
143: (UInt) map->getVirtualAddress(),
144: (UInt) map->getLength());
145: #endif
146:
147: switch (i) {
148: case MEMORY_MAP_ENET_INDEX:
149: ioBaseEnet = (IOPPCAddress) map->getVirtualAddress();
150: ioBaseEnetROM = (IOPPCAddress) ((map->getPhysicalAddress() &
151: ~0xffff) | kControllerROMOffset);
152: break;
153:
154: case MEMORY_MAP_TXDMA_INDEX:
155: ioBaseEnetTxDMA = (IODBDMAChannelRegisters *)
156: map->getVirtualAddress();
157: break;
158:
159: case MEMORY_MAP_RXDMA_INDEX:
160: ioBaseEnetRxDMA = (IODBDMAChannelRegisters *)
161: map->getVirtualAddress();
162: break;
163: }
164:
165: maps[i] = map;
166: }
167:
168: // Manually create an IODeviceMemory for the ROM memory
169: // range.
170: //
171: IODeviceMemory * romMemory = IODeviceMemory::withRange(
172: (UInt) ioBaseEnetROM, 0x1000);
173: if (!romMemory) {
174: IOLog("Mace: can't create ROM memory object\n");
175: return false;
176: }
177:
178: romMap = romMemory->map();
179: romMemory->release();
180:
181: if (!romMap)
182: return false;
183:
184: ioBaseEnetROM = (IOPPCAddress) romMap->getVirtualAddress();
185:
186: #ifdef DEBUG_XXX
187: IOLog("Mace: ioBaseEnet : %08x\n", (UInt) ioBaseEnet);
188: IOLog("Mace: ioBaseEnetTxDMA : %08x\n", (UInt) ioBaseEnetTxDMA);
189: IOLog("Mace: ioBaseEnetRxDMA : %08x\n", (UInt) ioBaseEnetRxDMA);
190: IOLog("Mace: ioBaseEnetROM : %08x\n", (UInt) ioBaseEnetROM);
191: #endif
192:
193: //
194: // Get a reference to the IOWorkLoop in our superclass.
195: //
196: IOWorkLoop * myWorkLoop = (IOWorkLoop *) getWorkLoop();
197: assert(myWorkLoop);
198:
199: //
200: // Allocate two IOInterruptEventSources.
201: //
202: txIntSrc = IOInterruptEventSource::interruptEventSource
203: (this,
204: (IOInterruptEventAction) &MaceEnet::interruptOccurredForSource,
205: provider, PROVIDER_DMA_TX);
206: if (!txIntSrc
207: || (myWorkLoop->addEventSource(txIntSrc) != kIOReturnSuccess)) {
208: IOLog("Mace: txIntSrc init failure\n");
209: return false;
210: }
211:
212: rxIntSrc = IOInterruptEventSource::interruptEventSource
213: (this,
214: (IOInterruptEventAction) &MaceEnet::interruptOccurredForSource,
215: provider, PROVIDER_DMA_RX);
216: if (!rxIntSrc
217: || (myWorkLoop->addEventSource(rxIntSrc) != kIOReturnSuccess)) {
218: IOLog("Mace: rxIntSrc init failure\n");
219: return false;
220: }
221:
222: timerSrc = IOTimerEventSource::timerEventSource
223: (this, (IOTimerEventSource::Action) &MaceEnet::timeoutOccurred);
224: if (!timerSrc
225: || (myWorkLoop->addEventSource(timerSrc) != kIOReturnSuccess)) {
226: IOLog("Mace: timerSrc init failure\n");
227: return false;
228: }
229:
230: MGETHDR(txDebuggerPkt, M_DONTWAIT, MT_DATA);
231: if (!txDebuggerPkt)
232: {
233: IOLog("Mace: Can't allocate KDB buffer\n");
234: return false;
235: }
236:
237: #if 0
238: // Do not enable interrupt sources until the hardware
239: // is enabled.
240:
241: // Enable the interrupt event sources.
242: myWorkLoop->enableAllInterrupts();
243: #endif
244:
245: #if 0
246: // Do not reset the hardware until we are ready to use it.
247: // Otherwise, we would have messed up kdp_mace driver's
248: // state. And we won't be able to break into the debugger
249: // until we attach our debugger client.
250:
251: //
252: // Perform a hardware reset.
253: //
254: if ( !resetAndEnable(false) )
255: {
256: return false;
257: }
258: #endif
259:
260: // Cache my MAC address.
261: //
262: getHardwareAddress(&myAddress);
263:
264: //
265: // Allocate memory for ring buffers.
266: //
267: if (_allocateMemory() == false)
268: {
269: return false;
270: }
271:
272: //
273: // Attach a kernel debugger client.
274: //
275: attachDebuggerClient(&debugger);
276:
277: //
278: // Allocate and initialize an IONetworkInterface object.
279: //
280: if (!attachNetworkInterface((IONetworkInterface **) &networkInterface))
281: return false;
282:
283: return true;
284: }
285:
286: /*-------------------------------------------------------------------------
287: *
288: *
289: *
290: *-------------------------------------------------------------------------*/
291:
292: void MaceEnet::free()
293: {
294: UInt i;
295:
296: timerSrc->cancelTimeout();
297:
298: _resetChip();
299:
300: if (debugger)
301: debugger->release();
302:
303: if (timerSrc)
304: timerSrc->release();
305:
306: if (rxIntSrc)
307: rxIntSrc->release();
308:
309: if (txIntSrc)
310: txIntSrc->release();
311:
312: if (transmitQueue)
313: transmitQueue->release();
314:
315: if (debugQueue)
316: debugQueue->release();
317:
318: if (networkInterface)
319: networkInterface->release();
320:
321: if (mbufCursor)
322: mbufCursor->release();
323:
324: if (txDebuggerPkt)
325: freePacket(txDebuggerPkt);
326:
327: for (i = 0; i < rxMaxCommand; i++)
328: if (rxMbuf[i]) freePacket(rxMbuf[i]);
329:
330: for (i = 0; i < txMaxCommand; i++)
331: if (txMbuf[i]) freePacket(txMbuf[i]);
332:
333: if (romMap) romMap->release();
334:
335: for (i = 0; i < MEMORY_MAP_COUNT; i++)
336: if (maps[i]) maps[i]->release();
337:
338: if (dmaMemory.ptr)
339: {
340: IOFree(dmaMemory.ptrReal, dmaMemory.sizeReal);
341: dmaMemory.ptr = 0;
342: }
343:
344: super::free();
345: }
346:
347: /*-------------------------------------------------------------------------
348: *
349: *
350: *
351: *-------------------------------------------------------------------------*/
352:
353: void MaceEnet::interruptOccurredForSource(IOInterruptEventSource *src,
354: int /*count*/)
355: {
356: bool doFlushQueue = false;
357: bool doService = false;
358:
359: // IOLog("Mace: interrupt %08x %d\n", (UInt) src, count);
360:
361: if (!ready) {
362: // IOLog("Mace: unexpected interrupt\n");
363: return;
364: }
365:
366: reserveDebuggerLock();
367:
368: if (src == txIntSrc) {
369: txWDInterrupts++;
370: KERNEL_DEBUG(DBG_MACE_TXIRQ | DBG_FUNC_START, 0, 0, 0, 0, 0 );
371: doService = _transmitInterruptOccurred();
372: KERNEL_DEBUG(DBG_MACE_TXIRQ | DBG_FUNC_END, 0, 0, 0, 0, 0 );
373: }
374: else {
375: KERNEL_DEBUG(DBG_MACE_RXIRQ | DBG_FUNC_START, 0, 0, 0, 0, 0 );
376: doFlushQueue = _receiveInterruptOccurred();
377: KERNEL_DEBUG(DBG_MACE_RXIRQ | DBG_FUNC_END, 0, 0, 0, 0, 0 );
378: }
379:
380: releaseDebuggerLock();
381:
382: /*
383: * Submit all received packets queued up by _receiveInterruptOccurred()
384: * to the network stack. The up call is performed without holding the
385: * debugger lock.
386: */
387: if (doFlushQueue)
388: networkInterface->flushInputQueue();
389:
390: /*
391: * Make sure the output queue is not stalled.
392: */
393: if (doService && netifClient)
394: transmitQueue->service();
395: }
396:
397: /*-------------------------------------------------------------------------
398: *
399: *
400: *
401: *-------------------------------------------------------------------------*/
402:
403: UInt32 MaceEnet::outputPacket(struct mbuf *pkt)
404: {
405: u_int32_t i;
406: u_int8_t regValue;
407: UInt32 ret = kIOOQReturnSuccess;
408:
409: // IOLog("Mace: outputPacket %d\n", pkt->m_pkthdr.len);
410:
411: KERNEL_DEBUG(DBG_MACE_TXQUEUE | DBG_FUNC_NONE, (int) pkt,
412: (int) pkt->m_pkthdr.len, 0, 0, 0 );
413:
414: /*
415: * Hold the debugger lock so the debugger can't interrupt us
416: */
417: reserveDebuggerLock();
418:
419: do
420: {
421: /*
422: * Someone is turning off the receiver before the first transmit.
423: * Dont know who yet!
424: */
425: regValue = ReadMaceRegister( ioBaseEnet, kMacCC );
426: regValue |= kMacCCEnRcv;
427: WriteMaceRegister( ioBaseEnet, kMacCC, regValue );
428:
429: /*
430: * Preliminary sanity checks
431: */
432: assert(pkt && netifClient);
433:
434: /*
435: * Remove any completed packets from the Tx ring
436: */
437: _transmitInterruptOccurred();
438:
439: i = txCommandTail + 1;
440: if ( i >= txMaxCommand ) i = 0;
441: if ( i == txCommandHead )
442: {
443: ret = kIOOQReturnStall;
444: continue;
445: }
446:
447: /*
448: * If there is space on the Tx ring, add the packet directly to the
449: * ring
450: */
451: _transmitPacket(pkt);
452: }
453: while ( 0 );
454:
455: releaseDebuggerLock();
456:
457: return ret;
458: }
459:
460: /*-------------------------------------------------------------------------
461: * Called by IOEthernetInterface client to enable the controller.
462: * This method is always called while running on the default workloop
463: * thread.
464: *-------------------------------------------------------------------------*/
465:
466: IOReturn MaceEnet::enable(IONetworkInterface * netif)
467: {
468: IONetworkParameter * param;
469:
470: // If an interface client has previously enabled us,
471: // and we know there can only be one interface client
472: // for this driver, then simply return true.
473: //
474: if (netifClient) {
475: IOLog("Mace: already enabled\n");
476: return kIOReturnSuccess;
477: }
478:
479: param = netif->getParameter(kIONetworkStatsKey);
480: if (!param || !(netStats = (IONetworkStats *) param->getBuffer()))
481: {
482: IOLog("Mace: invalid network statistics\n");
483: return kIOReturnError;
484: }
485:
486: if ((ready == false) && !resetAndEnable(true))
487: return kIOReturnIOError;
488:
489: // Record the interface as an active client.
490: //
491: netifClient = true;
492:
493: // Start our IOOutputQueue object.
494: //
495: transmitQueue->setCapacity(TRANSMIT_QUEUE_SIZE);
496: transmitQueue->start();
497:
498: return kIOReturnSuccess;
499: }
500:
501: /*-------------------------------------------------------------------------
502: * Called by IOEthernetInterface client to disable the controller.
503: * This method is always called while running on the default workloop
504: * thread.
505: *-------------------------------------------------------------------------*/
506:
507: IOReturn MaceEnet::disable(IONetworkInterface * /*netif*/)
508: {
509: // If we have no active clients, then disable the controller.
510: //
511: if (debugClient == false)
512: resetAndEnable(false);
513:
514: // Disable our IOOutputQueue object.
515: //
516: transmitQueue->stop();
517:
518: // Flush all packets currently in the output queue.
519: //
520: transmitQueue->setCapacity(0);
521: transmitQueue->flush();
522:
523: netifClient = false;
524:
525: return kIOReturnSuccess;
526: }
527:
528: /*-------------------------------------------------------------------------
529: * This method is called by our debugger client to bring up the controller
530: * just before the controller is registered as the debugger device. The
531: * debugger client is attached in response to the attachDebuggerClient()
532: * call.
533: *
534: * This method is always called while running on the default workloop
535: * thread.
536: *-------------------------------------------------------------------------*/
537:
538: IOReturn MaceEnet::handleDebuggerOpen(IOKernelDebugger * /*debugger*/)
539: {
540: // Enable hardware and make it ready to support the debugger client.
541: //
542: if ((ready == false) && !resetAndEnable(true))
543: return kIOReturnIOError;
544:
545: // Record the debugger as an active client of ours.
546: //
547: debugClient = true;
548:
549: // Returning true will allow the kdp registration to continue.
550: // If we return false, then we will not be registered as the
551: // debugger device, and the attachDebuggerClient() call will
552: // return NULL.
553: //
554: return kIOReturnSuccess;
555: }
556:
557: /*-------------------------------------------------------------------------
558: * This method is called by our debugger client to stop the controller.
559: * The debugger will call this method when we issue a detachDebuggerClient().
560: *
561: * This method is always called while running on the default workloop
562: * thread.
563: *-------------------------------------------------------------------------*/
564:
565: IOReturn MaceEnet::handleDebuggerClose(IOKernelDebugger * /*debugger*/)
566: {
567: debugClient = false;
568:
569: // If we have no active clients, then disable the controller.
570: //
571: if (netifClient == false)
572: resetAndEnable(false);
573:
574: return kIOReturnSuccess;
575: }
576:
577: /*-------------------------------------------------------------------------
578: *
579: *
580: *
581: *-------------------------------------------------------------------------*/
582:
583: bool MaceEnet::resetAndEnable(bool enable)
584: {
585: bool ret = true;
586:
587: if (timerSrc)
588: timerSrc->cancelTimeout();
589:
590: _disableAdapterInterrupts();
591: if (getWorkLoop()) getWorkLoop()->disableAllInterrupts();
592:
593: reserveDebuggerLock();
594:
595: ready = false;
596:
597: _resetChip();
598:
599: do {
600: if (!enable) break;
601:
602: if ( !_initRxRing() || !_initTxRing() || !_initChip() )
603: {
604: ret = false;
605: break;
606: }
607:
608: _startChip();
609:
610: ready = true;
611:
612: releaseDebuggerLock();
613:
614: timerSrc->setTimeoutMS(WATCHDOG_TIMER_MS);
615:
616: if (getWorkLoop()) getWorkLoop()->enableAllInterrupts();
617: _enableAdapterInterrupts();
618:
619: return true;
620: }
621: while (0);
622:
623: releaseDebuggerLock();
624:
625: return ret;
626: }
627:
628: /*-------------------------------------------------------------------------
629: *
630: *
631: *
632: *-------------------------------------------------------------------------*/
633:
634: void MaceEnet::_sendTestPacket()
635: {
636: // IOOutputPacketStatus ret;
637: unsigned char * buf;
638: const unsigned int size = 64;
639:
640: struct mbuf * m = allocatePacket(size);
641: if (!m) {
642: IOLog("Mace: _sendTestpacket: allocatePacket() failed\n");
643: return;
644: }
645:
646: buf = mtod(m, unsigned char *);
647:
648: bcopy(&myAddress, buf, NUM_EN_ADDR_BYTES);
649: buf += NUM_EN_ADDR_BYTES;
650: bcopy(&myAddress, buf, NUM_EN_ADDR_BYTES);
651: buf += NUM_EN_ADDR_BYTES;
652: *buf++ = 0;
653: *buf++ = 0;
654:
655: outputPacket(m);
656: }
657:
658: /*-------------------------------------------------------------------------
659: *
660: *
661: *
662: *-------------------------------------------------------------------------*/
663:
664: void MaceEnet::timeoutOccurred(IOTimerEventSource * /*timer*/)
665: {
666: u_int32_t dmaStatus;
667: bool doFlushQueue = false;
668: bool doService = false;
669:
670: reserveDebuggerLock();
671:
672: /*
673: * Check for DMA shutdown on receive channel
674: */
675: dmaStatus = IOGetDBDMAChannelStatus( ioBaseEnetRxDMA );
676: if ( !(dmaStatus & kdbdmaActive) )
677: {
678: #if 0
679: IOLog("Mace: Timeout check - RxHead = %d RxTail = %d\n",
680: rxCommandHead, rxCommandTail);
681: #endif
682:
683: #if 0
684: IOLog( "Mace: Rx Commands = %08x(p) Rx DMA Ptr = %08x(p)\n\r", rxDMACommandsPhys, IOGetDBDMACommandPtr(ioBaseEnetRxDMA) );
685: [self _dumpDesc:(void *)rxDMACommands Size:rxMaxCommand * sizeof(enet_dma_cmd_t)];
686: #endif
687:
688: doFlushQueue = _receiveInterruptOccurred();
689: }
690:
691: /*
692: * If there are pending entries on the Tx ring
693: */
694: if ( txCommandHead != txCommandTail )
695: {
696: /*
697: * If we did not service the Tx ring during the last timeout interval,
698: * then force servicing of the Tx ring.
699: * If we have more than one timeout interval without any transmit
700: * interrupts, then force the transmitter to reset.
701: */
702: if ( txWDInterrupts == 0 )
703: {
704: if ( ++txWDTimeouts > 1 ) txWDForceReset = true;
705:
706: #if 0
707: IOLog( "Mace: Checking for timeout - TxHead = %d TxTail = %d\n",
708: txCommandHead, txCommandTail);
709: #endif
710: doService = _transmitInterruptOccurred();
711: }
712: else
713: {
714: txWDTimeouts = 0;
715: txWDInterrupts = 0;
716: }
717: }
718: else
719: {
720: txWDTimeouts = 0;
721: txWDInterrupts = 0;
722: }
723:
724: // Clean-up after the debugger if the debugger was active.
725: //
726: if (debugTxPoll)
727: {
728: debugQueue->flush();
729: debugTxPoll = false;
730: releaseDebuggerLock();
731: doService = true;
732: }
733: else
734: {
735: releaseDebuggerLock();
736: }
737:
738: /*
739: * Submit all received packets queued up by _receiveInterruptOccurred()
740: * to the network stack. The up call is performed without holding the
741: * debugger lock.
742: */
743: if (doFlushQueue)
744: {
745: networkInterface->flushInputQueue();
746: }
747:
748: /*
749: * Make sure the output queue is not stalled.
750: */
751: if (doService && netifClient)
752: {
753: transmitQueue->service();
754: }
755:
756: /*
757: * Restart the watchdog timer
758: */
759: timerSrc->setTimeoutMS(WATCHDOG_TIMER_MS);
760: }
761:
762: /*-------------------------------------------------------------------------
763: *
764: *
765: *
766: *-------------------------------------------------------------------------*/
767:
768: const char * MaceEnet::getVendorString() const
769: {
770: return ("Apple");
771: }
772:
773: const char * MaceEnet::getModelString() const
774: {
775: return ("Mace");
776: }
777:
778: const char * MaceEnet::getRevisionString() const
779: {
780: return ("");
781: }
782:
783: /*-------------------------------------------------------------------------
784: *
785: *
786: *
787: *-------------------------------------------------------------------------*/
788:
789: IOReturn MaceEnet::_setPromiscuousMode(IOEnetPromiscuousMode mode)
790: {
791: u_int8_t regVal;
792:
793: regVal = ReadMaceRegister( ioBaseEnet, kMacCC );
794: WriteMaceRegister( ioBaseEnet, kMacCC, regVal & ~kMacCCEnRcv );
795: if (mode == kIOEnetPromiscuousModeOff) {
796: regVal &= ~kMacCCProm;
797: isPromiscuous = false;
798: }
799: else {
800: regVal |= kMacCCProm;
801: isPromiscuous = true;
802: }
803: WriteMaceRegister( ioBaseEnet, kMacCC, regVal );
804:
805: return kIOReturnSuccess;
806:
807: }
808:
809: IOReturn MaceEnet::setPromiscuousMode(IOEnetPromiscuousMode mode)
810: {
811: IOReturn ret;
812:
813: reserveDebuggerLock();
814: ret = _setPromiscuousMode(mode);
815: releaseDebuggerLock();
816:
817: return ret;
818: }
819:
820: IOReturn MaceEnet::setMulticastMode(IOEnetMulticastMode mode)
821: {
822: multicastEnabled = (mode == kIOEnetMulticastModeOff) ? false : true;
823: return kIOReturnSuccess;
824: }
825:
826: IOReturn MaceEnet::setMulticastList(enet_addr_t *addrs, UInt count)
827: {
828: reserveDebuggerLock();
829: _resetHashTableMask();
830: for (UInt i = 0; i < count; i++) {
831: _addToHashTableMask(addrs->ea_byte);
832: addrs++;
833: }
834: _updateHashTableMask();
835: releaseDebuggerLock();
836: return kIOReturnSuccess;
837: }
838:
839: /*
840: * Allocate an IOOutputQueue object.
841: */
842: IOOutputQueue * MaceEnet::allocateOutputQueue()
843: {
844: return IOOQGateFIFOQueue::withTarget( this, getWorkLoop() );
845: }
846:
847: /*
848: * Kernel Debugger Support
849: */
850: void MaceEnet::sendPacket(void *pkt, UInt pkt_len)
851: {
852: _sendPacket(pkt, pkt_len);
853: }
854:
855: void MaceEnet::receivePacket(void *pkt, UInt *pkt_len, UInt timeout)
856: {
857: _receivePacket(pkt, pkt_len, timeout);
858: }
859:
860: #if 0 // no power management stuff in IOKit yet.
861: /*
862: * Power management methods.
863: */
864: - (IOReturn)getPowerState:(PMPowerState *)state_p
865: {
866: return kIOReturnUnsupported;
867: }
868:
869: - (IOReturn)setPowerState:(PMPowerState)state
870: {
871: if (state == PM_OFF) {
872: resetAndEnabled = NO;
873: [self _resetChip];
874: return kIOReturnSuccess;
875: }
876: return kIOReturnUnsupported;
877: }
878:
879: - (IOReturn)getPowerManagement:(PMPowerManagementState *)state_p
880: {
881: return kIOReturnUnsupported;
882: }
883:
884: - (IOReturn)setPowerManagement:(PMPowerManagementState)state
885: {
886: return kIOReturnUnsupported;
887: }
888: #endif /* 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.