![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_qe.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxif|
Return to if_qe.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxif |
1.1 root 1: /* @(#)if_qe.c 7.6 (Berkeley) 5/28/88 */
2:
3: /* from @(#)if_qe.c 1.15 (ULTRIX) 4/16/86 */
4:
5:
6: /****************************************************************
7: * *
8: * Licensed from Digital Equipment Corporation *
9: * Copyright (c) *
10: * Digital Equipment Corporation *
11: * Maynard, Massachusetts *
12: * 1985, 1986 *
13: * All rights reserved. *
14: * *
15: * The Information in this software is subject to change *
16: * without notice and should not be construed as a commitment *
17: * by Digital Equipment Corporation. Digital makes no *
18: * representations about the suitability of this software for *
19: * any purpose. It is supplied "As Is" without expressed or *
20: * implied warranty. *
21: * *
22: * If the Regents of the University of California or its *
23: * licensees modify the software in a manner creating *
24: * derivative copyright rights, appropriate copyright *
25: * legends may be placed on the derivative work in addition *
26: * to that set forth above. *
27: * *
28: ****************************************************************/
29: /* ---------------------------------------------------------------------
30: * Modification History
31: *
32: * 15-Apr-86 -- afd
33: * Rename "unused_multi" to "qunused_multi" for extending Generic
34: * kernel to MicroVAXen.
35: *
36: * 18-mar-86 -- jaw br/cvec changed to NOT use registers.
37: *
38: * 12 March 86 -- Jeff Chase
39: * Modified to handle the new MCLGET macro
40: * Changed if_qe_data.c to use more receive buffers
41: * Added a flag to poke with adb to log qe_restarts on console
42: *
43: * 19 Oct 85 -- rjl
44: * Changed the watch dog timer from 30 seconds to 3. VMS is using
45: * less than 1 second in their's. Also turned the printf into an
46: * mprintf.
47: *
48: * 09/16/85 -- Larry Cohen
49: * Add 43bsd alpha tape changes for subnet routing
50: *
51: * 1 Aug 85 -- rjl
52: * Panic on a non-existent memory interrupt and the case where a packet
53: * was chained. The first should never happen because non-existant
54: * memory interrupts cause a bus reset. The second should never happen
55: * because we hang 2k input buffers on the device.
56: *
57: * 1 Aug 85 -- rich
58: * Fixed the broadcast loopback code to handle Clusters without
59: * wedging the system.
60: *
61: * 27 Feb. 85 -- ejf
62: * Return default hardware address on ioctl request.
63: *
64: * 12 Feb. 85 -- ejf
65: * Added internal extended loopback capability.
66: *
67: * 27 Dec. 84 -- rjl
68: * Fixed bug that caused every other transmit descriptor to be used
69: * instead of every descriptor.
70: *
71: * 21 Dec. 84 -- rjl
72: * Added watchdog timer to mask hardware bug that causes device lockup.
73: *
74: * 18 Dec. 84 -- rjl
75: * Reworked driver to use q-bus mapping routines. MicroVAX-I now does
76: * copying instead of m-buf shuffleing.
77: * A number of deficencies in the hardware/firmware were compensated
78: * for. See comments in qestart and qerint.
79: *
80: * 14 Nov. 84 -- jf
81: * Added usage counts for multicast addresses.
82: * Updated general protocol support to allow access to the Ethernet
83: * header.
84: *
85: * 04 Oct. 84 -- jf
86: * Added support for new ioctls to add and delete multicast addresses
87: * and set the physical address.
88: * Add support for general protocols.
89: *
90: * 14 Aug. 84 -- rjl
91: * Integrated Shannon changes. (allow arp above 1024 and ? )
92: *
93: * 13 Feb. 84 -- rjl
94: *
95: * Initial version of driver. derived from IL driver.
96: *
97: * ---------------------------------------------------------------------
98: */
99:
100: #include "qe.h"
101: #if NQE > 0
102: /*
103: * Digital Q-BUS to NI Adapter
104: */
105: #include "param.h"
106: #include "systm.h"
107: #include "mbuf.h"
108: #include "buf.h"
109: #include "protosw.h"
110: #include "socket.h"
111: #include "vmmac.h"
112: #include "ioctl.h"
113: #include "errno.h"
114: #include "syslog.h"
115: #include "time.h"
116: #include "kernel.h"
117:
118: #include "../net/if.h"
119: #include "../net/netisr.h"
120: #include "../net/route.h"
121:
122: #ifdef INET
123: #include "../netinet/in.h"
124: #include "../netinet/in_systm.h"
125: #include "../netinet/in_var.h"
126: #include "../netinet/ip.h"
127: #include "../netinet/if_ether.h"
128: #endif
129:
130: #ifdef NS
131: #include "../netns/ns.h"
132: #include "../netns/ns_if.h"
133: #endif
134:
135: #include "../vax/pte.h"
136: #include "../vax/cpu.h"
137: #include "../vax/mtpr.h"
138: #include "if_qereg.h"
139: #include "if_uba.h"
140: #include "../vaxuba/ubareg.h"
141: #include "../vaxuba/ubavar.h"
142:
143: #if NQE > 1
144: #define NRCV 15 /* Receive descriptors */
145: #else
146: #define NRCV 20 /* Receive descriptors */
147: #endif
148: #define NXMT 5 /* Transmit descriptors */
149: #define NTOT (NXMT + NRCV)
150:
151: #define QETIMEOUT 2 /* transmit timeout, must be > 1 */
152:
153: /*
154: * This constant should really be 60 because the qna adds 4 bytes of crc.
155: * However when set to 60 our packets are ignored by deuna's , 3coms are
156: * okay ??????????????????????????????????????????
157: */
158: #define MINDATA 64
159:
160: /*
161: * Ethernet software status per interface.
162: *
163: * Each interface is referenced by a network interface structure,
164: * qe_if, which the routing code uses to locate the interface.
165: * This structure contains the output queue for the interface, its address, ...
166: */
167: struct qe_softc {
168: struct arpcom qe_ac; /* Ethernet common part */
169: #define qe_if qe_ac.ac_if /* network-visible interface */
170: #define qe_addr qe_ac.ac_enaddr /* hardware Ethernet address */
171: struct ifubinfo qe_uba; /* Q-bus resources */
172: struct ifrw qe_ifr[NRCV]; /* for receive buffers; */
173: struct ifxmt qe_ifw[NXMT]; /* for xmit buffers; */
174: int qe_flags; /* software state */
175: #define QEF_RUNNING 0x01
176: #define QEF_SETADDR 0x02
177: int setupaddr; /* mapping info for setup pkts */
178: struct qe_ring *rringaddr; /* mapping info for rings */
179: struct qe_ring *tringaddr; /* "" */
180: struct qe_ring rring[NRCV+1]; /* Receive ring descriptors */
181: struct qe_ring tring[NXMT+1]; /* Transmit ring descriptors */
182: u_char setup_pkt[16][8]; /* Setup packet */
183: int rindex; /* Receive index */
184: int tindex; /* Transmit index */
185: int otindex; /* Old transmit index */
186: int qe_intvec; /* Interrupt vector */
187: struct qedevice *addr; /* device addr */
188: int setupqueued; /* setup packet queued */
189: int nxmit; /* Transmits in progress */
190: int qe_restarts; /* timeouts */
191: } qe_softc[NQE];
192:
193: struct uba_device *qeinfo[NQE];
194:
195: extern struct timeval time;
196:
197: int qeprobe(), qeattach(), qeintr(), qetimeout();
198: int qeinit(), qeoutput(), qeioctl(), qereset();
199:
200: u_short qestd[] = { 0 };
201: struct uba_driver qedriver =
202: { qeprobe, 0, qeattach, 0, qestd, "qe", qeinfo };
203:
204: #define QE_TIMEO (15)
205: #define QEUNIT(x) minor(x)
206: static int mask = 0x3ffff; /* address mask */
207: /*
208: * The deqna shouldn't receive more than ETHERMTU + sizeof(struct ether_header)
209: * but will actually take in up to 2048 bytes. To guard against the receiver
210: * chaining buffers (which we aren't prepared to handle) we allocate 2kb
211: * size buffers.
212: */
213: #define MAXPACKETSIZE 2048 /* Should really be ETHERMTU */
214: /*
215: * Probe the QNA to see if it's there
216: */
217: qeprobe(reg)
218: caddr_t reg;
219: {
220: register int br, cvec; /* r11, r10 value-result */
221: register struct qedevice *addr = (struct qedevice *)reg;
222: register struct qe_ring *rp;
223: register struct qe_ring *prp; /* physical rp */
224: register int i, j;
225: static int next=0; /* softc index */
226: register struct qe_softc *sc = &qe_softc[next++];
227:
228: #ifdef lint
229: br = 0; cvec = br; br = cvec;
230: qeintr(0);
231: #endif
232: /*
233: * Set the address mask for the particular cpu
234: */
235: mask = 0x3ffff;
236:
237: /*
238: * The QNA interrupts on i/o operations. To do an I/O operation
239: * we have to setup the interface by transmitting a setup packet.
240: */
241: addr->qe_csr = QE_RESET;
242: addr->qe_vector = (uba_hd[numuba].uh_lastiv -= 4);
243:
244: /*
245: * Map the communications area and the setup packet.
246: */
247: sc->setupaddr =
248: uballoc(0, (caddr_t)sc->setup_pkt, sizeof(sc->setup_pkt), 0);
249: sc->rringaddr = (struct qe_ring *) uballoc(0, (caddr_t)sc->rring,
250: sizeof(struct qe_ring) * (NTOT+2), 0);
251: prp = (struct qe_ring *)((int)sc->rringaddr & mask);
252:
253: /*
254: * The QNA will loop the setup packet back to the receive ring
255: * for verification, therefore we initialize the first
256: * receive & transmit ring descriptors and link the setup packet
257: * to them.
258: */
259: qeinitdesc(sc->tring, (caddr_t)(sc->setupaddr & mask),
260: sizeof(sc->setup_pkt));
261: qeinitdesc(sc->rring, (caddr_t)(sc->setupaddr & mask),
262: sizeof(sc->setup_pkt));
263:
264: rp = (struct qe_ring *)sc->tring;
265: rp->qe_setup = 1;
266: rp->qe_eomsg = 1;
267: rp->qe_flag = rp->qe_status1 = QE_NOTYET;
268: rp->qe_valid = 1;
269:
270: rp = (struct qe_ring *)sc->rring;
271: rp->qe_flag = rp->qe_status1 = QE_NOTYET;
272: rp->qe_valid = 1;
273:
274: /*
275: * Get the addr off of the interface and place it into the setup
276: * packet. This code looks strange due to the fact that the address
277: * is placed in the setup packet in col. major order.
278: */
279: for( i = 0 ; i < 6 ; i++ )
280: sc->setup_pkt[i][1] = addr->qe_sta_addr[i];
281:
282: qesetup( sc );
283: /*
284: * Start the interface and wait for the packet.
285: */
286: j = cvec;
287: addr->qe_csr = QE_INT_ENABLE | QE_XMIT_INT | QE_RCV_INT;
288: addr->qe_rcvlist_lo = (short)prp;
289: addr->qe_rcvlist_hi = (short)((int)prp >> 16);
290: prp += NRCV+1;
291: addr->qe_xmtlist_lo = (short)prp;
292: addr->qe_xmtlist_hi = (short)((int)prp >> 16);
293: DELAY(10000);
294: /*
295: * All done with the bus resources.
296: */
297: ubarelse(0, &sc->setupaddr);
298: ubarelse(0, (int *)&sc->rringaddr);
299: if( cvec == j )
300: return 0; /* didn't interrupt */
301:
302: br = 0x15; /* q-bus doesn't get level */
303: return( sizeof(struct qedevice) );
304: }
305:
306: /*
307: * Interface exists: make available by filling in network interface
308: * record. System will initialize the interface when it is ready
309: * to accept packets.
310: */
311: qeattach(ui)
312: struct uba_device *ui;
313: {
314: register struct qe_softc *sc = &qe_softc[ui->ui_unit];
315: register struct ifnet *ifp = &sc->qe_if;
316: register struct qedevice *addr = (struct qedevice *)ui->ui_addr;
317: register int i;
318:
319: ifp->if_unit = ui->ui_unit;
320: ifp->if_name = "qe";
321: ifp->if_mtu = ETHERMTU;
322: ifp->if_flags = IFF_BROADCAST;
323:
324: /*
325: * Read the address from the prom and save it.
326: */
327: for( i=0 ; i<6 ; i++ )
328: sc->setup_pkt[i][1] = sc->qe_addr[i] = addr->qe_sta_addr[i] & 0xff;
329: printf("qe%d: hardware address %s\n", ui->ui_unit,
330: ether_sprintf(sc->qe_addr));
331:
332: /*
333: * Save the vector for initialization at reset time.
334: */
335: sc->qe_intvec = addr->qe_vector;
336:
337: ifp->if_init = qeinit;
338: ifp->if_output = qeoutput;
339: ifp->if_ioctl = qeioctl;
340: ifp->if_reset = qereset;
341: ifp->if_watchdog = qetimeout;
342: sc->qe_uba.iff_flags = UBA_CANTWAIT;
343: if_attach(ifp);
344: }
345:
346: /*
347: * Reset of interface after UNIBUS reset.
348: * If interface is on specified uba, reset its state.
349: */
350: qereset(unit, uban)
351: int unit, uban;
352: {
353: register struct uba_device *ui;
354:
355: if (unit >= NQE || (ui = qeinfo[unit]) == 0 || ui->ui_alive == 0 ||
356: ui->ui_ubanum != uban)
357: return;
358: printf(" qe%d", unit);
359: qe_softc[unit].qe_if.if_flags &= ~IFF_RUNNING;
360: qeinit(unit);
361: }
362:
363: /*
364: * Initialization of interface.
365: */
366: qeinit(unit)
367: int unit;
368: {
369: register struct qe_softc *sc = &qe_softc[unit];
370: register struct uba_device *ui = qeinfo[unit];
371: register struct qedevice *addr = (struct qedevice *)ui->ui_addr;
372: register struct ifnet *ifp = &sc->qe_if;
373: register i;
374: int s;
375:
376: /* address not known */
377: if (ifp->if_addrlist == (struct ifaddr *)0)
378: return;
379: if (sc->qe_flags & QEF_RUNNING)
380: return;
381:
382: if ((ifp->if_flags & IFF_RUNNING) == 0) {
383: /*
384: * map the communications area onto the device
385: */
386: sc->rringaddr = (struct qe_ring *)
387: ((int) uballoc(0, (caddr_t)sc->rring,
388: sizeof(struct qe_ring) * (NTOT+2), 0) & mask);
389: sc->tringaddr = sc->rringaddr + NRCV + 1;
390: sc->setupaddr = uballoc(0, (caddr_t)sc->setup_pkt,
391: sizeof(sc->setup_pkt), 0) & mask;
392: /*
393: * init buffers and maps
394: */
395: if (if_ubaminit(&sc->qe_uba, ui->ui_ubanum,
396: sizeof (struct ether_header), (int)btoc(MAXPACKETSIZE),
397: sc->qe_ifr, NRCV, sc->qe_ifw, NXMT) == 0) {
398: printf("qe%d: can't initialize\n", unit);
399: sc->qe_if.if_flags &= ~IFF_UP;
400: return;
401: }
402: }
403: /*
404: * Init the buffer descriptors and indexes for each of the lists and
405: * loop them back to form a ring.
406: */
407: for (i = 0; i < NRCV; i++) {
408: qeinitdesc( &sc->rring[i],
409: (caddr_t)(sc->qe_ifr[i].ifrw_info & mask), MAXPACKETSIZE);
410: sc->rring[i].qe_flag = sc->rring[i].qe_status1 = QE_NOTYET;
411: sc->rring[i].qe_valid = 1;
412: }
413: qeinitdesc(&sc->rring[i], (caddr_t)NULL, 0);
414:
415: sc->rring[i].qe_addr_lo = (short)sc->rringaddr;
416: sc->rring[i].qe_addr_hi = (short)((int)sc->rringaddr >> 16);
417: sc->rring[i].qe_chain = 1;
418: sc->rring[i].qe_flag = sc->rring[i].qe_status1 = QE_NOTYET;
419: sc->rring[i].qe_valid = 1;
420:
421: for( i = 0 ; i <= NXMT ; i++ )
422: qeinitdesc(&sc->tring[i], (caddr_t)NULL, 0);
423: i--;
424:
425: sc->tring[i].qe_addr_lo = (short)sc->tringaddr;
426: sc->tring[i].qe_addr_hi = (short)((int)sc->tringaddr >> 16);
427: sc->tring[i].qe_chain = 1;
428: sc->tring[i].qe_flag = sc->tring[i].qe_status1 = QE_NOTYET;
429: sc->tring[i].qe_valid = 1;
430:
431: sc->nxmit = sc->otindex = sc->tindex = sc->rindex = 0;
432:
433: /*
434: * Take the interface out of reset, program the vector,
435: * enable interrupts, and tell the world we are up.
436: */
437: s = splimp();
438: addr->qe_vector = sc->qe_intvec;
439: sc->addr = addr;
440: addr->qe_csr = QE_RCV_ENABLE | QE_INT_ENABLE | QE_XMIT_INT |
441: QE_RCV_INT | QE_ILOOP;
442: addr->qe_rcvlist_lo = (short)sc->rringaddr;
443: addr->qe_rcvlist_hi = (short)((int)sc->rringaddr >> 16);
444: ifp->if_flags |= IFF_UP | IFF_RUNNING;
445: sc->qe_flags |= QEF_RUNNING;
446: qesetup( sc );
447: qestart( unit );
448: splx( s );
449:
450: }
451:
452: /*
453: * Start output on interface.
454: *
455: */
456: qestart(unit)
457: int unit;
458: {
459: struct uba_device *ui = qeinfo[unit];
460: register struct qe_softc *sc = &qe_softc[unit];
461: register struct qedevice *addr;
462: register struct qe_ring *rp;
463: register index;
464: struct mbuf *m;
465: int buf_addr, len, s;
466:
467:
468: s = splimp();
469: addr = (struct qedevice *)ui->ui_addr;
470: /*
471: * The deqna doesn't look at anything but the valid bit
472: * to determine if it should transmit this packet. If you have
473: * a ring and fill it the device will loop indefinately on the
474: * packet and continue to flood the net with packets until you
475: * break the ring. For this reason we never queue more than n-1
476: * packets in the transmit ring.
477: *
478: * The microcoders should have obeyed their own defination of the
479: * flag and status words, but instead we have to compensate.
480: */
481: for( index = sc->tindex;
482: sc->tring[index].qe_valid == 0 && sc->nxmit < (NXMT-1) ;
483: sc->tindex = index = ++index % NXMT){
484: rp = &sc->tring[index];
485: if( sc->setupqueued ) {
486: buf_addr = sc->setupaddr;
487: len = 128;
488: rp->qe_setup = 1;
489: sc->setupqueued = 0;
490: } else {
491: IF_DEQUEUE(&sc->qe_if.if_snd, m);
492: if( m == 0 ){
493: splx(s);
494: return;
495: }
496: buf_addr = sc->qe_ifw[index].ifw_info;
497: len = if_ubaput(&sc->qe_uba, &sc->qe_ifw[index], m);
498: }
499: /*
500: * Does buffer end on odd byte ?
501: */
502: if( len & 1 ) {
503: len++;
504: rp->qe_odd_end = 1;
505: }
506: if( len < MINDATA )
507: len = MINDATA;
508: rp->qe_buf_len = -(len/2);
509: buf_addr &= mask;
510: rp->qe_flag = rp->qe_status1 = QE_NOTYET;
511: rp->qe_addr_lo = (short)buf_addr;
512: rp->qe_addr_hi = (short)(buf_addr >> 16);
513: rp->qe_eomsg = 1;
514: rp->qe_flag = rp->qe_status1 = QE_NOTYET;
515: rp->qe_valid = 1;
516: sc->nxmit++;
517: sc->qe_if.if_timer = QETIMEOUT;
518:
519: /*
520: * See if the xmit list is invalid.
521: */
522: if( addr->qe_csr & QE_XL_INVALID ) {
523: buf_addr = (int)(sc->tringaddr+index);
524: addr->qe_xmtlist_lo = (short)buf_addr;
525: addr->qe_xmtlist_hi = (short)(buf_addr >> 16);
526: }
527: }
528: splx( s );
529: }
530:
531: /*
532: * Ethernet interface interrupt processor
533: */
534: qeintr(unit)
535: int unit;
536: {
537: register struct qe_softc *sc = &qe_softc[unit];
538: struct qedevice *addr = (struct qedevice *)qeinfo[unit]->ui_addr;
539: int s, buf_addr, csr;
540:
541: s = splimp();
542: csr = addr->qe_csr;
543: addr->qe_csr = QE_RCV_ENABLE | QE_INT_ENABLE | QE_XMIT_INT | QE_RCV_INT | QE_ILOOP;
544: if( csr & QE_RCV_INT )
545: qerint( unit );
546: if( csr & QE_XMIT_INT )
547: qetint( unit );
548: if( csr & QE_NEX_MEM_INT )
549: panic("qe: Non existant memory interrupt");
550:
551: if( addr->qe_csr & QE_RL_INVALID && sc->rring[sc->rindex].qe_status1 == QE_NOTYET ) {
552: buf_addr = (int)&sc->rringaddr[sc->rindex];
553: addr->qe_rcvlist_lo = (short)buf_addr;
554: addr->qe_rcvlist_hi = (short)(buf_addr >> 16);
555: }
556: splx( s );
557: }
558:
559: /*
560: * Ethernet interface transmit interrupt.
561: */
562:
563: qetint(unit)
564: int unit;
565: {
566: register struct qe_softc *sc = &qe_softc[unit];
567: register struct qe_ring *rp;
568: register struct ifxmt *ifxp;
569: int status1, setupflag;
570: short len;
571:
572:
573: while( sc->otindex != sc->tindex && sc->tring[sc->otindex].qe_status1 != QE_NOTYET && sc->nxmit > 0 ) {
574: /*
575: * Save the status words from the descriptor so that it can
576: * be released.
577: */
578: rp = &sc->tring[sc->otindex];
579: status1 = rp->qe_status1;
580: setupflag = rp->qe_setup;
581: len = (-rp->qe_buf_len) * 2;
582: if( rp->qe_odd_end )
583: len++;
584: /*
585: * Init the buffer descriptor
586: */
587: bzero((caddr_t)rp, sizeof(struct qe_ring));
588: if( --sc->nxmit == 0 )
589: sc->qe_if.if_timer = 0;
590: if( !setupflag ) {
591: /*
592: * Do some statistics.
593: */
594: sc->qe_if.if_opackets++;
595: sc->qe_if.if_collisions += ( status1 & QE_CCNT ) >> 4;
596: if (status1 & QE_ERROR)
597: sc->qe_if.if_oerrors++;
598: /*
599: * If this was a broadcast packet loop it
600: * back because the hardware can't hear its own
601: * transmits.
602: */
603: ifxp = &sc->qe_ifw[sc->otindex];
604: if (bcmp((caddr_t)((struct ether_header *)ifxp->ifw_addr)->ether_dhost,
605: (caddr_t)etherbroadcastaddr,
606: sizeof(etherbroadcastaddr)) == 0)
607: qeread(sc, &ifxp->ifrw,
608: len - sizeof(struct ether_header));
609: if (ifxp->ifw_xtofree) {
610: m_freem(ifxp->ifw_xtofree);
611: ifxp->ifw_xtofree = 0;
612: }
613: }
614: sc->otindex = ++sc->otindex % NXMT;
615: }
616: qestart( unit );
617: }
618:
619: /*
620: * Ethernet interface receiver interrupt.
621: * If can't determine length from type, then have to drop packet.
622: * Othewise decapsulate packet based on type and pass to type specific
623: * higher-level input routine.
624: */
625: qerint(unit)
626: int unit;
627: {
628: register struct qe_softc *sc = &qe_softc[unit];
629: register struct qe_ring *rp;
630: int len, status1, status2;
631: int bufaddr;
632:
633: /*
634: * Traverse the receive ring looking for packets to pass back.
635: * The search is complete when we find a descriptor not in use.
636: *
637: * As in the transmit case the deqna doesn't honor it's own protocols
638: * so there exists the possibility that the device can beat us around
639: * the ring. The proper way to guard against this is to insure that
640: * there is always at least one invalid descriptor. We chose instead
641: * to make the ring large enough to minimize the problem. With a ring
642: * size of 4 we haven't been able to see the problem. To be safe we
643: * doubled that to 8.
644: *
645: */
646: for( ; sc->rring[sc->rindex].qe_status1 != QE_NOTYET ; sc->rindex = ++sc->rindex % NRCV ){
647: rp = &sc->rring[sc->rindex];
648: status1 = rp->qe_status1;
649: status2 = rp->qe_status2;
650: bzero((caddr_t)rp, sizeof(struct qe_ring));
651: if( (status1 & QE_MASK) == QE_MASK )
652: panic("qe: chained packet");
653: len = ((status1 & QE_RBL_HI) | (status2 & QE_RBL_LO)) + 60;
654: sc->qe_if.if_ipackets++;
655:
656: if (status1 & QE_ERROR) {
657: if ((status1 & QE_RUNT) == 0)
658: sc->qe_if.if_ierrors++;
659: } else {
660: /*
661: * We don't process setup packets.
662: */
663: if( !(status1 & QE_ESETUP) )
664: qeread(sc, &sc->qe_ifr[sc->rindex],
665: len - sizeof(struct ether_header));
666: }
667: /*
668: * Return the buffer to the ring
669: */
670: bufaddr = (int)sc->qe_ifr[sc->rindex].ifrw_info & mask;
671: rp->qe_buf_len = -((MAXPACKETSIZE)/2);
672: rp->qe_addr_lo = (short)bufaddr;
673: rp->qe_addr_hi = (short)((int)bufaddr >> 16);
674: rp->qe_flag = rp->qe_status1 = QE_NOTYET;
675: rp->qe_valid = 1;
676: }
677: }
678: /*
679: * Ethernet output routine.
680: * Encapsulate a packet of type family for the local net.
681: * Use trailer local net encapsulation if enough data in first
682: * packet leaves a multiple of 512 bytes of data in remainder.
683: */
684: qeoutput(ifp, m0, dst)
685: struct ifnet *ifp;
686: struct mbuf *m0;
687: struct sockaddr *dst;
688: {
689: int type, s, error;
690: u_char edst[6];
691: struct in_addr idst;
692: register struct qe_softc *is = &qe_softc[ifp->if_unit];
693: register struct mbuf *m = m0;
694: register struct ether_header *eh;
695: register int off;
696: int usetrailers;
697:
698: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
699: error = ENETDOWN;
700: goto bad;
701: }
702:
703: switch (dst->sa_family) {
704:
705: #ifdef INET
706: case AF_INET:
707: idst = ((struct sockaddr_in *)dst)->sin_addr;
708: if (!arpresolve(&is->qe_ac, m, &idst, edst, &usetrailers))
709: return (0); /* if not yet resolved */
710: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
711: if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
712: m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
713: type = ETHERTYPE_TRAIL + (off>>9);
714: m->m_off -= 2 * sizeof (u_short);
715: m->m_len += 2 * sizeof (u_short);
716: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
717: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
718: goto gottrailertype;
719: }
720: type = ETHERTYPE_IP;
721: off = 0;
722: goto gottype;
723: #endif
724: #ifdef NS
725: case AF_NS:
726: type = ETHERTYPE_NS;
727: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
728: (caddr_t)edst, sizeof (edst));
729: off = 0;
730: goto gottype;
731: #endif
732:
733:
734: case AF_UNSPEC:
735: eh = (struct ether_header *)dst->sa_data;
736: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
737: type = eh->ether_type;
738: goto gottype;
739:
740: default:
741: printf("qe%d: can't handle af%d\n", ifp->if_unit,
742: dst->sa_family);
743: error = EAFNOSUPPORT;
744: goto bad;
745: }
746:
747: gottrailertype:
748: /*
749: * Packet to be sent as trailer: move first packet
750: * (control information) to end of chain.
751: */
752: while (m->m_next)
753: m = m->m_next;
754: m->m_next = m0;
755: m = m0->m_next;
756: m0->m_next = 0;
757: m0 = m;
758:
759: gottype:
760: /*
761: * Add local net header. If no space in first mbuf,
762: * allocate another.
763: */
764: if (m->m_off > MMAXOFF ||
765: MMINOFF + sizeof (struct ether_header) > m->m_off) {
766: m = m_get(M_DONTWAIT, MT_HEADER);
767: if (m == 0) {
768: error = ENOBUFS;
769: goto bad;
770: }
771: m->m_next = m0;
772: m->m_off = MMINOFF;
773: m->m_len = sizeof (struct ether_header);
774: } else {
775: m->m_off -= sizeof (struct ether_header);
776: m->m_len += sizeof (struct ether_header);
777: }
778: eh = mtod(m, struct ether_header *);
779: eh->ether_type = htons((u_short)type);
780: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
781: bcopy((caddr_t)is->qe_addr, (caddr_t)eh->ether_shost, sizeof (is->qe_addr));
782:
783: /*
784: * Queue message on interface, and start output if interface
785: * not yet active.
786: */
787: s = splimp();
788: if (IF_QFULL(&ifp->if_snd)) {
789: IF_DROP(&ifp->if_snd);
790: splx(s);
791: m_freem(m);
792: return (ENOBUFS);
793: }
794: IF_ENQUEUE(&ifp->if_snd, m);
795: qestart(ifp->if_unit);
796: splx(s);
797: return (0);
798:
799: bad:
800: m_freem(m0);
801: return (error);
802: }
803:
804:
805: /*
806: * Process an ioctl request.
807: */
808: qeioctl(ifp, cmd, data)
809: register struct ifnet *ifp;
810: int cmd;
811: caddr_t data;
812: {
813: struct qe_softc *sc = &qe_softc[ifp->if_unit];
814: struct ifaddr *ifa = (struct ifaddr *)data;
815: int s = splimp(), error = 0;
816:
817: switch (cmd) {
818:
819: case SIOCSIFADDR:
820: ifp->if_flags |= IFF_UP;
821: qeinit(ifp->if_unit);
822: switch(ifa->ifa_addr.sa_family) {
823: #ifdef INET
824: case AF_INET:
825: ((struct arpcom *)ifp)->ac_ipaddr =
826: IA_SIN(ifa)->sin_addr;
827: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
828: break;
829: #endif
830: #ifdef NS
831: case AF_NS:
832: {
833: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
834:
835: if (ns_nullhost(*ina))
836: ina->x_host = *(union ns_host *)(sc->qe_addr);
837: else
838: qe_setaddr(ina->x_host.c_host, ifp->if_unit);
839: break;
840: }
841: #endif
842: }
843: break;
844:
845: case SIOCSIFFLAGS:
846: if ((ifp->if_flags & IFF_UP) == 0 &&
847: sc->qe_flags & QEF_RUNNING) {
848: ((struct qedevice *)
849: (qeinfo[ifp->if_unit]->ui_addr))->qe_csr = QE_RESET;
850: sc->qe_flags &= ~QEF_RUNNING;
851: } else if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) ==
852: IFF_RUNNING && (sc->qe_flags & QEF_RUNNING) == 0)
853: qerestart(sc);
854: break;
855:
856: default:
857: error = EINVAL;
858:
859: }
860: splx(s);
861: return (error);
862: }
863:
864: /*
865: * set ethernet address for unit
866: */
867: qe_setaddr(physaddr, unit)
868: u_char *physaddr;
869: int unit;
870: {
871: register struct qe_softc *sc = &qe_softc[unit];
872: register int i;
873:
874: for (i = 0; i < 6; i++)
875: sc->setup_pkt[i][1] = sc->qe_addr[i] = physaddr[i];
876: sc->qe_flags |= QEF_SETADDR;
877: if (sc->qe_if.if_flags & IFF_RUNNING)
878: qesetup(sc);
879: qeinit(unit);
880: }
881:
882:
883: /*
884: * Initialize a ring descriptor with mbuf allocation side effects
885: */
886: qeinitdesc(rp, addr, len)
887: register struct qe_ring *rp;
888: caddr_t addr; /* mapped address */
889: int len;
890: {
891: /*
892: * clear the entire descriptor
893: */
894: bzero((caddr_t)rp, sizeof(struct qe_ring));
895:
896: if( len ) {
897: rp->qe_buf_len = -(len/2);
898: rp->qe_addr_lo = (short)addr;
899: rp->qe_addr_hi = (short)((int)addr >> 16);
900: }
901: }
902: /*
903: * Build a setup packet - the physical address will already be present
904: * in first column.
905: */
906: qesetup( sc )
907: struct qe_softc *sc;
908: {
909: register i, j;
910:
911: /*
912: * Copy the target address to the rest of the entries in this row.
913: */
914: for ( j = 0; j < 6 ; j++ )
915: for ( i = 2 ; i < 8 ; i++ )
916: sc->setup_pkt[j][i] = sc->setup_pkt[j][1];
917: /*
918: * Duplicate the first half.
919: */
920: bcopy((caddr_t)sc->setup_pkt[0], (caddr_t)sc->setup_pkt[8], 64);
921: /*
922: * Fill in the broadcast address.
923: */
924: for ( i = 0; i < 6 ; i++ )
925: sc->setup_pkt[i][2] = 0xff;
926: sc->setupqueued++;
927: }
928:
929: /*
930: * Pass a packet to the higher levels.
931: * We deal with the trailer protocol here.
932: */
933: qeread(sc, ifrw, len)
934: register struct qe_softc *sc;
935: struct ifrw *ifrw;
936: int len;
937: {
938: struct ether_header *eh;
939: struct mbuf *m;
940: int off, resid;
941: struct ifqueue *inq;
942:
943: /*
944: * Deal with trailer protocol: if type is INET trailer
945: * get true type from first 16-bit word past data.
946: * Remember that type was trailer by setting off.
947: */
948:
949: eh = (struct ether_header *)ifrw->ifrw_addr;
950: eh->ether_type = ntohs((u_short)eh->ether_type);
951: #define qedataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off))))
952: if (eh->ether_type >= ETHERTYPE_TRAIL &&
953: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
954: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512;
955: if (off >= ETHERMTU)
956: return; /* sanity */
957: eh->ether_type = ntohs(*qedataaddr(eh,off, u_short *));
958: resid = ntohs(*(qedataaddr(eh, off+2, u_short *)));
959: if (off + resid > len)
960: return; /* sanity */
961: len = off + resid;
962: } else
963: off = 0;
964: if (len == 0)
965: return;
966:
967: /*
968: * Pull packet off interface. Off is nonzero if packet
969: * has trailing header; qeget will then force this header
970: * information to be at the front, but we still have to drop
971: * the type and length which are at the front of any trailer data.
972: */
973: m = if_ubaget(&sc->qe_uba, ifrw, len, off, &sc->qe_if);
974:
975: if (m == 0)
976: return;
977:
978: if (off) {
979: struct ifnet *ifp;
980:
981: ifp = *(mtod(m, struct ifnet **));
982: m->m_off += 2 * sizeof (u_short);
983: m->m_len -= 2 * sizeof (u_short);
984: *(mtod(m, struct ifnet **)) = ifp;
985: }
986: switch (eh->ether_type) {
987:
988: #ifdef INET
989: case ETHERTYPE_IP:
990: schednetisr(NETISR_IP);
991: inq = &ipintrq;
992: break;
993:
994: case ETHERTYPE_ARP:
995: arpinput(&sc->qe_ac, m);
996: return;
997: #endif
998: #ifdef NS
999: case ETHERTYPE_NS:
1000: schednetisr(NETISR_NS);
1001: inq = &nsintrq;
1002: break;
1003:
1004: #endif
1005:
1006: default:
1007: m_freem(m);
1008: return;
1009: }
1010:
1011: if (IF_QFULL(inq)) {
1012: IF_DROP(inq);
1013: m_freem(m);
1014: return;
1015: }
1016: IF_ENQUEUE(inq, m);
1017: }
1018:
1019: /*
1020: * Watchdog timeout routine. There is a condition in the hardware that
1021: * causes the board to lock up under heavy load. This routine detects
1022: * the hang up and restarts the device.
1023: */
1024: qetimeout(unit)
1025: int unit;
1026: {
1027: register struct qe_softc *sc;
1028:
1029: sc = &qe_softc[unit];
1030: log(LOG_ERR, "qe%d: transmit timeout, restarted %d\n",
1031: unit, ++sc->qe_restarts);
1032: qerestart(sc);
1033: }
1034: /*
1035: * Restart for board lockup problem.
1036: */
1037: qerestart(sc)
1038: register struct qe_softc *sc;
1039: {
1040: register struct ifnet *ifp = &sc->qe_if;
1041: register struct qedevice *addr = sc->addr;
1042: register struct qe_ring *rp;
1043: register i;
1044:
1045: addr->qe_csr = QE_RESET;
1046: qesetup( sc );
1047: for (i = 0, rp = sc->tring; i < NXMT; rp++, i++) {
1048: rp->qe_flag = rp->qe_status1 = QE_NOTYET;
1049: rp->qe_valid = 0;
1050: }
1051: sc->nxmit = sc->otindex = sc->tindex = sc->rindex = 0;
1052: addr->qe_csr = QE_RCV_ENABLE | QE_INT_ENABLE | QE_XMIT_INT |
1053: QE_RCV_INT | QE_ILOOP;
1054: addr->qe_rcvlist_lo = (short)sc->rringaddr;
1055: addr->qe_rcvlist_hi = (short)((int)sc->rringaddr >> 16);
1056: sc->qe_flags |= QEF_RUNNING;
1057: qestart(ifp->if_unit);
1058: }
1059: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.