![[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 [Net/2] / Net2 / arch / vax / if|
Return to if_de.c CVS log | Up to [Net/2] / Net2 / arch / vax / if |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)if_de.c 7.12 (Berkeley) 12/16/90
34: */
35:
36: #include "de.h"
37: #if NDE > 0
38:
39: /*
40: * DEC DEUNA interface
41: *
42: * Lou Salkind
43: * New York University
44: *
45: * TODO:
46: * timeout routine (get statistics)
47: */
48: #include "../include/pte.h"
49:
50: #include "sys/param.h"
51: #include "sys/systm.h"
52: #include "sys/mbuf.h"
53: #include "sys/buf.h"
54: #include "sys/protosw.h"
55: #include "sys/socket.h"
56: #include "sys/vmmac.h"
57: #include "sys/ioctl.h"
58: #include "sys/errno.h"
59: #include "sys/syslog.h"
60:
61: #include "net/if.h"
62: #include "net/netisr.h"
63: #include "net/route.h"
64:
65: #ifdef INET
66: #include "netinet/in.h"
67: #include "netinet/in_systm.h"
68: #include "netinet/in_var.h"
69: #include "netinet/ip.h"
70: #include "netinet/if_ether.h"
71: #endif
72:
73: #ifdef NS
74: #include "netns/ns.h"
75: #include "netns/ns_if.h"
76: #endif
77:
78: #ifdef ISO
79: #include "netiso/iso.h"
80: #include "netiso/iso_var.h"
81: extern char all_es_snpa[], all_is_snpa[];
82: #endif
83:
84: #include "../include/cpu.h"
85: #include "../include/mtpr.h"
86: #include "if_dereg.h"
87: #include "if_uba.h"
88: #include "../uba/ubareg.h"
89: #include "../uba/ubavar.h"
90:
91: #define NXMT 3 /* number of transmit buffers */
92: #define NRCV 7 /* number of receive buffers (must be > 1) */
93:
94: int dedebug = 0;
95:
96: int deprobe(), deattach(), deintr();
97: struct uba_device *deinfo[NDE];
98: u_short destd[] = { 0 };
99: struct uba_driver dedriver =
100: { deprobe, 0, deattach, 0, destd, "de", deinfo };
101: int deinit(),ether_output(),deioctl(),dereset(),destart();
102:
103:
104: /*
105: * Ethernet software status per interface.
106: *
107: * Each interface is referenced by a network interface structure,
108: * ds_if, which the routing code uses to locate the interface.
109: * This structure contains the output queue for the interface, its address, ...
110: * We also have, for each interface, a UBA interface structure, which
111: * contains information about the UNIBUS resources held by the interface:
112: * map registers, buffered data paths, etc. Information is cached in this
113: * structure for use by the if_uba.c routines in running the interface
114: * efficiently.
115: */
116: struct de_softc {
117: struct arpcom ds_ac; /* Ethernet common part */
118: #define ds_if ds_ac.ac_if /* network-visible interface */
119: #define ds_addr ds_ac.ac_enaddr /* hardware Ethernet address */
120: int ds_flags;
121: #define DSF_RUNNING 2 /* board is enabled */
122: #define DSF_SETADDR 4 /* physical address is changed */
123: int ds_ubaddr; /* map info for incore structs */
124: struct ifubinfo ds_deuba; /* unibus resource structure */
125: struct ifrw ds_ifr[NRCV]; /* unibus receive maps */
126: struct ifxmt ds_ifw[NXMT]; /* unibus xmt maps */
127: /* the following structures are always mapped in */
128: struct de_pcbb ds_pcbb; /* port control block */
129: struct de_ring ds_xrent[NXMT]; /* transmit ring entrys */
130: struct de_ring ds_rrent[NRCV]; /* receive ring entrys */
131: struct de_udbbuf ds_udbbuf; /* UNIBUS data buffer */
132: /* end mapped area */
133: #define INCORE_BASE(p) ((char *)&(p)->ds_pcbb)
134: #define RVAL_OFF(n) ((char *)&de_softc[0].n - INCORE_BASE(&de_softc[0]))
135: #define LVAL_OFF(n) ((char *)de_softc[0].n - INCORE_BASE(&de_softc[0]))
136: #define PCBB_OFFSET RVAL_OFF(ds_pcbb)
137: #define XRENT_OFFSET LVAL_OFF(ds_xrent)
138: #define RRENT_OFFSET LVAL_OFF(ds_rrent)
139: #define UDBBUF_OFFSET RVAL_OFF(ds_udbbuf)
140: #define INCORE_SIZE RVAL_OFF(ds_xindex)
141: int ds_xindex; /* UNA index into transmit chain */
142: int ds_rindex; /* UNA index into receive chain */
143: int ds_xfree; /* index for next transmit buffer */
144: int ds_nxmit; /* # of transmits in progress */
145: } de_softc[NDE];
146:
147: deprobe(reg)
148: caddr_t reg;
149: {
150: register int br, cvec; /* r11, r10 value-result */
151: register struct dedevice *addr = (struct dedevice *)reg;
152: register i;
153:
154: #ifdef lint
155: br = 0; cvec = br; br = cvec;
156: i = 0; derint(i); deintr(i);
157: #endif
158:
159: /*
160: * Make sure self-test is finished before we screw with the board.
161: * Self-test on a DELUA can take 15 seconds (argh).
162: */
163: for (i = 0;
164: i < 160 &&
165: (addr->pcsr0 & PCSR0_FATI) == 0 &&
166: (addr->pcsr1 & PCSR1_STMASK) == STAT_RESET;
167: ++i)
168: DELAY(100000);
169: if ((addr->pcsr0 & PCSR0_FATI) != 0 ||
170: (addr->pcsr1 & PCSR1_STMASK) != STAT_READY)
171: return(0);
172:
173: addr->pcsr0 = 0;
174: DELAY(100);
175: addr->pcsr0 = PCSR0_RSET;
176: while ((addr->pcsr0 & PCSR0_INTR) == 0)
177: ;
178: /* make board interrupt by executing a GETPCBB command */
179: addr->pcsr0 = PCSR0_INTE;
180: addr->pcsr2 = 0;
181: addr->pcsr3 = 0;
182: addr->pcsr0 = PCSR0_INTE|CMD_GETPCBB;
183: DELAY(100000);
184: return(1);
185: }
186:
187: /*
188: * Interface exists: make available by filling in network interface
189: * record. System will initialize the interface when it is ready
190: * to accept packets. We get the ethernet address here.
191: */
192: deattach(ui)
193: struct uba_device *ui;
194: {
195: register struct de_softc *ds = &de_softc[ui->ui_unit];
196: register struct ifnet *ifp = &ds->ds_if;
197: register struct dedevice *addr = (struct dedevice *)ui->ui_addr;
198: int csr1;
199:
200: ifp->if_unit = ui->ui_unit;
201: ifp->if_name = "de";
202: ifp->if_mtu = ETHERMTU;
203: ifp->if_flags = IFF_BROADCAST;
204:
205: /*
206: * What kind of a board is this?
207: * The error bits 4-6 in pcsr1 are a device id as long as
208: * the high byte is zero.
209: */
210: csr1 = addr->pcsr1;
211: if (csr1 & 0xff60)
212: printf("de%d: broken\n", ui->ui_unit);
213: else if (csr1 & 0x10)
214: printf("de%d: delua\n", ui->ui_unit);
215: else
216: printf("de%d: deuna\n", ui->ui_unit);
217:
218: /*
219: * Reset the board and temporarily map
220: * the pcbb buffer onto the Unibus.
221: */
222: addr->pcsr0 = 0; /* reset INTE */
223: DELAY(100);
224: addr->pcsr0 = PCSR0_RSET;
225: (void)dewait(ui, "reset");
226:
227: ds->ds_ubaddr = uballoc(ui->ui_ubanum, (char *)&ds->ds_pcbb,
228: sizeof (struct de_pcbb), 0);
229: addr->pcsr2 = ds->ds_ubaddr & 0xffff;
230: addr->pcsr3 = (ds->ds_ubaddr >> 16) & 0x3;
231: addr->pclow = CMD_GETPCBB;
232: (void)dewait(ui, "pcbb");
233:
234: ds->ds_pcbb.pcbb0 = FC_RDPHYAD;
235: addr->pclow = CMD_GETCMD;
236: (void)dewait(ui, "read addr ");
237:
238: ubarelse(ui->ui_ubanum, &ds->ds_ubaddr);
239: bcopy((caddr_t)&ds->ds_pcbb.pcbb2, (caddr_t)ds->ds_addr,
240: sizeof (ds->ds_addr));
241: printf("de%d: hardware address %s\n", ui->ui_unit,
242: ether_sprintf(ds->ds_addr));
243: ifp->if_init = deinit;
244: ifp->if_output = ether_output;
245: ifp->if_ioctl = deioctl;
246: ifp->if_reset = dereset;
247: ifp->if_start = destart;
248: ds->ds_deuba.iff_flags = UBA_CANTWAIT;
249: #ifdef notdef
250: /* CAN WE USE BDP's ??? */
251: ds->ds_deuba.iff_flags |= UBA_NEEDBDP;
252: #endif
253: if_attach(ifp);
254: }
255:
256: /*
257: * Reset of interface after UNIBUS reset.
258: * If interface is on specified uba, reset its state.
259: */
260: dereset(unit, uban)
261: int unit, uban;
262: {
263: register struct uba_device *ui;
264:
265: if (unit >= NDE || (ui = deinfo[unit]) == 0 || ui->ui_alive == 0 ||
266: ui->ui_ubanum != uban)
267: return;
268: printf(" de%d", unit);
269: de_softc[unit].ds_if.if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
270: de_softc[unit].ds_flags &= ~DSF_RUNNING;
271: ((struct dedevice *)ui->ui_addr)->pcsr0 = PCSR0_RSET;
272: (void)dewait(ui, "reset");
273: deinit(unit);
274: }
275:
276: /*
277: * Initialization of interface; clear recorded pending
278: * operations, and reinitialize UNIBUS usage.
279: */
280: deinit(unit)
281: int unit;
282: {
283: register struct de_softc *ds = &de_softc[unit];
284: register struct uba_device *ui = deinfo[unit];
285: register struct dedevice *addr;
286: register struct ifrw *ifrw;
287: register struct ifxmt *ifxp;
288: struct ifnet *ifp = &ds->ds_if;
289: int s;
290: struct de_ring *rp;
291: int incaddr;
292:
293: /* not yet, if address still unknown */
294: if (ifp->if_addrlist == (struct ifaddr *)0)
295: return;
296:
297: if (ds->ds_flags & DSF_RUNNING)
298: return;
299: if ((ifp->if_flags & IFF_RUNNING) == 0) {
300: if (if_ubaminit(&ds->ds_deuba, ui->ui_ubanum,
301: sizeof (struct ether_header), (int)btoc(ETHERMTU),
302: ds->ds_ifr, NRCV, ds->ds_ifw, NXMT) == 0) {
303: printf("de%d: can't initialize\n", unit);
304: ds->ds_if.if_flags &= ~IFF_UP;
305: return;
306: }
307: ds->ds_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(ds),
308: INCORE_SIZE, 0);
309: }
310: addr = (struct dedevice *)ui->ui_addr;
311:
312: /* set the pcbb block address */
313: incaddr = ds->ds_ubaddr + PCBB_OFFSET;
314: addr->pcsr2 = incaddr & 0xffff;
315: addr->pcsr3 = (incaddr >> 16) & 0x3;
316: addr->pclow = 0; /* reset INTE */
317: DELAY(100);
318: addr->pclow = CMD_GETPCBB;
319: (void)dewait(ui, "pcbb");
320:
321: /* set the transmit and receive ring header addresses */
322: incaddr = ds->ds_ubaddr + UDBBUF_OFFSET;
323: ds->ds_pcbb.pcbb0 = FC_WTRING;
324: ds->ds_pcbb.pcbb2 = incaddr & 0xffff;
325: ds->ds_pcbb.pcbb4 = (incaddr >> 16) & 0x3;
326:
327: incaddr = ds->ds_ubaddr + XRENT_OFFSET;
328: ds->ds_udbbuf.b_tdrbl = incaddr & 0xffff;
329: ds->ds_udbbuf.b_tdrbh = (incaddr >> 16) & 0x3;
330: ds->ds_udbbuf.b_telen = sizeof (struct de_ring) / sizeof (short);
331: ds->ds_udbbuf.b_trlen = NXMT;
332: incaddr = ds->ds_ubaddr + RRENT_OFFSET;
333: ds->ds_udbbuf.b_rdrbl = incaddr & 0xffff;
334: ds->ds_udbbuf.b_rdrbh = (incaddr >> 16) & 0x3;
335: ds->ds_udbbuf.b_relen = sizeof (struct de_ring) / sizeof (short);
336: ds->ds_udbbuf.b_rrlen = NRCV;
337:
338: addr->pclow = CMD_GETCMD;
339: (void)dewait(ui, "wtring");
340:
341: /* initialize the mode - enable hardware padding */
342: ds->ds_pcbb.pcbb0 = FC_WTMODE;
343: /* let hardware do padding - set MTCH bit on broadcast */
344: ds->ds_pcbb.pcbb2 = MOD_TPAD|MOD_HDX;
345: addr->pclow = CMD_GETCMD;
346: (void)dewait(ui, "wtmode");
347:
348: /* set up the receive and transmit ring entries */
349: ifxp = &ds->ds_ifw[0];
350: for (rp = &ds->ds_xrent[0]; rp < &ds->ds_xrent[NXMT]; rp++) {
351: rp->r_segbl = ifxp->ifw_info & 0xffff;
352: rp->r_segbh = (ifxp->ifw_info >> 16) & 0x3;
353: rp->r_flags = 0;
354: ifxp++;
355: }
356: ifrw = &ds->ds_ifr[0];
357: for (rp = &ds->ds_rrent[0]; rp < &ds->ds_rrent[NRCV]; rp++) {
358: rp->r_slen = sizeof (struct de_buf);
359: rp->r_segbl = ifrw->ifrw_info & 0xffff;
360: rp->r_segbh = (ifrw->ifrw_info >> 16) & 0x3;
361: rp->r_flags = RFLG_OWN; /* hang receive */
362: ifrw++;
363: }
364:
365: /* start up the board (rah rah) */
366: s = splimp();
367: ds->ds_rindex = ds->ds_xindex = ds->ds_xfree = ds->ds_nxmit = 0;
368: ds->ds_if.if_flags |= IFF_RUNNING;
369: addr->pclow = PCSR0_INTE; /* avoid interlock */
370: destart(&ds->ds_if); /* queue output packets */
371: ds->ds_flags |= DSF_RUNNING; /* need before de_setaddr */
372: if (ds->ds_flags & DSF_SETADDR)
373: de_setaddr(ds->ds_addr, unit);
374: addr->pclow = CMD_START | PCSR0_INTE;
375: splx(s);
376: }
377:
378: /*
379: * Setup output on interface.
380: * Get another datagram to send off of the interface queue,
381: * and map it to the interface before starting the output.
382: * Must be called from ipl >= our interrupt level.
383: */
384: destart(ifp)
385: struct ifnet *ifp;
386: {
387: int len;
388: int unit = ifp->if_unit;
389: struct uba_device *ui = deinfo[unit];
390: struct dedevice *addr = (struct dedevice *)ui->ui_addr;
391: register struct de_softc *ds = &de_softc[unit];
392: register struct de_ring *rp;
393: struct mbuf *m;
394: register int nxmit;
395:
396: /*
397: * the following test is necessary, since
398: * the code is not reentrant and we have
399: * multiple transmission buffers.
400: */
401: if (ds->ds_if.if_flags & IFF_OACTIVE)
402: return;
403: for (nxmit = ds->ds_nxmit; nxmit < NXMT; nxmit++) {
404: IF_DEQUEUE(&ds->ds_if.if_snd, m);
405: if (m == 0)
406: break;
407: rp = &ds->ds_xrent[ds->ds_xfree];
408: if (rp->r_flags & XFLG_OWN)
409: panic("deuna xmit in progress");
410: len = if_ubaput(&ds->ds_deuba, &ds->ds_ifw[ds->ds_xfree], m);
411: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP)
412: UBAPURGE(ds->ds_deuba.iff_uba,
413: ds->ds_ifw[ds->ds_xfree].ifw_bdp);
414: rp->r_slen = len;
415: rp->r_tdrerr = 0;
416: rp->r_flags = XFLG_STP|XFLG_ENP|XFLG_OWN;
417:
418: ds->ds_xfree++;
419: if (ds->ds_xfree == NXMT)
420: ds->ds_xfree = 0;
421: }
422: if (ds->ds_nxmit != nxmit) {
423: ds->ds_nxmit = nxmit;
424: if (ds->ds_flags & DSF_RUNNING)
425: addr->pclow = PCSR0_INTE|CMD_PDMD;
426: }
427: }
428:
429: /*
430: * Command done interrupt.
431: */
432: deintr(unit)
433: int unit;
434: {
435: struct uba_device *ui = deinfo[unit];
436: register struct dedevice *addr = (struct dedevice *)ui->ui_addr;
437: register struct de_softc *ds = &de_softc[unit];
438: register struct de_ring *rp;
439: register struct ifxmt *ifxp;
440: short csr0;
441:
442: /* save flags right away - clear out interrupt bits */
443: csr0 = addr->pcsr0;
444: addr->pchigh = csr0 >> 8;
445:
446:
447: ds->ds_if.if_flags |= IFF_OACTIVE; /* prevent entering destart */
448: /*
449: * if receive, put receive buffer on mbuf
450: * and hang the request again
451: */
452: derecv(unit);
453:
454: /*
455: * Poll transmit ring and check status.
456: * Be careful about loopback requests.
457: * Then free buffer space and check for
458: * more transmit requests.
459: */
460: for ( ; ds->ds_nxmit > 0; ds->ds_nxmit--) {
461: rp = &ds->ds_xrent[ds->ds_xindex];
462: if (rp->r_flags & XFLG_OWN)
463: break;
464: ds->ds_if.if_opackets++;
465: ifxp = &ds->ds_ifw[ds->ds_xindex];
466: /* check for unusual conditions */
467: if (rp->r_flags & (XFLG_ERRS|XFLG_MTCH|XFLG_ONE|XFLG_MORE)) {
468: if (rp->r_flags & XFLG_ERRS) {
469: /* output error */
470: ds->ds_if.if_oerrors++;
471: if (dedebug)
472: printf("de%d: oerror, flags=%b tdrerr=%b (len=%d)\n",
473: unit, rp->r_flags, XFLG_BITS,
474: rp->r_tdrerr, XERR_BITS, rp->r_slen);
475: } else if (rp->r_flags & XFLG_ONE) {
476: /* one collision */
477: ds->ds_if.if_collisions++;
478: } else if (rp->r_flags & XFLG_MORE) {
479: /* more than one collision */
480: ds->ds_if.if_collisions += 2; /* guess */
481: } else if (rp->r_flags & XFLG_MTCH) {
482: /* received our own packet */
483: ds->ds_if.if_ipackets++;
484: deread(ds, &ifxp->ifrw,
485: rp->r_slen - sizeof (struct ether_header));
486: }
487: }
488: if (ifxp->ifw_xtofree) {
489: m_freem(ifxp->ifw_xtofree);
490: ifxp->ifw_xtofree = 0;
491: }
492: /* check if next transmit buffer also finished */
493: ds->ds_xindex++;
494: if (ds->ds_xindex == NXMT)
495: ds->ds_xindex = 0;
496: }
497: ds->ds_if.if_flags &= ~IFF_OACTIVE;
498: destart(&ds->ds_if);
499:
500: if (csr0 & PCSR0_RCBI) {
501: if (dedebug)
502: log(LOG_WARNING, "de%d: buffer unavailable\n", unit);
503: addr->pclow = PCSR0_INTE|CMD_PDMD;
504: }
505: }
506:
507: /*
508: * Ethernet interface receiver interface.
509: * If input error just drop packet.
510: * Otherwise purge input buffered data path and examine
511: * packet to determine type. If can't determine length
512: * from type, then have to drop packet. Othewise decapsulate
513: * packet based on type and pass to type specific higher-level
514: * input routine.
515: */
516: derecv(unit)
517: int unit;
518: {
519: register struct de_softc *ds = &de_softc[unit];
520: register struct de_ring *rp;
521: int len;
522:
523: rp = &ds->ds_rrent[ds->ds_rindex];
524: while ((rp->r_flags & RFLG_OWN) == 0) {
525: ds->ds_if.if_ipackets++;
526: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP)
527: UBAPURGE(ds->ds_deuba.iff_uba,
528: ds->ds_ifr[ds->ds_rindex].ifrw_bdp);
529: len = (rp->r_lenerr&RERR_MLEN) - sizeof (struct ether_header)
530: - 4; /* don't forget checksum! */
531: /* check for errors */
532: if ((rp->r_flags & (RFLG_ERRS|RFLG_FRAM|RFLG_OFLO|RFLG_CRC)) ||
533: (rp->r_flags&(RFLG_STP|RFLG_ENP)) != (RFLG_STP|RFLG_ENP) ||
534: (rp->r_lenerr & (RERR_BUFL|RERR_UBTO|RERR_NCHN)) ||
535: len < ETHERMIN || len > ETHERMTU) {
536: ds->ds_if.if_ierrors++;
537: if (dedebug)
538: printf("de%d: ierror, flags=%b lenerr=%b (len=%d)\n",
539: unit, rp->r_flags, RFLG_BITS, rp->r_lenerr,
540: RERR_BITS, len);
541: } else
542: deread(ds, &ds->ds_ifr[ds->ds_rindex], len);
543:
544: /* hang the receive buffer again */
545: rp->r_lenerr = 0;
546: rp->r_flags = RFLG_OWN;
547:
548: /* check next receive buffer */
549: ds->ds_rindex++;
550: if (ds->ds_rindex == NRCV)
551: ds->ds_rindex = 0;
552: rp = &ds->ds_rrent[ds->ds_rindex];
553: }
554: }
555:
556: /*
557: * Pass a packet to the higher levels.
558: * We deal with the trailer protocol here.
559: */
560: deread(ds, ifrw, len)
561: register struct de_softc *ds;
562: struct ifrw *ifrw;
563: int len;
564: {
565: struct ether_header *eh;
566: struct mbuf *m;
567: int off, resid;
568: int s;
569: register struct ifqueue *inq;
570:
571: /*
572: * Deal with trailer protocol: if type is trailer type
573: * get true type from first 16-bit word past data.
574: * Remember that type was trailer by setting off.
575: */
576: eh = (struct ether_header *)ifrw->ifrw_addr;
577: eh->ether_type = ntohs((u_short)eh->ether_type);
578: #define dedataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off))))
579: if (eh->ether_type >= ETHERTYPE_TRAIL &&
580: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
581: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512;
582: if (off >= ETHERMTU)
583: return; /* sanity */
584: eh->ether_type = ntohs(*dedataaddr(eh, off, u_short *));
585: resid = ntohs(*(dedataaddr(eh, off+2, u_short *)));
586: if (off + resid > len)
587: return; /* sanity */
588: len = off + resid;
589: } else
590: off = 0;
591: if (len == 0)
592: return;
593:
594: /*
595: * Pull packet off interface. Off is nonzero if packet
596: * has trailing header; if_ubaget will then force this header
597: * information to be at the front.
598: */
599: m = if_ubaget(&ds->ds_deuba, ifrw, len, off, &ds->ds_if);
600: if (m)
601: ether_input(&ds->ds_if, eh, m);
602: }
603: /*
604: * Process an ioctl request.
605: */
606: deioctl(ifp, cmd, data)
607: register struct ifnet *ifp;
608: int cmd;
609: caddr_t data;
610: {
611: register struct ifaddr *ifa = (struct ifaddr *)data;
612: register struct de_softc *ds = &de_softc[ifp->if_unit];
613: int s = splimp(), error = 0;
614:
615: switch (cmd) {
616:
617: case SIOCSIFADDR:
618: ifp->if_flags |= IFF_UP;
619: deinit(ifp->if_unit);
620:
621: switch (ifa->ifa_addr->sa_family) {
622: #ifdef INET
623: case AF_INET:
624: ((struct arpcom *)ifp)->ac_ipaddr =
625: IA_SIN(ifa)->sin_addr;
626: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
627: break;
628: #endif
629: #ifdef NS
630: case AF_NS:
631: {
632: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
633:
634: if (ns_nullhost(*ina))
635: ina->x_host = *(union ns_host *)(ds->ds_addr);
636: else
637: de_setaddr(ina->x_host.c_host,ifp->if_unit);
638: break;
639: }
640: #endif
641: }
642: break;
643:
644: case SIOCSIFFLAGS:
645: if ((ifp->if_flags & IFF_UP) == 0 &&
646: ds->ds_flags & DSF_RUNNING) {
647: ((struct dedevice *)
648: (deinfo[ifp->if_unit]->ui_addr))->pclow = 0;
649: DELAY(100);
650: ((struct dedevice *)
651: (deinfo[ifp->if_unit]->ui_addr))->pclow = PCSR0_RSET;
652: ds->ds_flags &= ~DSF_RUNNING;
653: ds->ds_if.if_flags &= ~IFF_OACTIVE;
654: } else if (ifp->if_flags & IFF_UP &&
655: (ds->ds_flags & DSF_RUNNING) == 0)
656: deinit(ifp->if_unit);
657: break;
658:
659: default:
660: error = EINVAL;
661: }
662: splx(s);
663: return (error);
664: }
665:
666: /*
667: * set ethernet address for unit
668: */
669: de_setaddr(physaddr, unit)
670: u_char *physaddr;
671: int unit;
672: {
673: register struct de_softc *ds = &de_softc[unit];
674: struct uba_device *ui = deinfo[unit];
675: register struct dedevice *addr= (struct dedevice *)ui->ui_addr;
676:
677: if (! (ds->ds_flags & DSF_RUNNING))
678: return;
679:
680: bcopy((caddr_t) physaddr, (caddr_t) &ds->ds_pcbb.pcbb2, 6);
681: ds->ds_pcbb.pcbb0 = FC_WTPHYAD;
682: addr->pclow = PCSR0_INTE|CMD_GETCMD;
683: if (dewait(ui, "address change") == 0) {
684: ds->ds_flags |= DSF_SETADDR;
685: bcopy((caddr_t) physaddr, (caddr_t) ds->ds_addr, 6);
686: }
687: }
688:
689: /*
690: * Await completion of the named function
691: * and check for errors.
692: */
693: dewait(ui, fn)
694: register struct uba_device *ui;
695: char *fn;
696: {
697: register struct dedevice *addr = (struct dedevice *)ui->ui_addr;
698: register csr0;
699:
700: while ((addr->pcsr0 & PCSR0_INTR) == 0)
701: ;
702: csr0 = addr->pcsr0;
703: addr->pchigh = csr0 >> 8;
704: if (csr0 & PCSR0_PCEI)
705: printf("de%d: %s failed, csr0=%b csr1=%b\n",
706: ui->ui_unit, fn, csr0, PCSR0_BITS,
707: addr->pcsr1, PCSR1_BITS);
708: return (csr0 & PCSR0_PCEI);
709: }
710: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.