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