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