![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to MaceEnet.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 / drvMaceEnet|
Return to MaceEnet.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvMaceEnet |
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) 1995-1996 NeXT Software, Inc.
27: *
28: * Hardware independent (relatively) code for the Mace Ethernet Controller
29: *
30: * HISTORY
31: *
32: * dd-mmm-yy
33: * Created.
34: *
35: */
36:
37: #import "MaceEnetPrivate.h"
38:
39: @implementation MaceEnet
40:
41: /*
42: * Public Factory Methods
43: */
44:
45: + (BOOL)probe:(IODeviceDescription *)devDesc
46: {
47: MaceEnet *MaceEnetInstance;
48: extern int kdp_flag;
49:
50: /*
51: * If bootargs: kdp bit 0 using in-kernel mace driver for early debugging,
52: * Don't probe this driver.
53: */
54: if( kdp_flag & 1)
55: {
56: return nil;
57: }
58:
59: MaceEnetInstance = [self alloc];
60: return [MaceEnetInstance initFromDeviceDescription:devDesc] != nil;
61: }
62:
63: /*
64: * Public Instance Methods
65: */
66:
67: /*-------------------------------------------------------------------------
68: *
69: *
70: *
71: *-------------------------------------------------------------------------*/
72:
73: - initFromDeviceDescription:(IOTreeDevice *)devDesc
74: {
75: IORange *ioRangeMace;
76:
77: if ([super initFromDeviceDescription:devDesc] == nil)
78: {
79: IOLog( "Ethernet(Mace): [super initFromDeviceDescription] failed\n");
80: return nil;
81: }
82:
83: if ( [devDesc numMemoryRanges] < 3 )
84: {
85: IOLog( "Ethernet(Mace): Incorrect deviceDescription - 1\n\r");
86: return nil;
87: }
88:
89: ioRangeMace = [devDesc memoryRangeList];
90:
91: ioBaseEnet = (IOPPCAddress) ioRangeMace[0].start;
92: ioBaseEnetTxDMA = (IOPPCAddress) ioRangeMace[1].start;
93: ioBaseEnetRxDMA = (IOPPCAddress) ioRangeMace[2].start;
94:
95: ioBaseEnetROM = (IOPPCAddress) (((unsigned int) ioBaseEnet & ~0xffff) | kControllerROMOffset);
96:
97: if ( ![self resetAndEnable:NO] )
98: {
99: [self free];
100: return nil;
101: }
102:
103: [self _getStationAddress:&myAddress];
104:
105: if ([self _allocateMemory] == NO)
106: {
107: [self free];
108: return nil;
109: }
110:
111: if ( ![self resetAndEnable:YES] )
112: {
113: [self free];
114: return nil;
115: }
116:
117: isPromiscuous = NO;
118: multicastEnabled = NO;
119:
120: networkInterface = [super attachToNetworkWithAddress:myAddress];
121:
122: return self;
123: }
124:
125:
126: /*-------------------------------------------------------------------------
127: *
128: *
129: *
130: *-------------------------------------------------------------------------*/
131:
132: - free
133: {
134: int i;
135:
136: [self clearTimeout];
137:
138: [self _resetChip];
139:
140: if (networkInterface)
141: [networkInterface free];
142:
143: for (i = 0; i < rxMaxCommand; i++)
144: if (rxNetbuf[i]) nb_free(rxNetbuf[i]);
145:
146: for (i = 0; i < txMaxCommand; i++)
147: if (txNetbuf[i]) nb_free(txNetbuf[i]);
148:
149: return [super free];
150: }
151:
152: /*-------------------------------------------------------------------------
153: *
154: *
155: *
156: *-------------------------------------------------------------------------*/
157: - (void) interruptOccurredAt:(int)irqNum
158: {
159:
160: [self reserveDebuggerLock];
161:
162: // kprintf("IRQ = %d\n",irqNum );
163:
164: switch ( irqNum )
165: {
166: case kIRQEnetTxDMA:
167: txWDInterrupts++;
168: KERNEL_DEBUG(DBG_MACE_TXIRQ | DBG_FUNC_START, 0, 0, 0, 0, 0 );
169: [self _transmitInterruptOccurred];
170: KERNEL_DEBUG(DBG_MACE_TXIRQ | DBG_FUNC_END, 0, 0, 0, 0, 0 );
171: [self enableInterrupt:kIRQEnetTxDMA];
172: [self serviceTransmitQueue];
173: break;
174: case kIRQEnetRxDMA:
175: KERNEL_DEBUG(DBG_MACE_RXIRQ | DBG_FUNC_START, 0, 0, 0, 0, 0 );
176: [self _receiveInterruptOccurred];
177: KERNEL_DEBUG(DBG_MACE_RXIRQ | DBG_FUNC_END, 0, 0, 0, 0, 0 );
178: [self enableInterrupt:kIRQEnetRxDMA];
179: break;
180: }
181:
182: [self releaseDebuggerLock];
183: }
184:
185:
186: /*-------------------------------------------------------------------------
187: *
188: *
189: *
190: *-------------------------------------------------------------------------*/
191:
192: - (void) serviceTransmitQueue
193: {
194: netbuf_t packet;
195: u_int32_t i;
196:
197: while ( 1 )
198: {
199: if ( ![transmitQueue count] )
200: {
201: break;
202: }
203:
204: i = txCommandTail + 1;
205: if ( i >= txMaxCommand ) i = 0;
206: if ( i == txCommandHead )
207: {
208: break;
209: }
210: packet = [transmitQueue dequeue];
211: [self _transmitPacket:packet];
212: }
213:
214: }
215:
216: /*-------------------------------------------------------------------------
217: *
218: *
219: *
220: *-------------------------------------------------------------------------*/
221:
222: - (void)transmit:(netbuf_t)pkt
223: {
224: u_int32_t i;
225: u_int32_t n;
226: u_int8_t regValue;
227:
228: KERNEL_DEBUG(DBG_MACE_TXQUEUE | DBG_FUNC_NONE, (int) pkt, (int) nb_size(pkt), 0, 0, 0 );
229:
230: /*
231: * Hold the debugger lock so the debugger can't interrupt us
232: */
233: [self reserveDebuggerLock];
234:
235: do
236: {
237: /*
238: * Someone is turning off the receiver before the first transmit.
239: * Dont know who yet!
240: */
241: regValue = ReadMaceRegister( ioBaseEnet, kMacCC );
242: regValue |= kMacCCEnRcv;
243: WriteMaceRegister( ioBaseEnet, kMacCC, regValue );
244:
245: /*
246: * Preliminary sanity checks
247: */
248: if (!pkt)
249: {
250: IOLog("EtherNet(Mace): transmit received NULL netbuf\n");
251: continue;
252: }
253: if ( ![self isRunning] )
254: {
255: nb_free(pkt);
256: continue;
257: }
258:
259: /*
260: * Remove any completed packets from the Tx ring
261: */
262: [self _transmitInterruptOccurred];
263:
264: /*
265: * Refill the Tx ring from the Transmit waiting list
266: */
267: [self serviceTransmitQueue];
268:
269: /*
270: * If the Transmit waiting list is not empty or the Tx ring is
271: * full, add the new packet to the waiting list.
272: */
273: n = [transmitQueue count];
274: if ( n > 0 )
275: {
276: if ( n >= [transmitQueue maxCount] )
277: {
278: IOLog("Ethernet(Mace) Transmit queue overflow\n");
279: }
280:
281: [transmitQueue enqueue:pkt];
282: continue;
283: }
284: i = txCommandTail + 1;
285: if ( i >= txMaxCommand ) i = 0;
286: if ( i == txCommandHead )
287: {
288: [transmitQueue enqueue:pkt];
289: continue;
290: }
291:
292: /*
293: * If there is space on the Tx ring, add the packet directly to the
294: * ring
295: */
296: [self _transmitPacket:pkt];
297: }
298: while( 0 );
299:
300: [self releaseDebuggerLock];
301:
302: }
303:
304: /*-------------------------------------------------------------------------
305: *
306: *
307: *
308: *-------------------------------------------------------------------------*/
309:
310: - (int) transmitQueueSize
311: {
312: return (TRANSMIT_QUEUE_SIZE);
313: }
314:
315: - (int) transmitQueueCount
316: {
317: return ([transmitQueue count]);
318: }
319: /*-------------------------------------------------------------------------
320: *
321: *
322: *
323: *-------------------------------------------------------------------------*/
324:
325: - (BOOL)resetAndEnable:(BOOL)enable
326: {
327: resetAndEnabled = NO;
328: [self clearTimeout];
329: [self disableAllInterrupts];
330: [self _resetChip];
331:
332: if (enable)
333: {
334: if ( ![self _initRxRing] || ![self _initTxRing] || ![self _initChip] )
335: {
336: [self setRunning:NO];
337: return NO;
338: }
339:
340: [self _startChip];
341:
342: [self setRelativeTimeout: WATCHDOG_TIMER_MS];
343:
344: [self enableInterrupt:kIRQEnetRxDMA];
345: [self enableInterrupt:kIRQEnetTxDMA];
346: [self _enableAdapterInterrupts];
347:
348: resetAndEnabled = YES;
349: }
350:
351: [self setRunning:enable];
352:
353: return YES;
354: }
355:
356: /*-------------------------------------------------------------------------
357: *
358: *
359: *
360: *-------------------------------------------------------------------------*/
361:
362: - (void)timeoutOccurred
363: {
364: u_int32_t dmaStatus;
365:
366: if ( ![self isRunning] )
367: {
368: return;
369: }
370:
371: [self reserveDebuggerLock];
372:
373: /*
374: * Check for DMA shutdown on receive channel
375: */
376: dmaStatus = IOGetDBDMAChannelStatus( ioBaseEnetRxDMA );
377: if ( !(dmaStatus & kdbdmaActive) )
378: {
379: IOLog( "Ethernet(Mace): Checking for timeout - RxHead = %d RxTail = %d\n\r", rxCommandHead, rxCommandTail);
380: #if 0
381: IOLog( "Ethernet(Mace): Rx Commands = %08x(p) Rx DMA Ptr = %08x(p)\n\r", rxDMACommandsPhys, IOGetDBDMACommandPtr(ioBaseEnetRxDMA) );
382: [self _dumpDesc:(void *)rxDMACommands Size:rxMaxCommand * sizeof(enet_dma_cmd_t)];
383: #endif
384: [self _receiveInterruptOccurred];
385: }
386:
387: /*
388: * If there are pending entries on the Tx ring
389: */
390: if ( txCommandHead != txCommandTail )
391: {
392: /*
393: * If we did not service the Tx ring during the last timeout interval,
394: * then force servicing of the Tx ring.
395: * If we have more than one timeout interval without any transmit interrupts,
396: * then force the transmitter to reset.
397: */
398: if ( txWDInterrupts == 0 )
399: {
400: if ( ++txWDTimeouts > 1 ) txWDForceReset = YES;
401:
402: IOLog( "Ethernet(Mace): Checking for timeout - TxHead = %d TxTail = %d\n\r", txCommandHead, txCommandTail);
403: [self _transmitInterruptOccurred];
404: }
405: else
406: {
407: txWDTimeouts = 0;
408: txWDInterrupts = 0;
409: }
410: }
411: else
412: {
413: txWDTimeouts = 0;
414: txWDInterrupts = 0;
415: }
416:
417: /*
418: * Restart the watchdog timer
419: */
420: [self setRelativeTimeout: WATCHDOG_TIMER_MS];
421:
422: [self releaseDebuggerLock];
423:
424: }
425:
426: /*-------------------------------------------------------------------------
427: *
428: *
429: *
430: *-------------------------------------------------------------------------*/
431:
432: - (netbuf_t)allocateNetbuf
433: {
434: netbuf_t packet;
435:
436: packet = nb_alloc(NETWORK_BUFSIZE);
437: if (!packet)
438: {
439: IOLog("nb_alloc() returned NULL\n");
440: }
441:
442: return packet;
443: }
444:
445: /*-------------------------------------------------------------------------
446: *
447: *
448: *
449: *-------------------------------------------------------------------------*/
450:
451: - (BOOL)enablePromiscuousMode
452: {
453: u_int8_t regVal;
454:
455: isPromiscuous = YES;
456:
457: [self reserveDebuggerLock];
458:
459: regVal = ReadMaceRegister( ioBaseEnet, kMacCC );
460: WriteMaceRegister( ioBaseEnet, kMacCC, regVal & ~kMacCCEnRcv );
461: regVal |= kMacCCProm;
462: WriteMaceRegister( ioBaseEnet, kMacCC, regVal );
463:
464: [self releaseDebuggerLock];
465:
466: return YES;
467: }
468:
469: - (void)disablePromiscuousMode
470: {
471: u_int8_t regVal;
472:
473: isPromiscuous = NO;
474:
475: [self reserveDebuggerLock];
476:
477: regVal = ReadMaceRegister(ioBaseEnet, kMacCC);
478: WriteMaceRegister( ioBaseEnet, kMacCC, regVal & ~kMacCCEnRcv );
479: regVal &= ~kMacCCProm;
480: WriteMaceRegister( ioBaseEnet, kMacCC, regVal );
481:
482: [self releaseDebuggerLock];
483:
484: }
485:
486: - (BOOL)enableMulticastMode
487: {
488: multicastEnabled = YES;
489: return YES;
490: }
491:
492: - (void)disableMulticastMode
493: {
494: multicastEnabled = NO;
495: }
496:
497: - (void)addMulticastAddress:(enet_addr_t *)addr
498: {
499: multicastEnabled = YES;
500: [self reserveDebuggerLock];
501: [self _addToHashTableMask:addr->ea_byte];
502: [self _updateHashTableMask];
503: [self releaseDebuggerLock];
504: }
505:
506: - (void)removeMulticastAddress:(enet_addr_t *)addr
507: {
508: [self reserveDebuggerLock];
509: [self _removeFromHashTableMask:addr->ea_byte];
510: [self _updateHashTableMask];
511: [self releaseDebuggerLock];
512: }
513:
514: /*
515: * Kernel Debugger Support
516: */
517: - (void)sendPacket:(void *)pkt length:(unsigned int)pkt_len
518: {
519: [self _sendPacket:(void *)pkt length:(unsigned int)pkt_len];
520: }
521:
522: - (void)receivePacket:(void *)pkt length:(unsigned int *)pkt_len timeout:(unsigned int)timeout
523: {
524: [self _receivePacket:(void *)pkt length:(unsigned int *)pkt_len timeout:(unsigned int)timeout];
525: }
526:
527: /*
528: * Power management methods.
529: */
530: - (IOReturn)getPowerState:(PMPowerState *)state_p
531: {
532: return IO_R_UNSUPPORTED;
533: }
534:
535: - (IOReturn)setPowerState:(PMPowerState)state
536: {
537: if (state == PM_OFF) {
538: resetAndEnabled = NO;
539: [self _resetChip];
540: return IO_R_SUCCESS;
541: }
542: return IO_R_UNSUPPORTED;
543: }
544:
545: - (IOReturn)getPowerManagement:(PMPowerManagementState *)state_p
546: {
547: return IO_R_UNSUPPORTED;
548: }
549:
550: - (IOReturn)setPowerManagement:(PMPowerManagementState)state
551: {
552: return IO_R_UNSUPPORTED;
553: }
554:
555: @end
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.