4.3BSD - /usr/src/sys/vaxif/if_ec.c

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

Defined functions

Defined variables

Defined struct's

Defined macros