![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_un.eg CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso|
Return to if_un.eg CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso |
1.1 root 1: /*
2: * Copyright IBM Corporation 1987,1990
3: *
4: * All Rights Reserved
5: *
6: * Permission to use, copy, modify, and distribute this software and its
7: * documentation for any purpose and without fee is hereby granted,
8: * provided that the above copyright notice appear in all copies and that
9: * both that copyright notice and this permission notice appear in
10: * supporting documentation, and that the name of IBM not be
11: * used in advertising or publicity pertaining to distribution of the
12: * software without specific, written prior permission.
13: *
14: * IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
15: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR USE.
16: * IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
17: * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
18: * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
19: * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
20: * THIS SOFTWARE.
21: *
22: * @(#)if_un.eg 7.1 (Berkeley) 10/29/90
23: */
24:
25: /*
26: * Ungermann-Bass PC-NIC (Ethernet) Adapter (4.3 driver)
27: */
28:
29: #include "un.h"
30: #if NUN > 0
31:
32: #include "../machine/pte.h"
33:
34: #include "param.h"
35: #include "systm.h"
36: #include "mbuf.h"
37: #include "buf.h"
38: #include "protosw.h"
39: #include "socket.h"
40: #include "vmmac.h"
41: #include "ioctl.h"
42: #include "errno.h"
43:
44: #include "../net/if.h"
45: #include "../net/netisr.h"
46: #include "../net/route.h"
47:
48: #ifdef INET
49: #include "../netinet/in.h"
50: #include "../netinet/in_systm.h"
51: #include "../netinet/in_var.h"
52: #include "../netinet/ip.h"
53: #include "../netinet/if_ether.h"
54: #endif INET
55:
56: #ifdef NS
57: #include "../netns/ns.h"
58: #include "../netns/ns_if.h"
59: #endif NS
60:
61: #ifdef ISO
62: #include "../netargo/if_clnp.h"
63: #include "../netargo/iso.h"
64: #include "../netargo/iso_var.h"
65: #include "../netargo/argo_debug.h"
66: #endif ISO
67:
68: #include "../machine/io.h"
69: #include "if_unreg.h"
70: #ifdef IEEELLC
71: #include "if_llc.h"
72: #endif IEEELLC
73: #include "../machineio/ioccvar.h"
74: #include "../machine/debug.h"
75:
76: int unprobe(), unattach();
77:
78: #ifdef AT
79: caddr_t unstd[] = { (caddr_t) 0xa0000, (caddr_t) 0xa8000,
80: (caddr_t) 0xb0000, (caddr_t) 0xb8000, 0 };
81: #else
82: caddr_t unstd[] = { (caddr_t) 0xf4080000, (caddr_t) 0xf4088000,
83: (caddr_t) 0xf4090000, (caddr_t) 0xf4098000, 0 };
84: #endif AT
85:
86: struct iocc_device *uninfo[NUN];
87:
88: int unint(), uninit(), unioctl(), unoutput(), unreset();
89:
90: struct iocc_driver undriver =
91: { unprobe, 0, unattach, 0, unstd, "un", uninfo,
92: 0, 0, unint, UN_EADDROFF };
93:
94: struct mbuf *unget();
95:
96: /*
97: * Ethernet software status per adapter.
98: */
99: struct un_softc {
100: struct arpcom us_ac; /* generic network interface stuff */
101: #define us_if us_ac.ac_if /* ifnet struct */
102: #define us_addr us_ac.ac_enaddr /* hardware (i.e. ethernet) address */
103: short us_oactive; /* 1 => output active */
104: short us_nextpage; /* next receive buffer page */
105: short us_xbuf; /* in-use xmt buf (if output active) */
106: short us_xfull[2]; /* 1 => a full xmt buf */
107: short us_xstart[2]; /* start address used in unstart */
108: } un_softc[NUN];
109:
110: #ifdef DEBUG
111: char undebug = 0;
112: #endif DEBUG
113:
114: #ifdef ATR
115: #define move_window(window, addr) {\
116: int real_addr;\
117: int new_window;\
118: \
119: window = get_128_window();\
120: real_addr = 0xfffff & (int) addr;\
121: new_window = real_addr & 0xe0000;\
122: set_128_window(new_window);\
123: addr = (struct undevice *) (real_addr - new_window);\
124: }
125:
126: #define restore_window(window) set_128_window(window)
127: #define bcopyin(from,to,len) bcopy((from)+pcif_128_fw,to,len)
128: #define bcopyout(from,to,len) bcopy(from,(to)+pcif_128_fw,len)
129: #endif ATR
130:
131: #ifdef IBMRTPC
132: #define bcopyin bcopy
133: #define bcopyout bcopy
134: #endif IBMRTPC
135: /*
136: * unprobe - try to generate an interrupt (to see if the board is there)
137: */
138: unprobe(p)
139: register caddr_t p;
140: {
141: register struct undevice *addr = (struct undevice *) p;
142: #ifdef ATR
143: register int old_window;
144: move_window(old_window, addr);
145: #endif ATR
146: (void) unzap(addr);
147: UN_GLOBIENB(0); /* global interrrupt enable */
148: MM_OUT(&addr->un_csr, UN_GSFTINT); /* generate software interrupt */
149: PROBE_DELAY(100000);
150: MM_OUT(&addr->un_csr, 0);
151: #ifdef ATR
152: restore_window(old_window);
153: #endif ATR
154: return(PROBE_OK);
155: }
156:
157: /*
158: * unattach - make the interface available to the network software
159: * (if the auto-configuration software determines that the interface
160: * exists). The system will initialize the interface when it is
161: * ready to accept packets.
162: */
163: unattach(iod)
164: register struct iocc_device *iod;
165: {
166: register struct un_softc *us = &un_softc[iod->iod_unit];
167: register struct ifnet *ifp = &us->us_if;
168: register struct undevice *addr = (struct undevice *) iod->iod_addr;
169: register int i;
170: #ifdef ATR
171: register int old_window;
172:
173: move_window(old_window, addr);
174: #endif ATR
175: ifp->if_unit = iod->iod_unit;
176: ifp->if_name = "un";
177:
178: #ifdef IEEELLC
179: ifp->if_mtu = ETHERMTU - 3; /* 3 bytes for UI LLC frame */
180: #else
181: ifp->if_mtu = ETHERMTU;
182: #endif IEEELCC
183:
184: /*
185: * Read the ethernet address off the board.
186: * Save it and also write it to the edlc chip.
187: */
188: for (i = 0; i < ETH_ADDR_SIZE; i++){
189: us->us_addr[i] = MM_IN(&addr->un_eprom[UN_EADDROFF+i]);
190: MM_OUT(&addr->un_edlc.nodeID[i], us->us_addr[i]);
191: }
192: printf("un%d: ethernet address ", ifp->if_unit);
193: unprintethaddr(us->us_addr);
194: printf("\n");
195: ifp->if_init = uninit;
196: ifp->if_ioctl = unioctl;
197: ifp->if_output = unoutput;
198: ifp->if_reset = unreset;
199: ifp->if_flags = IFF_BROADCAST;
200: #ifdef ISO
201: ifp->if_flags |= IFF_EAVESDROP;
202: #endif ISO
203: if_attach(ifp);
204: DEBUGF(undebug, printf("un%d: attached\n", iod->iod_unit);)
205: #ifdef ATR
206: restore_window(old_window);
207: #endif ATR
208: }
209:
210: /*
211: * unreset - reset interface
212: */
213: unreset(unit)
214: register unsigned int unit;
215: {
216: register struct iocc_device *iod;
217:
218: if (unit < NUN && (iod = uninfo[unit]) != 0 && iod->iod_alive != 0){
219: un_softc[unit].us_if.if_flags &= ~IFF_RUNNING;
220: DEBUGF(undebug, printf("un%d: reset\n", unit);)
221: uninit(unit);
222: }
223: }
224:
225: /*
226: * uninit - initialize interface, enable packet reception, start any
227: * pending writes
228: */
229: uninit(unit)
230: register int unit;
231: {
232: register struct un_softc *us = &un_softc[unit];
233: register struct ifnet *ifp = &us->us_if;
234: register int s;
235: register struct undevice *addr;
236: register int i;
237:
238: if (ifp->if_addrlist == (struct ifaddr *) 0){
239: /* no address */
240: return;
241: }
242: if ((ifp->if_flags & IFF_RUNNING) == 0){
243: int old_window;
244:
245: addr = (struct undevice *) (uninfo[unit]->iod_addr);
246: #ifdef ATR
247: move_window(old_window, addr);
248: #endif ATR
249: s = splimp();
250: us->us_nextpage = unzap(addr); /* initialize hardware */
251: /* unzap returns next receive page to be used */
252: for (i = 0; i < ETH_ADDR_SIZE; i++){
253: MM_OUT(&addr->un_edlc.nodeID[i], us->us_addr[i]);
254: }
255: us->us_oactive = 0; /* output not active */
256: /* turn adapter on */
257: ifp->if_flags |= IFF_RUNNING;
258: MM_OUT(&addr->un_csr, UN_PAVIENB);
259: /* Allow packet available interrupts */
260: UN_GLOBIENB(us->us_nextpage); /* global interrrupt enable */
261: if (ifp->if_snd.ifq_head){ /* anything on send queue */
262: struct mbuf *m;
263:
264: IF_DEQUEUE(&ifp->if_snd, m);
265: unput(us, addr, m, 0);
266: unstart(us, addr, 0);
267: if (ifp->if_snd.ifq_head){
268: IF_DEQUEUE(&ifp->if_snd, m);
269: unput(us, addr, m, 1);
270: }
271: }
272: splx(s);
273: #ifdef ATR
274: restore_window(old_window);
275: #endif ATR
276: }
277: DEBUGF(undebug, printf("un%d: init'ed\n", unit);)
278: }
279:
280: /*
281: * unstart - start output from one of the adapter's 2 transmit buffers
282: */
283: unstart(us, addr, xbuf)
284: register struct un_softc *us;
285: register struct undevice *addr;
286: register int xbuf;
287: {
288: us->us_oactive = 1;
289: us->us_xbuf = xbuf;
290: UN_XMIT(addr, us->us_xstart[xbuf]);
291: MM_OUT(&addr->un_csr, UN_IENABLE); /* enable transmit done interrupt */
292: }
293:
294: /*
295: * unint - interrupt handler. find the cause of the interrupt and
296: * dispatch an appropriate handler routine.
297: */
298: unint(unit)
299: register int unit;
300: {
301: register struct un_softc *us = &un_softc[unit];
302: register struct undevice *addr =
303: (struct undevice *) uninfo[unit]->iod_addr;
304: register char status;
305: register int rc = 1;
306: #ifdef ATR
307: register int old_window;
308:
309: move_window(old_window, addr);
310: #endif ATR
311:
312: UN_DISABLE(us->us_nextpage);
313: while ((status = ~MM_IN(&addr->un_csr)) & UN_PAVINT){
314: DEBUGF(undebug & 0x2, printf("unint: unit = %d, csr = %b",
315: unit, status & 0xff, UN_CSRBITS);)
316: unrint(unit, us, addr);
317: rc = 0;
318: }
319: if (status & UN_TXRINT){
320: DEBUGF(undebug & 0x2, printf("unint: unit = %d, csr = %b",
321: unit, status & 0xff, UN_CSRBITS);)
322: unxint(unit, us, addr);
323: rc = 0;
324: }
325: UN_ENABLE(us->us_nextpage);
326: #ifdef ATR
327: restore_window(old_window);
328: #endif ATR
329: return(rc);
330: }
331:
332: /*
333: * unrint - interrupt handler for packet reception.
334: *
335: * log error if error bits are latched, examine packet to determine
336: * type, if can't determine packet length from type, drop packet.
337: * otherwise decapsulate packet based on type and pass to an appropriate
338: * higher-level input routine.
339: */
340: unrint(unit, us, addr)
341: int unit;
342: register struct un_softc *us;
343: register struct undevice *addr;
344: {
345: register struct ether_header *eh;
346: register struct mbuf *m;
347: register int len;
348: register int off;
349: int resid;
350: struct ifqueue *inq;
351: char status = MM_IN(&addr->un_edlc.rstat);
352: u_short type;
353: u_short ungetushortatoff();
354: #ifdef IEEELLC
355: struct ether_header ehbuf;
356: #endif IEEELLC
357:
358: MM_OUT(&addr->un_edlc.rstat, status); /* clear status */
359: /* (the hardware xor's in the value of status setting rstat to 0) */
360: DEBUGF(undebug & 0x2, printf(" rstat = %b", status, RS_BITS);)
361: /*
362: * Latch errors. (Errors found correspond to packets
363: * that were received prior to the current packet
364: * since packet available interrupts are generated
365: * for good packets only.)
366: */
367: if (status & RS_ERR){
368: DEBUGF(undebug, printf("unrint: input error\n");)
369: us->us_if.if_ierrors++;
370: }
371: us->us_if.if_ipackets++;
372:
373: /*
374: * determine the length of the received packet.
375: */
376: len = 0;
377: off = us->us_nextpage;
378:
379: #define BUMP(page) if (++(page) == UN_NUMRBUFS) page = 0
380: while ((MM_IN(&addr->un_pram[us->us_nextpage]) & UN_LAST_PAGE) == 0){
381: len += UN_RBUFSIZE;
382: BUMP(us->us_nextpage);
383: }
384: len += (MM_IN(&addr->un_pram[us->us_nextpage]) &
385: UN_PAGE_LENGTH_MASK) + 1;
386: BUMP(us->us_nextpage);
387: #undef BUMP
388: DEBUGF(undebug & 0x2, printf(" len = %d ", len);)
389: if (len > UN_XBSIZE){
390: printf("un%d: huge packet!\n",unit);
391: goto chuckit;
392: }
393: /*
394: * Process the packet
395: */
396: eh = (struct ether_header *) &addr->un_rcvbuf[off][0];
397: DEBUGF(undebug & 0x2,
398: { char cbuf[6];
399: printf(" from = ");
400: bcopyin(eh->ether_shost, cbuf, sizeof(cbuf));
401: unprintethaddr(cbuf);
402: printf(" to = ");
403: bcopyin(eh->ether_dhost, cbuf, sizeof(cbuf));
404: unprintethaddr(cbuf);
405: printf(" "); }
406: )
407: len -= sizeof(struct ether_header);
408: type = ntohs((u_short) MM_INW(&eh->ether_type));
409: /*
410: * The ETHERTYPE_NTRAILER packet types starting at ETHERTYPE_TRAIL
411: * have (type - ETHERTYPE_TRAIL) * 512 bytes of data followed by
412: * a type field and then a (variable length) header
413: */
414: if (type >= ETHERTYPE_TRAIL &&
415: type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER){
416: off = (type - ETHERTYPE_TRAIL) * 512;
417: if (off >= ETHERMTU){
418: goto chuckit;
419: }
420: type = ungetushortatoff(addr, eh, off);
421: resid = ungetushortatoff(addr, eh, off + 2);
422: if (off + resid > len){
423: goto chuckit;
424: }
425: len = off + resid;
426: } else {
427: off = 0;
428: }
429: if (len == 0){
430: goto chuckit;
431: }
432:
433: #ifdef IEEELLC
434: if (type <= ETHERMTU) {
435: /* may need ether_header for XID, TEST LLC functions */
436: ehbuf = *eh;
437: }
438: #endif IEEELLC
439:
440: /*
441: * pull packet off interface. if off is non-zero, the
442: * packet has a trailing "header". unget will move this
443: * header to the front, but we still have to remove the
444: * type and length fields from the front of the data.
445: */
446: m = unget(addr, (char *) eh, len, off, &us->us_if);
447: /*
448: * update the full page pointer and clear the packet available
449: * flag if necessary. update the fpp here to free the on-board
450: * receive pages as soon as possible.
451: */
452: unupdatefpp(addr, us->us_nextpage);
453: if (m != 0){
454: if (off){
455: #ifdef ISO
456: /*
457: * Move snpa header over by 4 bytes to skip
458: * the trailer Type and Header length fields.
459: */
460: struct snpa_hdr sh;
461:
462: bcopy(mtod(m, char *), (caddr_t)&sh, sizeof(struct snpa_hdr));
463: m->m_off += 2 * sizeof(u_short);
464: m->m_len -= 2 * sizeof(u_short);
465: bcopy((caddr_t)&sh, mtod(m, char *), sizeof(struct snpa_hdr));
466: #else ISO
467: struct ifnet *ifp;
468: /*
469: * bcopy is used since word moves must be on 4 byte
470: * boundaries on the RT PC
471: */
472: bcopy(mtod(m, char *), (char *) &ifp, sizeof(ifp));
473: m->m_off += 2 * sizeof(u_short);
474: m->m_len -= 2 * sizeof(u_short);
475: bcopy((char *) &ifp, mtod(m, char *), sizeof(ifp));
476: #endif ISO
477: }
478: switch (type){
479: #ifdef INET
480: case ETHERTYPE_IP:
481: {
482: int s;
483:
484: DEBUGF(undebug & 0x2, printf("ip packet\n");)
485: schednetisr(NETISR_IP);
486: s = splimp();
487: inq = &ipintrq;
488: if (IF_QFULL(inq)){
489: DEBUGF(undebug & 0x2, printf(" qfull\n");)
490: IF_DROP(inq);
491: m_freem(m);
492: } else {
493: IF_ENQUEUE(inq, m);
494: DEBUGF(undebug & 0x2, printf(" queued\n");)
495: }
496: splx(s);
497: break;
498: }
499:
500: case ETHERTYPE_ARP:
501: DEBUGF(undebug & 0x2, printf("arp packet\n");)
502: arpinput(&us->us_ac, m); /* arpinput frees m */
503: break;
504: #endif INET
505: #ifdef NS
506: case ETHERTYPE_NS:
507: DEBUGF(undebug & 0x2, printf("ns packet\n");)
508: schednetisr(NETISR_NS);
509: inq = &nsintrq;
510: break;
511: #endif NS
512: #ifndef IEEELLC
513: #ifdef ISO
514: case ETHERTYPE_CLNP: /* should be CLNL */
515: DEBUGF(undebug & 0x2, printf("clnl packet\n");)
516:
517: /* IFF_EAVESDROP can not be turned off for Ethernet */
518:
519: schednetisr(NETISR_CLNP);
520: inq = &clnlintrq;
521: if (IF_QFULL(inq)){
522: DEBUGF(undebug & 0x2, printf(" qfull\n");)
523: IF_DROP(inq);
524: m_freem(m);
525: } else {
526: IF_ENQUEUE(inq, m);
527: DEBUGF(undebug & 0x2, printf(" queued\n");)
528: }
529: break;
530: #endif ISO
531: default:
532: DEBUGF(undebug & 0x2, printf("unknown packet\n");)
533: m_freem(m);
534: break;
535: #else
536: default: {
537: struct llc *l;
538: caddr_t pkt_start;
539: #ifdef ISO
540: #define PREPENDED_SIZE sizeof(struct snpa_hdr)
541: #else
542: #define PREPENDED_SIZE sizeof(struct ifnet *)
543: #endif ISO
544: if (type > ETHERMTU)
545: goto not802;
546:
547: /*
548: * This assumes that the snpa header is in the same mbuf
549: * as the llc header. Currently this is ok, but if
550: * unget allocates a cluster, this will not be the case
551: */
552: pkt_start = mtod(m, caddr_t);
553: l = (struct llc *) (pkt_start + PREPENDED_SIZE);
554:
555: IFDEBUG(D_ETHER)
556: printf("unrint: llc: length %d, control x%x:\n", type,
557: l->llc_control);
558: ENDDEBUG
559:
560: switch (l->llc_control) {
561: case LLC_UI:
562: /* LLC_UI_P forbidden in class 1 service */
563: #ifdef ISO
564: if (l->llc_dsap == LLC_ISO_LSAP) {
565: if ((IS_MULTICAST(ehbuf.ether_dhost)) &&
566: ((us->us_if.if_flags & IFF_EAVESDROP) == 0) &&
567: (!snpac_ownmulti(ehbuf.ether_dhost, 6))) {
568: m_freem(m);
569: return;
570: }
571:
572: /* move struct snpa_header over the llc header */
573: clnp_ypocb(pkt_start, pkt_start + 3,
574: PREPENDED_SIZE);
575: m->m_off += 3;
576: m->m_len -= 3;
577:
578: DEBUGF(undebug & 0x2, printf("clnp packet\n");)
579: schednetisr(NETISR_CLNP);
580: inq = &clnlintrq;
581: if (IF_QFULL(inq)){
582: DEBUGF(undebug & 0x2, printf(" qfull\n");)
583: IF_DROP(inq);
584: m_freem(m);
585: } else {
586: IF_ENQUEUE(inq, m);
587: DEBUGF(undebug & 0x2, printf(" queued\n");)
588: }
589: return;
590: } else {
591: IFDEBUG(D_ETHER)
592: printf("unrint: unknown llc sap\n");
593: ENDDEBUG
594: m_freem(m);
595: return;
596: }
597: #endif ISO
598: break;
599: /* LLC_XID, LLC_XID_P, LLC_TEST, and LLC_TEST_P are untested */
600: case LLC_XID:
601: case LLC_XID_P: /* control field is untouched for resp */
602: if(m->m_len < 6)
603: goto not802;
604: l->llc_fid = LLC_IEEE_basic_format;
605: l->llc_class = LLC_CLASS1;
606: l->llc_window = 0;
607: l->llc_dsap = l->llc_ssap = 0;
608: /* FALL THROUGH */
609: case LLC_TEST:
610: case LLC_TEST_P: {
611: struct ifnet *ifp = &us->us_if;
612: struct sockaddr_iso siso;
613: u_char c = l->llc_dsap;
614: l->llc_dsap = l->llc_ssap;
615: l->llc_ssap = c;
616:
617: /* Do not TEST or XID to multicasts */
618: if (IS_MULTICAST(ehbuf.ether_dhost)) {
619: m_freem(m);
620: break;
621: }
622:
623: siso.siso_family = AF_ISO;
624: bcopy(ehbuf.ether_shost, siso.siso_addr.sna_idi, 6);
625: siso.siso_addr.isoa_afi = AFI_SNA;
626: siso.siso_addr.isoa_len = 7;
627:
628: /* trim off prepended snpa_hdr or ifp */
629: m->m_off += PREPENDED_SIZE;
630: m->m_len -= PREPENDED_SIZE;
631:
632: unoutput(ifp, m, &siso);
633: return;
634: }
635: not802:
636: default:
637: DEBUGF(undebug & 0x2, printf("unknown packet\n");)
638: m_freem(m);
639: break;
640: }
641: }
642: #endif IEEELLC
643: }
644: }
645: return;
646: chuckit:
647: DEBUGF(undebug, printf("unrint: packet dropped\n");)
648: unupdatefpp(addr, us->us_nextpage);
649: }
650:
651: /*
652: * unxint - interrupt handler for transmit ready
653: */
654: unxint(unit, us, addr)
655: register int unit;
656: register struct un_softc *us;
657: register struct undevice *addr;
658: {
659: register char status;
660: register int next_buf;
661:
662: /*
663: * collect stats on last packet
664: */
665: status = MM_IN(&addr->un_edlc.xstat);
666: MM_OUT(&addr->un_edlc.xstat, status); /* clear status bits */
667: DEBUGF(undebug & 0x2, printf(" unxint: xstat = %b\n",
668: status & 0xff, XS_BITS);)
669: if (status & XS_16CL){
670: us->us_if.if_collisions += 16;
671: us->us_if.if_oerrors++;
672: printf("un%d: ethernet jammed\n", unit);
673: }
674: else if (status & XS_SHRT){
675: us->us_if.if_oerrors++;
676: printf( "un%d: ethernet not responding (is it connected?)\n",
677: unit);
678: }
679: else {
680: us->us_if.if_opackets++;
681: us->us_if.if_collisions += UN_NCOLL(addr);
682: }
683: DEBUGF(undebug & 0x2,
684: printf(" ipkt = %d ierr = %d okt = %d oerr = %d coll = %d\n",
685: us->us_if.if_ipackets, us->us_if.if_ierrors,
686: us->us_if.if_opackets, us->us_if.if_oerrors,
687: us->us_if.if_collisions);)
688: /* mark the current transmit buffer empty */
689: us->us_xfull[us->us_xbuf] = 0;
690: /* switch to the other transmit buffer */
691: next_buf = 1 - us->us_xbuf;
692: if (us->us_xfull[next_buf]){ /* if it's full */
693: unstart(us, addr, next_buf); /* start output from it */
694: if (us->us_if.if_snd.ifq_head){ /* if more on out queue */
695: struct mbuf *m;
696:
697: IF_DEQUEUE(&us->us_if.if_snd, m); /* fill empty buf */
698: unput(us, addr, m, 1 - next_buf);
699: }
700: }
701: else { /* the other transmit buffer is empty */
702: us->us_oactive = 0;
703: MM_OUT(&addr->un_csr, UN_PAVIENB); /* Turn off TxRIENB */
704: }
705: }
706:
707: /*
708: * unoutput - ethernet output routine. encapsulate a packet of type
709: * family for the local net. use trailer local net encapsulation if
710: * the number of bytes in the mbufs after the first is a multiple of
711: * 512.
712: */
713: unoutput(ifp, m0, dst)
714: register struct ifnet *ifp;
715: register struct mbuf *m0;
716: register struct sockaddr *dst;
717: {
718: u_short type;
719: int s;
720: int error;
721: char edst[ETH_ADDR_SIZE];
722: struct in_addr idst;
723: register struct un_softc *us = &un_softc[ifp->if_unit];
724: register struct mbuf *m = m0;
725: register struct ether_header *eh;
726: int off;
727: struct mbuf *m_get();
728: int usetrailers;
729:
730: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)){
731: error = ENETDOWN;
732: goto bad;
733: }
734: switch (dst->sa_family){
735:
736: #ifdef INET
737: case AF_INET:
738: idst = ((struct sockaddr_in *)dst)->sin_addr;
739: if (!arpresolve(&us->us_ac, m, &idst, edst, &usetrailers)){
740: /* not resolved */
741: return(0);
742: }
743: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
744: if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
745: m->m_off >= MMINOFF + 2 * sizeof(u_short)){
746: type = ETHERTYPE_TRAIL + (off>>9);
747: m->m_off -= 2 * sizeof(u_short);
748: m->m_len += 2 * sizeof(u_short);
749: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
750: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
751: /*
752: * Packet to be sent with trailer, move first packet
753: * (control information) to end of chain.
754: */
755: while (m->m_next)
756: m = m->m_next;
757: m->m_next = m0;
758: m = m0->m_next;
759: m0->m_next = 0;
760: m0 = m;
761: }
762: else {
763: type = ETHERTYPE_IP;
764: }
765: break;
766: #endif INET
767: #ifdef NS
768: case AF_NS:
769: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
770: (caddr_t)edst, sizeof(edst));
771: type = ETHERTYPE_NS;
772: off = 0;
773: break;
774: #endif NS
775: #ifdef ISO
776: case AF_ISO: {
777: int ret;
778: int len;
779: struct iso_addr *dst_nsap = &((struct sockaddr_iso *)dst)->siso_addr;
780:
781: if ((ret = iso_tryloopback(m, dst)) >= 0)
782: return (ret);
783: else if (ret = iso_snparesolve(&us->us_ac.ac_if, dst_nsap, edst, &len)){
784: /* not resolved */
785: IFDEBUG(D_ETHER)
786: printf("unoutput: clnp packet dropped\n");
787: ENDDEBUG
788: m_freem(m);
789: return(ret);
790: } else if (len != 6) {
791: printf("unoutput: snpa len is not 6 (%d)\n", len);
792: m_freem(m);
793: return(ENETUNREACH);
794: }
795:
796: #ifndef IEEELLC
797: type = ETHERTYPE_CLNP;
798: #else
799: /* check for enough space for LLC header */
800: {
801: struct mbuf *llcm;
802: char *cp;
803: if (m->m_off >= MMAXOFF || m->m_off < MMINOFF + 3) {
804: MGET(llcm, M_DONTWAIT, MT_DATA);
805: if (llcm == NULL) {
806: m_freem(m);
807: return(0);
808: }
809: llcm->m_off = MMAXOFF - 3;
810: llcm->m_len = 3;
811: llcm->m_next = m;
812: m = llcm;
813: } else {
814: m->m_off -= 3;
815: m->m_len += 3;
816: }
817: type = m_datalen(m);
818:
819: cp = mtod(m, u_char *);
820: cp[0] = cp[1] = LLC_ISO_LSAP; cp[2] = LLC_UI;
821: off = 0;
822: }
823: #endif IEEELLC
824: off = 0;
825: IFDEBUG(D_ETHER)
826: int i;
827: printf("unoutput: sending pkt to: ");
828: for (i=0; i<6; i++)
829: printf("%x ", edst[i] & 0xff);
830: #ifdef IEEELLC
831: printf(" llc len %d", type);
832: #endif IEEELLC
833: printf("\n");
834: ENDDEBUG
835: } break;
836: #endif ISO
837: case AF_UNSPEC:
838: eh = (struct ether_header *)dst->sa_data;
839: bcopy((char *)eh->ether_dhost, (caddr_t)edst, sizeof(edst));
840: type = eh->ether_type;
841: break;
842: default:
843: printf("un%d: can't handle af%d\n", ifp->if_unit,
844: dst->sa_family);
845: error = EAFNOSUPPORT;
846: goto bad;
847: }
848: /*
849: * Add local net header. If no space in first mbuf,
850: * allocate another.
851: */
852: if (m->m_off > MMAXOFF ||
853: MMINOFF + sizeof(struct ether_header) > m->m_off){
854: m = m_get(M_DONTWAIT, MT_HEADER);
855: /*
856: * Note: m_get, m_freem etc. guard against concurrent
857: * updates to the list of free mbufs.
858: */
859: if (m == 0){
860: error = ENOBUFS;
861: goto bad;
862: }
863: m->m_next = m0;
864: m->m_off = MMINOFF;
865: m->m_len = sizeof(struct ether_header);
866: } else {
867: m->m_off -= sizeof(struct ether_header);
868: m->m_len += sizeof(struct ether_header);
869: }
870: eh = mtod(m, struct ether_header *);
871: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof(edst));
872: bcopy((caddr_t)us->us_addr, (caddr_t)eh->ether_shost,
873: sizeof(eh->ether_shost));
874: bcopy((caddr_t)&type, (caddr_t)&eh->ether_type, sizeof(u_short));
875:
876: /*
877: * queue packet for transmission. if there is an empty
878: * transmit buffer on the adapter, use it.
879: */
880: s = splimp();
881: if (IF_QFULL(&ifp->if_snd)){
882: IF_DROP(&ifp->if_snd);
883: error = ENOBUFS;
884: goto qfull;
885: }
886: if (us->us_xfull[0] == 0 || us->us_xfull[1] == 0){ /* empty xmt buf */
887: struct undevice *addr = (struct undevice *)
888: uninfo[ifp->if_unit]->iod_addr;
889: int next_buf;
890: #ifdef ATR
891: int old_window;
892: move_window(old_window, addr);
893: #endif ATR
894: if (us->us_xfull[0] == 0){
895: next_buf = 0;
896: }
897: else {
898: next_buf = 1;
899: }
900: unput(us, addr, m, next_buf);
901: if (us->us_oactive == 0){
902: unstart(us, addr, next_buf);
903: }
904: #ifdef ATR
905: restore_window(old_window);
906: #endif ATR
907: }
908: else {
909: IF_ENQUEUE(&ifp->if_snd, m);
910: }
911: splx(s);
912: return(0);
913: qfull:
914: m0 = m;
915: splx(s);
916: bad:
917: m_freem(m0);
918: return(error);
919: }
920:
921: /*
922: * unput - copy packet from an mbuf chain to one of the adapter's
923: * transmit buffers. the packet is extended to the minimum legal
924: * size if necessary. the extra bytes could be zeroed out to improve
925: * security but are not to maximize performance.
926: */
927: unput(us, addr, m, xbuf)
928: struct un_softc *us;
929: struct undevice *addr;
930: register struct mbuf *m;
931: register int xbuf;
932: {
933: register unsigned off;
934: register struct mbuf *mp;
935: register char *bp;
936:
937: /*
938: * compute starting address in transmit buffer. packets must be
939: * "end_aligned".
940: */
941: for (off = UN_XBSIZE, mp = m; mp; mp = mp->m_next){
942: off -= mp->m_len;
943: }
944: if (UN_XBSIZE - off < ETHERMIN + sizeof(struct ether_header)){
945: /* packet too short => extend it */
946: off = UN_XBSIZE - ETHERMIN - sizeof(struct ether_header);
947: }
948: if (xbuf == 1){ /* use the second buffer */
949: off += UN_XBSIZE; /* the 2 buffers are adjacent */
950: }
951: bp = ((char *)(addr->un_xmtbuf)) + off;
952: for (mp = m; mp; mp = mp->m_next){
953: register unsigned len = mp->m_len;
954:
955: bcopyout(mtod(mp, char *), bp, len);
956: bp += len;
957: }
958: /* save starting address so interrupt handler can find it */
959: us->us_xstart[xbuf] = off; /* start address to be passed to adapter */
960: us->us_xfull[xbuf] = 1; /* mark buffer full */
961: m_freem(m);
962: }
963:
964: /*
965: * unget - copy packet from adapter's receive buffers into a chain of mbufs
966: *
967: */
968: struct mbuf *
969: unget(addr, unbuf, totlen, off0, ifp)
970: struct undevice *addr;
971: char *unbuf;
972: register int totlen;
973: int off0;
974: struct ifnet *ifp;
975: {
976: register struct mbuf *m;
977: struct mbuf *top = 0;
978: register struct mbuf **mp = ⊤
979: register int off = off0;
980: register int len;
981: register char *cp;
982: #ifdef ISO
983: int copied_snpa = 0;
984: #endif ISO
985:
986: cp = unbuf + sizeof(struct ether_header);
987: while (totlen > 0){
988: char *mcp;
989:
990: MGET(m, M_DONTWAIT, MT_DATA);
991: if (m == 0)
992: goto bad;
993: if (off){ /* trailer exists */
994: len = totlen - off;
995: cp = unbuf + sizeof(struct ether_header) + off;
996: } else
997: len = totlen;
998: #ifdef ISO
999: if (!copied_snpa)
1000: len += sizeof(struct snpa_hdr);
1001: #else ISO
1002: if (ifp)
1003: len += sizeof(ifp);
1004: #endif ISO
1005: if (len >= NBPG){
1006: MCLGET(m);
1007: if (m->m_len == CLBYTES)
1008: m->m_len = len = MIN(len, CLBYTES);
1009: else
1010: m->m_len = len = MIN(MLEN, len);
1011: } else {
1012: m->m_len = len = MIN(MLEN, len);
1013: m->m_off = MMINOFF;
1014: }
1015: mcp = mtod(m, char *);
1016: #ifdef ISO
1017: if (!copied_snpa) {
1018: /*
1019: * Prepend snpa_hdr to first mbuf
1020: * The hardcoded 12 below refers to the length of the dhost
1021: * and shost fields. We recklessly assume
1022: * the order of dhost,shost in the snpa_hdr is the same
1023: * as the order in the ether_header.
1024: */
1025: struct snpa_hdr *sh = (struct snpa_hdr *)mcp;
1026: struct ether_header *eh = (struct ether_header *)unbuf;
1027:
1028: bcopy((char *) &ifp, (caddr_t)&sh->snh_ifp, sizeof(ifp));
1029: bcopy((caddr_t)eh, (caddr_t)sh->snh_dhost, 12);
1030: mcp += sizeof(struct snpa_hdr);
1031: len -= sizeof(struct snpa_hdr);
1032: copied_snpa = 1;
1033: }
1034: #else ISO
1035: if (ifp){
1036: /* prepend ifp to first mbuf */
1037: /*
1038: * bcopy is used since since word moves must
1039: * be on 4 byte boundaries on the RT PC
1040: */
1041: bcopy((char *) &ifp, mcp, sizeof(ifp));
1042: mcp += sizeof(ifp);
1043: len -= sizeof(ifp);
1044: ifp = (struct ifnet *) 0;
1045: }
1046: #endif ISO
1047: unbcopy(addr, cp, mcp, len);
1048: cp += len;
1049: *mp = m;
1050: mp = &m->m_next;
1051: if (off == 0){
1052: totlen -= len;
1053: continue;
1054: }
1055: off += len;
1056: if (off == totlen){
1057: cp = unbuf + sizeof(struct ether_header);
1058: off = 0;
1059: totlen = off0;
1060: }
1061: }
1062: return(top);
1063: bad:
1064: m_freem(top);
1065: return(0);
1066: }
1067:
1068:
1069: /*
1070: * ioctl - process an ioctl request.
1071: */
1072: unioctl(ifp, cmd, data)
1073: register struct ifnet *ifp;
1074: register int cmd;
1075: register caddr_t data;
1076: {
1077: register struct ifaddr *ifa = (struct ifaddr *)data;
1078: register int s = splimp();
1079: register int error = 0;
1080:
1081: switch (cmd){
1082: case SIOCSIFADDR:
1083: ifp->if_flags |= IFF_UP;
1084:
1085: switch (ifa->ifa_addr.sa_family){
1086: #ifdef INET
1087: case AF_INET:
1088: uninit(ifp->if_unit); /* before arpwhohas */
1089: ((struct arpcom *) ifp)->ac_ipaddr =
1090: IA_SIN(ifa)->sin_addr;
1091: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
1092: break;
1093: #endif INET
1094: #ifdef NS
1095: case AF_NS:
1096: {
1097: struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
1098: struct un_softc *us = &un_softc[ifp->if_unit];
1099:
1100: if (ns_nullhost(*ina))
1101: ina->x_host = *(union ns_host *)(us->us_addr);
1102: else {
1103: ifp->if_flags &= ~IFF_RUNNING;
1104: bcopy((caddr_t) ina->x_host.c_host,
1105: (caddr_t) us->us_addr, sizeof(us->us_addr));
1106: /*
1107: * the uninit will set the hardware address
1108: * since the IFF_RUNNING flag is off
1109: */
1110: }
1111: uninit(ifp->if_unit);
1112: break;
1113: }
1114: #endif NS
1115: default:
1116: uninit(ifp->if_unit);
1117: break;
1118: }
1119: break;
1120: case SIOCSIFFLAGS:
1121: if ((ifp->if_flags & IFF_UP) == 0 && ifp->if_flags &
1122: IFF_RUNNING){
1123: #ifdef ATR
1124: int old_window;
1125: #endif ATR
1126: struct undevice *addr;
1127:
1128: addr = (struct undevice *) uninfo[ifp->if_unit]->
1129: iod_addr;
1130: #ifdef ATR
1131: move_window(old_window, addr);
1132: #endif ATR
1133: (void) unzap((struct undevice *) addr);
1134: ifp->if_flags &= ~IFF_RUNNING;
1135: #ifdef ATR
1136: restore_window(old_window);
1137: #endif ATR
1138: } else if (ifp->if_flags & IFF_UP && (ifp->if_flags &
1139: IFF_RUNNING) == 0)
1140: uninit(ifp->if_unit);
1141: break;
1142: default:
1143: error = EINVAL;
1144: }
1145: splx(s);
1146: return(error);
1147: }
1148:
1149: /*
1150: * unzap - initialize adapter but don't enable it.
1151: * returns page number of next receive page to be used.
1152: */
1153: unzap(addr)
1154: register struct undevice *addr;
1155: {
1156: register int next;
1157:
1158: MM_OUT(&addr->un_csr, 0); /* disable interrupts */
1159: MM_OUT(&addr->un_edlc.reset, RESET_ON);
1160: /* set reset bit while init'ing */
1161: MM_OUT(&addr->un_edlc.rstat, RS_CLEAR);
1162: MM_OUT(&addr->un_edlc.xstat, XS_CLEAR);
1163: MM_OUT(&addr->un_edlc.rmask, 0);
1164: MM_OUT(&addr->un_edlc.xmask, 0);
1165: MM_OUT(&addr->un_edlc.rmode, RM_NORMAL);
1166: /*
1167: * the next line puts the transmitter in loopback mode so
1168: * that a spurious packet is not sent when the reset bit is
1169: * cleared.
1170: */
1171: MM_OUT(&addr->un_edlc.tmode, TM_NORMAL - TM_LBC);
1172: MM_OUT(&addr->un_edlc.reset, RESET_OFF); /* clear reset bit */
1173: /*
1174: * clear the receive buffers. assign the value in the empty
1175: * page pointer to the full page pointer and clear the packet
1176: * available flag.
1177: */
1178: next = MM_IN(&addr->un_fppepp) & UN_PAGE_MASK;
1179: /* clears the IKSYDK flag */
1180: MM_OUT(&addr->un_fppepp, next); /* fpp = epp */
1181: UN_CLRPAV(addr); /* clear the PAV flag */
1182: MM_OUT(&addr->un_edlc.tmode, TM_NORMAL);
1183: /* put transmitter in normal mode */
1184: DEBUGF(undebug & 0x2, printf("unzap: zzzzapped!\n");)
1185: return(next);
1186: }
1187:
1188: /*
1189: * unupdatefpp - update adapter's full page pointer and clear packet available
1190: * flag if appropriate
1191: */
1192: unupdatefpp(addr, nextpage)
1193: register struct undevice *addr;
1194: register int nextpage;
1195: {
1196: if (nextpage == /* EPP */ (MM_IN(&addr->un_fppepp) & UN_PAGE_MASK))
1197: UN_CLRPAV(addr);
1198: MM_OUT(&addr->un_fppepp, nextpage); /* set FPP */
1199: }
1200:
1201: /*
1202: * unbcopy - similar to bcopy but can deal with packets that wrap
1203: * around from the high end of the adapter's receive buffer to the
1204: * low end
1205: */
1206: unbcopy(addr, from, to, len)
1207: register struct undevice *addr;
1208: register char *from;
1209: register char *to;
1210: register int len;
1211: {
1212: register char *high_end = &addr->un_rcvbuf[UN_LASTRBUF][UN_RBUFSIZE];
1213: register int n;
1214:
1215: if (from + len <= high_end){
1216: bcopyin(from, to, len);
1217: }
1218: else if (from >= high_end){
1219: from -= sizeof(addr->un_rcvbuf);
1220: bcopyin(from, to, len);
1221: } else {
1222: n = high_end - from;
1223: bcopyin(from, to, n);
1224: to += n;
1225: bcopyin((char *)addr->un_rcvbuf, to, len - n);
1226: }
1227: }
1228:
1229: /*
1230: * ungetushortatoff - return the u_short at offset in the received packet,
1231: * handling wrap-around in the receive buffer and conversion between network
1232: * and host formats as necessary.
1233: */
1234: u_short ungetushortatoff(addr, eh, off)
1235: register struct undevice *addr;
1236: register struct ether_header *eh;
1237: register int off;
1238: {
1239: register char *high_end = &addr->un_rcvbuf[UN_LASTRBUF][UN_RBUFSIZE];
1240: register char *p;
1241:
1242: p = (caddr_t)(eh + 1) + off;
1243: if (p >= high_end){
1244: p -= sizeof(addr->un_rcvbuf);
1245: }
1246: return(ntohs((u_short) MM_INW(p)));
1247: }
1248:
1249: /*
1250: * unprintethaddr - print an ethernet address
1251: */
1252: unprintethaddr(p)
1253: register char *p;
1254: {
1255: register int i;
1256:
1257: for (i = 0; i < ETH_ADDR_SIZE; i++){
1258: if (i != 0) printf(":");
1259: printf("%x", *p++);
1260: }
1261: }
1262:
1263: #endif NUN > 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.