![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ex.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_ex.c CVS log | Up to [Net/2] / Net2 / arch / vax / if |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Excelan Inc.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)if_ex.c 7.9 (Berkeley) 12/16/90
37: */
38:
39: #include "ex.h"
40: #if NEX > 0
41:
42: /*
43: * Excelan EXOS 204 Interface
44: *
45: * George Powers
46: * Excelan Inc.
47: */
48:
49: #include "sys/param.h"
50: #include "sys/systm.h"
51: #include "sys/mbuf.h"
52: #include "sys/buf.h"
53: #include "sys/protosw.h"
54: #include "sys/socket.h"
55: #include "sys/vmmac.h"
56: #include "sys/ioctl.h"
57: #include "sys/syslog.h"
58: #include "sys/errno.h"
59:
60: #include "net/if.h"
61: #include "net/netisr.h"
62: #include "net/route.h"
63:
64: #ifdef INET
65: #include "netinet/in.h"
66: #include "netinet/in_systm.h"
67: #include "netinet/in_var.h"
68: #include "netinet/ip.h"
69: #include "netinet/if_ether.h"
70: #endif
71:
72: #ifdef NS
73: #include "netns/ns.h"
74: #include "netns/ns_if.h"
75: #endif
76:
77: #ifdef ISO
78: #include "netiso/iso.h"
79: #include "netiso/iso_var.h"
80: extern char all_es_snpa[], all_is_snpa[];
81: #endif
82:
83: #include "../include/pte.h"
84: #include "../include/cpu.h"
85: #include "../include/mtpr.h"
86: #include "if_exreg.h"
87: #include "if_uba.h"
88: #include "../uba/ubareg.h"
89: #include "../uba/ubavar.h"
90:
91: /* #define DEBUG /* check for "impossible" events */
92:
93: #define NH2X 4 /* a sufficient number is critical */
94: #define NX2H 4 /* this is pretty arbitrary */
95: #define EXWATCHINTVL 10 /* call exwatch() every 10 seconds */
96:
97: int exprobe(), exattach(), excdint();
98: struct uba_device *exinfo[NEX];
99: u_short exstd[] = { 0 };
100: struct uba_driver exdriver =
101: { exprobe, 0, exattach, 0, exstd, "ex", exinfo };
102: int exinit(),exstart(),ether_output(),exioctl(),exreset(),exwatch();
103: struct ex_msg *exgetcbuf();
104:
105: /*
106: * Ethernet software status per interface.
107: *
108: * Each interface is referenced by a network interface structure,
109: * xs_if, which the routing code uses to locate the interface.
110: * This structure contains the output queue for the interface, its address, ...
111: * We also have, for each interface, a UBA interface structure, which
112: * contains information about the UNIBUS resources held by the interface:
113: * map registers, buffered data paths, etc. Information is cached in this
114: * structure for use by the if_uba.c routines in running the interface
115: * efficiently.
116: */
117: struct ex_softc {
118: struct arpcom xs_ac; /* Ethernet common part */
119: #define xs_if xs_ac.ac_if /* network-visible interface */
120: #define xs_addr xs_ac.ac_enaddr /* hardware Ethernet address */
121: #ifdef DEBUG
122: int xs_wait;
123: #endif
124: struct ifuba xs_ifuba; /* UNIBUS resources */
125: int xs_flags; /* private flags */
126: #define EX_XPENDING 1 /* xmit rqst pending on EXOS */
127: #define EX_STATPENDING (1<<1) /* stats rqst pending on EXOS */
128: #define EX_RUNNING (1<<2) /* board is running */
129: #define EX_SETADDR (1<<3) /* physaddr has been changed */
130: struct ex_msg *xs_h2xnext; /* host pointer to request queue */
131: struct ex_msg *xs_x2hnext; /* host pointer to reply queue */
132: int xs_ubaddr; /* map info for structs below */
133: #define UNIADDR(x) ((u_long)(x)&0x3FFFF)
134: #define P_UNIADDR(x) ((u_long)(x)&0x3FFF0)
135: /* the following structures are always mapped in */
136: u_short xs_h2xhdr; /* EXOS's request queue header */
137: u_short xs_x2hhdr; /* EXOS's reply queue header */
138: struct ex_msg xs_h2xent[NH2X]; /* request msg buffers */
139: struct ex_msg xs_x2hent[NX2H]; /* reply msg buffers */
140: struct confmsg xs_cm; /* configuration message */
141: struct stat_array xs_xsa; /* EXOS writes stats here */
142: /* end mapped area */
143: #define INCORE_BASE(p) ((caddr_t)((u_long)(&(p)->xs_h2xhdr) & 0xFFFFFFF0))
144: #define RVAL_OFF(unit, n) \
145: ((caddr_t)(&(ex_softc[unit].n)) - INCORE_BASE(&ex_softc[unit]))
146: #define LVAL_OFF(unit, n) \
147: ((caddr_t)(ex_softc[unit].n) - INCORE_BASE(&ex_softc[unit]))
148: #define H2XHDR_OFFSET(unit) RVAL_OFF(unit, xs_h2xhdr)
149: #define X2HHDR_OFFSET(unit) RVAL_OFF(unit, xs_x2hhdr)
150: #define H2XENT_OFFSET(unit) LVAL_OFF(unit, xs_h2xent)
151: #define X2HENT_OFFSET(unit) LVAL_OFF(unit, xs_x2hent)
152: #define CM_OFFSET(unit) RVAL_OFF(unit, xs_cm)
153: #define SA_OFFSET(unit) RVAL_OFF(unit, xs_xsa)
154: #define INCORE_SIZE(unit) RVAL_OFF(unit, xs_end)
155: int xs_end; /* place holder */
156: } ex_softc[NEX];
157:
158: /*
159: * The following structure is a kludge to store a cvec value
160: * between the time exprobe is called, and exconfig.
161: */
162: struct ex_cvecs {
163: struct exdevice *xc_csraddr;
164: int xc_cvec;
165: }ex_cvecs[NEX];
166:
167: int ex_ncall = 0; /* counts calls to exprobe */
168:
169: exprobe(reg)
170: caddr_t reg;
171: {
172: register int br, cvec; /* r11, r10 value-result */
173: register struct exdevice *addr = (struct exdevice *)reg;
174: register i;
175:
176: /*
177: * We program the EXOS interrupt vector, like dmf device.
178: */
179: br = 0x15;
180: cvec = (uba_hd[numuba].uh_lastiv -= 4);
181: ex_cvecs[ex_ncall].xc_csraddr = addr;
182: ex_cvecs[ex_ncall].xc_cvec = cvec;
183: /*
184: * Reset EXOS and run self-test (guaranteed to
185: * complete within 2 seconds).
186: */
187: addr->xd_porta = EX_RESET;
188: i = 2000;
189: while (((addr->xd_portb & EX_TESTOK) == 0) && --i)
190: DELAY(1000);
191: if ((addr->xd_portb & EX_TESTOK) == 0) {
192: printf("ex: self-test failed\n");
193: return 0;
194: }
195: #ifdef lint
196: br = br;
197: excdint(0);
198: #endif
199: ex_ncall++;
200: return (sizeof(struct exdevice));
201: }
202:
203: /*
204: * Interface exists: make available by filling in network interface
205: * record. System will initialize the interface when it is ready
206: * to accept packets. Board is temporarily configured and issues
207: * a NET_ADDRS command, only to get the Ethernet address.
208: */
209: exattach(ui)
210: register struct uba_device *ui;
211: {
212: register struct ex_softc *xs = &ex_softc[ui->ui_unit];
213: register struct ifnet *ifp = &xs->xs_if;
214: register struct exdevice *addr = (struct exdevice *)ui->ui_addr;
215: register struct ex_msg *bp;
216: int unit = ui->ui_unit;
217: ifp->if_unit = ui->ui_unit;
218: ifp->if_name = "ex";
219: ifp->if_mtu = ETHERMTU;
220:
221: /*
222: * Temporarily map queues in order to configure EXOS
223: */
224: xs->xs_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(xs),
225: INCORE_SIZE(unit), 0);
226: exconfig(ui, 0); /* without interrupts */
227: if (xs->xs_cm.cm_cc) goto badconf;
228:
229: bp = exgetcbuf(xs);
230: bp->mb_rqst = LLNET_ADDRS;
231: bp->mb_na.na_mask = READ_OBJ;
232: bp->mb_na.na_slot = PHYSSLOT;
233: bp->mb_status |= MH_EXOS;
234: addr->xd_portb = EX_NTRUPT;
235: bp = xs->xs_x2hnext;
236: while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */
237: ;
238: printf("ex%d: HW %c.%c, NX %c.%c, hardware address %s\n",
239: ui->ui_unit, xs->xs_cm.cm_vc[2], xs->xs_cm.cm_vc[3],
240: xs->xs_cm.cm_vc[0], xs->xs_cm.cm_vc[1],
241: ether_sprintf(bp->mb_na.na_addrs));
242: bcopy((caddr_t)bp->mb_na.na_addrs, (caddr_t)xs->xs_addr,
243: sizeof (xs->xs_addr));
244:
245: ifp->if_init = exinit;
246: ifp->if_output = ether_output;
247: ifp->if_start = exstart;
248: ifp->if_ioctl = exioctl;
249: ifp->if_reset = exreset;
250: ifp->if_flags = IFF_BROADCAST;
251: xs->xs_ifuba.ifu_flags = UBA_CANTWAIT;
252: if_attach(ifp);
253: badconf:
254: ubarelse(ui->ui_ubanum, &xs->xs_ubaddr);
255: }
256:
257: /*
258: * Reset of interface after UNIBUS reset.
259: * If interface is on specified uba, reset its state.
260: */
261: exreset(unit, uban)
262: int unit, uban;
263: {
264: register struct uba_device *ui;
265:
266: if (unit >= NEX || (ui = exinfo[unit]) == 0 || ui->ui_alive == 0 ||
267: ui->ui_ubanum != uban)
268: return;
269: printf(" ex%d", unit);
270: ex_softc[unit].xs_if.if_flags &= ~IFF_RUNNING;
271: ex_softc[unit].xs_flags &= ~EX_RUNNING;
272: exinit(unit);
273: }
274:
275: /*
276: * Initialization of interface; clear recorded pending
277: * operations, and reinitialize UNIBUS usage.
278: * Called at boot time (with interrupts disabled?),
279: * and at ifconfig time via exioctl, with interrupts disabled.
280: */
281: exinit(unit)
282: int unit;
283: {
284: register struct ex_softc *xs = &ex_softc[unit];
285: register struct uba_device *ui = exinfo[unit];
286: register struct exdevice *addr = (struct exdevice *)ui->ui_addr;
287: register struct ifnet *ifp = &xs->xs_if;
288: register struct ex_msg *bp;
289: int s;
290:
291: /* not yet, if address still unknown */
292: if (ifp->if_addrlist == (struct ifaddr *)0)
293: return;
294: if (xs->xs_flags & EX_RUNNING)
295: return;
296:
297: if ((ifp->if_flags & IFF_RUNNING) == 0) {
298: if (if_ubainit(&xs->xs_ifuba, ui->ui_ubanum,
299: sizeof (struct ether_header),
300: (int)btoc(EXMAXRBUF-sizeof(struct ether_header))) == 0) {
301: printf("ex%d: can't initialize\n", unit);
302: xs->xs_if.if_flags &= ~IFF_UP;
303: return;
304: }
305: xs->xs_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(xs),
306: INCORE_SIZE(unit), 0);
307: }
308: exconfig(ui, 4); /* with vectored interrupts*/
309: /*
310: * Put EXOS on the Ethernet, using NET_MODE command
311: */
312: bp = exgetcbuf(xs);
313: bp->mb_rqst = LLNET_MODE;
314: bp->mb_nm.nm_mask = WRITE_OBJ;
315: bp->mb_nm.nm_optn = 0;
316: bp->mb_nm.nm_mode = MODE_PERF;
317: bp->mb_status |= MH_EXOS;
318: addr->xd_portb = EX_NTRUPT;
319: bp = xs->xs_x2hnext;
320: while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */
321: ;
322: bp->mb_length = MBDATALEN;
323: bp->mb_status |= MH_EXOS; /* free up buffer */
324: addr->xd_portb = EX_NTRUPT; /* tell EXOS about it */
325: xs->xs_x2hnext = xs->xs_x2hnext->mb_next;
326:
327: ifp->if_watchdog = exwatch;
328: ifp->if_timer = EXWATCHINTVL;
329: s = splimp(); /* are interrupts always disabled here, anyway? */
330: exhangrcv(unit); /* hang receive request */
331: xs->xs_if.if_flags |= IFF_RUNNING;
332: xs->xs_flags |= EX_RUNNING;
333: if (xs->xs_flags & EX_SETADDR)
334: ex_setaddr((u_char *)0, unit);
335: #ifdef ISO
336: ex_setmulti(all_es_snpa, unit, 1);
337: ex_setmulti(all_is_snpa, unit, 2);
338: #endif
339: (void) exstart(&xs->xs_if); /* start transmits */
340: splx(s);
341: }
342:
343: /*
344: * Reset, test, and configure EXOS. This routine assumes
345: * that message queues, etc. have already been mapped into
346: * the UBA. It is called by exinit, and should also be
347: * callable by exattach.
348: */
349: exconfig(ui, itype)
350: struct uba_device *ui;
351: int itype;
352: {
353: register int unit = ui->ui_unit;
354: register struct ex_softc *xs = &ex_softc[unit];
355: register struct exdevice *addr = (struct exdevice *) ui->ui_addr;
356: register struct confmsg *cm = &xs->xs_cm;
357: register struct ex_msg *bp;
358: int i;
359: u_long shiftreg;
360:
361: xs->xs_flags = 0;
362: /*
363: * Reset EXOS, wait for self-test to complete
364: */
365: addr->xd_porta = EX_RESET;
366: while ((addr->xd_portb & EX_TESTOK) == 0)
367: ;
368: /*
369: * Set up configuration message.
370: */
371: cm->cm_1rsrv = 1;
372: cm->cm_cc = 0xFF;
373: cm->cm_opmode = 0; /* link-level controller mode */
374: cm->cm_dfo = 0x0101; /* enable host data order conversion */
375: cm->cm_dcn1 = 1;
376: cm->cm_2rsrv[0] = cm->cm_2rsrv[1] = 0;
377: cm->cm_ham = 3; /* absolute address mode */
378: cm->cm_3rsrv = 0;
379: cm->cm_mapsiz = 0;
380: cm->cm_byteptrn[0] = 0x01; /* EXOS deduces data order of host */
381: cm->cm_byteptrn[1] = 0x03; /* by looking at this pattern */
382: cm->cm_byteptrn[2] = 0x07;
383: cm->cm_byteptrn[3] = 0x0F;
384: cm->cm_wordptrn[0] = 0x0103;
385: cm->cm_wordptrn[1] = 0x070F;
386: cm->cm_lwordptrn = 0x0103070F;
387: for (i=0; i<20; i++) cm->cm_rsrvd[i] = 0;
388: cm->cm_mba = 0xFFFFFFFF;
389: cm->cm_nproc = 0xFF;
390: cm->cm_nmbox = 0xFF;
391: cm->cm_nmcast = 0xFF;
392: cm->cm_nhost = 1;
393: cm->cm_h2xba = P_UNIADDR(xs->xs_ubaddr);
394: cm->cm_h2xhdr = H2XHDR_OFFSET(unit);
395: cm->cm_h2xtyp = 0; /* should never wait for rqst buffer */
396: cm->cm_x2hba = cm->cm_h2xba;
397: cm->cm_x2hhdr = X2HHDR_OFFSET(unit);
398: cm->cm_x2htyp = itype; /* 0 for none, 4 for vectored */
399: for (i=0; (addr != ex_cvecs[i].xc_csraddr); i++)
400: #ifdef DEBUG
401: if (i >= NEX)
402: panic("ex: matching csr address not found");
403: #endif
404: ;
405: cm->cm_x2haddr = ex_cvecs[i].xc_cvec; /* stashed here by exprobe */
406: /*
407: * Set up message queues and headers.
408: * First the request queue.
409: */
410: for (bp = &xs->xs_h2xent[0]; bp < &xs->xs_h2xent[NH2X]; bp++) {
411: bp->mb_link = (u_short)((char *)(bp+1)-INCORE_BASE(xs));
412: bp->mb_rsrv = 0;
413: bp->mb_length = MBDATALEN;
414: bp->mb_status = MH_HOST;
415: bp->mb_next = bp+1;
416: }
417: xs->xs_h2xhdr =
418: xs->xs_h2xent[NH2X-1].mb_link = (u_short)H2XENT_OFFSET(unit);
419: xs->xs_h2xnext = xs->xs_h2xent[NH2X-1].mb_next = xs->xs_h2xent;
420:
421: /* Now the reply queue. */
422: for (bp = &xs->xs_x2hent[0]; bp < &xs->xs_x2hent[NX2H]; bp++) {
423: bp->mb_link = (u_short)((char *)(bp+1)-INCORE_BASE(xs));
424: bp->mb_rsrv = 0;
425: bp->mb_length = MBDATALEN;
426: bp->mb_status = MH_EXOS;
427: bp->mb_next = bp+1;
428: }
429: xs->xs_x2hhdr =
430: xs->xs_x2hent[NX2H-1].mb_link = (u_short)X2HENT_OFFSET(unit);
431: xs->xs_x2hnext = xs->xs_x2hent[NX2H-1].mb_next = xs->xs_x2hent;
432:
433: /*
434: * Write config msg address to EXOS and wait for
435: * configuration to complete (guaranteed response
436: * within 2 seconds).
437: */
438: shiftreg = (u_long)0x0000FFFF;
439: for (i = 0; i < 8; i++) {
440: if (i == 4)
441: shiftreg = P_UNIADDR(xs->xs_ubaddr) + CM_OFFSET(unit);
442: while (addr->xd_portb & EX_UNREADY)
443: ;
444: addr->xd_portb = (u_char)(shiftreg & 0xFF);
445: shiftreg >>= 8;
446: }
447: for (i = 1000000; (cm->cm_cc == 0xFF) && i; --i);
448: if (cm->cm_cc)
449: printf("ex%d: configuration failed; cc = %x\n",
450: unit, cm->cm_cc);
451: }
452:
453: /*
454: * Start or re-start output on interface.
455: * Get another datagram to send off of the interface queue,
456: * and map it to the interface before starting the output.
457: * This routine is called by exinit(), ether_output(), and excdint().
458: * In all cases, interrupts by EXOS are disabled.
459: */
460: exstart(ifp)
461: struct ifnet *ifp;
462: {
463: int unit = ifp->if_unit;
464: struct uba_device *ui = exinfo[unit];
465: register struct ex_softc *xs = &ex_softc[unit];
466: register struct exdevice *addr = (struct exdevice *)ui->ui_addr;
467: register struct ex_msg *bp;
468: struct mbuf *m;
469: int len;
470:
471: #ifdef DEBUG
472: if (xs->xs_if.if_flags & IFF_OACTIVE)
473: panic("exstart(): xmit still pending");
474: #endif
475: IF_DEQUEUE(&xs->xs_if.if_snd, m);
476: if (m == 0)
477: return (0);
478: len = if_wubaput(&xs->xs_ifuba, m);
479: if (len - sizeof(struct ether_header) < ETHERMIN)
480: len = ETHERMIN + sizeof(struct ether_header);
481: /*
482: * Place a transmit request.
483: */
484: bp = exgetcbuf(xs);
485: bp->mb_rqst = LLRTRANSMIT;
486: bp->mb_et.et_nblock = 1;
487: bp->mb_et.et_blks[0].bb_len = (u_short)len;
488: *(u_long *)bp->mb_et.et_blks[0].bb_addr =
489: UNIADDR(xs->xs_ifuba.ifu_w.ifrw_info);
490: xs->xs_if.if_flags |= IFF_OACTIVE;
491: bp->mb_status |= MH_EXOS;
492: addr->xd_portb = EX_NTRUPT;
493: return (0);
494: }
495:
496: /*
497: * Command done interrupt.
498: */
499: excdint(unit)
500: int unit;
501: {
502: register struct ex_softc *xs = &ex_softc[unit];
503: register struct ex_msg *bp = xs->xs_x2hnext;
504: struct uba_device *ui = exinfo[unit];
505: struct exdevice *addr = (struct exdevice *)ui->ui_addr;
506:
507: while ((bp->mb_status & MH_OWNER) == MH_HOST) {
508: switch (bp->mb_rqst) {
509: case LLRECEIVE:
510: exrecv(unit, bp);
511: exhangrcv(unit);
512: break;
513: case LLRTRANSMIT:
514: #ifdef DEBUG
515: if ((xs->xs_if.if_flags & IFF_OACTIVE) == 0)
516: panic("exxmit: no xmit pending");
517: #endif
518: xs->xs_if.if_flags &= ~IFF_OACTIVE;
519: xs->xs_if.if_opackets++;
520: if (bp->mb_rply == LL_OK) {
521: ;
522: } else if (bp->mb_rply & LLXM_1RTRY) {
523: xs->xs_if.if_collisions++;
524: } else if (bp->mb_rply & LLXM_RTRYS) {
525: xs->xs_if.if_collisions += 2; /* guess */
526: } else if (bp->mb_rply & LLXM_ERROR) {
527: xs->xs_if.if_oerrors++;
528: log(LOG_ERR, "ex%d: transmit error=%b\n",
529: unit, bp->mb_rply, XMIT_BITS);
530: }
531: if (xs->xs_ifuba.ifu_xtofree) {
532: m_freem(xs->xs_ifuba.ifu_xtofree);
533: xs->xs_ifuba.ifu_xtofree = 0;
534: }
535: (void) exstart(&xs->xs_if);
536: break;
537: case LLNET_STSTCS:
538: xs->xs_if.if_ierrors = xs->xs_xsa.sa_crc;
539: xs->xs_flags &= ~EX_STATPENDING;
540: break;
541: case LLNET_ADDRS:
542: case LLNET_RECV:
543: break;
544: #ifdef DEBUG
545: default:
546: panic("ex%d: unknown reply");
547: #endif
548: } /* end of switch */
549: bp->mb_length = MBDATALEN;
550: bp->mb_status |= MH_EXOS; /* free up buffer */
551: addr->xd_portb = EX_NTRUPT; /* tell EXOS about it */
552: bp = xs->xs_x2hnext = xs->xs_x2hnext->mb_next;
553: }
554: }
555:
556: /*
557: * Get a request buffer, fill in standard values, advance pointer.
558: */
559: struct ex_msg *
560: exgetcbuf(xs)
561: struct ex_softc *xs;
562: {
563: register struct ex_msg *bp = xs->xs_h2xnext;
564:
565: #ifdef DEBUG
566: if ((bp->mb_status & MH_OWNER) == MH_EXOS)
567: panic("exgetcbuf(): EXOS owns message buffer");
568: #endif
569: bp->mb_1rsrv = 0;
570: bp->mb_length = MBDATALEN;
571: xs->xs_h2xnext = xs->xs_h2xnext->mb_next;
572: return bp;
573: }
574:
575: /*
576: * Process Ethernet receive completion:
577: * If input error just drop packet.
578: * Otherwise purge input buffered data path and examine
579: * packet to determine type. If can't determine length
580: * from type, then have to drop packet. Otherwise decapsulate
581: * packet based on type and pass to type-specific higher-level
582: * input routine.
583: */
584: exrecv(unit, bp)
585: int unit;
586: register struct ex_msg *bp;
587: {
588: register struct ex_softc *xs = &ex_softc[unit];
589: register struct ether_header *eh;
590: struct mbuf *m;
591: register int len, off, resid;
592: register struct ifqueue *inq;
593: int s;
594:
595: xs->xs_if.if_ipackets++;
596: len = bp->mb_er.er_blks[0].bb_len - sizeof(struct ether_header) - 4;
597: if (bp->mb_rply != LL_OK) {
598: xs->xs_if.if_ierrors++;
599: log(LOG_ERR, "ex%d: receive error=%b\n",
600: unit, bp->mb_rply, RECV_BITS);
601: return;
602: }
603: eh = (struct ether_header *)(xs->xs_ifuba.ifu_r.ifrw_addr);
604:
605: /*
606: * Deal with trailer protocol: if type is trailer
607: * get true type from first 16-bit word past data.
608: * Remember that type was trailer by setting off.
609: */
610: eh->ether_type = ntohs((u_short)eh->ether_type);
611: #define exdataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off))))
612: if (eh->ether_type >= ETHERTYPE_TRAIL &&
613: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
614: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512;
615: if (off >= ETHERMTU)
616: return; /* sanity */
617: eh->ether_type = ntohs(*exdataaddr(eh, off, u_short *));
618: resid = ntohs(*(exdataaddr(eh, off+2, u_short *)));
619: if (off + resid > len)
620: return; /* sanity */
621: len = off + resid;
622: } else
623: off = 0;
624: if (len == 0)
625: return;
626:
627: /*
628: * Pull packet off interface. Off is nonzero if packet
629: * has trailing header; if_rubaget will then force this header
630: * information to be at the front, but we still have to drop
631: * the type and length which are at the front of any trailer data.
632: */
633: m = if_rubaget(&xs->xs_ifuba, len, off, &xs->xs_if);
634: if (m == 0)
635: return;
636: ether_input(&xs->xs_if, eh, m);
637: }
638:
639: /*
640: * Send receive request to EXOS.
641: * This routine is called by exinit and excdint,
642: * with interrupts disabled in both cases.
643: */
644: exhangrcv(unit)
645: int unit;
646: {
647: register struct ex_softc *xs = &ex_softc[unit];
648: register struct ex_msg *bp = exgetcbuf(xs);
649: struct exdevice *addr = (struct exdevice *)exinfo[unit]->ui_addr;
650:
651: bp->mb_rqst = LLRECEIVE;
652: bp->mb_er.er_nblock = 1;
653: bp->mb_er.er_blks[0].bb_len = EXMAXRBUF;
654: *(u_long *)bp->mb_er.er_blks[0].bb_addr =
655: UNIADDR(xs->xs_ifuba.ifu_r.ifrw_info);
656: bp->mb_status |= MH_EXOS;
657: addr->xd_portb = EX_NTRUPT;
658: }
659:
660: /*
661: * Watchdog routine - place stats request to EXOS
662: * (This could be dispensed with, if you don't care
663: * about the if_ierrors count, or are willing to receive
664: * bad packets in order to derive it.)
665: */
666: exwatch(unit)
667: int unit;
668: {
669: struct uba_device *ui = exinfo[unit];
670: struct exdevice *addr = (struct exdevice *)ui->ui_addr;
671: register struct ex_softc *xs = &ex_softc[unit];
672: register struct ex_msg *bp;
673: int s = splimp();
674:
675: if (xs->xs_flags & EX_STATPENDING) goto exspnd;
676: bp = exgetcbuf(xs);
677: xs->xs_flags |= EX_STATPENDING;
678: bp->mb_rqst = LLNET_STSTCS;
679: bp->mb_ns.ns_mask = READ_OBJ;
680: bp->mb_ns.ns_rsrv = 0;
681: bp->mb_ns.ns_nobj = 8; /* read all 8 stats objects */
682: bp->mb_ns.ns_xobj = 0; /* starting with the 1st one */
683: bp->mb_ns.ns_bufp = P_UNIADDR(xs->xs_ubaddr) + SA_OFFSET(unit);
684: bp->mb_status |= MH_EXOS;
685: addr->xd_portb = EX_NTRUPT;
686: exspnd:
687: splx(s);
688: xs->xs_if.if_timer = EXWATCHINTVL;
689: }
690:
691: /*
692: * Process an ioctl request.
693: */
694: exioctl(ifp, cmd, data)
695: register struct ifnet *ifp;
696: int cmd;
697: caddr_t data;
698: {
699: register struct ifaddr *ifa = (struct ifaddr *)data;
700: register struct ex_softc *xs = &ex_softc[ifp->if_unit];
701: int s = splimp(), error = 0;
702:
703: switch (cmd) {
704:
705: case SIOCSIFADDR:
706: ifp->if_flags |= IFF_UP;
707: exinit(ifp->if_unit);
708:
709: switch (ifa->ifa_addr->sa_family) {
710: #ifdef INET
711: case AF_INET:
712: ((struct arpcom *)ifp)->ac_ipaddr =
713: IA_SIN(ifa)->sin_addr;
714: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
715: break;
716: #endif
717: #ifdef NS
718: case AF_NS:
719: {
720: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
721:
722: if (ns_nullhost(*ina))
723: ina->x_host = *(union ns_host *)(xs->xs_addr);
724: else
725: ex_setaddr(ina->x_host.c_host,ifp->if_unit);
726: break;
727: }
728: #endif
729: }
730: break;
731:
732: case SIOCSIFFLAGS:
733: if ((ifp->if_flags & IFF_UP) == 0 &&
734: xs->xs_flags & EX_RUNNING) {
735: ((struct exdevice *)
736: (exinfo[ifp->if_unit]->ui_addr))->xd_porta = EX_RESET;
737: xs->xs_flags &= ~EX_RUNNING;
738: } else if (ifp->if_flags & IFF_UP &&
739: (xs->xs_flags & EX_RUNNING) == 0)
740: exinit(ifp->if_unit);
741: break;
742:
743: default:
744: error = EINVAL;
745: }
746: splx(s);
747: return (error);
748: }
749:
750: /*
751: * set ethernet address for unit
752: */
753: ex_setaddr(physaddr, unit)
754: u_char *physaddr;
755: int unit;
756: {
757: register struct ex_softc *xs = &ex_softc[unit];
758:
759: if (physaddr) {
760: xs->xs_flags |= EX_SETADDR;
761: bcopy((caddr_t)physaddr, (caddr_t)xs->xs_addr, 6);
762: }
763: ex_setmulti((u_char *)xs->xs_addr, unit, PHYSSLOT);
764: }
765: /*
766: * enable multicast reception on a particular address.
767: */
768: ex_setmulti(linkaddr, unit, slot)
769: u_char *linkaddr;
770: int unit;
771: {
772: register struct ex_softc *xs = &ex_softc[unit];
773: struct uba_device *ui = exinfo[unit];
774: register struct exdevice *addr= (struct exdevice *)ui->ui_addr;
775: register struct ex_msg *bp;
776:
777: if (! (xs->xs_flags & EX_RUNNING))
778: return;
779: bp = exgetcbuf(xs);
780: bp->mb_rqst = LLNET_ADDRS;
781: bp->mb_na.na_mask = READ_OBJ|WRITE_OBJ;
782: bp->mb_na.na_slot = slot;
783: bcopy((caddr_t)linkaddr, (caddr_t)bp->mb_na.na_addrs, 6);
784: bp->mb_status |= MH_EXOS;
785: addr->xd_portb = EX_NTRUPT;
786: bp = xs->xs_x2hnext;
787: while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */
788: ;
789: #ifdef DEBUG
790: log(LOG_DEBUG, "ex%d: %s %s (slot %d)\n", unit,
791: (slot == PHYSSLOT ? "reset addr" : "add multicast"
792: ether_sprintf(bp->mb_na.na_addrs), slot);
793: #endif
794: /*
795: * Now, re-enable reception on slot.
796: */
797: bp = exgetcbuf(xs);
798: bp->mb_rqst = LLNET_RECV;
799: bp->mb_nr.nr_mask = ENABLE_RCV|READ_OBJ|WRITE_OBJ;
800: bp->mb_nr.nr_slot = slot;
801: bp->mb_status |= MH_EXOS;
802: addr->xd_portb = EX_NTRUPT;
803: bp = xs->xs_x2hnext;
804: while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */
805: ;
806: }
807: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.