![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / enet / vaxif|
Return to if_ec.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / 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_ec.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "ec.h"
10: #include "enetfilter.h"
11: #if NEC > 0
12:
13: /*
14: * 3Com Ethernet Controller interface
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 "syslog.h"
25: #include "vmmac.h"
26: #include "ioctl.h"
27: #include "errno.h"
28:
29: #include "../net/if.h"
30: #include "../net/netisr.h"
31: #include "../net/route.h"
32:
33: #ifdef INET
34: #include "../netinet/in.h"
35: #include "../netinet/in_systm.h"
36: #include "../netinet/in_var.h"
37: #include "../netinet/ip.h"
38: #include "../netinet/if_ether.h"
39: #endif
40:
41: #ifdef NS
42: #include "../netns/ns.h"
43: #include "../netns/ns_if.h"
44: #endif
45:
46: #include "../vax/cpu.h"
47: #include "../vax/mtpr.h"
48: #include "if_ecreg.h"
49: #include "if_uba.h"
50: #if NENETFILTER > 0
51: #include "../net/enet.h"
52: #endif NENETFILTER > 0
53: #include "../vaxuba/ubareg.h"
54: #include "../vaxuba/ubavar.h"
55:
56: #if CLSIZE == 2
57: #define ECBUFSIZE 32 /* on-board memory, clusters */
58: #endif
59:
60: int ecubamem(), ecprobe(), ecattach(), ecrint(), ecxint(), eccollide();
61: struct uba_device *ecinfo[NEC];
62: u_short ecstd[] = { 0 };
63: struct uba_driver ecdriver =
64: { ecprobe, 0, ecattach, 0, ecstd, "ec", ecinfo, 0, 0, 0, ecubamem };
65:
66: int ecinit(),ecioctl(),ecoutput(),ecreset();
67: struct mbuf *ecget();
68:
69: extern struct ifnet loif;
70:
71: /*
72: * Ethernet software status per interface.
73: *
74: * Each interface is referenced by a network interface structure,
75: * es_if, which the routing code uses to locate the interface.
76: * This structure contains the output queue for the interface, its address, ...
77: * We also have, for each interface, a UBA interface structure, which
78: * contains information about the UNIBUS resources held by the interface:
79: * map registers, buffered data paths, etc. Information is cached in this
80: * structure for use by the if_uba.c routines in running the interface
81: * efficiently.
82: */
83: struct ec_softc {
84: struct arpcom es_ac; /* common Ethernet structures */
85: #define es_if es_ac.ac_if /* network-visible interface */
86: #define es_addr es_ac.ac_enaddr /* hardware Ethernet address */
87: struct ifuba es_ifuba; /* UNIBUS resources */
88: short es_mask; /* mask for current output delay */
89: short es_oactive; /* is output active? */
90: #if NENETFILTER > 0
91: short es_enetunit; /* unit number for enet filtering */
92: #endif NENETFILTER > 0
93: u_char *es_buf[16]; /* virtual addresses of buffers */
94: } ec_softc[NEC];
95:
96: /*
97: * Configure on-board memory for an interface.
98: * Called from autoconfig and after a uba reset.
99: * The address of the memory on the uba is supplied in the device flags.
100: */
101: ecubamem(ui, uban)
102: register struct uba_device *ui;
103: {
104: register caddr_t ecbuf = (caddr_t) &umem[uban][ui->ui_flags];
105: register struct ecdevice *addr = (struct ecdevice *)ui->ui_addr;
106:
107: /*
108: * Make sure csr is there (we run before ecprobe).
109: */
110: if (badaddr((caddr_t)addr, 2))
111: return (-1);
112: #if VAX780
113: if (cpu == VAX_780 && uba_hd[uban].uh_uba->uba_sr) {
114: uba_hd[uban].uh_uba->uba_sr = uba_hd[uban].uh_uba->uba_sr;
115: return (-1);
116: }
117: #endif
118: /*
119: * Make sure memory is turned on
120: */
121: addr->ec_rcr = EC_AROM;
122: /*
123: * Tell the system that the board has memory here, so it won't
124: * attempt to allocate the addresses later.
125: */
126: if (ubamem(uban, ui->ui_flags, ECBUFSIZE*CLSIZE, 1) == 0) {
127: printf("ec%d: cannot reserve uba addresses\n", ui->ui_unit);
128: addr->ec_rcr = EC_MDISAB; /* disable memory */
129: return (-1);
130: }
131: /*
132: * Check for existence of buffers on Unibus.
133: */
134: if (badaddr((caddr_t)ecbuf, 2)) {
135: bad:
136: printf("ec%d: buffer mem not found\n", ui->ui_unit);
137: (void) ubamem(uban, ui->ui_flags, ECBUFSIZE*2, 0);
138: addr->ec_rcr = EC_MDISAB; /* disable memory */
139: return (-1);
140: }
141: #if VAX780
142: if (cpu == VAX_780 && uba_hd[uban].uh_uba->uba_sr) {
143: uba_hd[uban].uh_uba->uba_sr = uba_hd[uban].uh_uba->uba_sr;
144: goto bad;
145: }
146: #endif
147: if (ui->ui_alive == 0) /* Only printf from autoconfig */
148: printf("ec%d: mem %x-%x\n", ui->ui_unit,
149: ui->ui_flags, ui->ui_flags + ECBUFSIZE*CLBYTES - 1);
150: ui->ui_type = 1; /* Memory on, allocated */
151: return (0);
152: }
153:
154: /*
155: * Do output DMA to determine interface presence and
156: * interrupt vector. DMA is too short to disturb other hosts.
157: */
158: ecprobe(reg, ui)
159: caddr_t reg;
160: struct uba_device *ui;
161: {
162: register int br, cvec; /* r11, r10 value-result */
163: register struct ecdevice *addr = (struct ecdevice *)reg;
164: register caddr_t ecbuf = (caddr_t) &umem[ui->ui_ubanum][ui->ui_flags];
165:
166: #ifdef lint
167: br = 0; cvec = br; br = cvec;
168: ecrint(0); ecxint(0); eccollide(0);
169: #endif
170:
171: /*
172: * Check that buffer memory was found and enabled.
173: */
174: if (ui->ui_type == 0)
175: return(0);
176: /*
177: * Make a one byte packet in what should be buffer #0.
178: * Submit it for sending. This should cause an xmit interrupt.
179: * The xmit interrupt vector is 8 bytes after the receive vector,
180: * so adjust for this before returning.
181: */
182: *(u_short *)ecbuf = (u_short) 03777;
183: ecbuf[03777] = '\0';
184: addr->ec_xcr = EC_XINTEN|EC_XWBN;
185: DELAY(100000);
186: addr->ec_xcr = EC_XCLR;
187: if (cvec > 0 && cvec != 0x200) {
188: if (cvec & 04) { /* collision interrupt */
189: cvec -= 04;
190: br += 1; /* rcv is collision + 1 */
191: } else { /* xmit interrupt */
192: cvec -= 010;
193: br += 2; /* rcv is xmit + 2 */
194: }
195: }
196: return (1);
197: }
198:
199: /*
200: * Interface exists: make available by filling in network interface
201: * record. System will initialize the interface when it is ready
202: * to accept packets.
203: */
204: ecattach(ui)
205: struct uba_device *ui;
206: {
207: struct ec_softc *es = &ec_softc[ui->ui_unit];
208: register struct ifnet *ifp = &es->es_if;
209: register struct ecdevice *addr = (struct ecdevice *)ui->ui_addr;
210: int i, j;
211: u_char *cp;
212:
213: ifp->if_unit = ui->ui_unit;
214: ifp->if_name = "ec";
215: ifp->if_mtu = ETHERMTU;
216:
217: /*
218: * Read the ethernet address off the board, one nibble at a time.
219: */
220: addr->ec_xcr = EC_UECLR; /* zero address pointer */
221: addr->ec_rcr = EC_AROM;
222: cp = es->es_addr;
223: #define NEXTBIT addr->ec_rcr = EC_AROM|EC_ASTEP; addr->ec_rcr = EC_AROM
224: for (i=0; i < sizeof (es->es_addr); i++) {
225: *cp = 0;
226: for (j=0; j<=4; j+=4) {
227: *cp |= ((addr->ec_rcr >> 8) & 0xf) << j;
228: NEXTBIT; NEXTBIT; NEXTBIT; NEXTBIT;
229: }
230: cp++;
231: }
232: printf("ec%d: hardware address %s\n", ui->ui_unit,
233: ether_sprintf(es->es_addr));
234: ifp->if_init = ecinit;
235: ifp->if_ioctl = ecioctl;
236: ifp->if_output = ecoutput;
237: ifp->if_reset = ecreset;
238: ifp->if_flags = IFF_BROADCAST;
239: for (i=0; i<16; i++)
240: es->es_buf[i]
241: = (u_char *)&umem[ui->ui_ubanum][ui->ui_flags + 2048*i];
242: #if NENETFILTER > 0
243: {
244: struct endevp enp;
245:
246: enp.end_dev_type = ENDT_10MB;
247: enp.end_addr_len = sizeof(es->es_addr);
248: enp.end_hdr_len = sizeof(struct ether_header);
249: enp.end_MTU = ETHERMTU;
250: bcopy((caddr_t)es->es_addr,
251: (caddr_t)(enp.end_addr), sizeof(es->es_addr));
252: bcopy((caddr_t)etherbroadcastaddr,
253: (caddr_t)(enp.end_broadaddr), sizeof(es->es_addr));
254:
255: es->es_enetunit = enetattach(&es->es_if, &enp);
256: }
257: #endif NENETFILTER > 0
258: if_attach(ifp);
259: }
260:
261: /*
262: * Reset of interface after UNIBUS reset.
263: * If interface is on specified uba, reset its state.
264: */
265: ecreset(unit, uban)
266: int unit, uban;
267: {
268: register struct uba_device *ui;
269:
270: if (unit >= NEC || (ui = ecinfo[unit]) == 0 || ui->ui_alive == 0 ||
271: ui->ui_ubanum != uban)
272: return;
273: printf(" ec%d", unit);
274: ec_softc[unit].es_if.if_flags &= ~IFF_RUNNING;
275: ecinit(unit);
276: }
277:
278: /*
279: * Initialization of interface; clear recorded pending
280: * operations, and reinitialize UNIBUS usage.
281: */
282: ecinit(unit)
283: int unit;
284: {
285: struct ec_softc *es = &ec_softc[unit];
286: struct ecdevice *addr;
287: register struct ifnet *ifp = &es->es_if;
288: int i, s;
289:
290: /* not yet, if address still unknown */
291: if (ifp->if_addrlist == (struct ifaddr *)0)
292: return;
293:
294: /*
295: * Hang receive buffers and start any pending writes.
296: * Writing into the rcr also makes sure the memory
297: * is turned on.
298: */
299: if ((ifp->if_flags & IFF_RUNNING) == 0) {
300: addr = (struct ecdevice *)ecinfo[unit]->ui_addr;
301: s = splimp();
302: /*
303: * write our ethernet address into the address recognition ROM
304: * so we can always use the same EC_READ bits (referencing ROM),
305: * in case we change the address sometime.
306: * Note that this is safe here as the receiver is NOT armed.
307: */
308: ec_setaddr(es->es_addr, unit);
309: /*
310: * Arm the receiver
311: */
312: for (i = ECRHBF; i >= ECRLBF; i--)
313: addr->ec_rcr = EC_READ | i;
314: es->es_oactive = 0;
315: es->es_mask = ~0;
316: es->es_if.if_flags |= IFF_RUNNING;
317: if (es->es_if.if_snd.ifq_head)
318: ecstart(unit);
319: splx(s);
320: }
321: }
322:
323: /*
324: * Start output on interface. Get another datagram to send
325: * off of the interface queue, and copy it to the interface
326: * before starting the output.
327: */
328: ecstart(unit)
329: {
330: register struct ec_softc *es = &ec_softc[unit];
331: struct ecdevice *addr;
332: struct mbuf *m;
333:
334: if ((es->es_if.if_flags & IFF_RUNNING) == 0)
335: return;
336: IF_DEQUEUE(&es->es_if.if_snd, m);
337: if (m == 0)
338: return;
339: ecput(es->es_buf[ECTBF], m);
340: addr = (struct ecdevice *)ecinfo[unit]->ui_addr;
341: addr->ec_xcr = EC_WRITE|ECTBF;
342: es->es_oactive = 1;
343: }
344:
345: /*
346: * Ethernet interface transmitter interrupt.
347: * Start another output if more data to send.
348: */
349: ecxint(unit)
350: int unit;
351: {
352: register struct ec_softc *es = &ec_softc[unit];
353: register struct ecdevice *addr =
354: (struct ecdevice *)ecinfo[unit]->ui_addr;
355:
356: if (es->es_oactive == 0)
357: return;
358: if ((addr->ec_xcr&EC_XDONE) == 0 || (addr->ec_xcr&EC_XBN) != ECTBF) {
359: printf("ec%d: stray xmit interrupt, xcr=%b\n", unit,
360: addr->ec_xcr, EC_XBITS);
361: es->es_oactive = 0;
362: addr->ec_xcr = EC_XCLR;
363: return;
364: }
365: es->es_if.if_opackets++;
366: es->es_oactive = 0;
367: es->es_mask = ~0;
368: addr->ec_xcr = EC_XCLR;
369: if (es->es_if.if_snd.ifq_head)
370: ecstart(unit);
371: }
372:
373: /*
374: * Collision on ethernet interface. Do exponential
375: * backoff, and retransmit. If have backed off all
376: * the way print warning diagnostic, and drop packet.
377: */
378: eccollide(unit)
379: int unit;
380: {
381: register struct ec_softc *es = &ec_softc[unit];
382: register struct ecdevice *addr =
383: (struct ecdevice *)ecinfo[unit]->ui_addr;
384: register i;
385: int delay;
386:
387: es->es_if.if_collisions++;
388: if (es->es_oactive == 0)
389: return;
390:
391: /*
392: * Es_mask is a 16 bit number with n low zero bits, with
393: * n the number of backoffs. When es_mask is 0 we have
394: * backed off 16 times, and give up.
395: */
396: if (es->es_mask == 0) {
397: es->es_if.if_oerrors++;
398: log(LOG_ERR, "ec%d: send error\n", unit);
399: /*
400: * Reset interface, then requeue rcv buffers.
401: * Some incoming packets may be lost, but that
402: * can't be helped.
403: */
404: addr->ec_xcr = EC_UECLR;
405: for (i=ECRHBF; i>=ECRLBF; i--)
406: addr->ec_rcr = EC_READ|i;
407: /*
408: * Reset and transmit next packet (if any).
409: */
410: es->es_oactive = 0;
411: es->es_mask = ~0;
412: if (es->es_if.if_snd.ifq_head)
413: ecstart(unit);
414: return;
415: }
416: /*
417: * Do exponential backoff. Compute delay based on low bits
418: * of the interval timer (1 bit for each transmission attempt,
419: * but at most 5 bits). Then delay for that number of
420: * slot times. A slot time is 51.2 microseconds (rounded to 51).
421: * This does not take into account the time already used to
422: * process the interrupt.
423: */
424: es->es_mask <<= 1;
425: delay = mfpr(ICR) & 0x1f &~ es->es_mask;
426: DELAY(delay * 51);
427: /*
428: * Clear the controller's collision flag, thus enabling retransmit.
429: */
430: addr->ec_xcr = EC_CLEAR;
431: }
432:
433: /*
434: * Ethernet interface receiver interrupt.
435: * If input error just drop packet.
436: * Otherwise examine
437: * packet to determine type. If can't determine length
438: * from type, then have to drop packet. Othewise decapsulate
439: * packet based on type and pass to type specific higher-level
440: * input routine.
441: */
442: ecrint(unit)
443: int unit;
444: {
445: struct ecdevice *addr = (struct ecdevice *)ecinfo[unit]->ui_addr;
446:
447: while (addr->ec_rcr & EC_RDONE)
448: ecread(unit);
449: }
450:
451: ecread(unit)
452: int unit;
453: {
454: register struct ec_softc *es = &ec_softc[unit];
455: struct ecdevice *addr = (struct ecdevice *)ecinfo[unit]->ui_addr;
456: register struct ether_header *ec;
457: struct mbuf *m;
458: int len, off, resid, ecoff, rbuf;
459: register struct ifqueue *inq;
460: u_char *ecbuf;
461:
462: es->es_if.if_ipackets++;
463: rbuf = addr->ec_rcr & EC_RBN;
464: if (rbuf < ECRLBF || rbuf > ECRHBF)
465: panic("ecrint");
466: ecbuf = es->es_buf[rbuf];
467: ecoff = *(short *)ecbuf;
468: if (ecoff <= ECRDOFF || ecoff > 2046) {
469: es->es_if.if_ierrors++;
470: #ifdef notdef
471: if (es->es_if.if_ierrors % 100 == 0)
472: printf("ec%d: += 100 input errors\n", unit);
473: #endif
474: goto setup;
475: }
476:
477: /*
478: * Get input data length.
479: * Get pointer to ethernet header (in input buffer).
480: * Deal with trailer protocol: if type is trailer type
481: * get true type from first 16-bit word past data.
482: * Remember that type was trailer by setting off.
483: */
484: len = ecoff - ECRDOFF - sizeof (struct ether_header);
485: ec = (struct ether_header *)(ecbuf + ECRDOFF);
486: ec->ether_type = ntohs((u_short)ec->ether_type);
487: #define ecdataaddr(ec, off, type) ((type)(((caddr_t)((ec)+1)+(off))))
488: if (ec->ether_type >= ETHERTYPE_TRAIL &&
489: ec->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
490: off = (ec->ether_type - ETHERTYPE_TRAIL) * 512;
491: if (off >= ETHERMTU)
492: goto setup; /* sanity */
493: ec->ether_type = ntohs(*ecdataaddr(ec, off, u_short *));
494: resid = ntohs(*(ecdataaddr(ec, off+2, u_short *)));
495: if (off + resid > len)
496: goto setup; /* sanity */
497: len = off + resid;
498: } else
499: off = 0;
500: if (len == 0)
501: goto setup;
502:
503: /*
504: * Pull packet off interface. Off is nonzero if packet
505: * has trailing header; ecget will then force this header
506: * information to be at the front, but we still have to drop
507: * the type and length which are at the front of any trailer data.
508: */
509: m = ecget(ecbuf, len, off, &es->es_if);
510: if (m == 0)
511: goto setup;
512: if (off) {
513: struct ifnet *ifp;
514:
515: ifp = *(mtod(m, struct ifnet **));
516: m->m_off += 2 * sizeof (u_short);
517: m->m_len -= 2 * sizeof (u_short);
518: *(mtod(m, struct ifnet **)) = ifp;
519: }
520: switch (ec->ether_type) {
521:
522: #ifdef INET
523: case ETHERTYPE_IP:
524: schednetisr(NETISR_IP);
525: inq = &ipintrq;
526: break;
527:
528: case ETHERTYPE_ARP:
529: arpinput(&es->es_ac, m);
530: goto setup;
531: #endif
532: #ifdef NS
533: case ETHERTYPE_NS:
534: schednetisr(NETISR_NS);
535: inq = &nsintrq;
536: break;
537:
538: #endif
539: #if NENETFILTER > 0
540: default:
541: {
542: register struct mbuf *mtop;
543: register short *sp,*sp2;
544: int i;
545: /*
546: * We need the local net header after all. Oh well,
547: * this could be improved.
548: */
549: MGET(mtop, M_DONTWAIT, MT_DATA);
550: if (mtop == 0) { /* no more mbufs? */
551: m_freem(m); /* wasted effort */
552: goto setup;
553: }
554: ec->ether_type = htons((u_short)ec->ether_type);
555: sp = (short *) ec;
556: sp2 = mtod(mtop, short *);
557: for (i = 0 ; i < (sizeof(struct ether_header)/2) ; i++)
558: *sp2++ = *sp++;
559: mtop->m_len = sizeof(struct ether_header);
560: IF_ADJ(m);
561: mtop->m_next = m;
562: enetFilter(es->es_enetunit, mtop,
563: (len + sizeof(struct ether_header)) );
564: goto setup;
565: }
566: #else
567: default:
568: m_freem(m);
569: goto setup;
570: #endif NENETFILTER > 0
571: }
572:
573: if (IF_QFULL(inq)) {
574: IF_DROP(inq);
575: m_freem(m);
576: goto setup;
577: }
578: IF_ENQUEUE(inq, m);
579:
580: setup:
581: /*
582: * Reset for next packet.
583: */
584: addr->ec_rcr = EC_READ|EC_RCLR|rbuf;
585: }
586:
587: /*
588: * Ethernet output routine.
589: * Encapsulate a packet of type family for the local net.
590: * Use trailer local net encapsulation if enough data in first
591: * packet leaves a multiple of 512 bytes of data in remainder.
592: * If destination is this address or broadcast, send packet to
593: * loop device to kludge around the fact that 3com interfaces can't
594: * talk to themselves.
595: */
596: ecoutput(ifp, m0, dst)
597: struct ifnet *ifp;
598: struct mbuf *m0;
599: struct sockaddr *dst;
600: {
601: int type, s, error;
602: u_char edst[6];
603: struct in_addr idst;
604: register struct ec_softc *es = &ec_softc[ifp->if_unit];
605: register struct mbuf *m = m0;
606: register struct ether_header *ec;
607: register int off;
608: struct mbuf *mcopy = (struct mbuf *)0;
609: #if NENETFILTER > 0
610: struct mbuf *enetcopy = (struct mbuf *)0;
611: #endif NENETFILTER
612: int usetrailers;
613:
614: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
615: error = ENETDOWN;
616: goto bad;
617: }
618: switch (dst->sa_family) {
619:
620: #ifdef INET
621: case AF_INET:
622: idst = ((struct sockaddr_in *)dst)->sin_addr;
623: if (!arpresolve(&es->es_ac, m, &idst, edst, &usetrailers))
624: return (0); /* if not yet resolved */
625: if (!bcmp((caddr_t)edst, (caddr_t)etherbroadcastaddr,
626: sizeof(edst)))
627: mcopy = m_copy(m, 0, (int)M_COPYALL);
628: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
629: /* need per host negotiation */
630: if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
631: m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
632: type = ETHERTYPE_TRAIL + (off>>9);
633: m->m_off -= 2 * sizeof (u_short);
634: m->m_len += 2 * sizeof (u_short);
635: *mtod(m, u_short *) = ntohs((u_short)ETHERTYPE_IP);
636: *(mtod(m, u_short *) + 1) = ntohs((u_short)m->m_len);
637: goto gottrailertype;
638: }
639: type = ETHERTYPE_IP;
640: off = 0;
641: goto gottype;
642: #endif
643: #ifdef NS
644: case AF_NS:
645: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
646: (caddr_t)edst, sizeof (edst));
647:
648: if (!bcmp((caddr_t)edst, (caddr_t)&ns_broadhost,
649: sizeof(edst))) {
650:
651: mcopy = m_copy(m, 0, (int)M_COPYALL);
652: } else if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost,
653: sizeof(edst))) {
654:
655: return(looutput(&loif, m, dst));
656: }
657: type = ETHERTYPE_NS;
658: off = 0;
659: goto gottype;
660: #endif
661: #if NENETFILTER > 0
662: case AF_IMPLINK:
663: ec = mtod(m, struct ether_header *);
664: /* see if we need to fake loopback */
665: if ( /* is packet to us? */
666: (!bcmp((caddr_t)ec->ether_dhost,
667: (caddr_t)es->es_addr,
668: sizeof(ec->ether_dhost)))
669: || /* or is it a broadcast? */
670: (!bcmp((caddr_t)ec->ether_dhost,
671: (caddr_t)etherbroadcastaddr,
672: sizeof(ec->ether_dhost)))
673: ) {
674: enetcopy = m_copy(m, 0, (int)M_COPYALL);
675: }
676: goto gotheader;
677: #endif NENETFILTER
678:
679: case AF_UNSPEC:
680: ec = (struct ether_header *)dst->sa_data;
681: bcopy((caddr_t)ec->ether_dhost, (caddr_t)edst, sizeof (edst));
682: type = ec->ether_type;
683: goto gottype;
684:
685: default:
686: printf("ec%d: can't handle af%d\n", ifp->if_unit,
687: dst->sa_family);
688: error = EAFNOSUPPORT;
689: goto bad;
690: }
691:
692: gottrailertype:
693: /*
694: * Packet to be sent as trailer: move first packet
695: * (control information) to end of chain.
696: */
697: while (m->m_next)
698: m = m->m_next;
699: m->m_next = m0;
700: m = m0->m_next;
701: m0->m_next = 0;
702: m0 = m;
703:
704: gottype:
705: /*
706: * Add local net header. If no space in first mbuf,
707: * allocate another.
708: */
709: if (m->m_off > MMAXOFF ||
710: MMINOFF + sizeof (struct ether_header) > m->m_off) {
711: m = m_get(M_DONTWAIT, MT_HEADER);
712: if (m == 0) {
713: error = ENOBUFS;
714: goto bad;
715: }
716: m->m_next = m0;
717: m->m_off = MMINOFF;
718: m->m_len = sizeof (struct ether_header);
719: } else {
720: m->m_off -= sizeof (struct ether_header);
721: m->m_len += sizeof (struct ether_header);
722: }
723: ec = mtod(m, struct ether_header *);
724: ec->ether_type = htons((u_short)type);
725: bcopy((caddr_t)edst, (caddr_t)ec->ether_dhost, sizeof (edst));
726: #if NENETFILTER > 0
727: gotheader:
728: #endif NENETFILTER
729: bcopy((caddr_t)es->es_addr, (caddr_t)ec->ether_shost,
730: sizeof(ec->ether_shost));
731:
732: /*
733: * Queue message on interface, and start output if interface
734: * not yet active.
735: */
736: s = splimp();
737: if (IF_QFULL(&ifp->if_snd)) {
738: IF_DROP(&ifp->if_snd);
739: error = ENOBUFS;
740: goto qfull;
741: }
742: IF_ENQUEUE(&ifp->if_snd, m);
743: if (es->es_oactive == 0)
744: ecstart(ifp->if_unit);
745: #if NENETFILTER > 0
746: if (enetcopy) { /* we have a loopback that isn't an IP */
747: register int count = 0;
748: register struct mbuf *mt = enetcopy;
749:
750: /* figure out how long the packet is */
751: do {
752: count += mt->m_len;
753: mt = mt->m_next;
754: } while (mt);
755:
756: /*
757: * should perhaps reject certain packet types here,
758: * but probably less total effort to let enetFilter
759: * reject them.
760: */
761: enetFilter(es->es_enetunit, enetcopy, count);
762: }
763: #endif NENETFILTER
764: splx(s);
765: return (mcopy ? looutput(&loif, mcopy, dst) : 0);
766:
767: qfull:
768: m0 = m;
769: splx(s);
770: bad:
771: m_freem(m0);
772: if (mcopy)
773: m_freem(mcopy);
774: #if NENETFILTER > 0
775: if (enetcopy)
776: m_freem(enetcopy);
777: #endif NENETFILTER
778: return (error);
779: }
780:
781: /*
782: * Routine to copy from mbuf chain to transmit
783: * buffer in UNIBUS memory.
784: * If packet size is less than the minimum legal size,
785: * the buffer is expanded. We probably should zero out the extra
786: * bytes for security, but that would slow things down.
787: */
788: ecput(ecbuf, m)
789: u_char *ecbuf;
790: struct mbuf *m;
791: {
792: register struct mbuf *mp;
793: register int off;
794: u_char *bp;
795:
796: for (off = 2048, mp = m; mp; mp = mp->m_next)
797: off -= mp->m_len;
798: if (2048 - off < ETHERMIN + sizeof (struct ether_header))
799: off = 2048 - ETHERMIN - sizeof (struct ether_header);
800: *(u_short *)ecbuf = off;
801: bp = (u_char *)(ecbuf + off);
802: for (mp = m; mp; mp = mp->m_next) {
803: register unsigned len = mp->m_len;
804: u_char *mcp;
805:
806: if (len == 0)
807: continue;
808: mcp = mtod(mp, u_char *);
809: if ((unsigned)bp & 01) {
810: *bp++ = *mcp++;
811: len--;
812: }
813: if (off = (len >> 1)) {
814: register u_short *to, *from;
815:
816: to = (u_short *)bp;
817: from = (u_short *)mcp;
818: do
819: *to++ = *from++;
820: while (--off > 0);
821: bp = (u_char *)to,
822: mcp = (u_char *)from;
823: }
824: if (len & 01)
825: *bp++ = *mcp++;
826: }
827: m_freem(m);
828: }
829:
830: /*
831: * Routine to copy from UNIBUS memory into mbufs.
832: * Similar in spirit to if_rubaget.
833: *
834: * Warning: This makes the fairly safe assumption that
835: * mbufs have even lengths.
836: */
837: struct mbuf *
838: ecget(ecbuf, totlen, off0, ifp)
839: u_char *ecbuf;
840: int totlen, off0;
841: struct ifnet *ifp;
842: {
843: register struct mbuf *m;
844: struct mbuf *top = 0, **mp = ⊤
845: register int off = off0, len;
846: u_char *cp;
847:
848: cp = ecbuf + ECRDOFF + sizeof (struct ether_header);
849: while (totlen > 0) {
850: register int words;
851: u_char *mcp;
852:
853: MGET(m, M_DONTWAIT, MT_DATA);
854: if (m == 0)
855: goto bad;
856: if (off) {
857: len = totlen - off;
858: cp = ecbuf + ECRDOFF +
859: sizeof (struct ether_header) + off;
860: } else
861: len = totlen;
862: if (ifp)
863: len += sizeof(ifp);
864: if (len >= NBPG) {
865: MCLGET(m);
866: if (m->m_len == CLBYTES)
867: m->m_len = len = MIN(len, CLBYTES);
868: else
869: m->m_len = len = MIN(MLEN, len);
870: } else {
871: m->m_len = len = MIN(MLEN, len);
872: m->m_off = MMINOFF;
873: }
874: mcp = mtod(m, u_char *);
875: if (ifp) {
876: /*
877: * Prepend interface pointer to first mbuf.
878: */
879: *(mtod(m, struct ifnet **)) = ifp;
880: mcp += sizeof(ifp);
881: len -= sizeof(ifp);
882: ifp = (struct ifnet *)0;
883: }
884: if (words = (len >> 1)) {
885: register u_short *to, *from;
886:
887: to = (u_short *)mcp;
888: from = (u_short *)cp;
889: do
890: *to++ = *from++;
891: while (--words > 0);
892: mcp = (u_char *)to;
893: cp = (u_char *)from;
894: }
895: if (len & 01)
896: *mcp++ = *cp++;
897: *mp = m;
898: mp = &m->m_next;
899: if (off == 0) {
900: totlen -= len;
901: continue;
902: }
903: off += len;
904: if (off == totlen) {
905: cp = ecbuf + ECRDOFF + sizeof (struct ether_header);
906: off = 0;
907: totlen = off0;
908: }
909: }
910: return (top);
911: bad:
912: m_freem(top);
913: return (0);
914: }
915:
916: /*
917: * Process an ioctl request.
918: */
919: ecioctl(ifp, cmd, data)
920: register struct ifnet *ifp;
921: int cmd;
922: caddr_t data;
923: {
924: register struct ifaddr *ifa = (struct ifaddr *)data;
925: struct ec_softc *es = &ec_softc[ifp->if_unit];
926: struct ecdevice *addr;
927: int s = splimp(), error = 0;
928:
929: addr = (struct ecdevice *)(ecinfo[ifp->if_unit]->ui_addr);
930:
931: switch (cmd) {
932:
933: case SIOCSIFADDR:
934: ifp->if_flags |= IFF_UP;
935:
936: switch (ifa->ifa_addr.sa_family) {
937: #ifdef INET
938: case AF_INET:
939: ecinit(ifp->if_unit); /* before arpwhohas */
940: ((struct arpcom *)ifp)->ac_ipaddr =
941: IA_SIN(ifa)->sin_addr;
942: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
943: break;
944: #endif
945: #ifdef NS
946: case AF_NS:
947: {
948: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
949:
950: if (ns_nullhost(*ina))
951: ina->x_host = *(union ns_host *)(es->es_addr);
952: else {
953: /*
954: * The manual says we can't change the address
955: * while the receiver is armed,
956: * so reset everything
957: */
958: ifp->if_flags &= ~IFF_RUNNING;
959: bcopy((caddr_t)ina->x_host.c_host,
960: (caddr_t)es->es_addr, sizeof(es->es_addr));
961: }
962: ecinit(ifp->if_unit); /* does ec_setaddr() */
963: break;
964: }
965: #endif
966: default:
967: ecinit(ifp->if_unit);
968: break;
969: }
970: break;
971:
972: case SIOCSIFFLAGS:
973: if ((ifp->if_flags & IFF_UP) == 0 &&
974: ifp->if_flags & IFF_RUNNING) {
975: addr->ec_xcr = EC_UECLR;
976: ifp->if_flags &= ~IFF_RUNNING;
977: } else if (ifp->if_flags & IFF_UP &&
978: (ifp->if_flags & IFF_RUNNING) == 0)
979: ecinit(ifp->if_unit);
980: break;
981:
982: default:
983: error = EINVAL;
984: }
985: splx(s);
986: return (error);
987: }
988:
989: ec_setaddr(physaddr,unit)
990: u_char *physaddr;
991: int unit;
992: {
993: struct ec_softc *es = &ec_softc[unit];
994: struct uba_device *ui = ecinfo[unit];
995: register struct ecdevice *addr = (struct ecdevice *)ui->ui_addr;
996: register char nibble;
997: register int i, j;
998:
999: /*
1000: * Use the ethernet address supplied
1001: * Note that we do a UECLR here, so the receive buffers
1002: * must be requeued.
1003: */
1004:
1005: #ifdef DEBUG
1006: printf("ec_setaddr: setting address for unit %d = %s",
1007: unit, ether_sprintf(physaddr));
1008: #endif
1009: addr->ec_xcr = EC_UECLR;
1010: addr->ec_rcr = 0;
1011: /* load requested address */
1012: for (i = 0; i < 6; i++) { /* 6 bytes of address */
1013: es->es_addr[i] = physaddr[i];
1014: nibble = physaddr[i] & 0xf; /* lower nibble */
1015: addr->ec_rcr = (nibble << 8);
1016: addr->ec_rcr = (nibble << 8) + EC_AWCLK; /* latch nibble */
1017: addr->ec_rcr = (nibble << 8);
1018: for (j=0; j < 4; j++) {
1019: addr->ec_rcr = 0;
1020: addr->ec_rcr = EC_ASTEP; /* step counter */
1021: addr->ec_rcr = 0;
1022: }
1023: nibble = (physaddr[i] >> 4) & 0xf; /* upper nibble */
1024: addr->ec_rcr = (nibble << 8);
1025: addr->ec_rcr = (nibble << 8) + EC_AWCLK; /* latch nibble */
1026: addr->ec_rcr = (nibble << 8);
1027: for (j=0; j < 4; j++) {
1028: addr->ec_rcr = 0;
1029: addr->ec_rcr = EC_ASTEP; /* step counter */
1030: addr->ec_rcr = 0;
1031: }
1032: }
1033: #ifdef DEBUG
1034: /*
1035: * Read the ethernet address off the board, one nibble at a time.
1036: */
1037: addr->ec_xcr = EC_UECLR;
1038: addr->ec_rcr = 0; /* read RAM */
1039: cp = es->es_addr;
1040: #undef NEXTBIT
1041: #define NEXTBIT addr->ec_rcr = EC_ASTEP; addr->ec_rcr = 0
1042: for (i=0; i < sizeof (es->es_addr); i++) {
1043: *cp = 0;
1044: for (j=0; j<=4; j+=4) {
1045: *cp |= ((addr->ec_rcr >> 8) & 0xf) << j;
1046: NEXTBIT; NEXTBIT; NEXTBIT; NEXTBIT;
1047: }
1048: cp++;
1049: }
1050: printf("ec_setaddr: RAM address for unit %d = %s",
1051: unit, ether_sprintf(physaddr));
1052: #endif
1053: }
1054: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.