![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io|
Return to tn.c CVS log | Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io |
1.1 root 1: /* (-lgl
2: * COHERENT Driver Kit Version 1.1.0
3: * Copyright (c) 1982, 1990 by Mark Williams Company.
4: * All rights reserved. May not be copied without permission.
5: -lgl) */
6: /*
7: * Tiac ARCNET PC-234 Device Driver
8: *
9: * True support for up to 4 network cards through minor devices 0-3.
10: * Up to 4 protocols now supported. Novell access is through normal
11: * minor device. Netbios access is through novell minor device + 16.
12: */
13:
14: #include <sys/coherent.h>
15: #include <sys/con.h>
16: #include <sys/devices.h>
17: #include <sys/sched.h>
18: #include <sys/seg.h>
19: #include <sys/stat.h>
20: #include <sys/uproc.h>
21: #include <sys/tnioctl.h>
22: #include <errno.h>
23:
24: /*
25: * External functions.
26: */
27: extern int wakeup();
28: extern void pollwake();
29: extern void defer();
30:
31: /*
32: * Driver functions.
33: */
34: void tnopen();
35: void tnclose();
36: int tnread();
37: int tnwrite();
38: int tnioctl();
39: void tncycle();
40: void tnload();
41: void tnuload();
42: int tnpoll();
43: int nonedev();
44: int nulldev();
45: void tn0intr();
46: void tn1intr();
47: void tn2intr();
48: void tn3intr();
49: void tnintr();
50:
51: /*
52: * Driver Configuration.
53: */
54: CON
55: tncon = {
56: DFCHR|DFPOL, /* Flags */
57: TN_MAJOR, /* Major Index */
58: tnopen, /* Open */
59: tnclose, /* Close */
60: nonedev, /* Block */
61: tnread, /* Read */
62: tnwrite, /* Write */
63: tnioctl, /* Ioctl */
64: nulldev, /* Power fail */
65: tncycle, /* Timeout */
66: tnload, /* Load */
67: tnuload, /* Unload */
68: tnpoll /* Poll */
69: };
70:
71: /*
72: * Interrupt Entry Points.
73: */
74: void (*tnintf[4])() = {
75: tn0intr,
76: tn1intr,
77: tn2intr,
78: tn3intr
79: };
80:
81: #define BIT(n) (1 << (n))
82:
83: /*
84: * Bitmask, indexed by bit numbers 0..7.
85: */
86: static unsigned char bitm[8] = { BIT(0), BIT(1), BIT(2), BIT(3),
87: BIT(4), BIT(5), BIT(6), BIT(7) };
88:
89: /*
90: * Patchable parameters - Cards 0-3.
91: */
92: /* Card 0 1 2 3 */
93: int TNIRQ [4] = { 2, 7, 4, 0 };
94: saddr_t TNSEL [4] = { 0xD000, 0x0000, 0x0000, 0x0000 };
95: int TNPORT[4] = { 0x2E0, 0x220, 0x240, 0x000 };
96:
97: /*
98: * Patchable parameters - Prefix Byte.
99: * Indexed by high nibble of minor device.
100: */
101: int TNPREFIX[4] = { 0x00, 0xF3, 0x00, 0x00 };
102:
103: /*
104: * Patchable variables.
105: * TNTIME = Transmit watchdog timer in seconds.
106: */
107: int TNTIME = 5;
108:
109: /*
110: * Register addresses.
111: */
112: #define NIR (tp->tnport) /* Network Interrupt Mask Reg (w) */
113: #define NSR (tp->tnport) /* Network Status Register (r) */
114: #define NCR (tp->tnport+1) /* Network Command Register (w) */
115: #define NZR (tp->tnport+8) /* Network Zap (reset) Reg (w) */
116:
117: /*
118: * Network Interrupt Register (NIR).
119: */
120: #define NI_Tx BIT(0) /* Enable Transmitter Avail Intr */
121: #define NI_RECON BIT(2) /* Enable Reconfiguration Intr */
122: #define NI_Rx BIT(7) /* Enable Receiver Full Intr */
123:
124: /*
125: * Network Status Register (NSR).
126: */
127: #define NS_TxRDY BIT(0) /* Transmitter Available */
128: #define NS_TxACK BIT(1) /* Transmit Message Acknowledged */
129: #define NS_RECON BIT(2) /* Network Reconfiguration */
130: #define NS_TEST BIT(3) /* Test */
131: #define NS_POR BIT(4) /* Power on Reset */
132: #define NS_ETS1 BIT(5) /* Extended Timeout Status 1 */
133: #define NS_ETS2 BIT(6) /* Extended Timeout Status 2 */
134: #define NS_RxRDY BIT(7) /* Packet Received - Receiver Off */
135:
136: /*
137: * Network Command Register (NCR).
138: */
139: #define NC_TxDIS (((0)<<3) + 1) /* Disable Transmitter */
140: #define NC_RxDIS (((0)<<3) + 2) /* Disable Receiver */
141: #define NC_TxENA(n) (((n)<<3) + 3) /* Enable Transmitter on Page n */
142: #define NC_RxENA(n) (((n)<<3)+0x84) /* Enable Receiver on Page n */
143: #define NC_DFC (((1)<<3) + 5) /* Define Configuration (2k buf) */
144: #define NC_POR (((1)<<3) + 6) /* Clear NS_POR flag */
145: #define NC_RECON (((2)<<3) + 6) /* Clear NS_RECON flag */
146:
147: /*
148: * Packet Control.
149: */
150: struct tnet_s {
151:
152: /*
153: * Four buffers per card - 2 receive, 2 transmit.
154: */
155: struct tnbuf_s { /* tnget*,tnput* use tn_sel:tn_off */
156: unsigned tn_off; /* tn_sel:tn_off = current byte */
157: saddr_t tn_sel; /* network buffer selector */
158: struct tnbuf_s *tn_next;/* pointer to next pkt in queue */
159: unsigned tn_ena; /* Command to enable packet */
160: unsigned tn_base;/* tn_sel:tn_base = pkt address */
161: unsigned tn_xnid;/* Transmit node id */
162: unsigned tn_xlen;/* Transmit length */
163: } tnbuf [4];
164:
165: struct tnbuf_s * RxBusy[4];/* Queues of full receive packets*/
166: struct tnbuf_s * RxIdle; /* Queue of empty receive packets */
167:
168: struct tnbuf_s * TxBusy; /* Queue of full transmit packets */
169: struct tnbuf_s * TxIdle; /* Queue of empty transmit packets */
170:
171: event_t RxPoll[4];/* Polls for input packets */
172: event_t TxPoll; /* Polls for empty output packets */
173:
174: char RxReq[4];/* 1 = Proc waiting for recv buf */
175: char TxReq; /* 1 = Proc waiting for xmit buf */
176: char refc[4];/* # opens, indexed by prefix code */
177:
178: unsigned tnmask; /* Interrupt enable mask */
179: unsigned tnport; /* Base I/O port */
180: char tnaddr[8];/* ARC-NET Node ID, low byte 1st */
181:
182: unsigned tntime; /* transmit watchdog timer */
183: unsigned recon; /* number of long reconfigurations */
184: unsigned pri; /* priority event occurred */
185: long rbolt; /* lbolt at last reconfiguration */
186: unsigned char bad[32];/* bit mask of bad nodes */
187: unsigned char mod[32];/* bit mask of changed nodes */
188: long recons; /* reconfiguration statistic */
189: SEG * statseg;/* Segment containing stats */
190:
191: } tnet [4];
192:
193: /*
194: * Load Routine.
195: */
196: void
197: tnload()
198: {
199: register struct tnet_s * tp;
200: register struct tnbuf_s * np;
201: faddr_t faddr;
202: paddr_t paddr;
203: int i;
204: int nid;
205: long delay;
206:
207: for ( tp = &tnet[0], i = 0; i < 4; i++, tp++ ) {
208:
209: /*
210: * Validate patchable parameters.
211: */
212: if ( (TNSEL[i] == 0) || (TNPORT[i] == 0) || (TNIRQ[i] == 0) ) {
213: TNPORT[i] = 0;
214: TNSEL[i] = 0;
215: TNIRQ[i] = 0;
216: continue;
217: }
218:
219: tp->tnport = TNPORT[i];
220:
221: /*
222: * Clear Power-On-Reset Flag.
223: */
224: outb( NCR, NC_POR );
225:
226: /*
227: * Validate card presence.
228: * NOTE: tp->tnport must be programmed before using NIR macro.
229: */
230: if ( inb(NSR) & (NS_TEST|NS_POR) ) {
231: tp->tnport = 0;
232: continue;
233: }
234:
235: /*
236: * Convert physical address into virtual address.
237: */
238: paddr = TNSEL[i] << 4L;
239: faddr = ptov( paddr, (fsize_t) 2048 );
240:
241: /*
242: * Verify dual-port memory existence.
243: * NOTE: Do not overwrite first two bytes [0xD1,nid].
244: */
245: sfword( faddr+8, 0x1234 );
246: if ( ffword( faddr+8 ) != 0x1234 ) {
247: vrelse( faddr );
248: tp->tnport = 0;
249: continue;
250: }
251:
252: /*
253: * Allocate statistics segment.
254: */
255: tp->statseg = salloc( (fsize_t) (256*NTNST*4), SFSYST|SFHIGH );
256:
257: /*
258: * Out of memory.
259: */
260: if ( ! tp->statseg ) {
261: printf( "tn%d: out of memory\n", i );
262: vrelse( faddr );
263: tp->tnport = 0;
264: continue;
265: }
266:
267: tp->tnbuf[0].tn_sel =
268: tp->tnbuf[1].tn_sel =
269: tp->tnbuf[2].tn_sel =
270: tp->tnbuf[3].tn_sel = FP_SEL(faddr);
271:
272: tp->tnbuf[0].tn_ena = NC_TxENA(0);
273: tp->tnbuf[1].tn_ena = NC_TxENA(1);
274: tp->tnbuf[2].tn_ena = NC_RxENA(2);
275: tp->tnbuf[3].tn_ena = NC_RxENA(3);
276:
277: tp->tnbuf[0].tn_base = 0 * 512;
278: tp->tnbuf[1].tn_base = 1 * 512;
279: tp->tnbuf[2].tn_base = 2 * 512;
280: tp->tnbuf[3].tn_base = 3 * 512;
281:
282: /*
283: * Initialize transmit idle queue.
284: */
285: tp->TxIdle = &tp->tnbuf[0];
286: tp->tnbuf[0].tn_next = &tp->tnbuf[1];
287:
288: /*
289: * Initialize receive idle queue.
290: */
291: tp->RxIdle = &tp->tnbuf[2];
292: tp->tnbuf[2].tn_next = &tp->tnbuf[3];
293:
294: /*
295: * Validate Node Id.
296: */
297: np = &tp->tnbuf[0];
298: np->tn_off = 0;
299: if ( tngetc(np) != 0xD1 ) {
300:
301: /*
302: * Initiate Power On Reset.
303: */
304: outb( NZR, 1 );
305:
306: /*
307: * Wait minimimum of 180 [suggest 250] milli-seconds.
308: * Should function properly up to at least 16 Mhz clock.
309: */
310: for ( delay = 250000L; --delay != 0; )
311: ;
312: }
313:
314: /*
315: * Validate and Remember Node Id.
316: */
317: np->tn_off = 0;
318: if ( tngetc(np) == 0xD1 )
319: tp->tnaddr[0] = tngetc( np );
320:
321: /*
322: * Record starting time of statistics collection.
323: */
324: faddr = tp->statseg->s_faddr + TnELAPSED*4;
325: for ( nid = 0; nid < 256; nid++, faddr += NTNST*4 )
326: kfcopy( &lbolt, faddr, sizeof(lbolt) );
327:
328: memset( tp->bad, -1, 32 ); /* Assume LAN is down */
329: memset( tp->mod, 0, 32 ); /* Assume no node changes */
330: tp->tnmask = NI_Rx | NI_RECON; /* Interrupts to enable */
331: outb( NIR, 0 ); /* Disable Interrupts */
332: outb( NCR, NC_POR ); /* Clear POR Flag */
333: outb( NCR, NC_DFC ); /* Define 2K buf config */
334: outb( NCR, NC_TxDIS ); /* Disable Transmitter */
335: outb( NCR, tp->RxIdle->tn_ena); /* Enable receiver */
336: setivec( TNIRQ[i], tnintf[i] ); /* Seize Interrupt Vector */
337: outb( NIR, tp->tnmask ); /* Enable Interrupts */
338: }
339:
340: /*
341: * Enable watchdog timer
342: */
343: drvl[TN_MAJOR].d_time = 1;
344: }
345:
346: /*
347: * Unload Routine.
348: */
349: void
350: tnuload( dev )
351: dev_t dev;
352: {
353: register struct tnet_s * tp;
354: register int i;
355: faddr_t faddr;
356:
357: /*
358: * Disable watchdog timer.
359: */
360: drvl[TN_MAJOR].d_time = 0;
361:
362: /*
363: * Scan network adaptors.
364: */
365: for ( tp = &tnet[0], i = 0; i < 4; i++, tp++ ) {
366:
367: if ( tp->tnport == 0 )
368: continue;
369:
370: /*
371: * Disable Interrupts
372: */
373: outb( NIR, 0 );
374:
375: /*
376: * Release interrupt vector.
377: */
378: clrivec( TNIRQ[i] );
379:
380: /*
381: * Release virtual address AFTER disabling interrupts.
382: */
383: if ( FP_SEL(faddr) = tp->tnbuf[0].tn_sel )
384: vrelse( faddr );
385:
386: /*
387: * Release stats segment.
388: */
389: if ( tp->statseg != NULL )
390: sfree( tp->statseg );
391: }
392: }
393:
394: /*
395: * Open Routine.
396: *
397: * Low nibble of minor device is card identifier 0 to 3.
398: * High nibble of minor device is code identifier 0 to 3.
399: */
400: void
401: tnopen( dev, mode )
402: dev_t dev;
403: {
404: register struct tnet_s * tp;
405: int card = (dev & 0x0F);
406: int code = (dev & 0xF0) >> 4;
407:
408: /*
409: * Validate minor device and card existence.
410: */
411: if ( (card > 3) || (code > 3) || (tnet[card].tnport == 0)) {
412: u.u_error = ENXIO;
413: return;
414: }
415:
416: /*
417: * Code identifiers 1 to 3 are only valid if a prefix code is known.
418: */
419: if ( (code > 0) && (TNPREFIX[code] == 0) ) {
420: u.u_error = ENXIO;
421: return;
422: }
423:
424: /*
425: * Access network information.
426: */
427: tp = &tnet[card];
428:
429: /*
430: * Increment reference count (# opens).
431: */
432: tp->refc[code]++;
433: }
434:
435: /*
436: * Close Routine.
437: */
438: void
439: tnclose( dev )
440: dev_t dev;
441: {
442: register struct tnet_s * tp =tp = &tnet[ dev & 3];
443: register struct tnbuf_s * np;
444: int code = (dev & 0x30) >> 4;
445: int s;
446:
447: /*
448: * Decrement reference count.
449: */
450: if ( --tp->refc[code] != 0 )
451: return;
452:
453: /*
454: * Last close.
455: * Release all queued packets.
456: */
457: while ( np = tp->RxBusy[code] ) {
458: s = sphi( );
459: tp->RxBusy[code] = np->tn_next;
460: tn_rxena( tp, np );
461: spl( s );
462: }
463: }
464:
465: /*
466: * Watchdog Timing Routine
467: *
468: * If transmit has been enabled for 1-2 seconds:
469: * Abort transmission of packet, forcing interrupt.
470: */
471: void
472: tncycle( )
473: {
474: register struct tnet_s * tp;
475: register int code;
476: int s;
477:
478: /*
479: * Scan all network cards.
480: */
481: for ( tp = &tnet[0]; tp <= &tnet[3]; tp++ ) {
482:
483: if ( ! tp->tnport )
484: continue;
485:
486: /*
487: * Disable interrupts.
488: */
489: s = sphi();
490:
491: /*
492: * Enable broadcasts after 5 seconds without reconfiguration.
493: */
494: if ( (tp->recon > 0) && ((lbolt - tp->rbolt) > (5*HZ)) ) {
495: /*
496: * LAN was previously down.
497: */
498: if ( tp->bad[0] & 1 ) {
499: faddr_t fp = tp->statseg->s_faddr;
500: aflong( fp+TnSTATMOD*4, 1 );
501: tp->mod[0] |= 1;
502: tp->pri = 1;
503: }
504: tp->bad[0] &= ~1;
505: tp->recon = 0;
506: }
507:
508: /*
509: * Discard bad packet on transmit watchdog timeout.
510: */
511: if ( (tp->tntime > 0) && (--(tp->tntime) == 0) )
512: outb( NCR, NC_TxDIS );
513:
514: /*
515: * Enable interrupts.
516: */
517: spl( s );
518:
519: /*
520: * LAN/DEVICE UP/DOWN event has occurred.
521: */
522: if ( tp->pri == 1 ) {
523:
524: tp->pri = 2;
525:
526: for ( code = 0; code < 4; code++ )
527: if ( tp->RxPoll[code].e_procp )
528: pollwake( &tp->RxPoll[code] );
529: }
530: }
531: }
532:
533: static
534: tnioctl( dev, com, arg )
535: dev_t dev;
536: int com;
537: register tnattr_t * arg;
538: {
539: register struct tnet_s * tp = &tnet[dev & 3];
540: faddr_t fp;
541: int nid;
542: long t;
543: tnattr_t local; /* to avoid fucopy() problems */
544:
545: switch ( com ) {
546:
547: case TNGETA:
548: case TNGETAF:
549: /*
550: * Access node statistics.
551: */
552: nid = getubd( &arg->host[5] );
553: fp = tp->statseg->s_faddr + nid * (NTNST*4);
554:
555: /*
556: * Disable interrupts to avoid race condition with tnintr().
557: */
558: sphi();
559:
560: /*
561: * Copy node status.
562: */
563: if ( tp->bad[nid/8] & bitm[nid%8] )
564: putubd( &arg->bad, 1 );
565: else
566: putubd( &arg->bad, 0 );
567:
568: /*
569: * Copy network reconfigurations to user space.
570: * NOTE: This is not a node statistic, but a network stat.
571: */
572: kucopy( &tp->recons, &arg->recons, sizeof(tp->recons) );
573:
574: /*
575: * Copy node statistics to user space.
576: */
577: fkcopy( fp, &local.stats[0], sizeof(local.stats) );
578: kucopy( &local.stats[0], &arg->stats[0], sizeof(arg->stats) );
579:
580: /*
581: * Copy true elapsed time of statistics collection.
582: */
583: fkcopy( fp+TnELAPSED*4, &t, sizeof(t) );
584: t = lbolt - t;
585: kucopy( &t, &arg->stats[TnELAPSED], sizeof(arg->stats[0]) );
586:
587: /*
588: * Clear node statistics.
589: * NOTE: Elapsed time statistic is time of last clear.
590: */
591: if ( com == TNGETAF ) {
592: fclear( fp, NTNST * 4 );
593: kfcopy( &lbolt, fp+TnELAPSED*4, sizeof(lbolt) );
594: if ( nid == 0 )
595: tp->recons = 0;
596: }
597:
598: /*
599: * Enable interrupts.
600: */
601: splo();
602:
603: return( 0 );
604:
605: default:
606: u.u_error = EINVAL;
607: }
608: }
609:
610: /*
611: * Polling Routine.
612: *
613: * Note: Double-looks are performed to prevent critical race with
614: * interrupt handlers, without having to disable interrupts.
615: */
616: static
617: tnpoll( dev, ev, msec )
618: dev_t dev;
619: int ev;
620: int msec;
621: {
622: register struct tnet_s * tp = &tnet[dev & 3];
623: int code = (dev & 0x30) >> 4;
624: int rev = 0;
625:
626: /*
627: * Fast check for priority, input, and output polls.
628: * Priority poll checks for LAN UP/DOWN transition.
629: * Input poll checks for a full receive buffer.
630: * Output poll checks for an empty transmit buffer, or LAN down.
631: */
632: if ( (ev & POLLPRI) && (tp->pri != 0) )
633: rev |= POLLPRI;
634: if ( (ev & POLLIN) && (tp->RxBusy[code] != NULL) )
635: rev |= POLLIN;
636: if ( (ev & POLLOUT) && ((tp->TxIdle != 0) || (tp->bad[0] & 1)) )
637: rev |= POLLOUT;
638:
639: /*
640: * Fast check found an event, or this is a non-blocking poll.
641: */
642: if ( (rev != 0) || (msec == 0) )
643: return( rev );
644:
645: /*
646: * Blocking Input poll.
647: */
648: if ( ev & POLLIN ) {
649:
650: pollopen( &tp->RxPoll[code] );
651:
652: /*
653: * Second look to avoid interrupt race.
654: */
655: if ( tp->RxBusy[code] )
656: return( POLLIN );
657: }
658:
659: /*
660: * Blocking Output poll.
661: */
662: if ( ev & POLLOUT ) {
663:
664: pollopen( &tp->TxPoll );
665:
666: /*
667: * Second look to avoid interrupt race.
668: * NOTE: When the LAN is down broadcasts [nid 0] are disabled.
669: */
670: if ( (tp->TxIdle != 0) || (tp->bad[0] & 1) )
671: return( POLLOUT );
672: }
673:
674: return( rev );
675: }
676:
677: /*
678: * Interrupt Entry Point - Card 0.
679: */
680: void
681: tn0intr()
682: {
683: tnintr( &tnet[0] );
684: }
685:
686: /*
687: * Interrupt Entry Point - Card 1.
688: */
689: void
690: tn1intr()
691: {
692: tnintr( &tnet[1] );
693: }
694:
695: /*
696: * Interrupt Entry Point - Card 2.
697: */
698: void
699: tn2intr()
700: {
701: tnintr( &tnet[2] );
702: }
703:
704: /*
705: * Interrupt Entry Point - Card 3.
706: */
707: void
708: tn3intr()
709: {
710: tnintr( &tnet[3] );
711: }
712:
713: /*
714: * Interrupt Handler.
715: *
716: * Process transmit/receive interrupts.
717: */
718: void
719: tnintr( tp )
720: register struct tnet_s * tp;
721: {
722: register struct tnbuf_s * np;
723: register int csr;
724: int nid;
725: int n;
726: int bit;
727:
728: /*
729: * Read interrupt status.
730: * Disable interrupts to ensure edge occurs later.
731: */
732: csr = inb( NSR );
733: tp->tnmask = NI_RECON;
734: outb( NIR, 0 );
735:
736: /*
737: * Reconfigurations with a period of 840 msec [600-1100]
738: * increment tp->recon. Other periods clear tp->recon.
739: * After 5 reconfigurations at 840 msecs, the network is down.
740: * After 1 reconfiguration at another interval, the network is up.
741: * Network also comes up in tncycle() 5 seconds after last reconfig.
742: */
743: if ( csr & NS_RECON ) {
744:
745: outb( NCR, NC_RECON );
746: nid = (unsigned) (lbolt - tp->rbolt) * (1000/HZ);
747: tp->rbolt = lbolt;
748: tp->recons++;
749:
750: /*
751: * Not a chained reconfiguration.
752: * Assume the network is up.
753: * NOTE: Expect 840 msecs, but allow interrupt latency slip.
754: */
755: if ( (nid < 700) || (nid > 1000) ) {
756: if ( tp->bad[0] & 1 ) {
757: tp->mod[0] |= 1;
758: tp->bad[0] &= ~1;
759: tp->pri = 1;
760: }
761: tp->recon = 0;
762: }
763:
764: /*
765: * Chained reconfiguration - threshold exceeded.
766: */
767: else if ( (++(tp->recon) == 5) && ((tp->bad[0] & 1) == 0) ) {
768: faddr_t fp = tp->statseg->s_faddr;
769: aflong( fp+TnSTATMOD*4, 1 );
770: memset( tp->bad, -1, sizeof(tp->bad) );
771: tp->mod[0] |= 1;
772: tp->pri = 1;
773: }
774: }
775:
776: /*
777: * Service Power on Resets.
778: */
779: if ( csr & NS_POR ) {
780:
781: csr &= ~(NS_RxRDY|NS_TxRDY); /* Ignore receive/transmit */
782: outb( NCR, NC_DFC ); /* Define 2K buf config */
783: outb( NCR, NC_POR ); /* Clear POR flag */
784:
785: /*
786: * Enable receiver
787: */
788: if ( np = tp->RxIdle )
789: outb( NCR, np->tn_ena );
790:
791: /*
792: * Enable transmitter
793: */
794: if ( np = tp->TxBusy )
795: outb( NCR, np->tn_ena );
796: }
797:
798: /*
799: * Service transmit interupts if transmit is pending.
800: */
801: if ( np = tp->TxBusy ) {
802:
803: tp->tnmask |= NI_Tx;
804:
805: /*
806: * Check for transmission completed.
807: */
808: if ( csr & NS_TxRDY ) {
809:
810: /*
811: * Destination Node Id is in 2nd byte of packet.
812: */
813: np->tn_off = np->tn_base + 1;
814: nid = tngetc( np );
815:
816: /*
817: * Get length of short/long packets.
818: */
819: n = 256 - tngetc(np);
820: if ( n == 256 )
821: n = 512 - tngetc(np);
822:
823: /*
824: * Transmitted packet was acknowledged.
825: */
826: if ( csr & NS_TxACK ) {
827: /*
828: * Adjust global and node statistics.
829: */
830: faddr_t fp = tp->statseg->s_faddr;
831: aflong( fp+TnTxPACKS*4, 1 );
832: aflong( fp+TnTxBYTES*4, n );
833: fp += nid * (NTNST * 4);
834: aflong( fp+TnTxPACKS*4, 1 );
835: aflong( fp+TnTxBYTES*4, n );
836: }
837:
838: /*
839: * Transmitted packet was discarded.
840: * NOTE: Do not flag broadcast [nid 0] as bad.
841: */
842: else if ( nid != 0 ) {
843: /*
844: * Adjust global and node statistics.
845: */
846: faddr_t fp = tp->statseg->s_faddr;
847: aflong( fp+TnDISCARD*4, 1 );
848: fp += nid * (NTNST * 4);
849: aflong( fp+TnDISCARD*4, 1 );
850: aflong( fp+TnSTATMOD*4, 1 );
851:
852: /*
853: * Flag node as being bad.
854: */
855: bit = bitm[ nid % 8 ];
856: tp->bad[ nid / 8 ] |= bit;
857: tp->mod[ nid / 8 ] |= bit;
858: tp->pri = 1;
859: }
860:
861: /*
862: * Move packet buffer to idle transmit queue.
863: */
864: tp->TxBusy = np->tn_next;
865: np->tn_next = tp->TxIdle;
866: tp->TxIdle = np;
867:
868: /*
869: * Check for another packet to transmit.
870: */
871: if ( np = tp->TxBusy ) {
872:
873: /*
874: * Enable transmitter, start watchdog timer.
875: */
876: outb( NCR, np->tn_ena );
877: tp->tntime = TNTIME;
878: }
879:
880: /*
881: * Disable Transmit Interrupt, clear watchdog timer.
882: */
883: else {
884: tp->tnmask &= ~NI_Tx;
885: tp->tntime = 0;
886: }
887:
888: /*
889: * Wake processes waiting to transmit.
890: */
891: if ( tp->TxReq ) {
892: tp->TxReq = 0;
893: defer( wakeup, &tp->TxReq );
894: }
895:
896: if ( tp->TxPoll.e_procp )
897: defer( pollwake, &tp->TxPoll );
898: }
899: }
900:
901: /*
902: * Check for receive request.
903: */
904: if ( np = tp->RxIdle ) {
905:
906: tp->tnmask |= NI_Rx;
907:
908: /*
909: * Check for packet received.
910: */
911: if ( csr & NS_RxRDY ) {
912:
913: /*
914: * Remove first packet from receive ready queue.
915: * Re-enable receiver or disable receive interrupts.
916: */
917: if ( tp->RxIdle = np->tn_next ) {
918: outb( NCR, np->tn_next->tn_ena );
919: np->tn_next = 0;
920: }
921: else
922: tp->tnmask &= ~NI_Rx;
923:
924: /*
925: * Source Node Id is in 1st byte of packet.
926: */
927: np->tn_off = np->tn_base;
928: nid = tngetc( np );
929:
930: /*
931: * Try to establish our Node Id if not already set.
932: * Destination Node Id (our station)
933: * is in 2nd byte of the received packet.
934: * NOTE: Always read node id byte.
935: * This ensures offset bytes can be read.
936: */
937: if ( (n = tngetc(np)) && (tp->tnaddr[0] == 0) )
938: tp->tnaddr[0] = n;
939:
940: /*
941: * Get offset to first data byte in short/long packet.
942: * Short packet offset is in 3rd byte of packet.
943: * Long packet offset is in 4th byte of packet.
944: */
945: if ( n = tngetc(np) )
946: np->tn_off = np->tn_base + n;
947: else
948: np->tn_off = np->tn_base + tngetc(np);
949:
950: /*
951: * LAN has come up.
952: * Clear bad flag for the broadcast node.
953: */
954: if ( tp->bad[0] & 1 ) {
955: tp->bad[ 0 ] &= ~1;
956: tp->mod[ 0 ] |= 1;
957: tp->pri = 1;
958: }
959:
960: /*
961: * Node has come up.
962: * Clear bad flag for the Source Node.
963: */
964: bit = bitm[ nid % 8 ];
965: if ( tp->bad[ nid / 8 ] & bit ) {
966: faddr_t fp = tp->statseg->s_faddr;
967: aflong( fp+TnSTATMOD*4, 1 );
968: fp += nid * (NTNST * 4);
969: aflong( fp+TnSTATMOD*4, 1 );
970: tp->bad[ nid / 8 ] &= ~bit;
971: tp->mod[ nid / 8 ] |= bit;
972: tp->pri = 1;
973: }
974:
975: /*
976: * Get first data byte from packet.
977: */
978: bit = tngetc( np );
979:
980: /*
981: * Determine prefix code associated with packet.
982: */
983: for ( n = 3; n > 0; n-- ) {
984: if ( TNPREFIX[n] == bit )
985: break;
986: }
987:
988: /*
989: * Interface is open.
990: */
991: if ( tp->refc[n] ) {
992:
993: /*
994: * Append received packet to received queue.
995: * NOTE: At most 2 packets in any queue.
996: */
997: if ( tp->RxBusy[n] )
998: tp->RxBusy[n]->tn_next = np;
999: else
1000: tp->RxBusy[n] = np;
1001:
1002: /*
1003: * Wake processes waiting to read.
1004: */
1005: if ( tp->RxReq[n] ) {
1006: tp->RxReq[n] = 0;
1007: defer( wakeup, &tp->RxReq[n] );
1008: }
1009:
1010: if ( tp->RxPoll[n].e_procp )
1011: defer( pollwake, &tp->RxPoll[n] );
1012: }
1013:
1014: /*
1015: * Interface is closed.
1016: * Return packet to end of receive idle queue.
1017: */
1018: else
1019: tn_rxena( tp, np );
1020: }
1021: }
1022:
1023: /*
1024: * Restore interrupt mask.
1025: */
1026: outb( NIR, tp->tnmask );
1027: }
1028:
1029: /*
1030: * Read Routine.
1031: *
1032: * Wait for a packet to be received.
1033: * Transform packet header and copy packet body.
1034: * Place packet buffer on receive idle queue.
1035: * If receiver was inhibited, enable receiver.
1036: */
1037:
1038:
1039: tnread ( dev, iop )
1040:
1041: dev_t dev;
1042: register IO * iop;
1043:
1044: {
1045: register struct tnet_s * tp = &tnet[ dev & 3 ];
1046: register struct tnbuf_s * np;
1047: int code = (dev & 0x30) >> 4;
1048: unsigned len;
1049: unsigned cnt;
1050: unsigned srcid;
1051: int s;
1052:
1053: /*
1054: * Driver information requested.
1055: */
1056: if ( iop->io_ioc <= 2 + sizeof(tp->bad) + sizeof(tp->mod) ) {
1057:
1058: /*
1059: * Supply null byte, then our node id.
1060: */
1061: ioputc( 0, iop );
1062: ioputc( tp->tnaddr[0], iop );
1063:
1064: /*
1065: * Bad and modified node bit masks requested.
1066: * Disable interrupts during transfer to prevent
1067: * critical race with tnintr().
1068: */
1069: if ( iop->io_ioc == sizeof(tp->bad) + sizeof(tp->mod) ) {
1070: sphi();
1071: iowrite( iop, tp->bad, sizeof(tp->bad) );
1072: iowrite( iop, tp->mod, sizeof(tp->mod) );
1073: kclear( tp->mod, sizeof(tp->mod) );
1074: tp->pri = 0;
1075: splo();
1076: }
1077:
1078: /*
1079: * Bad node bit mask requested.
1080: */
1081: else if ( iop->io_ioc == sizeof(tp->bad) )
1082: iowrite( iop, tp->bad, sizeof(tp->bad) );
1083:
1084: return;
1085: }
1086:
1087: /*
1088: * Wait for packet reception.
1089: */
1090: for ( ; ; ) {
1091:
1092: s = sphi( );
1093:
1094: /*
1095: * Check for received packet.
1096: */
1097: if ( np = tp->RxBusy[code] ) {
1098: tp->RxBusy[code] = np->tn_next;
1099: np->tn_next = 0;
1100: spl( s );
1101: break;
1102: }
1103:
1104: /*
1105: * Non-blocking reads.
1106: */
1107: if ( iop->io_flag & IONDLY ) {
1108: u.u_error = EAGAIN;
1109: spl( s );
1110: return;
1111: }
1112:
1113: tp->RxReq[code] = 1;
1114:
1115: sleep( &tp->RxReq[code], CVTTIN, IVTTIN, SVTTIN );
1116: spl( s );
1117:
1118: /*
1119: * Check for pending signal.
1120: */
1121: if ( nondsig() ) {
1122: u.u_error = EINTR;
1123: return;
1124: }
1125: }
1126:
1127: /*
1128: * Copy source and destination node ids
1129: */
1130: np->tn_off = np->tn_base;
1131: ioputc( srcid = tngetc(np), iop );
1132: ioputc( tngetc(np), iop );
1133:
1134: /*
1135: * Check for short packet.
1136: */
1137: if ( cnt = tngetc(np) ) {
1138:
1139: np->tn_off = np->tn_base + cnt;
1140: len = 256 - cnt;
1141: }
1142:
1143: /*
1144: * Check for long packet.
1145: */
1146: else if ( cnt = tngetc(np) ) {
1147:
1148: np->tn_off = np->tn_base + cnt;
1149: len = 512 - cnt;
1150: }
1151:
1152: /*
1153: * Check for non-empty packet.
1154: */
1155: if ( cnt != 0 ) {
1156:
1157: /*
1158: * Truncate packet if necessary.
1159: */
1160: if ( iop->io_ioc < len )
1161: len = iop->io_ioc;
1162:
1163: /*
1164: * Copy packet body.
1165: */
1166: tucopy( np, iop->io_base, len );
1167: iop->io_ioc -= len;
1168: iop->io_base += len;
1169: }
1170:
1171: /*
1172: * Adjust received data statistics.
1173: */
1174: if ( tp->statseg != NULL ) {
1175: faddr_t fp = tp->statseg->s_faddr;
1176: aflong( fp+TnRxPACKS*4, 1 );
1177: aflong( fp+TnRxBYTES*4, len );
1178: fp += srcid * (NTNST * 4);
1179: aflong( fp+TnRxPACKS*4, 1 );
1180: aflong( fp+TnRxBYTES*4, len );
1181: }
1182:
1183: /*
1184: * Enable packet reception with buffer.
1185: */
1186: tn_rxena( tp, np );
1187: }
1188:
1189:
1190: /*
1191: * Write Routine.
1192: *
1193: * Wait for a empty transmit buffer to become available.
1194: * Format the buffer and place on transmit queue.
1195: * If transmit queue was empty, start transmitter.
1196: */
1197:
1198: tnwrite ( dev, iop )
1199:
1200: dev_t dev;
1201: register IO * iop;
1202:
1203: {
1204: register struct tnet_s * tp = &tnet[ dev & 3 ];
1205: register struct tnbuf_s * np;
1206: unsigned len, cnt;
1207: int dstid;
1208: int s;
1209:
1210: /*
1211: * Validate size of write.
1212: */
1213: if ( ( iop->io_ioc < 3 ) || ( iop->io_ioc > 510 ) ) {
1214: u.u_error = EINVAL;
1215: return;
1216: }
1217:
1218: /*
1219: * Destination Node Id is 2nd byte of write.
1220: */
1221: iogetc( iop );
1222: dstid = iogetc( iop );
1223:
1224: /*
1225: * Wait for empty transmit buffer.
1226: */
1227: for ( ; ; ) {
1228:
1229: /*
1230: * If Destination Node appears bad, set errno to EDATTN.
1231: */
1232: if ( tp->bad[ dstid / 8 ] & (1 << (dstid % 8)) ) {
1233: u.u_error = EDATTN;
1234: return;
1235: }
1236:
1237: s = sphi( );
1238:
1239: /*
1240: * Check for empty transmit buffer.
1241: */
1242: if ( np = tp->TxIdle ) {
1243:
1244: tp->TxIdle = np->tn_next;
1245: np->tn_next = 0;
1246: spl( s );
1247: break;
1248: }
1249:
1250: /*
1251: * Non-blocking writes.
1252: */
1253: if ( iop->io_flag & IONDLY ) {
1254: /*
1255: * Adjust delayed write stats.
1256: */
1257: faddr_t fp = tp->statseg->s_faddr;
1258: aflong( fp+TnWRTDLYS*4, 1 );
1259: fp += dstid * (NTNST * 4);
1260: aflong( fp+TnWRTDLYS*4, 1 );
1261:
1262: u.u_error = EAGAIN;
1263: spl( s );
1264: return;
1265: }
1266:
1267: tp->TxReq = 1;
1268: sleep( &tp->TxReq, CVTTOUT, IVTTOUT, SVTTOUT );
1269: spl( s );
1270:
1271: /*
1272: * Check for pending signal.
1273: */
1274: if ( nondsig() ) {
1275: u.u_error = EINTR;
1276: return;
1277: }
1278: }
1279:
1280: /*
1281: * Copy source and destination node ids
1282: * NOTE: Hardware inserts source node id automatically.
1283: */
1284: np->tn_off = np->tn_base;
1285: tnputc( np, 0 );
1286: tnputc( np, dstid );
1287:
1288: len = iop->io_ioc;
1289:
1290: /*
1291: * Check for long packet.
1292: */
1293: if ( len > 253 ) {
1294: tnputc( np, 0 );
1295: tnputc( np, cnt = 512 - len );
1296: np->tn_off = np->tn_base + cnt;
1297: }
1298:
1299: /*
1300: * Short packet.
1301: */
1302: else {
1303: tnputc( np, cnt = 256 - len );
1304: np->tn_off = np->tn_base + cnt;
1305: }
1306:
1307: /*
1308: * Copy packet body.
1309: */
1310: utcopy( iop->io_base, np, len );
1311: iop->io_base += len;
1312: iop->io_ioc -= len;
1313:
1314: /*
1315: * Record length in header structure.
1316: */
1317: np->tn_xlen = iop->io_ioc;
1318:
1319: sphi();
1320:
1321: /*
1322: * Put packet on transmit ready queue, prime transmitter if necessary.
1323: */
1324: if ( ! tp->TxBusy ) {
1325: tp->TxBusy = np;
1326: outb( NCR, np->tn_ena ); /* enable transmitter */
1327: outb( NIR, tp->tnmask |= NI_Tx); /* enable xmit intr */
1328: tp->tntime = TNTIME; /* restart watchdog */
1329: }
1330: else
1331: tp->TxBusy->tn_next = np;
1332:
1333: spl(s);
1334: }
1335:
1336: /*
1337: * Enable packet reception with buffer.
1338: */
1339: tn_rxena( tp, np )
1340: register struct tnet_s * tp;
1341: register struct tnbuf_s * np;
1342: {
1343: int s;
1344:
1345: s = sphi( );
1346:
1347: /*
1348: * Put packet on receive ready queue, prime receiver if necessary.
1349: */
1350: if ( tp->RxIdle == NULL ) {
1351: tp->RxIdle = np;
1352: outb( NCR, np->tn_ena );
1353: outb( NIR, tp->tnmask |= NI_Rx );
1354: }
1355: else
1356: tp->RxIdle->tn_next = np;
1357:
1358: np->tn_next = 0;
1359: spl( s );
1360: }
1361:
1362: /*
1363: * Adjust far long.
1364: */
1365: static
1366: aflong( fp, i )
1367: faddr_t fp;
1368: int i;
1369: {
1370: long lw;
1371:
1372: fkcopy( fp, &lw, sizeof(lw) );
1373: lw += i;
1374: kfcopy( &lw, fp, sizeof(lw) );
1375: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.