![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_en.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / enet / vaxif|
Return to if_en.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / enet / 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_en.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "en.h"
10: #include "enetfilter.h"
11: #if NEN > 0
12:
13: /*
14: * Xerox prototype (3 Mb) Ethernet interface driver.
15: */
16: #include "../machine/pte.h"
17:
18: #include "param.h"
19: #include "systm.h"
20: #include "mbuf.h"
21: #include "buf.h"
22: #include "protosw.h"
23: #include "socket.h"
24: #include "vmmac.h"
25: #include "errno.h"
26: #include "ioctl.h"
27:
28: #include "../net/if.h"
29: #include "../net/netisr.h"
30: #include "../net/route.h"
31:
32: #ifdef INET
33: #include "../netinet/in.h"
34: #include "../netinet/in_systm.h"
35: #include "../netinet/in_var.h"
36: #include "../netinet/ip.h"
37: #endif
38:
39: #ifdef PUP
40: #include "../netpup/pup.h"
41: #include "../netpup/ether.h"
42: #endif
43:
44: #ifdef NS
45: #include "../netns/ns.h"
46: #include "../netns/ns_if.h"
47: #endif
48:
49: #include "../vax/cpu.h"
50: #include "../vax/mtpr.h"
51: #include "if_en.h"
52: #include "if_enreg.h"
53: #include "if_uba.h"
54: #if NENETFILTER > 0
55: #include "../net/enet.h"
56: #endif NENETFILTER > 0
57: #include "../vaxuba/ubareg.h"
58: #include "../vaxuba/ubavar.h"
59:
60: #define ENMTU (1024+512)
61: #define ENMRU (1024+512+16) /* 16 is enough to receive trailer */
62:
63: int enprobe(), enattach(), enrint(), enxint(), encollide();
64: struct uba_device *eninfo[NEN];
65: u_short enstd[] = { 0 };
66: struct uba_driver endriver =
67: { enprobe, 0, enattach, 0, enstd, "en", eninfo };
68: #define ENUNIT(x) minor(x)
69:
70: int eninit(),enoutput(),enreset(),enioctl();
71:
72: #ifdef notdef
73: /*
74: * If you need to byte swap IP's in the system, define
75: * this and do a SIOCSIFFLAGS at boot time.
76: */
77: #define ENF_SWABIPS 0x1000
78: #endif
79:
80: /*
81: * Ethernet software status per interface.
82: *
83: * Each interface is referenced by a network interface structure,
84: * es_if, which the routing code uses to locate the interface.
85: * This structure contains the output queue for the interface, its address, ...
86: * We also have, for each interface, a UBA interface structure, which
87: * contains information about the UNIBUS resources held by the interface:
88: * map registers, buffered data paths, etc. Information is cached in this
89: * structure for use by the if_uba.c routines in running the interface
90: * efficiently.
91: */
92: struct en_softc {
93: struct ifnet es_if; /* network-visible interface */
94: struct ifuba es_ifuba; /* UNIBUS resources */
95: short es_host; /* hardware host number */
96: short es_delay; /* current output delay */
97: short es_mask; /* mask for current output delay */
98: short es_lastx; /* host last transmitted to */
99: short es_oactive; /* is output active? */
100: short es_olen; /* length of last output */
101: short es_nsactive; /* is interface enabled for ns? */
102: #if NENETFILTER > 0
103: short es_enetunit; /* unit number for enet filtering */
104: #endif NENETFILTER > 0
105: } en_softc[NEN];
106:
107: /*
108: * Do output DMA to determine interface presence and
109: * interrupt vector. DMA is too short to disturb other hosts.
110: */
111: enprobe(reg)
112: caddr_t reg;
113: {
114: register int br, cvec; /* r11, r10 value-result */
115: register struct endevice *addr = (struct endevice *)reg;
116:
117: #ifdef lint
118: br = 0; cvec = br; br = cvec;
119: enrint(0); enxint(0); encollide(0);
120: #endif
121: addr->en_istat = 0;
122: addr->en_owc = -1;
123: addr->en_oba = 0;
124: addr->en_ostat = EN_IEN|EN_GO;
125: DELAY(100000);
126: addr->en_ostat = 0;
127: return (1);
128: }
129:
130: /*
131: * Interface exists: make available by filling in network interface
132: * record. System will initialize the interface when it is ready
133: * to accept packets.
134: */
135: enattach(ui)
136: struct uba_device *ui;
137: {
138: register struct en_softc *es = &en_softc[ui->ui_unit];
139:
140: es->es_if.if_unit = ui->ui_unit;
141: es->es_if.if_name = "en";
142: es->es_if.if_mtu = ENMTU;
143: es->es_if.if_flags = IFF_BROADCAST;
144: es->es_if.if_init = eninit;
145: es->es_if.if_output = enoutput;
146: es->es_if.if_ioctl = enioctl;
147: es->es_if.if_reset = enreset;
148: es->es_ifuba.ifu_flags = UBA_NEEDBDP | UBA_NEED16 | UBA_CANTWAIT;
149: #if defined(VAX750)
150: /* don't chew up 750 bdp's */
151: if (cpu == VAX_750 && ui->ui_unit > 0)
152: es->es_ifuba.ifu_flags &= ~UBA_NEEDBDP;
153: #endif
154: #if NENETFILTER > 0
155: {
156: struct endevp enp;
157: struct en_header dummy;
158: struct endevice *enaddr = (struct endevice *)ui->ui_addr;
159:
160: #ifdef SWABALL
161: enp.end_dev_type = ENDT_3MB;
162: #else
163: enp.end_dev_type = ENDT_BS3MB; /* packets appear byte-swapped */
164: #endif
165:
166: enp.end_addr_len = sizeof(dummy.en_shost);
167: enp.end_hdr_len = sizeof(struct en_header);
168: enp.end_MTU = ENMTU;
169: enp.end_addr[0] = (~enaddr->en_addr) & 0xFF;
170: enp.end_broadaddr[0] = 0;
171:
172: es->es_enetunit = enetattach(&es->es_if, &enp);
173: }
174: #endif NENETFILTER > 0
175: if_attach(&es->es_if);
176: }
177:
178: /*
179: * Reset of interface after UNIBUS reset.
180: * If interface is on specified uba, reset its state.
181: */
182: enreset(unit, uban)
183: int unit, uban;
184: {
185: register struct uba_device *ui;
186:
187: if (unit >= NEN || (ui = eninfo[unit]) == 0 || ui->ui_alive == 0 ||
188: ui->ui_ubanum != uban)
189: return;
190: printf(" en%d", unit);
191: eninit(unit);
192: }
193:
194: /*
195: * Initialization of interface; clear recorded pending
196: * operations, and reinitialize UNIBUS usage.
197: */
198: eninit(unit)
199: int unit;
200: {
201: register struct en_softc *es = &en_softc[unit];
202: register struct uba_device *ui = eninfo[unit];
203: register struct endevice *addr;
204: int s;
205:
206: if (es->es_if.if_addrlist == (struct ifaddr *)0)
207: return;
208: if (if_ubainit(&es->es_ifuba, ui->ui_ubanum,
209: sizeof (struct en_header), (int)btoc(ENMRU)) == 0) {
210: printf("en%d: can't initialize\n", unit);
211: es->es_if.if_flags &= ~IFF_UP;
212: return;
213: }
214: addr = (struct endevice *)ui->ui_addr;
215: addr->en_istat = addr->en_ostat = 0;
216:
217: /*
218: * Hang a receive and start any
219: * pending writes by faking a transmit complete.
220: */
221: s = splimp();
222: addr->en_iba = es->es_ifuba.ifu_r.ifrw_info;
223: addr->en_iwc = -(sizeof (struct en_header) + ENMRU) >> 1;
224: addr->en_istat = EN_IEN|EN_GO;
225: es->es_oactive = 1;
226: es->es_if.if_flags |= IFF_RUNNING;
227: enxint(unit);
228: splx(s);
229: }
230:
231: int enalldelay = 0;
232: int enlastdel = 50;
233: int enlastmask = (~0) << 5;
234:
235: /*
236: * Start or restart output on interface.
237: * If interface is already active, then this is a retransmit
238: * after a collision, and just restuff registers and delay.
239: * If interface is not already active, get another datagram
240: * to send off of the interface queue, and map it to the interface
241: * before starting the output.
242: */
243: enstart(dev)
244: dev_t dev;
245: {
246: int unit = ENUNIT(dev);
247: struct uba_device *ui = eninfo[unit];
248: register struct en_softc *es = &en_softc[unit];
249: register struct endevice *addr;
250: register struct en_header *en;
251: struct mbuf *m;
252: int dest;
253:
254: if (es->es_oactive)
255: goto restart;
256:
257: /*
258: * Not already active: dequeue another request
259: * and map it to the UNIBUS. If no more requests,
260: * just return.
261: */
262: IF_DEQUEUE(&es->es_if.if_snd, m);
263: if (m == 0) {
264: es->es_oactive = 0;
265: return;
266: }
267: en = mtod(m, struct en_header *);
268: dest = en->en_dhost;
269: en->en_shost = es->es_host;
270: es->es_olen = if_wubaput(&es->es_ifuba, m);
271: #ifdef ENF_SWABIPS
272: /*
273: * The Xerox interface does word at a time DMA, so
274: * someone must do byte swapping of user data if high
275: * and low ender machines are to communicate.
276: */
277: if (es->es_if.if_flags & ENF_SWABIPS) {
278: en = (struct en_header *)es->es_ifuba.ifu_w.ifrw_addr;
279: enswab((caddr_t)(en + 1), (caddr_t)(en + 1),
280: es->es_olen - sizeof (struct en_header) + 1);
281: }
282: #endif
283:
284: /*
285: * Ethernet cannot take back-to-back packets (no
286: * buffering in interface. To help avoid overrunning
287: * receivers, enforce a small delay (about 1ms) in interface:
288: * * between all packets when enalldelay
289: * * whenever last packet was broadcast
290: * * whenever this packet is to same host as last packet
291: */
292: if (enalldelay || es->es_lastx == 0 || es->es_lastx == dest) {
293: es->es_delay = enlastdel;
294: es->es_mask = enlastmask;
295: }
296: es->es_lastx = dest;
297:
298: restart:
299: /*
300: * Have request mapped to UNIBUS for transmission.
301: * Purge any stale data from this BDP, and start the otput.
302: */
303: if (es->es_ifuba.ifu_flags & UBA_NEEDBDP)
304: UBAPURGE(es->es_ifuba.ifu_uba, es->es_ifuba.ifu_w.ifrw_bdp);
305: addr = (struct endevice *)ui->ui_addr;
306: addr->en_oba = (int)es->es_ifuba.ifu_w.ifrw_info;
307: addr->en_odelay = es->es_delay;
308: addr->en_owc = -((es->es_olen + 1) >> 1);
309: addr->en_ostat = EN_IEN|EN_GO;
310: es->es_oactive = 1;
311: }
312:
313: /*
314: * Ethernet interface transmitter interrupt.
315: * Start another output if more data to send.
316: */
317: enxint(unit)
318: int unit;
319: {
320: register struct uba_device *ui = eninfo[unit];
321: register struct en_softc *es = &en_softc[unit];
322: register struct endevice *addr = (struct endevice *)ui->ui_addr;
323:
324: if (es->es_oactive == 0)
325: return;
326: if (es->es_mask && (addr->en_ostat&EN_OERROR)) {
327: es->es_if.if_oerrors++;
328: endocoll(unit);
329: return;
330: }
331: es->es_if.if_opackets++;
332: es->es_oactive = 0;
333: es->es_delay = 0;
334: es->es_mask = ~0;
335: if (es->es_ifuba.ifu_xtofree) {
336: m_freem(es->es_ifuba.ifu_xtofree);
337: es->es_ifuba.ifu_xtofree = 0;
338: }
339: if (es->es_if.if_snd.ifq_head == 0) {
340: es->es_lastx = 256; /* putatively illegal */
341: return;
342: }
343: enstart(unit);
344: }
345:
346: /*
347: * Collision on ethernet interface. Do exponential
348: * backoff, and retransmit. If have backed off all
349: * the way print warning diagnostic, and drop packet.
350: */
351: encollide(unit)
352: int unit;
353: {
354: struct en_softc *es = &en_softc[unit];
355:
356: es->es_if.if_collisions++;
357: if (es->es_oactive == 0)
358: return;
359: endocoll(unit);
360: }
361:
362: endocoll(unit)
363: int unit;
364: {
365: register struct en_softc *es = &en_softc[unit];
366:
367: /*
368: * Es_mask is a 16 bit number with n low zero bits, with
369: * n the number of backoffs. When es_mask is 0 we have
370: * backed off 16 times, and give up.
371: */
372: if (es->es_mask == 0) {
373: printf("en%d: send error\n", unit);
374: enxint(unit);
375: return;
376: }
377: /*
378: * Another backoff. Restart with delay based on n low bits
379: * of the interval timer.
380: */
381: es->es_mask <<= 1;
382: es->es_delay = mfpr(ICR) &~ es->es_mask;
383: enstart(unit);
384: }
385:
386: #ifdef notdef
387: struct sockproto enproto = { AF_ETHERLINK };
388: struct sockaddr_en endst = { AF_ETHERLINK };
389: struct sockaddr_en ensrc = { AF_ETHERLINK };
390: #endif
391: /*
392: * Ethernet interface receiver interrupt.
393: * If input error just drop packet.
394: * Otherwise purge input buffered data path and examine
395: * packet to determine type. If can't determine length
396: * from type, then have to drop packet. Othewise decapsulate
397: * packet based on type and pass to type specific higher-level
398: * input routine.
399: */
400: enrint(unit)
401: int unit;
402: {
403: register struct en_softc *es = &en_softc[unit];
404: struct endevice *addr = (struct endevice *)eninfo[unit]->ui_addr;
405: register struct en_header *en;
406: struct mbuf *m;
407: int len; short resid;
408: register struct ifqueue *inq;
409: int off, s;
410:
411: es->es_if.if_ipackets++;
412:
413: /*
414: * Purge BDP; drop if input error indicated.
415: */
416: if (es->es_ifuba.ifu_flags & UBA_NEEDBDP)
417: UBAPURGE(es->es_ifuba.ifu_uba, es->es_ifuba.ifu_r.ifrw_bdp);
418: if (addr->en_istat&EN_IERROR) {
419: es->es_if.if_ierrors++;
420: goto setup;
421: }
422:
423: /*
424: * Calculate input data length.
425: * Get pointer to ethernet header (in input buffer).
426: * Deal with trailer protocol: if type is PUP trailer
427: * get true type from first 16-bit word past data.
428: * Remember that type was trailer by setting off.
429: */
430: resid = addr->en_iwc;
431: if (resid)
432: resid |= 0176000;
433: len = (((sizeof (struct en_header) + ENMRU) >> 1) + resid) << 1;
434: len -= sizeof (struct en_header);
435: if (len > ENMRU || len <= 0)
436: goto setup; /* sanity */
437: en = (struct en_header *)(es->es_ifuba.ifu_r.ifrw_addr);
438: #ifdef SWABALL
439: enswab((caddr_t)(en + 1), (caddr_t)(en + 1), len);
440: #else
441: en->en_type = ntohs(en->en_type);
442: #endif SWABALL
443: #define endataaddr(en, off, type) ((type)(((caddr_t)((en)+1)+(off))))
444: if (en->en_type >= ENTYPE_TRAIL &&
445: en->en_type < ENTYPE_TRAIL+ENTYPE_NTRAILER) {
446: off = (en->en_type - ENTYPE_TRAIL) * 512;
447: if (off > ENMTU)
448: goto setup; /* sanity */
449: #ifndef SWABALL
450: en->en_type = *endataaddr(en, off, u_short *);
451: resid = *(endataaddr(en, off+2, u_short *));
452: #else SWABALL
453: en->en_type = ntohs(*endataaddr(en, off, u_short *));
454: resid = ntohs(*(endataaddr(en, off+2, u_short *)));
455: #endif SWABALL
456: if (off + resid > len)
457: goto setup; /* sanity */
458: len = off + resid;
459: } else
460: off = 0;
461: if (len == 0)
462: goto setup;
463: #ifdef ENF_SWABIPS
464: if (es->es_if.if_flags & ENF_SWABIPS && en->en_type == ENTYPE_IP)
465: enswab((caddr_t)(en + 1), (caddr_t)(en + 1), len);
466: #endif
467: /*
468: * Pull packet off interface. Off is nonzero if packet
469: * has trailing header; if_rubaget will then force this header
470: * information to be at the front, but we still have to drop
471: * the type and length which are at the front of any trailer data.
472: */
473: m = if_rubaget(&es->es_ifuba, len, off, &es->es_if);
474: if (m == 0)
475: goto setup;
476: if (off) {
477: struct ifnet *ifp;
478:
479: ifp = *(mtod(m, struct ifnet **));
480: m->m_off += 2 * sizeof (u_short);
481: m->m_len -= 2 * sizeof (u_short);
482: *(mtod(m, struct ifnet **)) = ifp;
483: }
484: switch (en->en_type) {
485:
486: #ifdef INET
487: case ENTYPE_IP:
488: schednetisr(NETISR_IP);
489: inq = &ipintrq;
490: break;
491: #endif
492: #ifdef PUP
493: case ENTYPE_PUP:
494: rpup_input(m);
495: goto setup;
496: #endif
497: #ifdef NS
498: case ETHERTYPE_NS:
499: if (es->es_nsactive) {
500: schednetisr(NETISR_NS);
501: inq = &nsintrq;
502: } else {
503: m_freem(m);
504: goto setup;
505: }
506: break;
507: #endif
508:
509: #if NENETFILTER > 0
510: default:
511: {
512: register struct mbuf *mtop;
513: /*
514: * We need the local net header after all. Oh well,
515: * this could be improved.
516: */
517: MGET(mtop, M_DONTWAIT, MT_DATA);
518: if (mtop == 0) { /* no more mbufs? */
519: m_freem(m); /* wasted effort */
520: goto setup;
521: }
522: #ifdef SWABALL
523: /*
524: * the interface has put en_type in host order and we
525: * want it in net order.
526: */
527: en->en_type = htons(en->en_type);
528: #endif SWABALL
529: bcopy(en, mtod(mtop, struct en_header *),
530: sizeof(struct en_header));
531: mtop->m_len = sizeof(struct en_header);
532: IF_ADJ(m);
533: mtop->m_next = m;
534: enetFilter(es->es_enetunit, mtop,
535: (len + sizeof(struct en_header)) );
536: goto setup;
537: }
538: #else
539: default:
540: #ifdef notdef
541: enproto.sp_protocol = en->en_type;
542: endst.sen_host = en->en_dhost;
543: endst.sen_net = ensrc.sen_net = es->es_if.if_net;
544: ensrc.sen_host = en->en_shost;
545: raw_input(m, &enproto,
546: (struct sockaddr *)&ensrc, (struct sockaddr *)&endst);
547: #else
548: m_freem(m);
549: #endif
550: goto setup;
551: #endif NENETFILTER > 0
552: }
553:
554: s = splimp();
555: if (IF_QFULL(inq)) {
556: IF_DROP(inq);
557: m_freem(m);
558: } else
559: IF_ENQUEUE(inq, m);
560: splx(s);
561:
562: setup:
563: /*
564: * Reset for next packet.
565: */
566: addr->en_iba = es->es_ifuba.ifu_r.ifrw_info;
567: addr->en_iwc = -(sizeof (struct en_header) + ENMRU) >> 1;
568: addr->en_istat = EN_IEN|EN_GO;
569: }
570:
571: /*
572: * Ethernet output routine.
573: * Encapsulate a packet of type family for the local net.
574: * Use trailer local net encapsulation if enough data in first
575: * packet leaves a multiple of 512 bytes of data in remainder.
576: */
577: enoutput(ifp, m0, dst)
578: struct ifnet *ifp;
579: struct mbuf *m0;
580: struct sockaddr *dst;
581: {
582: int type, dest, s, error;
583: register struct mbuf *m = m0;
584: register struct en_header *en;
585: register int off;
586:
587: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
588: error = ENETDOWN;
589: goto bad;
590: }
591: switch (dst->sa_family) {
592:
593: #ifdef INET
594: case AF_INET:
595: {
596: struct in_addr in;
597:
598: in = ((struct sockaddr_in *)dst)->sin_addr;
599: if (in_broadcast(in))
600: dest = EN_BROADCAST;
601: else
602: dest = in_lnaof(in);
603: }
604: if (dest >= 0x100) {
605: error = EPERM; /* ??? */
606: goto bad;
607: }
608: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
609: /* need per host negotiation */
610: if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
611: if (off > 0 && (off & 0x1ff) == 0 &&
612: m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
613: type = ENTYPE_TRAIL + (off>>9);
614: m->m_off -= 2 * sizeof (u_short);
615: m->m_len += 2 * sizeof (u_short);
616: *mtod(m, u_short *) = htons((u_short)ENTYPE_IP);
617: *(mtod(m, u_short *) + 1) = ntohs((u_short)m->m_len);
618: goto gottrailertype;
619: }
620: type = ENTYPE_IP;
621: off = 0;
622: goto gottype;
623: #endif
624: #ifdef NS
625: case AF_NS:
626: {
627: u_char *up;
628:
629: type = ETHERTYPE_NS;
630: up = ((struct sockaddr_ns *)dst)->sns_addr.x_host.c_host;
631: if (*up & 1)
632: dest = EN_BROADCAST;
633: else
634: dest = up[5];
635:
636: off = 0;
637: goto gottype;
638: }
639: #endif
640: #ifdef PUP
641: case AF_PUP:
642: dest = ((struct sockaddr_pup *)dst)->spup_host;
643: type = ENTYPE_PUP;
644: off = 0;
645: goto gottype;
646: #endif
647:
648: #if NENETFILTER > 0
649: case AF_IMPLINK:
650: en = mtod(m, struct en_header *);
651: #ifdef SWABALL
652: /*
653: * enstart doesn't swab header fields; en_type is in
654: * net order and interface expects host order.
655: */
656: en->en_type = ntohs(en->en_type);
657: #endif SWABALL
658: goto gotheader;
659: #endif
660:
661: default:
662: printf("en%d: can't handle af%d\n", ifp->if_unit,
663: dst->sa_family);
664: error = EAFNOSUPPORT;
665: goto bad;
666: }
667:
668: gottrailertype:
669: /*
670: * Packet to be sent as trailer: move first packet
671: * (control information) to end of chain.
672: */
673: while (m->m_next)
674: m = m->m_next;
675: m->m_next = m0;
676: m = m0->m_next;
677: m0->m_next = 0;
678: m0 = m;
679:
680: gottype:
681: /*
682: * Add local net header. If no space in first mbuf,
683: * allocate another.
684: */
685: if (m->m_off > MMAXOFF ||
686: MMINOFF + sizeof (struct en_header) > m->m_off) {
687: MGET(m, M_DONTWAIT, MT_HEADER);
688: if (m == 0) {
689: error = ENOBUFS;
690: goto bad;
691: }
692: m->m_next = m0;
693: m->m_off = MMINOFF;
694: m->m_len = sizeof (struct en_header);
695: } else {
696: m->m_off -= sizeof (struct en_header);
697: m->m_len += sizeof (struct en_header);
698: }
699: en = mtod(m, struct en_header *);
700: /* add en_shost later */
701: en->en_dhost = dest;
702: #ifdef SWABALL
703: en->en_type = type;
704: #else
705: en->en_type = htons((u_short)type);
706: #endif
707: #if NENETFILTER > 0
708: gotheader: /* will add en_shost later, in enstart() */
709: #endif
710: /*
711: * Queue message on interface, and start output if interface
712: * not yet active.
713: */
714: s = splimp();
715: if (IF_QFULL(&ifp->if_snd)) {
716: IF_DROP(&ifp->if_snd);
717: error = ENOBUFS;
718: goto qfull;
719: }
720: IF_ENQUEUE(&ifp->if_snd, m);
721: if (en_softc[ifp->if_unit].es_oactive == 0)
722: enstart(ifp->if_unit);
723: splx(s);
724: return (0);
725: qfull:
726: m0 = m;
727: splx(s);
728: bad:
729: m_freem(m0);
730: return (error);
731: }
732:
733: /*
734: * Process an ioctl request.
735: */
736: enioctl(ifp, cmd, data)
737: register struct ifnet *ifp;
738: int cmd;
739: caddr_t data;
740: {
741: register struct en_softc *es = ((struct en_softc *)ifp);
742: struct ifaddr *ifa = (struct ifaddr *) data;
743: int s = splimp(), error = 0;
744: struct endevice *enaddr;
745:
746: switch (cmd) {
747:
748: case SIOCSIFADDR:
749: enaddr = (struct endevice *)eninfo[ifp->if_unit]->ui_addr;
750: es->es_host = (~enaddr->en_addr) & 0xff;
751: /*
752: * Attempt to check agreement of protocol address
753: * and board address.
754: */
755: switch (ifa->ifa_addr.sa_family) {
756: case AF_INET:
757: if (in_lnaof(IA_SIN(ifa)->sin_addr) != es->es_host)
758: return (EADDRNOTAVAIL);
759: break;
760: #ifdef NS
761: case AF_NS:
762: if (IA_SNS(ifa)->sns_addr.x_host.c_host[5]
763: != es->es_host)
764: return (EADDRNOTAVAIL);
765: es->es_nsactive = 1;
766: break;
767: #endif
768: }
769: ifp->if_flags |= IFF_UP;
770: if ((ifp->if_flags & IFF_RUNNING) == 0)
771: eninit(ifp->if_unit);
772: break;
773:
774: default:
775: error = EINVAL;
776: break;
777: }
778: splx(s);
779: return (error);
780: }
781:
782: #if defined(SWABALL) || defined(ENF_SWABIPS)
783: /*
784: * Swab bytes
785: * Jeffrey Mogul, Stanford
786: */
787: enswab(from, to, n)
788: register unsigned char *from, *to;
789: register int n;
790: {
791: register unsigned long temp;
792:
793: if ((n <= 0) || (n > 0xFFFF)) {
794: printf("enswab: bad len %d\n", n);
795: return;
796: }
797:
798: n >>= 1; n++;
799: #define STEP {temp = *from++;*to++ = *from++;*to++ = temp;}
800: /* round to multiple of 8 */
801: while ((--n) & 07)
802: STEP;
803: n >>= 3;
804: while (--n >= 0) {
805: STEP; STEP; STEP; STEP;
806: STEP; STEP; STEP; STEP;
807: }
808: }
809: #endif
810: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.