![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxif|
Return to if_ec.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxif |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)if_ec.c 7.1 (Berkeley) 6/5/86 ! 7: */ ! 8: ! 9: #include "ec.h" ! 10: #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 = ⊤ ! 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
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.