1: /*	@(#)if_qe.c	7.1 (Berkeley) 6/5/86 */
   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 "../machine/pte.h"
 106: 
 107: #include "param.h"
 108: #include "systm.h"
 109: #include "mbuf.h"
 110: #include "buf.h"
 111: #include "protosw.h"
 112: #include "socket.h"
 113: #include "vmmac.h"
 114: #include "ioctl.h"
 115: #include "errno.h"
 116: #include "syslog.h"
 117: #include "time.h"
 118: #include "kernel.h"
 119: 
 120: #include "../net/if.h"
 121: #include "../net/netisr.h"
 122: #include "../net/route.h"
 123: 
 124: #ifdef INET
 125: #include "../netinet/in.h"
 126: #include "../netinet/in_systm.h"
 127: #include "../netinet/in_var.h"
 128: #include "../netinet/ip.h"
 129: #include "../netinet/if_ether.h"
 130: #endif
 131: 
 132: #ifdef NS
 133: #include "../netns/ns.h"
 134: #include "../netns/ns_if.h"
 135: #endif
 136: 
 137: #include "../vax/cpu.h"
 138: #include "../vax/mtpr.h"
 139: #include "if_qereg.h"
 140: #include "if_uba.h"
 141: #include "../vaxuba/ubareg.h"
 142: #include "../vaxuba/ubavar.h"
 143: 
 144: #define NRCV    25          /* Receive descriptors		*/
 145: #define NXMT    5           /* Transmit descriptors		*/
 146: #define NTOT    (NXMT + NRCV)
 147: 
 148: /*
 149:  * This constant should really be 60 because the qna adds 4 bytes of crc.
 150:  * However when set to 60 our packets are ignored by deuna's , 3coms are
 151:  * okay ??????????????????????????????????????????
 152:  */
 153: #define MINDATA 64
 154: 
 155: /*
 156:  * Ethernet software status per interface.
 157:  *
 158:  * Each interface is referenced by a network interface structure,
 159:  * is_if, which the routing code uses to locate the interface.
 160:  * This structure contains the output queue for the interface, its address, ...
 161:  */
 162: struct  qe_softc {
 163:     struct  arpcom is_ac;       /* Ethernet common part 	*/
 164: #define is_if   is_ac.ac_if     /* network-visible interface 	*/
 165: #define is_addr is_ac.ac_enaddr     /* hardware Ethernet address 	*/
 166:     struct  ifubinfo qe_uba;    /* Q-bus resources 		*/
 167:     struct  ifrw qe_ifr[NRCV];  /*	for receive buffers;	*/
 168:     struct  ifxmt qe_ifw[NXMT]; /*	for xmit buffers;	*/
 169:     int qe_flags;       /* software state		*/
 170: #define QEF_RUNNING 0x01
 171: #define QEF_SETADDR 0x02
 172:     int setupaddr;      /* mapping info for setup pkts  */
 173:     struct  qe_ring *rringaddr; /* mapping info for rings	*/
 174:     struct  qe_ring *tringaddr; /*       ""			*/
 175:     struct  qe_ring rring[NRCV+1];  /* Receive ring descriptors 	*/
 176:     struct  qe_ring tring[NXMT+1];  /* Transmit ring descriptors 	*/
 177:     u_char  setup_pkt[16][8];   /* Setup packet			*/
 178:     int rindex;         /* Receive index		*/
 179:     int tindex;         /* Transmit index		*/
 180:     int otindex;        /* Old transmit index		*/
 181:     int qe_intvec;      /* Interrupt vector 		*/
 182:     struct  qedevice *addr;     /* device addr			*/
 183:     int     setupqueued;        /* setup packet queued		*/
 184:     int nxmit;          /* Transmits in progress	*/
 185:     int timeout;        /* watchdog			*/
 186:     int qe_restarts;        /* timeouts			*/
 187: } qe_softc[NQE];
 188: 
 189: struct  uba_device *qeinfo[NQE];
 190: 
 191: extern struct timeval time;
 192: extern timeout();
 193: 
 194: int qeprobe(), qeattach(), qeintr(), qewatch();
 195: int qeinit(),qeoutput(),qeioctl(),qereset(),qewatch();
 196: 
 197: u_short qestd[] = { 0 };
 198: struct  uba_driver qedriver =
 199:     { qeprobe, 0, qeattach, 0, qestd, "qe", qeinfo };
 200: 
 201: #define QE_TIMEO    (15)
 202: #define QEUNIT(x)   minor(x)
 203: static int mask = 0x3ffff;      /* address mask		*/
 204: int qewatchrun = 0;         /* watchdog running	*/
 205: /*
 206:  * The deqna shouldn't receive more than ETHERMTU + sizeof(struct ether_header)
 207:  * but will actually take in up to 2048 bytes. To guard against the receiver
 208:  * chaining buffers (which we aren't prepared to handle) we allocate 2kb
 209:  * size buffers.
 210:  */
 211: #define MAXPACKETSIZE 2048      /* Should really be ETHERMTU	*/
 212: /*
 213:  * Probe the QNA to see if it's there
 214:  */
 215: qeprobe(reg)
 216:     caddr_t reg;
 217: {
 218:     register int br, cvec;      /* r11, r10 value-result */
 219:     register struct qedevice *addr = (struct qedevice *)reg;
 220:     register struct qe_ring *rp;
 221:     register struct qe_ring *prp;   /* physical rp 		*/
 222:     register int i, j;
 223:     static int next=0;      /* softc index		*/
 224:     register struct qe_softc *sc = &qe_softc[next++];
 225: 
 226: #ifdef lint
 227:     br = 0; cvec = br; br = cvec;
 228:     qeintr(0);
 229: #endif
 230:     /*
 231: 	 * Set the address mask for the particular cpu
 232: 	 */
 233:     mask = 0x3ffff;
 234: 
 235:     /*
 236: 	 * The QNA interrupts on i/o operations. To do an I/O operation
 237: 	 * we have to setup the interface by transmitting a setup  packet.
 238: 	 */
 239:     addr->qe_csr = QE_RESET;
 240:     addr->qe_vector = (uba_hd[numuba].uh_lastiv -= 4);
 241: 
 242:     /*
 243: 	 * Map the communications area and the setup packet.
 244: 	 */
 245:     sc->setupaddr =
 246:         uballoc(0, (caddr_t)sc->setup_pkt, sizeof(sc->setup_pkt), 0);
 247:     sc->rringaddr = (struct qe_ring *) uballoc(0, (caddr_t)sc->rring,
 248:         sizeof(struct qe_ring) * (NTOT+2), 0);
 249:     prp = (struct qe_ring *)((int)sc->rringaddr & mask);
 250: 
 251:     /*
 252: 	 * The QNA will loop the setup packet back to the receive ring
 253: 	 * for verification, therefore we initialize the first
 254: 	 * receive & transmit ring descriptors and link the setup packet
 255: 	 * to them.
 256: 	 */
 257:     qeinitdesc(sc->tring, (caddr_t)(sc->setupaddr & mask),
 258:         sizeof(sc->setup_pkt));
 259:     qeinitdesc(sc->rring, (caddr_t)(sc->setupaddr & mask),
 260:         sizeof(sc->setup_pkt));
 261: 
 262:     rp = (struct qe_ring *)sc->tring;
 263:     rp->qe_setup = 1;
 264:     rp->qe_eomsg = 1;
 265:     rp->qe_flag = rp->qe_status1 = QE_NOTYET;
 266:     rp->qe_valid = 1;
 267: 
 268:     rp = (struct qe_ring *)sc->rring;
 269:     rp->qe_flag = rp->qe_status1 = QE_NOTYET;
 270:     rp->qe_valid = 1;
 271: 
 272:     /*
 273: 	 * Get the addr off of the interface and place it into the setup
 274: 	 * packet. This code looks strange due to the fact that the address
 275: 	 * is placed in the setup packet in col. major order.
 276: 	 */
 277:     for( i = 0 ; i < 6 ; i++ )
 278:         sc->setup_pkt[i][1] = addr->qe_sta_addr[i];
 279: 
 280:     qesetup( sc );
 281:     /*
 282: 	 * Start the interface and wait for the packet.
 283: 	 */
 284:     j = cvec;
 285:     addr->qe_csr = QE_INT_ENABLE | QE_XMIT_INT | QE_RCV_INT;
 286:     addr->qe_rcvlist_lo = (short)prp;
 287:     addr->qe_rcvlist_hi = (short)((int)prp >> 16);
 288:     prp += NRCV+1;
 289:     addr->qe_xmtlist_lo = (short)prp;
 290:     addr->qe_xmtlist_hi = (short)((int)prp >> 16);
 291:     DELAY(10000);
 292:     /*
 293: 	 * All done with the bus resources.
 294: 	 */
 295:     ubarelse(0, &sc->setupaddr);
 296:     ubarelse(0, (int *)&sc->rringaddr);
 297:     if( cvec == j )
 298:         return 0;       /* didn't interrupt	*/
 299: 
 300:     return( sizeof(struct qedevice) );
 301: }
 302: 
 303: /*
 304:  * Interface exists: make available by filling in network interface
 305:  * record.  System will initialize the interface when it is ready
 306:  * to accept packets.
 307:  */
 308: qeattach(ui)
 309:     struct uba_device *ui;
 310: {
 311:     register struct qe_softc *sc = &qe_softc[ui->ui_unit];
 312:     register struct ifnet *ifp = &sc->is_if;
 313:     register struct qedevice *addr = (struct qedevice *)ui->ui_addr;
 314:     register int i;
 315: 
 316:     ifp->if_unit = ui->ui_unit;
 317:     ifp->if_name = "qe";
 318:     ifp->if_mtu = ETHERMTU;
 319:     ifp->if_flags = IFF_BROADCAST;
 320: 
 321:     /*
 322: 	 * Read the address from the prom and save it.
 323: 	 */
 324:     for( i=0 ; i<6 ; i++ )
 325:         sc->setup_pkt[i][1] = sc->is_addr[i] = addr->qe_sta_addr[i] & 0xff;
 326: 
 327:     /*
 328: 	 * Save the vector for initialization at reset time.
 329: 	 */
 330:     sc->qe_intvec = addr->qe_vector;
 331: 
 332:     ifp->if_init = qeinit;
 333:     ifp->if_output = qeoutput;
 334:     ifp->if_ioctl = qeioctl;
 335:     ifp->if_reset = qereset;
 336:     sc->qe_uba.iff_flags = UBA_CANTWAIT;
 337:     if_attach(ifp);
 338: }
 339: 
 340: /*
 341:  * Reset of interface after UNIBUS reset.
 342:  * If interface is on specified uba, reset its state.
 343:  */
 344: qereset(unit, uban)
 345:     int unit, uban;
 346: {
 347:     register struct uba_device *ui;
 348: 
 349:     if (unit >= NQE || (ui = qeinfo[unit]) == 0 || ui->ui_alive == 0 ||
 350:         ui->ui_ubanum != uban)
 351:         return;
 352:     printf(" qe%d", unit);
 353:     qe_softc[unit].is_if.if_flags &= ~IFF_RUNNING;
 354:     qeinit(unit);
 355: }
 356: 
 357: /*
 358:  * Initialization of interface.
 359:  */
 360: qeinit(unit)
 361:     int unit;
 362: {
 363:     register struct qe_softc *sc = &qe_softc[unit];
 364:     register struct uba_device *ui = qeinfo[unit];
 365:     register struct qedevice *addr = (struct qedevice *)ui->ui_addr;
 366:     register struct ifnet *ifp = &sc->is_if;
 367:     register i;
 368:     int s;
 369: 
 370:     /* address not known */
 371:     if (ifp->if_addrlist == (struct ifaddr *)0)
 372:             return;
 373:     if (sc->qe_flags & QEF_RUNNING)
 374:         return;
 375: 
 376:     if ((ifp->if_flags & IFF_RUNNING) == 0) {
 377:         /*
 378: 		 * map the communications area onto the device
 379: 		 */
 380:         sc->rringaddr = (struct qe_ring *)
 381:             ((int) uballoc(0, (caddr_t)sc->rring,
 382:             sizeof(struct qe_ring) * (NTOT+2), 0) & mask);
 383:         sc->tringaddr = sc->rringaddr + NRCV + 1;
 384:         sc->setupaddr = uballoc(0, (caddr_t)sc->setup_pkt,
 385:             sizeof(sc->setup_pkt), 0) & mask;
 386:         /*
 387: 		 * init buffers and maps
 388: 		 */
 389:         if (if_ubaminit(&sc->qe_uba, ui->ui_ubanum,
 390:             sizeof (struct ether_header), (int)btoc(MAXPACKETSIZE),
 391:             sc->qe_ifr, NRCV, sc->qe_ifw, NXMT) == 0) {
 392:             printf("qe%d: can't initialize\n", unit);
 393:             sc->is_if.if_flags &= ~IFF_UP;
 394:             return;
 395:         }
 396:     }
 397:     /*
 398: 	 * Init the buffer descriptors and indexes for each of the lists and
 399: 	 * loop them back to form a ring.
 400: 	 */
 401:     for (i = 0; i < NRCV; i++) {
 402:         qeinitdesc( &sc->rring[i],
 403:             (caddr_t)(sc->qe_ifr[i].ifrw_info & mask), MAXPACKETSIZE);
 404:         sc->rring[i].qe_flag = sc->rring[i].qe_status1 = QE_NOTYET;
 405:         sc->rring[i].qe_valid = 1;
 406:     }
 407:     qeinitdesc(&sc->rring[i], (caddr_t)NULL, 0);
 408: 
 409:     sc->rring[i].qe_addr_lo = (short)sc->rringaddr;
 410:     sc->rring[i].qe_addr_hi = (short)((int)sc->rringaddr >> 16);
 411:     sc->rring[i].qe_chain = 1;
 412:     sc->rring[i].qe_flag = sc->rring[i].qe_status1 = QE_NOTYET;
 413:     sc->rring[i].qe_valid = 1;
 414: 
 415:     for( i = 0 ; i <= NXMT ; i++ )
 416:         qeinitdesc(&sc->tring[i], (caddr_t)NULL, 0);
 417:     i--;
 418: 
 419:     sc->tring[i].qe_addr_lo = (short)sc->tringaddr;
 420:     sc->tring[i].qe_addr_hi = (short)((int)sc->tringaddr >> 16);
 421:     sc->tring[i].qe_chain = 1;
 422:     sc->tring[i].qe_flag = sc->tring[i].qe_status1 = QE_NOTYET;
 423:     sc->tring[i].qe_valid = 1;
 424: 
 425:     sc->nxmit = sc->otindex = sc->tindex = sc->rindex = 0;
 426: 
 427:     /*
 428: 	 * Take the interface out of reset, program the vector,
 429: 	 * enable interrupts, and tell the world we are up.
 430: 	 */
 431:     s = splimp();
 432:     addr->qe_vector = sc->qe_intvec;
 433:     sc->addr = addr;
 434:     addr->qe_csr = QE_RCV_ENABLE | QE_INT_ENABLE | QE_XMIT_INT |
 435:         QE_RCV_INT | QE_ILOOP;
 436:     addr->qe_rcvlist_lo = (short)sc->rringaddr;
 437:     addr->qe_rcvlist_hi = (short)((int)sc->rringaddr >> 16);
 438:     ifp->if_flags |= IFF_UP | IFF_RUNNING;
 439:     sc->qe_flags |= QEF_RUNNING;
 440:     qesetup( sc );
 441:     qestart( unit );
 442:     splx( s );
 443: 
 444: }
 445: 
 446: /*
 447:  * Start output on interface.
 448:  *
 449:  */
 450: qestart(dev)
 451:     dev_t dev;
 452: {
 453:     int unit = QEUNIT(dev);
 454:     struct uba_device *ui = qeinfo[unit];
 455:     register struct qe_softc *sc = &qe_softc[unit];
 456:     register struct qedevice *addr;
 457:     register struct qe_ring *rp;
 458:     register index;
 459:     struct mbuf *m;
 460:     int buf_addr, len, s;
 461: 
 462: 
 463:     s = splimp();
 464:     addr = (struct qedevice *)ui->ui_addr;
 465:     /*
 466: 	 * The deqna doesn't look at anything but the valid bit
 467: 	 * to determine if it should transmit this packet. If you have
 468: 	 * a ring and fill it the device will loop indefinately on the
 469: 	 * packet and continue to flood the net with packets until you
 470: 	 * break the ring. For this reason we never queue more than n-1
 471: 	 * packets in the transmit ring.
 472: 	 *
 473: 	 * The microcoders should have obeyed their own defination of the
 474: 	 * flag and status words, but instead we have to compensate.
 475: 	 */
 476:     for( index = sc->tindex;
 477:         sc->tring[index].qe_valid == 0 && sc->nxmit < (NXMT-1) ;
 478:         sc->tindex = index = ++index % NXMT){
 479:         rp = &sc->tring[index];
 480:         if( sc->setupqueued ) {
 481:             buf_addr = sc->setupaddr;
 482:             len = 128;
 483:             rp->qe_setup = 1;
 484:             sc->setupqueued = 0;
 485:         } else {
 486:             IF_DEQUEUE(&sc->is_if.if_snd, m);
 487:             if( m == 0 ){
 488:                 splx(s);
 489:                 return;
 490:             }
 491:             buf_addr = sc->qe_ifw[index].ifw_info;
 492:             len = if_ubaput(&sc->qe_uba, &sc->qe_ifw[index], m);
 493:         }
 494:         /*
 495: 		 *  Does buffer end on odd byte ?
 496: 		 */
 497:         if( len & 1 ) {
 498:             len++;
 499:             rp->qe_odd_end = 1;
 500:         }
 501:         if( len < MINDATA )
 502:             len = MINDATA;
 503:         rp->qe_buf_len = -(len/2);
 504:         buf_addr &= mask;
 505:         rp->qe_flag = rp->qe_status1 = QE_NOTYET;
 506:         rp->qe_addr_lo = (short)buf_addr;
 507:         rp->qe_addr_hi = (short)(buf_addr >> 16);
 508:         rp->qe_eomsg = 1;
 509:         rp->qe_flag = rp->qe_status1 = QE_NOTYET;
 510:         rp->qe_valid = 1;
 511:         sc->nxmit++;
 512:         /*
 513: 		 * If the watchdog time isn't running kick it.
 514: 		 */
 515:         sc->timeout=1;
 516:         if (qewatchrun == 0) {
 517:             qewatchrun++;
 518:             timeout(qewatch, (caddr_t)0, QE_TIMEO);
 519:         }
 520: 
 521:         /*
 522: 		 * See if the xmit list is invalid.
 523: 		 */
 524:         if( addr->qe_csr & QE_XL_INVALID ) {
 525:             buf_addr = (int)(sc->tringaddr+index);
 526:             addr->qe_xmtlist_lo = (short)buf_addr;
 527:             addr->qe_xmtlist_hi = (short)(buf_addr >> 16);
 528:         }
 529:     }
 530:     splx( s );
 531: }
 532: 
 533: /*
 534:  * Ethernet interface interrupt processor
 535:  */
 536: qeintr(unit)
 537:     int unit;
 538: {
 539:     register struct qe_softc *sc = &qe_softc[unit];
 540:     struct qedevice *addr = (struct qedevice *)qeinfo[unit]->ui_addr;
 541:     int s, buf_addr, csr;
 542: 
 543:     s = splimp();
 544:     csr = addr->qe_csr;
 545:     addr->qe_csr = QE_RCV_ENABLE | QE_INT_ENABLE | QE_XMIT_INT | QE_RCV_INT | QE_ILOOP;
 546:     if( csr & QE_RCV_INT )
 547:         qerint( unit );
 548:     if( csr & QE_XMIT_INT )
 549:         qetint( unit );
 550:     if( csr & QE_NEX_MEM_INT )
 551:         panic("qe: Non existant memory interrupt");
 552: 
 553:     if( addr->qe_csr & QE_RL_INVALID && sc->rring[sc->rindex].qe_status1 == QE_NOTYET ) {
 554:         buf_addr = (int)&sc->rringaddr[sc->rindex];
 555:         addr->qe_rcvlist_lo = (short)buf_addr;
 556:         addr->qe_rcvlist_hi = (short)(buf_addr >> 16);
 557:     }
 558:     splx( s );
 559: }
 560: 
 561: /*
 562:  * Ethernet interface transmit interrupt.
 563:  */
 564: 
 565: qetint(unit)
 566:     int unit;
 567: {
 568:     register struct qe_softc *sc = &qe_softc[unit];
 569:     register struct qe_ring *rp;
 570:     register struct ifxmt *ifxp;
 571:     int status1, setupflag;
 572:     short len;
 573: 
 574: 
 575:     while( sc->otindex != sc->tindex && sc->tring[sc->otindex].qe_status1 != QE_NOTYET && sc->nxmit > 0 ) {
 576:         /*
 577: 		 * Save the status words from the descriptor so that it can
 578: 		 * be released.
 579: 		 */
 580:         rp = &sc->tring[sc->otindex];
 581:         status1 = rp->qe_status1;
 582:         setupflag = rp->qe_setup;
 583:         len = (-rp->qe_buf_len) * 2;
 584:         if( rp->qe_odd_end )
 585:             len++;
 586:         /*
 587: 		 * Init the buffer descriptor
 588: 		 */
 589:         bzero((caddr_t)rp, sizeof(struct qe_ring));
 590:         if( --sc->nxmit == 0 )
 591:             sc->timeout = 0;
 592:         if( !setupflag ) {
 593:             /*
 594: 			 * Do some statistics.
 595: 			 */
 596:             sc->is_if.if_opackets++;
 597:             sc->is_if.if_collisions += ( status1 & QE_CCNT ) >> 4;
 598:             if (status1 & QE_ERROR)
 599:                 sc->is_if.if_oerrors++;
 600:             /*
 601: 			 * If this was a broadcast packet loop it
 602: 			 * back because the hardware can't hear its own
 603: 			 * transmits.
 604: 			 */
 605:             ifxp = &sc->qe_ifw[sc->otindex];
 606:             if (bcmp((caddr_t)ifxp->ifw_addr,
 607:                 (caddr_t)etherbroadcastaddr,
 608:                 sizeof(etherbroadcastaddr)) == 0)
 609:                 qeread(sc, &ifxp->ifrw, len);
 610:             if (ifxp->ifw_xtofree) {
 611:                 m_freem(ifxp->ifw_xtofree);
 612:                 ifxp->ifw_xtofree = 0;
 613:             }
 614:         }
 615:         sc->otindex = ++sc->otindex % NXMT;
 616:     }
 617:     qestart( unit );
 618: }
 619: 
 620: /*
 621:  * Ethernet interface receiver interrupt.
 622:  * If can't determine length from type, then have to drop packet.
 623:  * Othewise decapsulate packet based on type and pass to type specific
 624:  * higher-level input routine.
 625:  */
 626: qerint(unit)
 627:     int unit;
 628: {
 629:     register struct qe_softc *sc = &qe_softc[unit];
 630:     register struct qe_ring *rp;
 631:     int len, status1, status2;
 632:     int bufaddr;
 633: 
 634:     /*
 635: 	 * Traverse the receive ring looking for packets to pass back.
 636: 	 * The search is complete when we find a descriptor not in use.
 637: 	 *
 638: 	 * As in the transmit case the deqna doesn't honor it's own protocols
 639: 	 * so there exists the possibility that the device can beat us around
 640: 	 * the ring. The proper way to guard against this is to insure that
 641: 	 * there is always at least one invalid descriptor. We chose instead
 642: 	 * to make the ring large enough to minimize the problem. With a ring
 643: 	 * size of 4 we haven't been able to see the problem. To be safe we
 644: 	 * doubled that to 8.
 645: 	 *
 646: 	 */
 647:     for( ; sc->rring[sc->rindex].qe_status1 != QE_NOTYET ; sc->rindex = ++sc->rindex % NRCV ){
 648:         rp = &sc->rring[sc->rindex];
 649:         status1 = rp->qe_status1;
 650:         status2 = rp->qe_status2;
 651:         bzero((caddr_t)rp, sizeof(struct qe_ring));
 652:         if( (status1 & QE_MASK) == QE_MASK )
 653:             panic("qe: chained packet");
 654:         len = ((status1 & QE_RBL_HI) | (status2 & QE_RBL_LO)) + 60;
 655:         sc->is_if.if_ipackets++;
 656: 
 657:         if (status1 & QE_ERROR)
 658:             sc->is_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->is_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->is_addr, (caddr_t)eh->ether_shost, sizeof (is->is_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->is_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 &&
 852:             (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->is_addr[i] = physaddr[i];
 876:     sc->qe_flags |= QEF_SETADDR;
 877:     if (sc->is_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->is_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->is_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 timer 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: qewatch()
1025: {
1026:     register struct qe_softc *sc;
1027:     register int i;
1028:     int inprogress=0;
1029: 
1030:     for (i = 0; i < NQE; i++) {
1031:         sc = &qe_softc[i];
1032:         if (sc->timeout)
1033:             if (++sc->timeout > 3 ) {
1034:                 log(LOG_ERR,
1035:                      "qerestart: restarted qe%d %d\n",
1036:                      i, ++sc->qe_restarts);
1037:                 qerestart(sc);
1038:             } else
1039:                 inprogress++;
1040:     }
1041:     if (inprogress) {
1042:         timeout(qewatch, (caddr_t)0, QE_TIMEO);
1043:         qewatchrun++;
1044:     } else
1045:         qewatchrun=0;
1046: }
1047: /*
1048:  * Restart for board lockup problem.
1049:  */
1050: qerestart(sc)
1051:     register struct qe_softc *sc;
1052: {
1053:     register struct ifnet *ifp = &sc->is_if;
1054:     register struct qedevice *addr = sc->addr;
1055:     register struct qe_ring *rp;
1056:     register i;
1057: 
1058:     addr->qe_csr = QE_RESET;
1059:     sc->timeout = 0;
1060:     qesetup( sc );
1061:     for (i = 0, rp = sc->tring; i < NXMT; rp++, i++) {
1062:         rp->qe_flag = rp->qe_status1 = QE_NOTYET;
1063:         rp->qe_valid = 0;
1064:     }
1065:     sc->nxmit = sc->otindex = sc->tindex = sc->rindex = 0;
1066:     addr->qe_csr = QE_RCV_ENABLE | QE_INT_ENABLE | QE_XMIT_INT |
1067:         QE_RCV_INT | QE_ILOOP;
1068:     addr->qe_rcvlist_lo = (short)sc->rringaddr;
1069:     addr->qe_rcvlist_hi = (short)((int)sc->rringaddr >> 16);
1070:     sc->qe_flags |= QEF_RUNNING;
1071:     qestart(ifp->if_unit);
1072: }
1073: #endif

Defined functions

qe_setaddr defined in line 867; used 1 times
qeattach defined in line 308; used 2 times
qeinit defined in line 360; used 5 times
qeinitdesc defined in line 886; used 5 times
qeintr defined in line 536; used 2 times
qeioctl defined in line 808; used 2 times
qeoutput defined in line 684; used 2 times
qeprobe defined in line 215; used 2 times
qeread defined in line 933; used 2 times
qereset defined in line 344; used 2 times
qerestart defined in line 1050; used 2 times
qerint defined in line 626; used 1 times
qesetup defined in line 906; used 4 times
qestart defined in line 450; used 4 times
qetint defined in line 565; used 1 times
qewatch defined in line 1024; used 4 times

Defined variables

mask defined in line 203; used 9 times
qe_softc defined in line 187; used 12 times
qedriver defined in line 198; never used
qeinfo defined in line 189; used 6 times
qestd defined in line 197; used 1 times
qewatchrun defined in line 204; used 4 times

Defined struct's

qe_softc defined in line 162; used 28 times

Defined macros

MAXPACKETSIZE defined in line 211; used 3 times
MINDATA defined in line 153; used 2 times
NRCV defined in line 144; used 8 times
NTOT defined in line 146; used 2 times
NXMT defined in line 145; used 9 times
QEF_RUNNING defined in line 170; used 6 times
QEF_SETADDR defined in line 171; used 1 times
QEUNIT defined in line 202; used 1 times
QE_TIMEO defined in line 201; used 2 times
is_addr defined in line 165; used 5 times
is_if defined in line 164; used 13 times
qedataaddr defined in line 951; used 2 times
Last modified: 1986-06-06
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 2000
Valid CSS Valid XHTML 1.0 Strict