![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_de.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxif|
Return to if_de.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxif |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)if_de.c 7.1 (Berkeley) 6/5/86
7: */
8: #include "de.h"
9: #if NDE > 0
10:
11: /*
12: * DEC DEUNA interface
13: *
14: * Lou Salkind
15: * New York University
16: *
17: * TODO:
18: * timeout routine (get statistics)
19: */
20: #include "../machine/pte.h"
21:
22: #include "param.h"
23: #include "systm.h"
24: #include "mbuf.h"
25: #include "buf.h"
26: #include "protosw.h"
27: #include "socket.h"
28: #include "vmmac.h"
29: #include "ioctl.h"
30: #include "errno.h"
31: #include "syslog.h"
32:
33: #include "../net/if.h"
34: #include "../net/netisr.h"
35: #include "../net/route.h"
36:
37: #ifdef INET
38: #include "../netinet/in.h"
39: #include "../netinet/in_systm.h"
40: #include "../netinet/in_var.h"
41: #include "../netinet/ip.h"
42: #include "../netinet/if_ether.h"
43: #endif
44:
45: #ifdef NS
46: #include "../netns/ns.h"
47: #include "../netns/ns_if.h"
48: #endif
49:
50: #include "../vax/cpu.h"
51: #include "../vax/mtpr.h"
52: #include "if_dereg.h"
53: #include "if_uba.h"
54: #include "../vaxuba/ubareg.h"
55: #include "../vaxuba/ubavar.h"
56:
57: #define NXMT 3 /* number of transmit buffers */
58: #define NRCV 7 /* number of receive buffers (must be > 1) */
59:
60: int dedebug = 0;
61:
62: int deprobe(), deattach(), deintr();
63: struct uba_device *deinfo[NDE];
64: u_short destd[] = { 0 };
65: struct uba_driver dedriver =
66: { deprobe, 0, deattach, 0, destd, "de", deinfo };
67: int deinit(),deoutput(),deioctl(),dereset();
68:
69:
70: /*
71: * Ethernet software status per interface.
72: *
73: * Each interface is referenced by a network interface structure,
74: * ds_if, which the routing code uses to locate the interface.
75: * This structure contains the output queue for the interface, its address, ...
76: * We also have, for each interface, a UBA interface structure, which
77: * contains information about the UNIBUS resources held by the interface:
78: * map registers, buffered data paths, etc. Information is cached in this
79: * structure for use by the if_uba.c routines in running the interface
80: * efficiently.
81: */
82: struct de_softc {
83: struct arpcom ds_ac; /* Ethernet common part */
84: #define ds_if ds_ac.ac_if /* network-visible interface */
85: #define ds_addr ds_ac.ac_enaddr /* hardware Ethernet address */
86: int ds_flags;
87: #define DSF_LOCK 1 /* lock out destart */
88: #define DSF_RUNNING 2 /* board is enabled */
89: #define DSF_SETADDR 4 /* physical address is changed */
90: int ds_ubaddr; /* map info for incore structs */
91: struct ifubinfo ds_deuba; /* unibus resource structure */
92: struct ifrw ds_ifr[NRCV]; /* unibus receive maps */
93: struct ifxmt ds_ifw[NXMT]; /* unibus xmt maps */
94: /* the following structures are always mapped in */
95: struct de_pcbb ds_pcbb; /* port control block */
96: struct de_ring ds_xrent[NXMT]; /* transmit ring entrys */
97: struct de_ring ds_rrent[NRCV]; /* receive ring entrys */
98: struct de_udbbuf ds_udbbuf; /* UNIBUS data buffer */
99: /* end mapped area */
100: #define INCORE_BASE(p) ((char *)&(p)->ds_pcbb)
101: #define RVAL_OFF(n) ((char *)&de_softc[0].n - INCORE_BASE(&de_softc[0]))
102: #define LVAL_OFF(n) ((char *)de_softc[0].n - INCORE_BASE(&de_softc[0]))
103: #define PCBB_OFFSET RVAL_OFF(ds_pcbb)
104: #define XRENT_OFFSET LVAL_OFF(ds_xrent)
105: #define RRENT_OFFSET LVAL_OFF(ds_rrent)
106: #define UDBBUF_OFFSET RVAL_OFF(ds_udbbuf)
107: #define INCORE_SIZE RVAL_OFF(ds_xindex)
108: int ds_xindex; /* UNA index into transmit chain */
109: int ds_rindex; /* UNA index into receive chain */
110: int ds_xfree; /* index for next transmit buffer */
111: int ds_nxmit; /* # of transmits in progress */
112: } de_softc[NDE];
113:
114: deprobe(reg)
115: caddr_t reg;
116: {
117: register int br, cvec; /* r11, r10 value-result */
118: register struct dedevice *addr = (struct dedevice *)reg;
119: register i;
120:
121: #ifdef lint
122: br = 0; cvec = br; br = cvec;
123: i = 0; derint(i); deintr(i);
124: #endif
125:
126: addr->pcsr0 = PCSR0_RSET;
127: while ((addr->pcsr0 & PCSR0_INTR) == 0)
128: ;
129: /* make board interrupt by executing a GETPCBB command */
130: addr->pcsr0 = PCSR0_INTE;
131: addr->pcsr2 = 0;
132: addr->pcsr3 = 0;
133: addr->pcsr0 = PCSR0_INTE|CMD_GETPCBB;
134: DELAY(100000);
135: return(1);
136: }
137:
138: /*
139: * Interface exists: make available by filling in network interface
140: * record. System will initialize the interface when it is ready
141: * to accept packets. We get the ethernet address here.
142: */
143: deattach(ui)
144: struct uba_device *ui;
145: {
146: register struct de_softc *ds = &de_softc[ui->ui_unit];
147: register struct ifnet *ifp = &ds->ds_if;
148: register struct dedevice *addr = (struct dedevice *)ui->ui_addr;
149:
150: ifp->if_unit = ui->ui_unit;
151: ifp->if_name = "de";
152: ifp->if_mtu = ETHERMTU;
153: ifp->if_flags = IFF_BROADCAST;
154:
155: /*
156: * Reset the board and temporarily map
157: * the pcbb buffer onto the Unibus.
158: */
159: addr->pcsr0 = PCSR0_RSET;
160: (void)dewait(ui, "reset");
161:
162: ds->ds_ubaddr = uballoc(ui->ui_ubanum, (char *)&ds->ds_pcbb,
163: sizeof (struct de_pcbb), 0);
164: addr->pcsr2 = ds->ds_ubaddr & 0xffff;
165: addr->pcsr3 = (ds->ds_ubaddr >> 16) & 0x3;
166: addr->pclow = CMD_GETPCBB;
167: (void)dewait(ui, "pcbb");
168:
169: ds->ds_pcbb.pcbb0 = FC_RDPHYAD;
170: addr->pclow = CMD_GETCMD;
171: (void)dewait(ui, "read addr ");
172:
173: ubarelse(ui->ui_ubanum, &ds->ds_ubaddr);
174: bcopy((caddr_t)&ds->ds_pcbb.pcbb2, (caddr_t)ds->ds_addr,
175: sizeof (ds->ds_addr));
176: printf("de%d: hardware address %s\n", ui->ui_unit,
177: ether_sprintf(ds->ds_addr));
178: ifp->if_init = deinit;
179: ifp->if_output = deoutput;
180: ifp->if_ioctl = deioctl;
181: ifp->if_reset = dereset;
182: ds->ds_deuba.iff_flags = UBA_CANTWAIT;
183: #ifdef notdef
184: /* CAN WE USE BDP's ??? */
185: ds->ds_deuba.iff_flags |= UBA_NEEDBDP;
186: #endif
187: if_attach(ifp);
188: }
189:
190: /*
191: * Reset of interface after UNIBUS reset.
192: * If interface is on specified uba, reset its state.
193: */
194: dereset(unit, uban)
195: int unit, uban;
196: {
197: register struct uba_device *ui;
198:
199: if (unit >= NDE || (ui = deinfo[unit]) == 0 || ui->ui_alive == 0 ||
200: ui->ui_ubanum != uban)
201: return;
202: printf(" de%d", unit);
203: de_softc[unit].ds_if.if_flags &= ~IFF_RUNNING;
204: de_softc[unit].ds_flags &= ~(DSF_LOCK | DSF_RUNNING);
205: deinit(unit);
206: }
207:
208: /*
209: * Initialization of interface; clear recorded pending
210: * operations, and reinitialize UNIBUS usage.
211: */
212: deinit(unit)
213: int unit;
214: {
215: register struct de_softc *ds = &de_softc[unit];
216: register struct uba_device *ui = deinfo[unit];
217: register struct dedevice *addr;
218: register struct ifrw *ifrw;
219: register struct ifxmt *ifxp;
220: struct ifnet *ifp = &ds->ds_if;
221: int s;
222: struct de_ring *rp;
223: int incaddr;
224:
225: /* not yet, if address still unknown */
226: if (ifp->if_addrlist == (struct ifaddr *)0)
227: return;
228:
229: if (ds->ds_flags & DSF_RUNNING)
230: return;
231: if ((ifp->if_flags & IFF_RUNNING) == 0) {
232: if (if_ubaminit(&ds->ds_deuba, ui->ui_ubanum,
233: sizeof (struct ether_header), (int)btoc(ETHERMTU),
234: ds->ds_ifr, NRCV, ds->ds_ifw, NXMT) == 0) {
235: printf("de%d: can't initialize\n", unit);
236: ds->ds_if.if_flags &= ~IFF_UP;
237: return;
238: }
239: ds->ds_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(ds),
240: INCORE_SIZE, 0);
241: }
242: addr = (struct dedevice *)ui->ui_addr;
243:
244: /* set the pcbb block address */
245: incaddr = ds->ds_ubaddr + PCBB_OFFSET;
246: addr->pcsr2 = incaddr & 0xffff;
247: addr->pcsr3 = (incaddr >> 16) & 0x3;
248: addr->pclow = CMD_GETPCBB;
249: (void)dewait(ui, "pcbb");
250:
251: /* set the transmit and receive ring header addresses */
252: incaddr = ds->ds_ubaddr + UDBBUF_OFFSET;
253: ds->ds_pcbb.pcbb0 = FC_WTRING;
254: ds->ds_pcbb.pcbb2 = incaddr & 0xffff;
255: ds->ds_pcbb.pcbb4 = (incaddr >> 16) & 0x3;
256:
257: incaddr = ds->ds_ubaddr + XRENT_OFFSET;
258: ds->ds_udbbuf.b_tdrbl = incaddr & 0xffff;
259: ds->ds_udbbuf.b_tdrbh = (incaddr >> 16) & 0x3;
260: ds->ds_udbbuf.b_telen = sizeof (struct de_ring) / sizeof (short);
261: ds->ds_udbbuf.b_trlen = NXMT;
262: incaddr = ds->ds_ubaddr + RRENT_OFFSET;
263: ds->ds_udbbuf.b_rdrbl = incaddr & 0xffff;
264: ds->ds_udbbuf.b_rdrbh = (incaddr >> 16) & 0x3;
265: ds->ds_udbbuf.b_relen = sizeof (struct de_ring) / sizeof (short);
266: ds->ds_udbbuf.b_rrlen = NRCV;
267:
268: addr->pclow = CMD_GETCMD;
269: (void)dewait(ui, "wtring");
270:
271: /* initialize the mode - enable hardware padding */
272: ds->ds_pcbb.pcbb0 = FC_WTMODE;
273: /* let hardware do padding - set MTCH bit on broadcast */
274: ds->ds_pcbb.pcbb2 = MOD_TPAD|MOD_HDX;
275: addr->pclow = CMD_GETCMD;
276: (void)dewait(ui, "wtmode");
277:
278: /* set up the receive and transmit ring entries */
279: ifxp = &ds->ds_ifw[0];
280: for (rp = &ds->ds_xrent[0]; rp < &ds->ds_xrent[NXMT]; rp++) {
281: rp->r_segbl = ifxp->ifw_info & 0xffff;
282: rp->r_segbh = (ifxp->ifw_info >> 16) & 0x3;
283: rp->r_flags = 0;
284: ifxp++;
285: }
286: ifrw = &ds->ds_ifr[0];
287: for (rp = &ds->ds_rrent[0]; rp < &ds->ds_rrent[NRCV]; rp++) {
288: rp->r_slen = sizeof (struct de_buf);
289: rp->r_segbl = ifrw->ifrw_info & 0xffff;
290: rp->r_segbh = (ifrw->ifrw_info >> 16) & 0x3;
291: rp->r_flags = RFLG_OWN; /* hang receive */
292: ifrw++;
293: }
294:
295: /* start up the board (rah rah) */
296: s = splimp();
297: ds->ds_rindex = ds->ds_xindex = ds->ds_xfree = ds->ds_nxmit = 0;
298: ds->ds_if.if_flags |= IFF_RUNNING;
299: destart(unit); /* queue output packets */
300: addr->pclow = PCSR0_INTE; /* avoid interlock */
301: ds->ds_flags |= DSF_RUNNING; /* need before de_setaddr */
302: if (ds->ds_flags & DSF_SETADDR)
303: de_setaddr(ds->ds_addr, unit);
304: addr->pclow = CMD_START | PCSR0_INTE;
305: splx(s);
306: }
307:
308: /*
309: * Setup output on interface.
310: * Get another datagram to send off of the interface queue,
311: * and map it to the interface before starting the output.
312: */
313: destart(unit)
314: int unit;
315: {
316: int len;
317: struct uba_device *ui = deinfo[unit];
318: struct dedevice *addr = (struct dedevice *)ui->ui_addr;
319: register struct de_softc *ds = &de_softc[unit];
320: register struct de_ring *rp;
321: struct mbuf *m;
322: register int nxmit;
323:
324: /*
325: * the following test is necessary, since
326: * the code is not reentrant and we have
327: * multiple transmission buffers.
328: */
329: if (ds->ds_flags & DSF_LOCK)
330: return;
331: for (nxmit = ds->ds_nxmit; nxmit < NXMT; nxmit++) {
332: IF_DEQUEUE(&ds->ds_if.if_snd, m);
333: if (m == 0)
334: break;
335: rp = &ds->ds_xrent[ds->ds_xfree];
336: if (rp->r_flags & XFLG_OWN)
337: panic("deuna xmit in progress");
338: len = if_ubaput(&ds->ds_deuba, &ds->ds_ifw[ds->ds_xfree], m);
339: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP)
340: UBAPURGE(ds->ds_deuba.iff_uba,
341: ds->ds_ifw[ds->ds_xfree].ifw_bdp);
342: rp->r_slen = len;
343: rp->r_tdrerr = 0;
344: rp->r_flags = XFLG_STP|XFLG_ENP|XFLG_OWN;
345:
346: ds->ds_xfree++;
347: if (ds->ds_xfree == NXMT)
348: ds->ds_xfree = 0;
349: }
350: if (ds->ds_nxmit != nxmit) {
351: ds->ds_nxmit = nxmit;
352: if (ds->ds_flags & DSF_RUNNING)
353: addr->pclow = PCSR0_INTE|CMD_PDMD;
354: }
355: }
356:
357: /*
358: * Command done interrupt.
359: */
360: deintr(unit)
361: int unit;
362: {
363: struct uba_device *ui = deinfo[unit];
364: register struct dedevice *addr = (struct dedevice *)ui->ui_addr;
365: register struct de_softc *ds = &de_softc[unit];
366: register struct de_ring *rp;
367: register struct ifxmt *ifxp;
368: short csr0;
369:
370: /* save flags right away - clear out interrupt bits */
371: csr0 = addr->pcsr0;
372: addr->pchigh = csr0 >> 8;
373:
374:
375: ds->ds_flags |= DSF_LOCK; /* prevent entering destart */
376: /*
377: * if receive, put receive buffer on mbuf
378: * and hang the request again
379: */
380: derecv(unit);
381:
382: /*
383: * Poll transmit ring and check status.
384: * Be careful about loopback requests.
385: * Then free buffer space and check for
386: * more transmit requests.
387: */
388: for ( ; ds->ds_nxmit > 0; ds->ds_nxmit--) {
389: rp = &ds->ds_xrent[ds->ds_xindex];
390: if (rp->r_flags & XFLG_OWN)
391: break;
392: ds->ds_if.if_opackets++;
393: ifxp = &ds->ds_ifw[ds->ds_xindex];
394: /* check for unusual conditions */
395: if (rp->r_flags & (XFLG_ERRS|XFLG_MTCH|XFLG_ONE|XFLG_MORE)) {
396: if (rp->r_flags & XFLG_ERRS) {
397: /* output error */
398: ds->ds_if.if_oerrors++;
399: if (dedebug)
400: printf("de%d: oerror, flags=%b tdrerr=%b (len=%d)\n",
401: unit, rp->r_flags, XFLG_BITS,
402: rp->r_tdrerr, XERR_BITS, rp->r_slen);
403: } else if (rp->r_flags & XFLG_ONE) {
404: /* one collision */
405: ds->ds_if.if_collisions++;
406: } else if (rp->r_flags & XFLG_MORE) {
407: /* more than one collision */
408: ds->ds_if.if_collisions += 2; /* guess */
409: } else if (rp->r_flags & XFLG_MTCH) {
410: /* received our own packet */
411: ds->ds_if.if_ipackets++;
412: deread(ds, &ifxp->ifrw,
413: rp->r_slen - sizeof (struct ether_header));
414: }
415: }
416: if (ifxp->ifw_xtofree) {
417: m_freem(ifxp->ifw_xtofree);
418: ifxp->ifw_xtofree = 0;
419: }
420: /* check if next transmit buffer also finished */
421: ds->ds_xindex++;
422: if (ds->ds_xindex == NXMT)
423: ds->ds_xindex = 0;
424: }
425: ds->ds_flags &= ~DSF_LOCK;
426: destart(unit);
427:
428: if (csr0 & PCSR0_RCBI) {
429: if (dedebug)
430: log(LOG_WARNING, "de%d: buffer unavailable\n", unit);
431: addr->pclow = PCSR0_INTE|CMD_PDMD;
432: }
433: }
434:
435: /*
436: * Ethernet interface receiver interface.
437: * If input error just drop packet.
438: * Otherwise purge input buffered data path and examine
439: * packet to determine type. If can't determine length
440: * from type, then have to drop packet. Othewise decapsulate
441: * packet based on type and pass to type specific higher-level
442: * input routine.
443: */
444: derecv(unit)
445: int unit;
446: {
447: register struct de_softc *ds = &de_softc[unit];
448: register struct de_ring *rp;
449: int len;
450:
451: rp = &ds->ds_rrent[ds->ds_rindex];
452: while ((rp->r_flags & RFLG_OWN) == 0) {
453: ds->ds_if.if_ipackets++;
454: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP)
455: UBAPURGE(ds->ds_deuba.iff_uba,
456: ds->ds_ifr[ds->ds_rindex].ifrw_bdp);
457: len = (rp->r_lenerr&RERR_MLEN) - sizeof (struct ether_header)
458: - 4; /* don't forget checksum! */
459: /* check for errors */
460: if ((rp->r_flags & (RFLG_ERRS|RFLG_FRAM|RFLG_OFLO|RFLG_CRC)) ||
461: (rp->r_flags&(RFLG_STP|RFLG_ENP)) != (RFLG_STP|RFLG_ENP) ||
462: (rp->r_lenerr & (RERR_BUFL|RERR_UBTO|RERR_NCHN)) ||
463: len < ETHERMIN || len > ETHERMTU) {
464: ds->ds_if.if_ierrors++;
465: if (dedebug)
466: printf("de%d: ierror, flags=%b lenerr=%b (len=%d)\n",
467: unit, rp->r_flags, RFLG_BITS, rp->r_lenerr,
468: RERR_BITS, len);
469: } else
470: deread(ds, &ds->ds_ifr[ds->ds_rindex], len);
471:
472: /* hang the receive buffer again */
473: rp->r_lenerr = 0;
474: rp->r_flags = RFLG_OWN;
475:
476: /* check next receive buffer */
477: ds->ds_rindex++;
478: if (ds->ds_rindex == NRCV)
479: ds->ds_rindex = 0;
480: rp = &ds->ds_rrent[ds->ds_rindex];
481: }
482: }
483:
484: /*
485: * Pass a packet to the higher levels.
486: * We deal with the trailer protocol here.
487: */
488: deread(ds, ifrw, len)
489: register struct de_softc *ds;
490: struct ifrw *ifrw;
491: int len;
492: {
493: struct ether_header *eh;
494: struct mbuf *m;
495: int off, resid;
496: int s;
497: register struct ifqueue *inq;
498:
499: /*
500: * Deal with trailer protocol: if type is trailer type
501: * get true type from first 16-bit word past data.
502: * Remember that type was trailer by setting off.
503: */
504: eh = (struct ether_header *)ifrw->ifrw_addr;
505: eh->ether_type = ntohs((u_short)eh->ether_type);
506: #define dedataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off))))
507: if (eh->ether_type >= ETHERTYPE_TRAIL &&
508: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
509: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512;
510: if (off >= ETHERMTU)
511: return; /* sanity */
512: eh->ether_type = ntohs(*dedataaddr(eh, off, u_short *));
513: resid = ntohs(*(dedataaddr(eh, off+2, u_short *)));
514: if (off + resid > len)
515: return; /* sanity */
516: len = off + resid;
517: } else
518: off = 0;
519: if (len == 0)
520: return;
521:
522: /*
523: * Pull packet off interface. Off is nonzero if packet
524: * has trailing header; if_ubaget will then force this header
525: * information to be at the front, but we still have to drop
526: * the type and length which are at the front of any trailer data.
527: */
528: m = if_ubaget(&ds->ds_deuba, ifrw, len, off, &ds->ds_if);
529: if (m == 0)
530: return;
531: if (off) {
532: struct ifnet *ifp;
533:
534: ifp = *(mtod(m, struct ifnet **));
535: m->m_off += 2 * sizeof (u_short);
536: m->m_len -= 2 * sizeof (u_short);
537: *(mtod(m, struct ifnet **)) = ifp;
538: }
539: switch (eh->ether_type) {
540:
541: #ifdef INET
542: case ETHERTYPE_IP:
543: schednetisr(NETISR_IP);
544: inq = &ipintrq;
545: break;
546:
547: case ETHERTYPE_ARP:
548: arpinput(&ds->ds_ac, m);
549: return;
550: #endif
551: #ifdef NS
552: case ETHERTYPE_NS:
553: schednetisr(NETISR_NS);
554: inq = &nsintrq;
555: break;
556:
557: #endif
558: default:
559: m_freem(m);
560: return;
561: }
562:
563: s = splimp();
564: if (IF_QFULL(inq)) {
565: IF_DROP(inq);
566: splx(s);
567: m_freem(m);
568: return;
569: }
570: IF_ENQUEUE(inq, m);
571: splx(s);
572: }
573:
574: /*
575: * Ethernet output routine.
576: * Encapsulate a packet of type family for the local net.
577: * Use trailer local net encapsulation if enough data in first
578: * packet leaves a multiple of 512 bytes of data in remainder.
579: */
580: deoutput(ifp, m0, dst)
581: struct ifnet *ifp;
582: struct mbuf *m0;
583: struct sockaddr *dst;
584: {
585: int type, s, error;
586: u_char edst[6];
587: struct in_addr idst;
588: register struct de_softc *ds = &de_softc[ifp->if_unit];
589: register struct mbuf *m = m0;
590: register struct ether_header *eh;
591: register int off;
592: int usetrailers;
593:
594: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
595: error = ENETDOWN;
596: goto bad;
597: }
598: switch (dst->sa_family) {
599:
600: #ifdef INET
601: case AF_INET:
602: idst = ((struct sockaddr_in *)dst)->sin_addr;
603: if (!arpresolve(&ds->ds_ac, m, &idst, edst, &usetrailers))
604: return (0); /* if not yet resolved */
605: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
606: if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
607: m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
608: type = ETHERTYPE_TRAIL + (off>>9);
609: m->m_off -= 2 * sizeof (u_short);
610: m->m_len += 2 * sizeof (u_short);
611: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
612: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
613: goto gottrailertype;
614: }
615: type = ETHERTYPE_IP;
616: off = 0;
617: goto gottype;
618: #endif
619: #ifdef NS
620: case AF_NS:
621: type = ETHERTYPE_NS;
622: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
623: (caddr_t)edst, sizeof (edst));
624: off = 0;
625: goto gottype;
626: #endif
627:
628: case AF_UNSPEC:
629: eh = (struct ether_header *)dst->sa_data;
630: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
631: type = eh->ether_type;
632: goto gottype;
633:
634: default:
635: printf("de%d: can't handle af%d\n", ifp->if_unit,
636: dst->sa_family);
637: error = EAFNOSUPPORT;
638: goto bad;
639: }
640:
641: gottrailertype:
642: /*
643: * Packet to be sent as trailer: move first packet
644: * (control information) to end of chain.
645: */
646: while (m->m_next)
647: m = m->m_next;
648: m->m_next = m0;
649: m = m0->m_next;
650: m0->m_next = 0;
651: m0 = m;
652:
653: gottype:
654: /*
655: * Add local net header. If no space in first mbuf,
656: * allocate another.
657: */
658: if (m->m_off > MMAXOFF ||
659: MMINOFF + sizeof (struct ether_header) > m->m_off) {
660: m = m_get(M_DONTWAIT, MT_HEADER);
661: if (m == 0) {
662: error = ENOBUFS;
663: goto bad;
664: }
665: m->m_next = m0;
666: m->m_off = MMINOFF;
667: m->m_len = sizeof (struct ether_header);
668: } else {
669: m->m_off -= sizeof (struct ether_header);
670: m->m_len += sizeof (struct ether_header);
671: }
672: eh = mtod(m, struct ether_header *);
673: eh->ether_type = htons((u_short)type);
674: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
675: /* DEUNA fills in source address */
676:
677: /*
678: * Queue message on interface, and start output if interface
679: * not yet active.
680: */
681: s = splimp();
682: if (IF_QFULL(&ifp->if_snd)) {
683: IF_DROP(&ifp->if_snd);
684: splx(s);
685: m_freem(m);
686: return (ENOBUFS);
687: }
688: IF_ENQUEUE(&ifp->if_snd, m);
689: destart(ifp->if_unit);
690: splx(s);
691: return (0);
692:
693: bad:
694: m_freem(m0);
695: return (error);
696: }
697:
698: /*
699: * Process an ioctl request.
700: */
701: deioctl(ifp, cmd, data)
702: register struct ifnet *ifp;
703: int cmd;
704: caddr_t data;
705: {
706: register struct ifaddr *ifa = (struct ifaddr *)data;
707: register struct de_softc *ds = &de_softc[ifp->if_unit];
708: int s = splimp(), error = 0;
709:
710: switch (cmd) {
711:
712: case SIOCSIFADDR:
713: ifp->if_flags |= IFF_UP;
714: deinit(ifp->if_unit);
715:
716: switch (ifa->ifa_addr.sa_family) {
717: #ifdef INET
718: case AF_INET:
719: ((struct arpcom *)ifp)->ac_ipaddr =
720: IA_SIN(ifa)->sin_addr;
721: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
722: break;
723: #endif
724: #ifdef NS
725: case AF_NS:
726: {
727: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
728:
729: if (ns_nullhost(*ina))
730: ina->x_host = *(union ns_host *)(ds->ds_addr);
731: else
732: de_setaddr(ina->x_host.c_host,ifp->if_unit);
733: break;
734: }
735: #endif
736: }
737: break;
738:
739: case SIOCSIFFLAGS:
740: if ((ifp->if_flags & IFF_UP) == 0 &&
741: ds->ds_flags & DSF_RUNNING) {
742: ((struct dedevice *)
743: (deinfo[ifp->if_unit]->ui_addr))->pclow = PCSR0_RSET;
744: ds->ds_flags &= ~(DSF_LOCK | DSF_RUNNING);
745: } else if (ifp->if_flags & IFF_UP &&
746: (ds->ds_flags & DSF_RUNNING) == 0)
747: deinit(ifp->if_unit);
748: break;
749:
750: default:
751: error = EINVAL;
752: }
753: splx(s);
754: return (error);
755: }
756:
757: /*
758: * set ethernet address for unit
759: */
760: de_setaddr(physaddr, unit)
761: u_char *physaddr;
762: int unit;
763: {
764: register struct de_softc *ds = &de_softc[unit];
765: struct uba_device *ui = deinfo[unit];
766: register struct dedevice *addr= (struct dedevice *)ui->ui_addr;
767:
768: if (! (ds->ds_flags & DSF_RUNNING))
769: return;
770:
771: bcopy(physaddr, &ds->ds_pcbb.pcbb2, 6);
772: ds->ds_pcbb.pcbb0 = FC_WTPHYAD;
773: addr->pclow = PCSR0_INTE|CMD_GETCMD;
774: if (dewait(ui, "address change") == 0) {
775: ds->ds_flags |= DSF_SETADDR;
776: bcopy(physaddr, ds->ds_addr, 6);
777: }
778: }
779:
780: /*
781: * Await completion of the named function
782: * and check for errors.
783: */
784: dewait(ui, fn)
785: register struct uba_device *ui;
786: char *fn;
787: {
788: register struct dedevice *addr = (struct dedevice *)ui->ui_addr;
789: register csr0;
790:
791: while ((addr->pcsr0 & PCSR0_INTR) == 0)
792: ;
793: csr0 = addr->pcsr0;
794: addr->pchigh = csr0 >> 8;
795: if (csr0 & PCSR0_PCEI)
796: printf("de%d: %s failed, csr0=%b csr1=%b\n",
797: ui->ui_unit, fn, csr0, PCSR0_BITS,
798: addr->pcsr1, PCSR1_BITS);
799: return (csr0 & PCSR0_PCEI);
800: }
801: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.