![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_enp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / tahoeif|
Return to if_enp.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / tahoeif |
1.1 root 1: #include "enp.h"
2: #define ENPBPTE 128
3: #if NENP > 0
4:
5: /*
6: * Modified 3 Com Ethernet Controller interface
7: * enp modifications added S. F. Holmgren
8: */
9:
10: #include "../h/param.h"
11: #include "../h/systm.h"
12: #include "../h/mbuf.h"
13: #include "../h/buf.h"
14: #include "../h/protosw.h"
15: #include "../h/socket.h"
16: #include "../h/vmmac.h"
17: #include "../h/errno.h"
18: #include "../h/time.h"
19: #include "../h/kernel.h"
20: #include "../h/uio.h"
21: #include "../net/if.h"
22: #include "../net/netisr.h"
23: #include "../net/route.h"
24: #include "../netinet/in.h"
25: #include "../h/ioctl.h"
26:
27: #include "../netinet/in_systm.h"
28: #include "../netinet/ip.h"
29: #include "../netinet/ip_var.h"
30: #include "../netinet/if_ether.h"
31: #include "../netpup/pup.h"
32: #include "../vba/vbavar.h"
33: #include "../tahoeif/if_enp.h"
34: #include "../machine/mtpr.h"
35: #include "../tahoeif/if_debug.h"
36:
37: #define ENP0_PHYSADDR 0xf40000 /* board # 0 physical base addr */
38: #define ENP1_PHYSADDR 0xf60000 /* board # 1 physical base addr */
39: #define ENPSTART 0xf02000 /* standard enp start addr */
40:
41: int enpprobe(), enpattach(), enpintr();
42: extern nulldev();
43: caddr_t vtoph();
44: struct mbuf *m_tofree();
45: struct vba_device *enpinfo[ NENP ];
46:
47: /* Maximun 2 controllers per system supported */
48:
49: long enpstd[] = { ENP0_PHYSADDR+0x1000,ENP1_PHYSADDR+0x1000, 0 };
50: extern char enp0utl[], enp1utl[]; /* enp accessible ram map */
51: char *enpmap[]= { enp0utl, enp1utl };
52: extern long ENP0map[], ENP1map[];
53: long *ENPmap[] = {ENP0map, ENP1map};
54: long ENPmapa[] = {0xfff41000, 0xfff61000};
55: long enpismapped[NENP];
56:
57: unsigned short intvec[4] =
58: { 0xc1, 0xc2, 0xc3, 0xc4 }; /* intrvec of upto 4 enps */
59:
60: struct vba_driver enpdriver =
61: {
62: /* use of prom based version
63: enpprobe, 0, enpattach, 0, 0, enpintr,
64: */
65: enpprobe, 0, nulldev, 0,
66: enpstd, "enp", enpinfo, "ENP 20", 0
67: };
68:
69: int enpinit(),
70: enpioctl(),
71: enpoutput(),
72: enpreset(),
73: enpbroadcast(),
74: enptimeout();
75:
76: int enpcopy();
77:
78: struct mbuf *enpget();
79:
80: extern struct ifnet loif;
81:
82: /*
83: * Ethernet software status per interface.
84: *
85: * Each interface is referenced by a network interface structure,
86: * es_if, which the routing code uses to locate the interface.
87: * This structure contains the output queue for the interface, its address, ...
88: */
89:
90: struct enp_softc enp_softc[NENP];
91: long stat_addr[NENP]; /* enp statistic addr (for nstat use) */
92: long ring_addr[NENP]; /* enp dev ring addresses (for nstat use) */
93: int numenp = NENP;
94: int enp_intr = 0, /* no. of enp_to_host interrupts */
95: host_intr = 0; /* no. of host_to_enp interrupts */
96: short enpram[NENP]; /* open/close flags for enp devices */
97: /* Debugging tools, used to trace input packets */
98: extern int printerror; /* error print flag, from if_ace.c */
99: int save_enp_inpkt = 0;
100: #define ENPTRACE(X) if (save_enp_inpkt) X;
101:
102: struct inp_err enperr[NENP];
103:
104: /*
105: * Probe for device.
106: */
107:
108: enpprobe(reg)
109: caddr_t reg;
110: {
111: static int unit=0;
112: register ENPDEVICE *addr = (ENPDEVICE *)reg;
113:
114: if( (badaddr( addr, 2 ) ) || (badaddr( &addr->enp_ram[0], 2 ) ) )
115: return( 0 );
116: addr->enp_state = S_ENPRESET; /* controller is reset by vbus reset */
117: /* save address of statistic area for nstat uses */
118:
119: stat_addr[unit] = (long) &(addr->enp_stat);
120: ring_addr[unit++] = (long) &(addr->enp_toenp);
121:
122: return( ENPSIZE );
123: }
124:
125: /*
126: * Interface exists: make available by filling in network interface
127: * record. System will initialize the interface when it is ready
128: * to accept packets.
129: */
130:
131: enpattach( md )
132: register struct vba_device *md;
133: {
134: struct enp_softc *es = &enp_softc[md->ui_unit];
135: register struct ifnet *ifp = &es->es_if;
136: register ENPDEVICE *addr = (ENPDEVICE *)md->ui_addr;
137: struct sockaddr_in *sin;
138:
139: enpgetaddr( md->ui_unit );
140:
141: ifp->if_unit = md->ui_unit;
142: ifp->if_name = "enp";
143: ifp->if_mtu = ETHERMTU;
144:
145: /* bcopy(&es->es_boardaddr, es->es_enaddr, sizeof(es->es_enaddr)); */
146:
147: sin = (struct sockaddr_in *)&es->es_if.if_addr;
148: sin->sin_family = AF_INET;
149:
150: ifp->if_init = enpinit;
151: ifp->if_ioctl = enpioctl;
152: ifp->if_output = enpoutput;
153: ifp->if_reset = enpreset;
154: if_attach(ifp);
155: }
156:
157:
158: /*
159: * Reset of interface after UNIBUS reset.
160: */
161: enpreset(unit)
162: int unit;
163: {
164: register struct vba_device *md;
165:
166: if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0)
167: return(ENODEV);
168:
169: enpinit(unit);
170: }
171:
172: /*
173: * Initialization of interface; clear recorded pending
174: * operations.
175: */
176:
177: enpinit( unit )
178: int unit;
179: {
180: struct enp_softc *es = &enp_softc[unit];
181: ENPDEVICE *addr;
182: int i, s;
183: u_char *cp, *ap;
184: register struct ifnet *ifp = &es->es_if;
185: register struct sockaddr_in *sin, *sinb;
186:
187: sin = (struct sockaddr_in *)&ifp->if_addr;
188:
189: if ( !enpismapped[unit] ) {
190: ioaccess(ENPmap[unit],ENPmapa[unit],ENPBPTE);
191: ++enpismapped[unit];
192: }
193: if ((addr = (ENPDEVICE *)enpinfo[unit]->ui_addr) == (ENPDEVICE *)0)
194: return(ENODEV);
195: s = splimp();
196: RESET_ENP( addr );
197: DELAY( 200000 );
198:
199: #ifdef notdef
200: /* only needed if not downloading ( ie, ROM-resident ENP code) */
201: addr->enp_intrvec = intvec[unit];
202: ENP_GO( addr,ENPSTART );
203: DELAY( 200000 );
204: /* end of ROM-resident */
205: #endif notdef
206:
207: es->es_if.if_flags |= IFF_UP|IFF_RUNNING; /* open for business*/
208: splx(s);
209:
210: if_rtinit( &es->es_if,RTF_UP );
211: arpwhohas(&es->es_ac, &sin->sin_addr);
212: }
213:
214:
215: /*
216: * Ethernet interface interrupt.
217: */
218:
219: enpintr( unit )
220: {
221: register ENPDEVICE *addr;
222: register BCB *bcbp;
223: register struct vba_device *md;
224:
225: enp_intr++;
226:
227: if (unit >= NENP || (md = enpinfo[unit]) == 0)
228: return;
229:
230: addr = (ENPDEVICE *)md->ui_addr;
231:
232: if( IS_ENP_INTR(addr) == 0 )
233: return;
234:
235: ACK_ENP_INTR( addr );
236:
237: while( (bcbp = (BCB *)ringget( &addr->enp_tohost )) != 0 )
238: {
239: enpread( &enp_softc[ unit ],bcbp, unit );
240: ringput( &addr->enp_enpfree,bcbp );
241: }
242: return(0);
243: }
244:
245: #define MAXBLEN 1500
246: char errpkt[MAXBLEN];
247: int bufptr = 0;
248: int maxl_tosave = 200; /* save only the first 200 bytes */
249:
250: saverrpkt(errbuf, errtype, len)
251: register u_char *errbuf;
252: int errtype, len;
253: {
254: int remain, newptr;
255:
256: remain = MAXBLEN - bufptr;
257: if (remain < 50) /* if too small */
258: return; /* no space avail */
259: len = (len > maxl_tosave || len <= 0) ? maxl_tosave : len;
260: len = len > remain ? (remain - 2*sizeof(len)): len;
261: newptr = bufptr + len + 2*sizeof(len);
262: if (newptr <= MAXBLEN) {
263: enpcopy((char *)&len, &errpkt[bufptr], sizeof(len));
264: enpcopy((char *)&errtype, &errpkt[bufptr+sizeof(len)],
265: sizeof(errtype));
266: enpcopy(errbuf, &errpkt[bufptr+(2*sizeof(len))], len);
267: }
268: bufptr = newptr;
269: }
270:
271: /*
272: * Read input packet, examine its packet type, and enqueue it.
273: */
274:
275: enpread( es, bcbp, unit )
276: struct enp_softc *es;
277: register BCB *bcbp;
278: int unit;
279: {
280: register struct ether_header *enp;
281: struct mbuf *m;
282: long int s, v;
283: register short *vp = (short *)&v,
284: *sp;
285: int len, off, resid, enptype;
286: register struct ifqueue *inq;
287:
288: es->es_if.if_ipackets++;
289:
290: /*
291: * Get input data length.
292: * Get pointer to ethernet header (in input buffer).
293: * Deal with trailer protocol: if type is PUP trailer
294: * get true type from first 16-bit word past data.
295: * Remember that type was trailer by setting off.
296: */
297:
298: len = bcbp->b_msglen - SIZEOF_ETHEADER;
299: #ifdef TAHOE
300: sp = (short *)&bcbp->b_addr;
301: *vp = *sp; vp[1] = sp[1];
302: enp = (struct ether_header *) v;
303: #else
304: enp = (struct ether_header *)bcbp->b_addr;
305: #endif TAHOE
306:
307: #define enpdataaddr(enp, off, type) ((type)(((caddr_t)(((char *)enp)+SIZEOF_ETHEADER)+(off))))
308:
309: enptype = enp->ether_type;
310: if (enptype >= ETHERPUP_TRAIL && enptype < ETHERPUP_TRAIL+ETHERPUP_NTRAILER)
311: {
312: off = (enptype - ETHERPUP_TRAIL) * 512;
313: if (off >= ETHERMTU) {
314: enperr[unit].bad_offset++;
315: ENPTRACE(saverrpkt((char *)enp, B_OFFSET, bcbp->b_msglen));
316:
317: goto badinput;
318: }
319: enptype = *enpdataaddr(enp, off, u_short *);
320: resid = *(enpdataaddr(enp, off+2, u_short *));
321:
322: if (off + resid > len) {
323: enperr[unit].bad_length++;
324: ENPTRACE(saverrpkt((char *)enp, B_LENGTH, bcbp->b_msglen));
325: goto badinput;
326: }
327: len = off + resid;
328: }
329: else
330: off = 0;
331:
332: if( len == 0 ) {
333: enperr[unit].bad_length++;
334: ENPTRACE(saverrpkt((char *)enp, B_LENGTH, bcbp->b_msglen));
335: goto badinput;
336: }
337: /*
338: * Pull packet off interface. Off is nonzero if packet
339: * has trailing header; enpget will then force this header
340: * information to be at the front, but we still have to drop
341: * the type and length which are at the front of any trailer data.
342: */
343:
344: m = enpget(bcbp, len, off);
345: if( m == 0 ) {
346: enperr[unit].h_nobuffer++; /* host runs out of buf */
347: goto badinput;
348: }
349: if( off )
350: {
351: m->m_off += 2 * sizeof (u_short);
352: m->m_len -= 2 * sizeof (u_short);
353: }
354:
355: switch (enptype)
356: {
357: #ifdef INET
358: case ETHERPUP_IPTYPE:
359: #ifdef notdef
360: arpipin(enp, m);
361: #endif notdef
362: schednetisr(NETISR_IP);
363: inq = &ipintrq;
364: break;
365:
366: case ETHERPUP_ARPTYPE:
367: arpinput(&es->es_ac, m);
368: return(0);
369: #endif
370: default: /* unrecognized ethernet header */
371: enperr[unit].bad_packetype++;
372: if (printerror) {
373: printf("\nenp%d: Undefined packet type 0x%x ", unit,
374: enp->ether_type);
375: printf("from host: %x.%x.%x.%x.%x.%x\n",
376: enp->ether_shost[0], enp->ether_shost[1],
377: enp->ether_shost[2], enp->ether_shost[3],
378: enp->ether_shost[4], enp->ether_shost[5]);
379: } /* end debugging aid */
380: ENPTRACE(saverrpkt((char *)enp, B_PACKETYPE, bcbp->b_msglen));
381: m_freem(m);
382: goto badinput;
383: }
384:
385: if (IF_QFULL(inq))
386: {
387: enperr[unit].inq_full++;
388: IF_DROP(inq);
389: m_freem(m);
390: return(0);
391: }
392: s = splimp();
393: IF_ENQUEUE(inq, m);
394: splx(s);
395: badinput:
396: return(0); /* sanity */
397: }
398:
399: /*
400: * Ethernet output routine. (called by user)
401: * Encapsulate a packet of type family for the local net.
402: * Use trailer local net encapsulation if enough data in first
403: * packet leaves a multiple of 512 bytes of data in remainder.
404: * If destination is this address or broadcast, send packet to
405: * loop device to kludge around the fact that 3com interfaces can't
406: * talk to themselves.
407: */
408:
409: enpoutput(ifp, m0, dst)
410: struct ifnet *ifp;
411: struct mbuf *m0;
412: struct sockaddr *dst;
413: {
414: int type, s, error;
415: struct ether_addr edst;
416: struct in_addr idst;
417:
418: register struct enp_softc *es = &enp_softc[ifp->if_unit];
419: register struct mbuf *m = m0;
420: register struct ether_header *enp;
421: register int off, i;
422:
423: struct mbuf *mcopy = (struct mbuf *) 0; /* Null */
424: int unit = ifp->if_unit;
425:
426: switch( dst->sa_family )
427: {
428: #ifdef INET
429: case AF_INET:
430: idst = ((struct sockaddr_in *)dst)->sin_addr;
431:
432: /* translate internet to ethernet address */
433:
434: switch(arpresolve(&es->es_ac, m, &idst, &edst)) {
435:
436: case ARPRESOLVE_WILLSEND:
437: return (0); /* if not yet resolved */
438: case ARPRESOLVE_BROADCAST:
439: mcopy = m_copy(m, 0, (int)M_COPYALL);
440: if (mcopy)
441: looutput(&loif, mcopy, dst);
442:
443: /* falls through ... */
444: case ARPRESOLVE_OK:
445: break;
446: }
447: off = ((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
448: if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
449: if (off > 0 && (off & 0x1ff) == 0 &&
450: m->m_off >= MMINOFF + 2 * sizeof (u_short))
451: {
452: type = ETHERPUP_TRAIL + (off>>9);
453: m->m_off -= 2 * sizeof (u_short);
454: m->m_len += 2 * sizeof (u_short);
455: *mtod(m, u_short *) = ETHERPUP_IPTYPE;
456: *(mtod(m, u_short *) + 1) = m->m_len;
457: goto gottrailertype;
458: }
459:
460: type = ETHERPUP_IPTYPE;
461: off = 0;
462: goto gottype;
463: #endif
464:
465: #ifdef notdef
466: case AF_RAW:
467: enp = mtod(m, struct ether_header *);
468: if (m->m_len < sizeof *enp)
469: {
470: error = EMSGSIZE;
471: goto bad;
472: }
473: goto gotheader;
474: #endif
475:
476: case AF_UNSPEC:
477: enp = (struct ether_header *)dst->sa_data;
478: bcopy( enp->ether_dhost, &edst, sizeof(edst));
479: type = enp->ether_type;
480: goto gottype;
481:
482: default:
483: if (printerror)
484: printf("enp%d: can't handle af%d\n", unit,dst->sa_family);
485: error = EAFNOSUPPORT;
486: goto bad;
487: }
488:
489: gottrailertype:
490: /*
491: * Packet to be sent as trailer: move first packet
492: * (control information) to end of chain.
493: */
494: while (m->m_next)
495: m = m->m_next;
496: m->m_next = m0;
497: m = m0->m_next;
498: m0->m_next = 0;
499: m0 = m;
500:
501: gottype:
502: /*
503: * Add local net header. If no space in first mbuf,
504: * allocate another.
505: */
506: if (m->m_off > MMAXOFF ||
507: MMINOFF + SIZEOF_ETHEADER > m->m_off)
508: {
509: m = m_get(M_DONTWAIT, MT_HEADER);
510: if (m == 0)
511: {
512: enperr[unit].h_nobuffer++; /* host runs out of buf */
513: error = ENOBUFS;
514: goto bad;
515: }
516: m->m_next = m0;
517: m->m_off = MMINOFF;
518: m->m_len = SIZEOF_ETHEADER;
519: }
520: else
521: {
522: m->m_off -= SIZEOF_ETHEADER;
523: m->m_len += SIZEOF_ETHEADER;
524: }
525: enp = mtod(m, struct ether_header *);
526: bcopy( &edst, enp->ether_dhost, sizeof(enp->ether_dhost) );
527: enp->ether_type = type;
528: gotheader:
529: bcopy( es->es_enaddr, enp->ether_shost, sizeof(enp->ether_shost));
530:
531: /*
532: * Queue message on interface if possible
533: */
534:
535: s = splimp();
536: if( enpput( unit,m ) )
537: {
538: error = ENOBUFS;
539: enperr[unit].c_nobuffer++; /* controller runs out of buf */
540: goto qfull;
541: }
542: splx( s );
543: es->es_if.if_opackets++;
544: return(0);
545: qfull:
546: splx( s );
547: m0 = m;
548: bad:
549: m_freem(m0);
550: return(error);
551: }
552:
553: /*
554: * Routine to copy from mbuf chain to transmitter
555: * buffer in Multibus memory.
556: */
557:
558: enpput( unit,m )
559: int unit;
560: struct mbuf *m;
561: {
562: register BCB *bcbp;
563: register ENPDEVICE *addr;
564: register struct mbuf *mp;
565: register u_char *bp;
566: int ctr = 0;
567: long int v;
568: register short *vp = (short *)&v,
569: *sp;
570:
571: addr = (ENPDEVICE *)enpinfo[ unit ]->ui_addr;
572:
573: if ( ringempty( &addr->enp_hostfree ) )
574: return( 1 );
575:
576: bcbp = (BCB *)ringget( &addr->enp_hostfree );
577: bcbp->b_len = 0;
578: #ifdef TAHOE
579: sp = (short *)&bcbp->b_addr;
580: *vp = *sp; vp[1] = sp[1];
581: bp = (u_char *)v;
582: #else
583: bp = (u_char *)bcbp->b_addr;
584: #endif TAHOE
585: for (mp = m; mp; mp = mp->m_next)
586: {
587: register unsigned len;
588: u_char *mcp;
589:
590: len = mp->m_len;
591: if( len == 0 )
592: continue;
593: mcp = mtod( mp,u_char * );
594: enpcopy( mcp,bp,len );
595: bp += len;
596: bcbp->b_len += len;
597: }
598: bcbp->b_len = max( MINPKTSIZE,bcbp->b_len );
599: bcbp->b_reserved = 0;
600: if ( ringput( &addr->enp_toenp,bcbp ) == 1 ) {
601: host_intr++;
602: INTR_ENP( addr );
603: }
604: m_freem(m);
605: return( 0 );
606: }
607:
608: /*
609: * Routine to copy from Multibus memory into mbufs.
610: *
611: * Warning: This makes the fairly safe assumption that
612: * mbufs have even lengths.
613: */
614: struct mbuf *
615: enpget( bcbp, totlen, off0 )
616: register BCB *bcbp;
617: int totlen, off0;
618: {
619: register struct mbuf *m;
620: register int off = off0;
621: register unsigned char *cp;
622: long int v;
623: register short *vp = (short *)&v,
624: *sp;
625:
626: int len;
627: struct mbuf *top = 0;
628: struct mbuf **mp = ⊤
629:
630: #ifdef TAHOE
631: sp = (short *)&bcbp->b_addr;
632: *vp = *sp; vp[1] = sp[1];
633: cp = (unsigned char *)v + SIZEOF_ETHEADER;
634: #else
635: cp = (unsigned char *)bcbp->b_addr + SIZEOF_ETHEADER;
636: #endif TAHOE
637:
638: while( totlen > 0 )
639: {
640: u_char *mcp;
641:
642: MGET(m, M_DONTWAIT, MT_DATA);
643: if (m == 0)
644: goto bad;
645: if( off )
646: {
647: len = totlen - off;
648: #ifdef TAHOE
649: sp = (short *)&bcbp->b_addr;
650: *vp = *sp; vp[1] = sp[1];
651: cp = (unsigned char *)v + SIZEOF_ETHEADER
652: + off;
653: #else
654: cp = (unsigned char *)bcbp->b_addr +
655: SIZEOF_ETHEADER + off;
656: #endif TAHOE
657: }
658: else
659: len = totlen;
660:
661:
662: if (len >= CLBYTES) {
663: struct mbuf *p;
664:
665: MCLGET(p, 1);
666: if (p != 0) {
667: m->m_len = len = CLBYTES;
668: m->m_off = (int)p - (int)m;
669: } else {
670: m->m_len = len = MIN(MLEN, len);
671: m->m_off = MMINOFF;
672: }
673: } else {
674: m->m_len = len = MIN(MLEN, len);
675: m->m_off = MMINOFF;
676: }
677:
678: mcp = mtod(m, u_char *);
679: enpcopy(cp, mcp, len);
680: cp += len;
681: *mp = m;
682: mp = &m->m_next;
683: if (off == 0)
684: {
685: totlen -= len;
686: continue;
687: }
688: off += len;
689: if (off == totlen)
690: {
691: #ifdef TAHOE
692: sp = (short *)&bcbp->b_addr;
693: *vp = *sp; vp[1] = sp[1];
694: cp = (unsigned char *)v + SIZEOF_ETHEADER;
695: #else
696: cp = (unsigned char *)bcbp->b_addr + SIZEOF_ETHEADER;
697: #endif TAHOE
698: off = 0;
699: totlen = off0;
700: }
701: }
702: return (top);
703: bad:
704: m_freem(top);
705: return (0);
706: }
707:
708: /*
709: * Process an ioctl request.
710: * this can be called via the "socket" route for SIOCSIFADDR or
711: * by the cdev/inode route for SIOCSIFCCFWR/RD
712: *
713: */
714:
715: enpioctl(ifp, cmd, data)
716: register struct ifnet *ifp;
717: int cmd;
718: caddr_t data;
719: {
720: register int unit = ifp->if_unit;
721: register struct vba_device *md;
722: int s, error = 0;
723: struct sockaddr_in *sin;
724: struct sockaddr *sa;
725: struct enp_softc *es = &enp_softc[ifp->if_unit];
726: ENPDEVICE *addr;
727: struct config_entry *cf;
728: struct ifreq *ifr = (struct ifreq *)data;
729: struct sockaddr_in *et_addr;
730: int code, i;
731:
732:
733: if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0)
734: return(ENODEV);
735:
736: switch (cmd) {
737:
738: case SIOCSIFADDR:
739: s = splimp();
740: sa = (struct sockaddr *)&ifr->ifr_addr;
741: if (sa->sa_family == AF_UNSPEC ) {
742: if (sa->sa_data[0] & 1){ /*broad or multi-cast*/
743: splx( s );
744: return( EINVAL );
745: }
746: bcopy(sa->sa_data,es->es_enaddr,sizeof(es->es_enaddr));
747: enpinit( ifp->if_unit);
748: break;
749: }
750: sin = (struct sockaddr_in *)&ifr->ifr_addr;
751: if (sin->sin_family != AF_INET){
752: splx( s );
753: return( EINVAL );
754: }
755: if (ifp->if_flags & IFF_RUNNING)
756: if_rtinit(ifp, -1); /* delete previous route */
757: enpsetaddr(ifp, sin);
758: enpinit(ifp->if_unit);
759: enpgetaddr( ifp->if_unit );
760: splx(s);
761: break;
762:
763:
764: case SIOCSETETADDR: /* Set Ethernet station address */
765: s = splimp();
766: ifp->if_flags &= (~IFF_RUNNING | IFF_UP);
767: et_addr = (struct sockaddr_in *)&ifr->ifr_addr;
768: addr = (ENPDEVICE *)enpinfo[ifp->if_unit]->ui_addr;
769:
770: /* Set station address and reset controller board */
771: {
772: u_char *to = &addr->enp_addr.e_baseaddr.ea_addr[0];
773: char *from = &et_addr->sin_zero[2];
774: int i;
775:
776: for (i = 0 ; i < ETHADDR_SIZE; i++)
777: *to++ = (u_char) (~(*from++ & 0xff));
778: }
779: enpcopy(&addr->enp_addr.e_listsize, &code, sizeof(code));
780: code |= E_ADDR_SUPP;
781: enpcopy(&code, &addr->enp_addr.e_listsize, sizeof(code));
782: enpreset(ifp->if_unit); /* Re-initialize */
783: enpgetaddr(ifp->if_unit);
784: splx(s);
785: break;
786:
787: case SIOCGETETADDR: /* Get Foreign Hosts' Ethernet addresses */
788: arpwhohas(&es->es_ac, (struct in_addr *)ifr->ifr_data);
789: break;
790:
791: default:
792: error = EINVAL;
793: }
794: return(error);
795: }
796:
797: enpsetaddr(ifp, sin)
798: register struct ifnet *ifp;
799: register struct sockaddr_in *sin;
800: {
801:
802: ifp->if_addr = *(struct sockaddr *)sin;
803: ifp->if_net = in_netof(sin->sin_addr);
804: ifp->if_host[0] = in_lnaof(sin->sin_addr);
805: sin = (struct sockaddr_in *)&ifp->if_broadaddr;
806: sin->sin_family = AF_INET;
807: sin->sin_addr = if_makeaddr(ifp->if_net, INADDR_ANY);
808: ifp->if_flags |= IFF_BROADCAST;
809: }
810:
811:
812: /*
813: * Get the ethernet addr, store it and print it
814: * Read the ethernet address off the board, one byte at a time.
815: * put it in enp_softc
816: */
817:
818:
819: enpgetaddr( unit )
820: int unit;
821: {
822: register struct enp_softc *es = &enp_softc[unit];
823: register ENPDEVICE *addr =(ENPDEVICE *)enpinfo[unit]->ui_addr;
824: int i;
825:
826: #ifdef TAHOE
827: enpcopy(&addr->enp_addr.e_baseaddr, &es->es_boardaddr, sizeof(es->es_boardaddr));
828: #else
829: es->es_boardaddr = addr->enp_addr.e_baseaddr;
830: #endif TAHOE
831: bcopy(&es->es_boardaddr, es->es_enaddr, ETHADDR_SIZE);
832: return( 1 );
833: }
834:
835: /*
836: * enpram device
837: *
838: */
839:
840: enpr_open( dev )
841: {
842: register int unit = minor(dev);
843: register struct vba_device *md;
844: register ENPDEVICE *addr;
845:
846: if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0 ||
847: (addr = (ENPDEVICE *)md->ui_addr) == (ENPDEVICE *)0)
848: return(ENODEV);
849: if (addr->enp_state != S_ENPRESET)
850: return(EACCES); /* enp is not in reset state, don't open */
851: if ( !enpismapped[unit] ) {
852: ioaccess(ENPmap[unit],ENPmapa[unit],ENPBPTE);
853: ++enpismapped[unit];
854: }
855: enpram[unit] = ENP_OPEN;
856: return( 0 );
857: }
858:
859: enpr_close(dev)
860: {
861: enpram[minor(dev)] = ENP_CLOSE;
862: return( 0 );
863: }
864:
865: enpr_read( dev,uio )
866: int dev;
867: register struct uio *uio;
868: {
869: register ENPDEVICE *addr;
870: register struct iovec *iov;
871: register r=0;
872:
873: if (enpram[minor(dev)] != ENP_OPEN)
874: return(EACCES);
875: if ( uio->uio_offset > RAM_SIZE )
876: return( ENODEV );
877: if ( uio->uio_offset + iov->iov_len > RAM_SIZE )
878: iov->iov_len = RAM_SIZE - uio->uio_offset;
879: addr = (ENPDEVICE *)enpinfo[ minor( dev ) ]->ui_addr;
880: iov = uio->uio_iov;
881:
882: if( r = enpcopyout( &addr->enp_ram[ uio->uio_offset ], iov->iov_base,
883: iov->iov_len ) )
884: return( r );
885:
886: uio->uio_resid -= iov->iov_len;
887: iov->iov_len = 0;
888:
889: return( 0 );
890: }
891:
892: enpr_write( dev,uio )
893: int dev;
894: register struct uio *uio;
895: {
896: register ENPDEVICE *addr;
897: register struct iovec *iov;
898: register r=0;
899:
900: if (enpram[minor(dev)] != ENP_OPEN)
901: return(EACCES);
902: addr = (ENPDEVICE *)enpinfo[ minor( dev ) ]->ui_addr;
903: iov = uio->uio_iov;
904:
905: if ( uio->uio_offset > RAM_SIZE )
906: return( ENODEV );
907: if ( uio->uio_offset + iov->iov_len > RAM_SIZE )
908: iov->iov_len = RAM_SIZE - uio->uio_offset;
909: if( r = enpcopyin( iov->iov_base, &addr->enp_ram[ uio->uio_offset ],
910: iov->iov_len ) )
911: return( r );
912:
913: uio->uio_resid -= iov->iov_len;
914: iov->iov_len = 0;
915:
916: return( 0 );
917: }
918:
919: enpr_ioctl( dev,cmd,arg,fflag )
920: dev_t dev;
921: caddr_t *arg;
922: {
923: register ENPDEVICE *addr;
924: long int v;
925: register short *vp = (short *)&v, *sp;
926: register unit = minor(dev);
927: register struct vba_device *md;
928:
929: if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0 ||
930: (addr = (ENPDEVICE *)md->ui_addr) == (ENPDEVICE *)0)
931: return(ENODEV);
932: switch( cmd )
933: {
934: case ENPIOGO:
935: /* not needed if prom based version */
936: #ifdef TAHOE
937: sp = (short *)&addr->enp_base;
938: v = (int)addr;
939: *sp = *vp; sp[1] = vp[1];
940: #else
941: addr->enp_base = (int)addr;
942: #endif TAHOE
943: addr->enp_intrvec = intvec[ unit ];
944: ENP_GO( addr, ENPSTART );
945: DELAY( 200000 );
946: enpattach( enpinfo[ unit ] );
947: enpinit( unit );
948: addr->enp_state = S_ENPRUN; /* it is running now */
949: /* end of not needed */
950:
951: break;
952:
953: case ENPIORESET:
954: RESET_ENP( addr );
955: addr->enp_state = S_ENPRESET; /* it is reset now */
956: DELAY( 100000 );
957: break;
958: }
959: return( 0 );
960: }
961:
962: /*
963: * routines to synchronize enp and host
964: */
965:
966: static
967: ringinit( rp,size )
968: register RING *rp;
969: {
970: register int i;
971: register short *sp;
972:
973: rp->r_rdidx = rp->r_wrtidx = 0;
974: rp->r_size = size;
975: }
976:
977: static
978: ringempty( rp )
979: register RING *rp;
980: {
981: return( rp->r_rdidx == rp->r_wrtidx );
982: }
983:
984: static
985: ringfull( rp )
986: register RING *rp;
987: {
988: register short idx;
989:
990: idx = (rp->r_wrtidx + 1) & (rp->r_size-1);
991: return( idx == rp->r_rdidx );
992: }
993:
994: static
995: ringput( rp,v )
996: register RING *rp;
997: {
998: register int idx;
999: register short *vp = (short *)&v,
1000: *sp;
1001:
1002: idx = (rp->r_wrtidx + 1) & (rp->r_size-1);
1003: if( idx != rp->r_rdidx )
1004: {
1005: #ifdef TAHOE
1006: sp = (short *)&rp->r_slot[ rp->r_wrtidx ];
1007: *sp = *vp; sp[1] = vp[1];
1008: #else
1009: rp->r_slot[ rp->r_wrtidx ] = v;
1010: #endif TAHOE
1011: rp->r_wrtidx = idx;
1012: if( (idx -= rp->r_rdidx) < 0 )
1013: idx += rp->r_size;
1014: return( idx ); /* num ring entries */
1015: }
1016: return( 0 );
1017: }
1018:
1019: static
1020: ringget( rp )
1021: register RING *rp;
1022: {
1023: register int i = 0;
1024: long int v;
1025: register short *vp = (short *)&v,
1026: *sp;
1027:
1028: if( rp->r_rdidx != rp->r_wrtidx )
1029: {
1030: #ifdef TAHOE
1031: sp = (short *)&rp->r_slot[ rp->r_rdidx ];
1032: *vp = *sp; vp[1] = sp[1];
1033: i = v;
1034: #else
1035: i = rp->r_slot[ rp->r_rdidx ];
1036: #endif TAHOE
1037: rp->r_rdidx = (++rp->r_rdidx) & (rp->r_size-1);
1038: }
1039: return( i );
1040: }
1041:
1042: #ifdef notdef
1043: struct mbuf *
1044: m_tofree( rp )
1045: register RING *rp;
1046: {
1047: long int v = 0;
1048: register short *vp = (short *)&v,
1049: *sp;
1050:
1051: if( rp->r_rdidx != rp->r_wrtidx )
1052: {
1053: #ifdef TAHOE
1054: sp = (short *)&rp->r_slot[ rp->r_rdidx ];
1055: *vp = *sp; vp[1] = sp[1];
1056: /* *sp = 0xffff; sp[1] = 0xffff; */
1057: #else
1058: v = rp->r_slot[ rp->r_rdidx ];
1059: #endif TAHOE
1060: rp->r_rdidx = (++rp->r_rdidx) & (rp->r_size-1);
1061: }
1062: return( (struct mbuf *)v );
1063: }
1064: #endif
1065: static
1066: fir( rp )
1067: register RING *rp;
1068: {
1069: long int v;
1070: register short *vp = (short *)&v,
1071: *sp;
1072:
1073: if( rp->r_rdidx != rp->r_wrtidx )
1074: #ifdef TAHOE
1075: {
1076: sp = (short *)&rp->r_slot[ rp->r_rdidx ];
1077: *vp = *sp; vp[1] = sp[1];
1078: return( v );
1079: }
1080: #else
1081: return( rp->r_slot[ rp->r_rdidx ] );
1082: #endif TAHOE
1083: else
1084: return( 0 );
1085: }
1086:
1087:
1088: static
1089: prtbytes( addr )
1090: register char *addr;
1091: {
1092: register int i;
1093:
1094: for( i = 0; i < 12; i++ )
1095: {
1096: printf("%X ",*addr&0377);
1097: addr++;
1098: }
1099: printf("\n");
1100: }
1101:
1102: static
1103: enpcopy(from, to, cnt)
1104: register char *from, *to;
1105: register cnt;
1106: {
1107: register c;
1108: register short *f, *t;
1109:
1110: if (((int)from & 01) && ((int)to & 01)) {
1111: /* source & dest at odd addresses */
1112: *to++ = *from++;
1113: --cnt;
1114: }
1115: if (cnt > 1 && (((int)to & 01)==0) && (((int)from & 01)==0)) {
1116: t = (short *) to;
1117: f = (short *) from;
1118: for( c = cnt>>1; c; --c) /* even address copy */
1119: *t++ = *f++;
1120: cnt &= 1;
1121: if ( cnt ) { /* odd len */
1122: from = (char *) f;
1123: to = (char *) t;
1124: *to = *from;
1125: }
1126: }
1127: while (cnt-- > 0) /* one of the address(es) must be odd */
1128: *to++ = *from++;
1129:
1130: }
1131:
1132: static
1133: enpcopyin(userv, kernv, cnt)
1134: {
1135:
1136: if (useracc(userv, cnt, 1)) {
1137: enpcopy( userv, kernv, cnt );
1138: return( 0 );
1139: }
1140: else return( EFAULT );
1141: }
1142:
1143:
1144: static
1145: enpcopyout(kernv, userv, cnt)
1146: {
1147:
1148: if (useracc(userv, cnt, 0)) {
1149: enpcopy( kernv, userv, cnt );
1150: return( 0 );
1151: }
1152: else return( EFAULT );
1153: }
1154: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.