![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_il.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_il.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_il.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "il.h"
10: #if NIL > 0
11:
12: /*
13: * Interlan Ethernet Communications Controller interface
14: */
15: #include "../machine/pte.h"
16:
17: #include "param.h"
18: #include "systm.h"
19: #include "mbuf.h"
20: #include "buf.h"
21: #include "protosw.h"
22: #include "socket.h"
23: #include "vmmac.h"
24: #include "ioctl.h"
25: #include "errno.h"
26:
27: #include "../net/if.h"
28: #include "../net/netisr.h"
29: #include "../net/route.h"
30:
31: #ifdef INET
32: #include "../netinet/in.h"
33: #include "../netinet/in_systm.h"
34: #include "../netinet/in_var.h"
35: #include "../netinet/ip.h"
36: #include "../netinet/if_ether.h"
37: #endif
38:
39: #ifdef NS
40: #include "../netns/ns.h"
41: #include "../netns/ns_if.h"
42: #endif
43:
44: #include "../vax/cpu.h"
45: #include "../vax/mtpr.h"
46: #include "if_il.h"
47: #include "if_ilreg.h"
48: #include "if_uba.h"
49: #include "../vaxuba/ubareg.h"
50: #include "../vaxuba/ubavar.h"
51:
52: int ilprobe(), ilattach(), ilrint(), ilcint();
53: struct uba_device *ilinfo[NIL];
54: u_short ilstd[] = { 0 };
55: struct uba_driver ildriver =
56: { ilprobe, 0, ilattach, 0, ilstd, "il", ilinfo };
57: #define ILUNIT(x) minor(x)
58: int ilinit(),iloutput(),ilioctl(),ilreset(),ilwatch();
59: int ildebug = 0;
60:
61: /*
62: * Ethernet software status per interface.
63: *
64: * Each interface is referenced by a network interface structure,
65: * is_if, which the routing code uses to locate the interface.
66: * This structure contains the output queue for the interface, its address, ...
67: * We also have, for each interface, a UBA interface structure, which
68: * contains information about the UNIBUS resources held by the interface:
69: * map registers, buffered data paths, etc. Information is cached in this
70: * structure for use by the if_uba.c routines in running the interface
71: * efficiently.
72: */
73: struct il_softc {
74: struct arpcom is_ac; /* Ethernet common part */
75: #define is_if is_ac.ac_if /* network-visible interface */
76: #define is_addr is_ac.ac_enaddr /* hardware Ethernet address */
77: struct ifuba is_ifuba; /* UNIBUS resources */
78: int is_flags;
79: #define ILF_OACTIVE 0x1 /* output is active */
80: #define ILF_RCVPENDING 0x2 /* start rcv in ilcint */
81: #define ILF_STATPENDING 0x4 /* stat cmd pending */
82: #define ILF_RUNNING 0x8 /* board is running */
83: #define ILF_SETADDR 0x10 /* physical address is changed */
84: short is_lastcmd; /* can't read csr, so must save it */
85: short is_scaninterval; /* interval of stat collection */
86: #define ILWATCHINTERVAL 60 /* once every 60 seconds */
87: struct il_stats is_stats; /* holds on-board statistics */
88: struct il_stats is_sum; /* summation over time */
89: int is_ubaddr; /* mapping registers of is_stats */
90: } il_softc[NIL];
91:
92: ilprobe(reg)
93: caddr_t reg;
94: {
95: register int br, cvec; /* r11, r10 value-result */
96: register struct ildevice *addr = (struct ildevice *)reg;
97: register i;
98:
99: #ifdef lint
100: br = 0; cvec = br; br = cvec;
101: i = 0; ilrint(i); ilcint(i); ilwatch(i);
102: #endif
103:
104: addr->il_csr = ILC_OFFLINE|IL_CIE;
105: DELAY(100000);
106: i = addr->il_csr; /* clear CDONE */
107: if (cvec > 0 && cvec != 0x200)
108: cvec -= 4;
109: return (1);
110: }
111:
112: /*
113: * Interface exists: make available by filling in network interface
114: * record. System will initialize the interface when it is ready
115: * to accept packets. A STATUS command is done to get the ethernet
116: * address and other interesting data.
117: */
118: ilattach(ui)
119: struct uba_device *ui;
120: {
121: register struct il_softc *is = &il_softc[ui->ui_unit];
122: register struct ifnet *ifp = &is->is_if;
123: register struct ildevice *addr = (struct ildevice *)ui->ui_addr;
124:
125: ifp->if_unit = ui->ui_unit;
126: ifp->if_name = "il";
127: ifp->if_mtu = ETHERMTU;
128: ifp->if_flags = IFF_BROADCAST;
129:
130: /*
131: * Reset the board and map the statistics
132: * buffer onto the Unibus.
133: */
134: addr->il_csr = ILC_RESET;
135: (void)ilwait(ui, "reset");
136:
137: is->is_ubaddr = uballoc(ui->ui_ubanum, (caddr_t)&is->is_stats,
138: sizeof (struct il_stats), 0);
139: addr->il_bar = is->is_ubaddr & 0xffff;
140: addr->il_bcr = sizeof (struct il_stats);
141: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT;
142: (void)ilwait(ui, "status");
143: ubarelse(ui->ui_ubanum, &is->is_ubaddr);
144: if (ildebug)
145: printf("il%d: module=%s firmware=%s\n", ui->ui_unit,
146: is->is_stats.ils_module, is->is_stats.ils_firmware);
147: bcopy((caddr_t)is->is_stats.ils_addr, (caddr_t)is->is_addr,
148: sizeof (is->is_addr));
149: printf("il%d: hardware address %s\n", ui->ui_unit,
150: ether_sprintf(is->is_addr));
151: ifp->if_init = ilinit;
152: ifp->if_output = iloutput;
153: ifp->if_ioctl = ilioctl;
154: ifp->if_reset = ilreset;
155: is->is_ifuba.ifu_flags = UBA_CANTWAIT;
156: if_attach(ifp);
157: }
158:
159: ilwait(ui, op)
160: struct uba_device *ui;
161: char *op;
162: {
163: register struct ildevice *addr = (struct ildevice *)ui->ui_addr;
164:
165: while ((addr->il_csr&IL_CDONE) == 0)
166: ;
167: if (addr->il_csr&IL_STATUS) {
168: printf("il%d: %s failed, csr=%b\n", ui->ui_unit, op,
169: addr->il_csr, IL_BITS);
170: return (-1);
171: }
172: return (0);
173: }
174:
175: /*
176: * Reset of interface after UNIBUS reset.
177: * If interface is on specified uba, reset its state.
178: */
179: ilreset(unit, uban)
180: int unit, uban;
181: {
182: register struct uba_device *ui;
183:
184: if (unit >= NIL || (ui = ilinfo[unit]) == 0 || ui->ui_alive == 0 ||
185: ui->ui_ubanum != uban)
186: return;
187: printf(" il%d", unit);
188: il_softc[unit].is_if.if_flags &= ~IFF_RUNNING;
189: il_softc[unit].is_flags &= ~ILF_RUNNING;
190: ilinit(unit);
191: }
192:
193: /*
194: * Initialization of interface; clear recorded pending
195: * operations, and reinitialize UNIBUS usage.
196: */
197: ilinit(unit)
198: int unit;
199: {
200: register struct il_softc *is = &il_softc[unit];
201: register struct uba_device *ui = ilinfo[unit];
202: register struct ildevice *addr;
203: register struct ifnet *ifp = &is->is_if;
204: int s;
205:
206: /* not yet, if address still unknown */
207: if (ifp->if_addrlist == (struct ifaddr *)0)
208: return;
209: if (is->is_flags & ILF_RUNNING)
210: return;
211:
212: if ((ifp->if_flags & IFF_RUNNING) == 0) {
213: if (if_ubainit(&is->is_ifuba, ui->ui_ubanum,
214: sizeof (struct il_rheader), (int)btoc(ETHERMTU)) == 0) {
215: printf("il%d: can't initialize\n", unit);
216: is->is_if.if_flags &= ~IFF_UP;
217: return;
218: }
219: is->is_ubaddr = uballoc(ui->ui_ubanum, (caddr_t)&is->is_stats,
220: sizeof (struct il_stats), 0);
221: }
222: ifp->if_watchdog = ilwatch;
223: is->is_scaninterval = ILWATCHINTERVAL;
224: ifp->if_timer = is->is_scaninterval;
225: addr = (struct ildevice *)ui->ui_addr;
226:
227: /*
228: * Turn off source address insertion (it's faster this way),
229: * and set board online. Former doesn't work if board is
230: * already online (happens on ubareset), so we put it offline
231: * first.
232: */
233: s = splimp();
234: addr->il_csr = ILC_RESET;
235: if (ilwait(ui, "hardware diag")) {
236: is->is_if.if_flags &= ~IFF_UP;
237: splx(s);
238: return;
239: }
240: addr->il_csr = ILC_CISA;
241: while ((addr->il_csr & IL_CDONE) == 0)
242: ;
243: /*
244: * If we must reprogram this board's physical ethernet
245: * address (as for secondary XNS interfaces), we do so
246: * before putting it on line, and starting receive requests.
247: * If you try this on an older 1010 board, it will total
248: * wedge the board.
249: */
250: if (is->is_flags & ILF_SETADDR) {
251: bcopy((caddr_t)is->is_addr, (caddr_t)&is->is_stats,
252: sizeof is->is_addr);
253: addr->il_bar = is->is_ubaddr & 0xffff;
254: addr->il_bcr = sizeof is->is_addr;
255: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_LDPA;
256: if (ilwait(ui, "setaddr"))
257: return;
258: addr->il_bar = is->is_ubaddr & 0xffff;
259: addr->il_bcr = sizeof (struct il_stats);
260: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT;
261: if (ilwait(ui, "verifying setaddr"))
262: return;
263: if (bcmp((caddr_t)is->is_stats.ils_addr, (caddr_t)is->is_addr,
264: sizeof (is->is_addr)) != 0) {
265: printf("il%d: setaddr didn't work\n", ui->ui_unit);
266: return;
267: }
268: }
269: /*
270: * Set board online.
271: * Hang receive buffer and start any pending
272: * writes by faking a transmit complete.
273: * Receive bcr is not a multiple of 8 so buffer
274: * chaining can't happen.
275: */
276: addr->il_csr = ILC_ONLINE;
277: while ((addr->il_csr & IL_CDONE) == 0)
278: ;
279: addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff;
280: addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6;
281: addr->il_csr =
282: ((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE;
283: while ((addr->il_csr & IL_CDONE) == 0)
284: ;
285: is->is_flags = ILF_OACTIVE;
286: is->is_if.if_flags |= IFF_RUNNING;
287: is->is_flags |= ILF_RUNNING;
288: is->is_lastcmd = 0;
289: ilcint(unit);
290: splx(s);
291: }
292:
293: /*
294: * Start output on interface.
295: * Get another datagram to send off of the interface queue,
296: * and map it to the interface before starting the output.
297: */
298: ilstart(dev)
299: dev_t dev;
300: {
301: int unit = ILUNIT(dev), len;
302: struct uba_device *ui = ilinfo[unit];
303: register struct il_softc *is = &il_softc[unit];
304: register struct ildevice *addr;
305: struct mbuf *m;
306: short csr;
307:
308: IF_DEQUEUE(&is->is_if.if_snd, m);
309: addr = (struct ildevice *)ui->ui_addr;
310: if (m == 0) {
311: if ((is->is_flags & ILF_STATPENDING) == 0)
312: return;
313: addr->il_bar = is->is_ubaddr & 0xffff;
314: addr->il_bcr = sizeof (struct il_stats);
315: csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT|IL_RIE|IL_CIE;
316: is->is_flags &= ~ILF_STATPENDING;
317: goto startcmd;
318: }
319: len = if_wubaput(&is->is_ifuba, m);
320: /*
321: * Ensure minimum packet length.
322: * This makes the safe assumtion that there are no virtual holes
323: * after the data.
324: * For security, it might be wise to zero out the added bytes,
325: * but we're mainly interested in speed at the moment.
326: */
327: if (len - sizeof(struct ether_header) < ETHERMIN)
328: len = ETHERMIN + sizeof(struct ether_header);
329: if (is->is_ifuba.ifu_flags & UBA_NEEDBDP)
330: UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_w.ifrw_bdp);
331: addr->il_bar = is->is_ifuba.ifu_w.ifrw_info & 0xffff;
332: addr->il_bcr = len;
333: csr =
334: ((is->is_ifuba.ifu_w.ifrw_info >> 2) & IL_EUA)|ILC_XMIT|IL_CIE|IL_RIE;
335:
336: startcmd:
337: is->is_lastcmd = csr & IL_CMD;
338: addr->il_csr = csr;
339: is->is_flags |= ILF_OACTIVE;
340: }
341:
342: /*
343: * Command done interrupt.
344: */
345: ilcint(unit)
346: int unit;
347: {
348: register struct il_softc *is = &il_softc[unit];
349: struct uba_device *ui = ilinfo[unit];
350: register struct ildevice *addr = (struct ildevice *)ui->ui_addr;
351: short csr;
352:
353: if ((is->is_flags & ILF_OACTIVE) == 0) {
354: printf("il%d: stray xmit interrupt, csr=%b\n", unit,
355: addr->il_csr, IL_BITS);
356: return;
357: }
358:
359: csr = addr->il_csr;
360: /*
361: * Hang receive buffer if it couldn't
362: * be done earlier (in ilrint).
363: */
364: if (is->is_flags & ILF_RCVPENDING) {
365: int s;
366:
367: addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff;
368: addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6;
369: addr->il_csr =
370: ((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE;
371: s = splhigh();
372: while ((addr->il_csr & IL_CDONE) == 0)
373: ;
374: splx(s);
375: is->is_flags &= ~ILF_RCVPENDING;
376: }
377: is->is_flags &= ~ILF_OACTIVE;
378: csr &= IL_STATUS;
379: switch (is->is_lastcmd) {
380:
381: case ILC_XMIT:
382: is->is_if.if_opackets++;
383: if (csr > ILERR_RETRIES)
384: is->is_if.if_oerrors++;
385: break;
386:
387: case ILC_STAT:
388: if (csr == ILERR_SUCCESS)
389: iltotal(is);
390: break;
391: }
392: if (is->is_ifuba.ifu_xtofree) {
393: m_freem(is->is_ifuba.ifu_xtofree);
394: is->is_ifuba.ifu_xtofree = 0;
395: }
396: ilstart(unit);
397: }
398:
399: /*
400: * Ethernet interface receiver interrupt.
401: * If input error just drop packet.
402: * Otherwise purge input buffered data path and examine
403: * packet to determine type. If can't determine length
404: * from type, then have to drop packet. Othewise decapsulate
405: * packet based on type and pass to type specific higher-level
406: * input routine.
407: */
408: ilrint(unit)
409: int unit;
410: {
411: register struct il_softc *is = &il_softc[unit];
412: struct ildevice *addr = (struct ildevice *)ilinfo[unit]->ui_addr;
413: register struct il_rheader *il;
414: struct mbuf *m;
415: int len, off, resid, s;
416: register struct ifqueue *inq;
417:
418: is->is_if.if_ipackets++;
419: if (is->is_ifuba.ifu_flags & UBA_NEEDBDP)
420: UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_r.ifrw_bdp);
421: il = (struct il_rheader *)(is->is_ifuba.ifu_r.ifrw_addr);
422: len = il->ilr_length - sizeof(struct il_rheader);
423: if ((il->ilr_status&(ILFSTAT_A|ILFSTAT_C)) || len < 46 ||
424: len > ETHERMTU) {
425: is->is_if.if_ierrors++;
426: #ifdef notdef
427: if (is->is_if.if_ierrors % 100 == 0)
428: printf("il%d: += 100 input errors\n", unit);
429: #endif
430: goto setup;
431: }
432:
433: /*
434: * Deal with trailer protocol: if type is trailer type
435: * get true type from first 16-bit word past data.
436: * Remember that type was trailer by setting off.
437: */
438: il->ilr_type = ntohs((u_short)il->ilr_type);
439: #define ildataaddr(il, off, type) ((type)(((caddr_t)((il)+1)+(off))))
440: if (il->ilr_type >= ETHERTYPE_TRAIL &&
441: il->ilr_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
442: off = (il->ilr_type - ETHERTYPE_TRAIL) * 512;
443: if (off >= ETHERMTU)
444: goto setup; /* sanity */
445: il->ilr_type = ntohs(*ildataaddr(il, off, u_short *));
446: resid = ntohs(*(ildataaddr(il, off+2, u_short *)));
447: if (off + resid > len)
448: goto setup; /* sanity */
449: len = off + resid;
450: } else
451: off = 0;
452: if (len == 0)
453: goto setup;
454:
455: /*
456: * Pull packet off interface. Off is nonzero if packet
457: * has trailing header; ilget will then force this header
458: * information to be at the front, but we still have to drop
459: * the type and length which are at the front of any trailer data.
460: */
461: m = if_rubaget(&is->is_ifuba, len, off, &is->is_if);
462: if (m == 0)
463: goto setup;
464: if (off) {
465: struct ifnet *ifp;
466:
467: ifp = *(mtod(m, struct ifnet **));
468: m->m_off += 2 * sizeof (u_short);
469: m->m_len -= 2 * sizeof (u_short);
470: *(mtod(m, struct ifnet **)) = ifp;
471: }
472: switch (il->ilr_type) {
473:
474: #ifdef INET
475: case ETHERTYPE_IP:
476: schednetisr(NETISR_IP);
477: inq = &ipintrq;
478: break;
479:
480: case ETHERTYPE_ARP:
481: arpinput(&is->is_ac, m);
482: goto setup;
483: #endif
484: #ifdef NS
485: case ETHERTYPE_NS:
486: schednetisr(NETISR_NS);
487: inq = &nsintrq;
488: break;
489:
490: #endif
491: default:
492: m_freem(m);
493: goto setup;
494: }
495:
496: s = splimp();
497: if (IF_QFULL(inq)) {
498: IF_DROP(inq);
499: m_freem(m);
500: } else
501: IF_ENQUEUE(inq, m);
502: splx(s);
503:
504: setup:
505: /*
506: * Reset for next packet if possible.
507: * If waiting for transmit command completion, set flag
508: * and wait until command completes.
509: */
510: if (is->is_flags & ILF_OACTIVE) {
511: is->is_flags |= ILF_RCVPENDING;
512: return;
513: }
514: addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff;
515: addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6;
516: addr->il_csr =
517: ((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE;
518: s = splhigh();
519: while ((addr->il_csr & IL_CDONE) == 0)
520: ;
521: splx(s);
522: }
523:
524: /*
525: * Ethernet output routine.
526: * Encapsulate a packet of type family for the local net.
527: * Use trailer local net encapsulation if enough data in first
528: * packet leaves a multiple of 512 bytes of data in remainder.
529: */
530: iloutput(ifp, m0, dst)
531: struct ifnet *ifp;
532: struct mbuf *m0;
533: struct sockaddr *dst;
534: {
535: int type, s, error;
536: u_char edst[6];
537: struct in_addr idst;
538: register struct il_softc *is = &il_softc[ifp->if_unit];
539: register struct mbuf *m = m0;
540: register struct ether_header *il;
541: register int off;
542: int usetrailers;
543:
544: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
545: error = ENETDOWN;
546: goto bad;
547: }
548: switch (dst->sa_family) {
549:
550: #ifdef INET
551: case AF_INET:
552: idst = ((struct sockaddr_in *)dst)->sin_addr;
553: if (!arpresolve(&is->is_ac, m, &idst, edst, &usetrailers))
554: return (0); /* if not yet resolved */
555: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
556: if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
557: m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
558: type = ETHERTYPE_TRAIL + (off>>9);
559: m->m_off -= 2 * sizeof (u_short);
560: m->m_len += 2 * sizeof (u_short);
561: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
562: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
563: goto gottrailertype;
564: }
565: type = ETHERTYPE_IP;
566: off = 0;
567: goto gottype;
568: #endif
569: #ifdef NS
570: case AF_NS:
571: type = ETHERTYPE_NS;
572: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
573: (caddr_t)edst, sizeof (edst));
574: off = 0;
575: goto gottype;
576: #endif
577:
578: case AF_UNSPEC:
579: il = (struct ether_header *)dst->sa_data;
580: bcopy((caddr_t)il->ether_dhost, (caddr_t)edst, sizeof (edst));
581: type = il->ether_type;
582: goto gottype;
583:
584: default:
585: printf("il%d: can't handle af%d\n", ifp->if_unit,
586: dst->sa_family);
587: error = EAFNOSUPPORT;
588: goto bad;
589: }
590:
591: gottrailertype:
592: /*
593: * Packet to be sent as trailer: move first packet
594: * (control information) to end of chain.
595: */
596: while (m->m_next)
597: m = m->m_next;
598: m->m_next = m0;
599: m = m0->m_next;
600: m0->m_next = 0;
601: m0 = m;
602:
603: gottype:
604: /*
605: * Add local net header. If no space in first mbuf,
606: * allocate another.
607: */
608: if (m->m_off > MMAXOFF ||
609: MMINOFF + sizeof (struct ether_header) > m->m_off) {
610: m = m_get(M_DONTWAIT, MT_HEADER);
611: if (m == 0) {
612: error = ENOBUFS;
613: goto bad;
614: }
615: m->m_next = m0;
616: m->m_off = MMINOFF;
617: m->m_len = sizeof (struct ether_header);
618: } else {
619: m->m_off -= sizeof (struct ether_header);
620: m->m_len += sizeof (struct ether_header);
621: }
622: il = mtod(m, struct ether_header *);
623: il->ether_type = htons((u_short)type);
624: bcopy((caddr_t)edst, (caddr_t)il->ether_dhost, sizeof (edst));
625: bcopy((caddr_t)is->is_addr, (caddr_t)il->ether_shost,
626: sizeof(il->ether_shost));
627:
628: /*
629: * Queue message on interface, and start output if interface
630: * not yet active.
631: */
632: s = splimp();
633: if (IF_QFULL(&ifp->if_snd)) {
634: IF_DROP(&ifp->if_snd);
635: splx(s);
636: m_freem(m);
637: return (ENOBUFS);
638: }
639: IF_ENQUEUE(&ifp->if_snd, m);
640: if ((is->is_flags & ILF_OACTIVE) == 0)
641: ilstart(ifp->if_unit);
642: splx(s);
643: return (0);
644:
645: bad:
646: m_freem(m0);
647: return (error);
648: }
649:
650: /*
651: * Watchdog routine, request statistics from board.
652: */
653: ilwatch(unit)
654: int unit;
655: {
656: register struct il_softc *is = &il_softc[unit];
657: register struct ifnet *ifp = &is->is_if;
658: int s;
659:
660: if (is->is_flags & ILF_STATPENDING) {
661: ifp->if_timer = is->is_scaninterval;
662: return;
663: }
664: s = splimp();
665: is->is_flags |= ILF_STATPENDING;
666: if ((is->is_flags & ILF_OACTIVE) == 0)
667: ilstart(ifp->if_unit);
668: splx(s);
669: ifp->if_timer = is->is_scaninterval;
670: }
671:
672: /*
673: * Total up the on-board statistics.
674: */
675: iltotal(is)
676: register struct il_softc *is;
677: {
678: register u_short *interval, *sum, *end;
679:
680: interval = &is->is_stats.ils_frames;
681: sum = &is->is_sum.ils_frames;
682: end = is->is_sum.ils_fill2;
683: while (sum < end)
684: *sum++ += *interval++;
685: is->is_if.if_collisions = is->is_sum.ils_collis;
686: }
687:
688: /*
689: * Process an ioctl request.
690: */
691: ilioctl(ifp, cmd, data)
692: register struct ifnet *ifp;
693: int cmd;
694: caddr_t data;
695: {
696: register struct ifaddr *ifa = (struct ifaddr *)data;
697: register struct il_softc *is = &il_softc[ifp->if_unit];
698: int s = splimp(), error = 0;
699:
700: switch (cmd) {
701:
702: case SIOCSIFADDR:
703: ifp->if_flags |= IFF_UP;
704: ilinit(ifp->if_unit);
705:
706: switch (ifa->ifa_addr.sa_family) {
707: #ifdef INET
708: case AF_INET:
709: ((struct arpcom *)ifp)->ac_ipaddr =
710: IA_SIN(ifa)->sin_addr;
711: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
712: break;
713: #endif
714: #ifdef NS
715: case AF_NS:
716: {
717: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
718:
719: if (ns_nullhost(*ina)) {
720: ina->x_host = * (union ns_host *)
721: (il_softc[ifp->if_unit].is_addr);
722: } else {
723: il_setaddr(ina->x_host.c_host, ifp->if_unit);
724: return (0);
725: }
726: break;
727: }
728: #endif
729: }
730: break;
731:
732: case SIOCSIFFLAGS:
733: if ((ifp->if_flags & IFF_UP) == 0 &&
734: is->is_flags & ILF_RUNNING) {
735: ((struct ildevice *)
736: (ilinfo[ifp->if_unit]->ui_addr))->il_csr = ILC_RESET;
737: is->is_flags &= ~ILF_RUNNING;
738: } else if (ifp->if_flags & IFF_UP &&
739: (is->is_flags & ILF_RUNNING) == 0)
740: ilinit(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: il_setaddr(physaddr, unit)
754: u_char *physaddr;
755: int unit;
756: {
757: register struct il_softc *is = &il_softc[unit];
758:
759: if (! (is->is_flags & ILF_RUNNING))
760: return;
761:
762: bcopy((caddr_t)physaddr, (caddr_t)is->is_addr, sizeof is->is_addr);
763: is->is_flags &= ~ILF_RUNNING;
764: is->is_flags |= ILF_SETADDR;
765: ilinit(unit);
766: }
767: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.