![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to BMacEnet.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvBMacEnet|
Return to BMacEnet.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvBMacEnet |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1998-1999 by Apple Computer, Inc., All rights reserved.
27: *
28: * Hardware independent (relatively) code for the BMac Ethernet Controller
29: *
30: * HISTORY
31: *
32: * dd-mmm-yy
33: * Created.
34: *
35: */
36:
37: #import "BMacEnetPrivate.h"
38:
39: @implementation BMacEnet
40:
41: /*
42: * Public Factory Methods
43: */
44:
45: + (BOOL)probe:(IOTreeDevice *)devDesc
46: {
47: BMacEnet *BMacEnetInstance;
48:
49: BMacEnetInstance = [self alloc];
50: return [BMacEnetInstance initFromDeviceDescription:devDesc] != nil;
51: }
52:
53: /*
54: * Public Instance Methods
55: */
56:
57: /*-------------------------------------------------------------------------
58: *
59: *
60: *
61: *-------------------------------------------------------------------------*/
62:
63: - initFromDeviceDescription:(IOTreeDevice *)devDesc
64: {
65: IOTreeDevice *devDescHeathrow;
66: IORange *ioRangeBMac;
67: IORange *ioRangeHeathrow;
68:
69: if ([super initFromDeviceDescription:devDesc] == nil)
70: {
71: IOLog( "Ethernet(BMac): [super initFromDeviceDescription] failed\n");
72: return nil;
73: }
74:
75: if ( [devDesc numMemoryRanges] < 3 )
76: {
77: IOLog( "Ethernet(BMac): Incorrect deviceDescription - 1\n\r");
78: return nil;
79: }
80:
81: ioRangeBMac = [devDesc memoryRangeList];
82:
83: ioBaseEnet = (IOPPCAddress) ioRangeBMac[0].start;
84: ioBaseEnetTxDMA = (IOPPCAddress) ioRangeBMac[1].start;
85: ioBaseEnetRxDMA = (IOPPCAddress) ioRangeBMac[2].start;
86:
87: devDescHeathrow = [[devDesc parent] deviceDescription];
88:
89: if ( [devDescHeathrow numMemoryRanges] < 1 )
90: {
91: IOLog( "Ethernet(BMac): Incorrect deviceDescription - 2\n\r");
92: return nil;
93: }
94:
95: ioRangeHeathrow = [devDescHeathrow memoryRangeList];
96:
97: ioBaseHeathrow = (IOPPCAddress) ioRangeHeathrow[0].start;
98:
99: sromAddressBits = 6;
100: enetAddressOffset = 20;
101: phyId = -1;
102: phyMIIDelay = MII_DEFAULT_DELAY;
103:
104: if ( ![self resetAndEnable:NO] )
105: {
106: [self free];
107: return nil;
108: }
109:
110: [self _getStationAddress:&myAddress];
111:
112: if ([self _allocateMemory] == NO)
113: {
114: [self free];
115: return nil;
116: }
117:
118: if ( ![self resetAndEnable:YES] )
119: {
120: [self free];
121: return nil;
122: }
123:
124: isPromiscuous = NO;
125: multicastEnabled = NO;
126:
127: networkInterface = [super attachToNetworkWithAddress:myAddress];
128:
129: [networkInterface getIONetworkIfnet]->if_eflags |= IFEF_DVR_REENTRY_OK;
130:
131: return self;
132: }
133:
134: /*-------------------------------------------------------------------------
135: *
136: *
137: *
138: *-------------------------------------------------------------------------*/
139:
140: - free
141: {
142: int i;
143:
144: [self clearTimeout];
145:
146: [self _resetChip];
147:
148: if (networkInterface)
149: [networkInterface free];
150:
151: for (i = 0; i < rxMaxCommand; i++)
152: if (rxNetbuf[i]) nb_free(rxNetbuf[i]);
153:
154: for (i = 0; i < txMaxCommand; i++)
155: if (txNetbuf[i]) nb_free(txNetbuf[i]);
156:
157: return [super free];
158: }
159:
160: /*-------------------------------------------------------------------------
161: *
162: *
163: *
164: *-------------------------------------------------------------------------*/
165:
166: - (void)interruptOccurredAt:(int)irqNum
167: {
168:
169: [self reserveDebuggerLock];
170:
171: switch ( irqNum )
172: {
173: /*
174: * On the transmit side, we use the chipset interrupt. Using the transmit
175: * DMA interrupt (or having multiple transmit DMA entries) would allows us to
176: * send the next frame to the chipset prior the transmit fifo going empty.
177: * However, this aggrevates a BMac chipset bug where the next frame going out
178: * gets corrupted (first two bytes lost) if the chipset had to retry the previous
179: * frame.
180: */
181: case kIRQEnetDev:
182: case kIRQEnetTxDMA:
183: txWDInterrupts++;
184: KERNEL_DEBUG(DBG_BMAC_TXIRQ | DBG_FUNC_START, 0, 0, 0, 0, 0 );
185: [self _transmitInterruptOccurred];
186: [self serviceTransmitQueue];
187: KERNEL_DEBUG(DBG_BMAC_TXIRQ | DBG_FUNC_END, 0, 0, 0, 0, 0 );
188: break;
189: case kIRQEnetRxDMA:
190: KERNEL_DEBUG(DBG_BMAC_RXIRQ | DBG_FUNC_START, 0, 0, 0, 0, 0 );
191: [self _receiveInterruptOccurred];
192: KERNEL_DEBUG(DBG_BMAC_RXIRQ | DBG_FUNC_END, 0, 0, 0, 0, 0 );
193: break;
194: }
195:
196: [self enableAllInterrupts];
197:
198: [self releaseDebuggerLock];
199: }
200:
201: /*-------------------------------------------------------------------------
202: *
203: *
204: *
205: *-------------------------------------------------------------------------*/
206:
207: - (void) serviceTransmitQueue
208: {
209: netbuf_t packet;
210: u_int32_t i;
211:
212: while ( 1 )
213: {
214: if ( ![transmitQueue count] )
215: {
216: break;
217: }
218:
219: i = txCommandTail + 1;
220: if ( i >= txMaxCommand ) i = 0;
221: if ( i == txCommandHead )
222: {
223: break;
224: }
225: packet = [transmitQueue dequeue];
226: [self _transmitPacket:packet];
227: }
228:
229: }
230:
231: /*-------------------------------------------------------------------------
232: *
233: *
234: *
235: *-------------------------------------------------------------------------*/
236:
237: - (void)transmit:(netbuf_t)pkt
238: {
239: u_int32_t i;
240: u_int32_t n;
241:
242: KERNEL_DEBUG(DBG_BMAC_TXQUEUE | DBG_FUNC_NONE, (int) pkt, (int) nb_size(pkt), 0, 0, 0 );
243:
244: /*
245: * Hold the debugger lock so the debugger can't interrupt us
246: */
247: [self reserveDebuggerLock];
248:
249: do
250: {
251: /*
252: * Preliminary sanity checks
253: */
254: if (!pkt)
255: {
256: IOLog("EtherNet(BMac): transmit received NULL netbuf\n");
257: continue;
258: }
259: if ( ![self isRunning] )
260: {
261: nb_free(pkt);
262: continue;
263: }
264:
265: #if 0
266: /*
267: * Remove any completed packets from the Tx ring
268: */
269: if ( chipId >= kCHIPID_PaddingtonXmitStreaming )
270: {
271: [self _transmitInterruptOccurred];
272: }
273: #endif
274:
275: /*
276: * Refill the Tx ring from the Transmit waiting list
277: */
278: [self serviceTransmitQueue];
279:
280: /*
281: * If the Transmit waiting list is not empty or the Tx ring is
282: * full, add the new packet to the waiting list.
283: */
284: n = [transmitQueue count];
285: if ( n > 0 )
286: {
287: if ( n >= [transmitQueue maxCount] )
288: {
289: IOLog("Ethernet(BMac): Transmit queue overflow\n");
290: }
291:
292: [transmitQueue enqueue:pkt];
293: continue;
294: }
295: i = txCommandTail + 1;
296: if ( i >= txMaxCommand ) i = 0;
297: if ( i == txCommandHead )
298: {
299: [transmitQueue enqueue:pkt];
300: continue;
301: }
302:
303: /*
304: * If there is space on the Tx ring, add the packet directly to the
305: * ring
306: */
307: [self _transmitPacket:pkt];
308: }
309: while( 0 );
310:
311: [self releaseDebuggerLock];
312: }
313:
314: /*-------------------------------------------------------------------------
315: *
316: *
317: *
318: *-------------------------------------------------------------------------*/
319:
320: - (int) transmitQueueSize
321: {
322: return (TRANSMIT_QUEUE_SIZE);
323: }
324:
325: - (int) transmitQueueCount
326: {
327: return ([transmitQueue count]);
328: }
329: /*-------------------------------------------------------------------------
330: *
331: *
332: *
333: *-------------------------------------------------------------------------*/
334:
335: - (BOOL)resetAndEnable:(BOOL)enable
336: {
337: resetAndEnabled = NO;
338: [self clearTimeout];
339: [self disableAllInterrupts];
340: [self _resetChip];
341:
342: if (enable)
343: {
344: if (![self _initRxRing] || ![self _initTxRing])
345: {
346: return NO;
347: }
348:
349: if ( phyId != 0xff )
350: {
351: [self miiInitializePHY:phyId];
352: }
353:
354: if ([self _initChip] == NO)
355: {
356: [self setRunning:NO];
357: return NO;
358: }
359:
360: [self _startChip];
361:
362: [self setRelativeTimeout: WATCHDOG_TIMER_MS];
363:
364: [self enableAllInterrupts];
365: [self _enableAdapterInterrupts];
366:
367: resetAndEnabled = YES;
368:
369: [self _sendDummyPacket];
370: }
371:
372: [self setRunning:enable];
373:
374: return YES;
375: }
376:
377: /*-------------------------------------------------------------------------
378: *
379: *
380: *
381: *-------------------------------------------------------------------------*/
382:
383: - (void)timeoutOccurred
384: {
385: u_int32_t dmaStatus;
386: u_int16_t phyStatus;
387: u_int16_t linkStatus;
388: u_int16_t phyStatusChange;
389: BOOL fullDuplex = NO;
390:
391: if ( ![self isRunning] )
392: {
393: return;
394: }
395:
396: [self reserveDebuggerLock];
397:
398: /*
399: * Check for DMA shutdown on receive channel
400: */
401: dmaStatus = IOGetDBDMAChannelStatus( ioBaseEnetRxDMA );
402: if ( !(dmaStatus & kdbdmaActive) )
403: {
404: IOLog( "Ethernet(BMac): Checking for timeout - RxHead = %d RxTail = %d\n\r", rxCommandHead, rxCommandTail);
405: #if 0
406: IOLog( "Ethernet(BMac): Rx Commands = %08x(p) Rx DMA Ptr = %08x(p)\n\r", rxDMACommandsPhys, IOGetDBDMACommandPtr(ioBaseEnetRxDMA) );
407: [self _dumpDesc:(void *)rxDMACommands Size:rxMaxCommand * sizeof(enet_dma_cmd_t)];
408: #endif
409: [self _receiveInterruptOccurred];
410: }
411:
412: /*
413: * If there are pending entries on the Tx ring
414: */
415: if ( txCommandHead != txCommandTail )
416: {
417: /*
418: * If we did not service the Tx ring during the last timeout interval,
419: * then force servicing of the Tx ring
420: */
421: if ( txWDInterrupts == 0 )
422: {
423: if ( txWDCount++ > 0 )
424: {
425: if ( [self _transmitInterruptOccurred] == NO )
426: {
427: IOLog( "Ethernet(BMac): Checking for timeout - TxHead = %d TxTail = %d\n\r", txCommandHead, txCommandTail);
428: [self _restartTransmitter];
429: }
430: }
431: }
432: else
433: {
434: txWDInterrupts = 0;
435: txWDCount = 0;
436: }
437: }
438: else
439: {
440: txWDInterrupts = 0;
441: txWDCount = 0;
442: }
443:
444: if ( phyId != 0xff )
445: {
446: if ( [self miiReadWord:&phyStatus reg:MII_STATUS phy:phyId] == YES )
447: {
448: phyStatusChange = (phyStatusPrev ^ phyStatus) & (MII_STATUS_LINK_STATUS | MII_STATUS_NEGOTIATION_COMPLETE);
449: if ( phyStatusChange )
450: {
451: if ( (phyStatus & MII_STATUS_LINK_STATUS) && (phyStatus & MII_STATUS_NEGOTIATION_COMPLETE ) )
452: {
453: if ( (phyType & MII_ST10040_MASK) == MII_ST10040_ID )
454: {
455: [self miiReadWord:&linkStatus reg:MII_ST10040_CHIPST phy:phyId];
456:
457: fullDuplex = (linkStatus & MII_ST10040_CHIPST_DUPLEX) ? YES : NO;
458:
459: IOLog( "Ethernet(BMac): Link is up at %sMb - %s Duplex\n\r",
460: (linkStatus & MII_ST10040_CHIPST_SPEED) ? "100" : "10",
461: (fullDuplex) ? "Full" : "Half" );
462: }
463: else if ( (phyType & MII_DP83843_MASK) == MII_DP83843_ID )
464: {
465: [self miiReadWord:&linkStatus reg:MII_DP83843_PHYSTS phy:phyId];
466:
467: fullDuplex = (linkStatus & MII_DP83843_PHYSTS_DUPLEX) ? YES : NO;
468:
469: IOLog( "Ethernet(BMac): Link is up at %sMb - %s Duplex\n\r",
470: (linkStatus & MII_DP83843_PHYSTS_SPEED10) ? "10" : "100",
471: (fullDuplex) ? "Full" : "Half" );
472: }
473: else
474: {
475: fullDuplex = NO ;
476: IOLog( "Ethernet(BMac): Link is up\n\r" );
477: }
478:
479: if ( fullDuplex != isFullDuplex )
480: {
481: [self _setDuplexMode: fullDuplex];
482: }
483: }
484: else
485: {
486: IOLog( "Ethernet(BMac): Link is down.\n\r" );
487: }
488: phyStatusPrev = phyStatus;
489: }
490: }
491: }
492:
493: /*
494: * Restart the watchdog timer
495: */
496: [self setRelativeTimeout: WATCHDOG_TIMER_MS];
497:
498: [self releaseDebuggerLock];
499:
500: }
501:
502: /*-------------------------------------------------------------------------
503: *
504: *
505: *
506: *-------------------------------------------------------------------------*/
507:
508: - (BOOL)enablePromiscuousMode
509: {
510: u_int16_t rxCFGVal;
511:
512: isPromiscuous = YES;
513:
514: [self reserveDebuggerLock];
515:
516: /*
517: * Turn off the receiver and wait for the chipset to acknowledge
518: */
519: rxCFGVal = ReadBigMacRegister(ioBaseEnet, kRXCFG);
520: WriteBigMacRegister(ioBaseEnet, kRXCFG, rxCFGVal & ~kRxMACEnable );
521: while( ReadBigMacRegister(ioBaseEnet, kRXCFG) & kRxMACEnable )
522: ;
523:
524: /*
525: * Set promiscuous mode and restore receiver state
526: */
527: rxCFGVal |= kRxPromiscEnable;
528: WriteBigMacRegister( ioBaseEnet, kRXCFG, rxCFGVal );
529:
530: [self releaseDebuggerLock];
531:
532: return YES;
533: }
534:
535: - (void)disablePromiscuousMode
536: {
537: u_int16_t rxCFGVal;
538:
539: isPromiscuous = NO;
540:
541: [self reserveDebuggerLock];
542:
543: /*
544: * Turn off the receiver and wait for the chipset to acknowledge
545: */
546: rxCFGVal = ReadBigMacRegister(ioBaseEnet, kRXCFG);
547: WriteBigMacRegister(ioBaseEnet, kRXCFG, rxCFGVal & ~kRxMACEnable );
548: while( ReadBigMacRegister(ioBaseEnet, kRXCFG) & kRxMACEnable )
549: ;
550:
551: /*
552: * Reset promiscuous mode and restore receiver state
553: */
554: rxCFGVal &= ~kRxPromiscEnable;
555: WriteBigMacRegister( ioBaseEnet, kRXCFG, rxCFGVal );
556:
557: [self releaseDebuggerLock];
558: }
559:
560: - (BOOL)enableMulticastMode
561: {
562: multicastEnabled = YES;
563: return YES;
564: }
565:
566: - (void)disableMulticastMode
567: {
568: multicastEnabled = NO;
569: }
570:
571: - (void)addMulticastAddress:(enet_addr_t *)addr
572: {
573: multicastEnabled = YES;
574: [self reserveDebuggerLock];
575: [self _addToHashTableMask:addr->ea_byte];
576: [self _updateBMacHashTableMask];
577: [self releaseDebuggerLock];
578: }
579:
580: - (void)removeMulticastAddress:(enet_addr_t *)addr
581: {
582: [self reserveDebuggerLock];
583: [self _removeFromHashTableMask:addr->ea_byte];
584: [self _updateBMacHashTableMask];
585: [self releaseDebuggerLock];
586: }
587:
588: /*
589: * Kernel Debugger Support
590: */
591: - (void)sendPacket:(void *)pkt length:(unsigned int)pkt_len
592: {
593: [self _sendPacket:(void *)pkt length:(unsigned int)pkt_len];
594: }
595:
596: - (void)receivePacket:(void *)pkt length:(unsigned int *)pkt_len timeout:(unsigned int)timeout
597: {
598: [self _receivePacket:(void *)pkt length:(unsigned int *)pkt_len timeout:(unsigned int)timeout];
599: }
600:
601: /*
602: * Power management methods.
603: */
604: - (IOReturn)getPowerState:(PMPowerState *)state_p
605: {
606: return IO_R_UNSUPPORTED;
607: }
608:
609: - (IOReturn)setPowerState:(PMPowerState)state
610: {
611: if (state == PM_OFF) {
612: resetAndEnabled = NO;
613: [self _resetChip];
614: return IO_R_SUCCESS;
615: }
616: return IO_R_UNSUPPORTED;
617: }
618:
619: - (IOReturn)getPowerManagement:(PMPowerManagementState *)state_p
620: {
621: return IO_R_UNSUPPORTED;
622: }
623:
624: - (IOReturn)setPowerManagement:(PMPowerManagementState)state
625: {
626: return IO_R_UNSUPPORTED;
627: }
628:
629: - (void)reserveDebuggerLock
630: {
631: if ( debuggerLockCount++ == 0 )
632: {
633: [super reserveDebuggerLock];
634: }
635: }
636:
637: - (void)releaseDebuggerLock
638: {
639: if ( --debuggerLockCount == 0 )
640: {
641: [super releaseDebuggerLock];
642: }
643: }
644:
645:
646: @end
647:
648:
649:
650:
651:
652:
653:
654:
655:
656:
657:
658:
659:
660:
661:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.