![[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] / 42BSD / sys / vaxif|
Return to if_ec.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / vaxif |
1.1 ! root 1: /* if_ec.c 6.1 83/07/29 */ ! 2: ! 3: #include "ec.h" ! 4: ! 5: /* ! 6: * 3Com Ethernet Controller interface ! 7: */ ! 8: #include "../machine/pte.h" ! 9: ! 10: #include "../h/param.h" ! 11: #include "../h/systm.h" ! 12: #include "../h/mbuf.h" ! 13: #include "../h/buf.h" ! 14: #include "../h/protosw.h" ! 15: #include "../h/socket.h" ! 16: #include "../h/vmmac.h" ! 17: #include "../h/ioctl.h" ! 18: #include "../h/errno.h" ! 19: ! 20: #include "../net/if.h" ! 21: #include "../net/netisr.h" ! 22: #include "../net/route.h" ! 23: #include "../netinet/in.h" ! 24: #include "../netinet/in_systm.h" ! 25: #include "../netinet/ip.h" ! 26: #include "../netinet/ip_var.h" ! 27: #include "../netinet/if_ether.h" ! 28: #include "../netpup/pup.h" ! 29: ! 30: #include "../vax/cpu.h" ! 31: #include "../vax/mtpr.h" ! 32: #include "../vaxif/if_ecreg.h" ! 33: #include "../vaxif/if_uba.h" ! 34: #include "../vaxuba/ubareg.h" ! 35: #include "../vaxuba/ubavar.h" ! 36: ! 37: #define ECMEM 0000000 ! 38: ! 39: int ecprobe(), ecattach(), ecrint(), ecxint(), eccollide(); ! 40: struct uba_device *ecinfo[NEC]; ! 41: u_short ecstd[] = { 0 }; ! 42: struct uba_driver ecdriver = ! 43: { ecprobe, 0, ecattach, 0, ecstd, "ec", ecinfo }; ! 44: #define ECUNIT(x) minor(x) ! 45: ! 46: int ecinit(),ecioctl(),ecoutput(),ecreset(); ! 47: struct mbuf *ecget(); ! 48: ! 49: extern struct ifnet loif; ! 50: ! 51: /* ! 52: * Ethernet software status per interface. ! 53: * ! 54: * Each interface is referenced by a network interface structure, ! 55: * es_if, which the routing code uses to locate the interface. ! 56: * This structure contains the output queue for the interface, its address, ... ! 57: * We also have, for each interface, a UBA interface structure, which ! 58: * contains information about the UNIBUS resources held by the interface: ! 59: * map registers, buffered data paths, etc. Information is cached in this ! 60: * structure for use by the if_uba.c routines in running the interface ! 61: * efficiently. ! 62: */ ! 63: struct ec_softc { ! 64: struct arpcom es_ac; /* common Ethernet structures */ ! 65: #define es_if es_ac.ac_if /* network-visible interface */ ! 66: #define es_addr es_ac.ac_enaddr /* hardware Ethernet address */ ! 67: struct ifuba es_ifuba; /* UNIBUS resources */ ! 68: short es_mask; /* mask for current output delay */ ! 69: short es_oactive; /* is output active? */ ! 70: u_char *es_buf[16]; /* virtual addresses of buffers */ ! 71: } ec_softc[NEC]; ! 72: ! 73: /* ! 74: * Do output DMA to determine interface presence and ! 75: * interrupt vector. DMA is too short to disturb other hosts. ! 76: */ ! 77: ecprobe(reg) ! 78: caddr_t reg; ! 79: { ! 80: register int br, cvec; /* r11, r10 value-result */ ! 81: register struct ecdevice *addr = (struct ecdevice *)reg; ! 82: register caddr_t ecbuf = (caddr_t) &umem[numuba][ECMEM]; ! 83: ! 84: #ifdef lint ! 85: br = 0; cvec = br; br = cvec; ! 86: ecrint(0); ecxint(0); eccollide(0); ! 87: #endif ! 88: /* ! 89: * Make sure memory is turned on ! 90: */ ! 91: addr->ec_rcr = EC_AROM; ! 92: /* ! 93: * Disable map registers for ec unibus space, ! 94: * but don't allocate yet. ! 95: */ ! 96: (void) ubamem(numuba, ECMEM, 32*2, 0); ! 97: /* ! 98: * Check for existence of buffers on Unibus. ! 99: */ ! 100: if (badaddr((caddr_t)ecbuf, 2)) { ! 101: bad1: ! 102: printf("ec: buffer mem not found\n"); ! 103: bad2: ! 104: (void) ubamem(numuba, 0, 0, 0); /* reenable map (780 only) */ ! 105: addr->ec_rcr = EC_MDISAB; /* disable memory */ ! 106: return (0); ! 107: } ! 108: #if VAX780 ! 109: if (cpu == VAX_780 && uba_hd[numuba].uh_uba->uba_sr) { ! 110: uba_hd[numuba].uh_uba->uba_sr = uba_hd[numuba].uh_uba->uba_sr; ! 111: goto bad1; ! 112: } ! 113: #endif ! 114: ! 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(numuba, ECMEM, 32*2, 1) == 0) { ! 120: printf("ecprobe: cannot reserve uba addresses\n"); ! 121: goto bad2; ! 122: } ! 123: ! 124: /* ! 125: * Make a one byte packet in what should be buffer #0. ! 126: * Submit it for sending. This whould cause an xmit interrupt. ! 127: * The xmit interrupt vector is 8 bytes after the receive vector, ! 128: * so adjust for this before returning. ! 129: */ ! 130: *(u_short *)ecbuf = (u_short) 03777; ! 131: ecbuf[03777] = '\0'; ! 132: addr->ec_xcr = EC_XINTEN|EC_XWBN; ! 133: DELAY(100000); ! 134: addr->ec_xcr = EC_XCLR; ! 135: if (cvec > 0 && cvec != 0x200) { ! 136: if (cvec & 04) { /* collision interrupt */ ! 137: cvec -= 04; ! 138: br += 1; /* rcv is collision + 1 */ ! 139: } else { /* xmit interrupt */ ! 140: cvec -= 010; ! 141: br += 2; /* rcv is xmit + 2 */ ! 142: } ! 143: } ! 144: return (1); ! 145: } ! 146: ! 147: /* ! 148: * Interface exists: make available by filling in network interface ! 149: * record. System will initialize the interface when it is ready ! 150: * to accept packets. ! 151: */ ! 152: ecattach(ui) ! 153: struct uba_device *ui; ! 154: { ! 155: struct ec_softc *es = &ec_softc[ui->ui_unit]; ! 156: register struct ifnet *ifp = &es->es_if; ! 157: register struct ecdevice *addr = (struct ecdevice *)ui->ui_addr; ! 158: struct sockaddr_in *sin; ! 159: int i, j; ! 160: u_char *cp; ! 161: ! 162: ifp->if_unit = ui->ui_unit; ! 163: ifp->if_name = "ec"; ! 164: ifp->if_mtu = ETHERMTU; ! 165: ! 166: /* ! 167: * Read the ethernet address off the board, one nibble at a time. ! 168: */ ! 169: addr->ec_xcr = EC_UECLR; ! 170: addr->ec_rcr = EC_AROM; ! 171: cp = es->es_addr; ! 172: #define NEXTBIT addr->ec_rcr = EC_AROM|EC_ASTEP; addr->ec_rcr = EC_AROM ! 173: for (i=0; i<6; i++) { ! 174: *cp = 0; ! 175: for (j=0; j<=4; j+=4) { ! 176: *cp |= ((addr->ec_rcr >> 8) & 0xf) << j; ! 177: NEXTBIT; NEXTBIT; NEXTBIT; NEXTBIT; ! 178: } ! 179: cp++; ! 180: } ! 181: sin = (struct sockaddr_in *)&es->es_if.if_addr; ! 182: sin->sin_family = AF_INET; ! 183: sin->sin_addr = arpmyaddr((struct arpcom *)0); ! 184: ifp->if_init = ecinit; ! 185: ifp->if_ioctl = ecioctl; ! 186: ifp->if_output = ecoutput; ! 187: ifp->if_reset = ecreset; ! 188: for (i=0; i<16; i++) ! 189: es->es_buf[i] = (u_char *)&umem[ui->ui_ubanum][ECMEM+2048*i]; ! 190: if_attach(ifp); ! 191: } ! 192: ! 193: /* ! 194: * Reset of interface after UNIBUS reset. ! 195: * If interface is on specified uba, reset its state. ! 196: */ ! 197: ecreset(unit, uban) ! 198: int unit, uban; ! 199: { ! 200: register struct uba_device *ui; ! 201: ! 202: if (unit >= NEC || (ui = ecinfo[unit]) == 0 || ui->ui_alive == 0 || ! 203: ui->ui_ubanum != uban) ! 204: return; ! 205: printf(" ec%d", unit); ! 206: (void) ubamem(uban, ECMEM, 32*2, 0); /* mr disable (no alloc) */ ! 207: ecinit(unit); ! 208: } ! 209: ! 210: /* ! 211: * Initialization of interface; clear recorded pending ! 212: * operations, and reinitialize UNIBUS usage. ! 213: */ ! 214: ecinit(unit) ! 215: int unit; ! 216: { ! 217: struct ec_softc *es = &ec_softc[unit]; ! 218: struct ecdevice *addr; ! 219: register struct ifnet *ifp = &es->es_if; ! 220: register struct sockaddr_in *sin; ! 221: int i, s; ! 222: ! 223: sin = (struct sockaddr_in *)&ifp->if_addr; ! 224: if (sin->sin_addr.s_addr == 0) /* address still unknown */ ! 225: return; ! 226: ! 227: /* ! 228: * Hang receive buffers and start any pending writes. ! 229: * Writing into the rcr also makes sure the memory ! 230: * is turned on. ! 231: */ ! 232: if ((es->es_if.if_flags & IFF_RUNNING) == 0) { ! 233: addr = (struct ecdevice *)ecinfo[unit]->ui_addr; ! 234: s = splimp(); ! 235: for (i = ECRHBF; i >= ECRLBF; i--) ! 236: addr->ec_rcr = EC_READ | i; ! 237: es->es_oactive = 0; ! 238: es->es_mask = ~0; ! 239: es->es_if.if_flags |= IFF_UP|IFF_RUNNING; ! 240: if (es->es_if.if_snd.ifq_head) ! 241: ecstart(unit); ! 242: splx(s); ! 243: } ! 244: if_rtinit(&es->es_if, RTF_UP); ! 245: arpattach(&es->es_ac); ! 246: arpwhohas(&es->es_ac, &sin->sin_addr); ! 247: } ! 248: ! 249: /* ! 250: * Start or restart output on interface. ! 251: * If interface is already active, then this is a retransmit ! 252: * after a collision, and just restuff registers. ! 253: * If interface is not already active, get another datagram ! 254: * to send off of the interface queue, and map it to the interface ! 255: * before starting the output. ! 256: */ ! 257: ecstart(dev) ! 258: dev_t dev; ! 259: { ! 260: int unit = ECUNIT(dev); ! 261: struct ec_softc *es = &ec_softc[unit]; ! 262: struct ecdevice *addr; ! 263: struct mbuf *m; ! 264: ! 265: if (es->es_oactive) ! 266: goto restart; ! 267: ! 268: IF_DEQUEUE(&es->es_if.if_snd, m); ! 269: if (m == 0) { ! 270: es->es_oactive = 0; ! 271: return; ! 272: } ! 273: ecput(es->es_buf[ECTBF], m); ! 274: ! 275: restart: ! 276: addr = (struct ecdevice *)ecinfo[unit]->ui_addr; ! 277: addr->ec_xcr = EC_WRITE|ECTBF; ! 278: es->es_oactive = 1; ! 279: } ! 280: ! 281: /* ! 282: * Ethernet interface transmitter interrupt. ! 283: * Start another output if more data to send. ! 284: */ ! 285: ecxint(unit) ! 286: int unit; ! 287: { ! 288: register struct ec_softc *es = &ec_softc[unit]; ! 289: register struct ecdevice *addr = ! 290: (struct ecdevice *)ecinfo[unit]->ui_addr; ! 291: ! 292: if (es->es_oactive == 0) ! 293: return; ! 294: if ((addr->ec_xcr&EC_XDONE) == 0 || (addr->ec_xcr&EC_XBN) != ECTBF) { ! 295: printf("ec%d: stray xmit interrupt, xcr=%b\n", unit, ! 296: addr->ec_xcr, EC_XBITS); ! 297: es->es_oactive = 0; ! 298: addr->ec_xcr = EC_XCLR; ! 299: return; ! 300: } ! 301: es->es_if.if_opackets++; ! 302: es->es_oactive = 0; ! 303: es->es_mask = ~0; ! 304: addr->ec_xcr = EC_XCLR; ! 305: if (es->es_if.if_snd.ifq_head) ! 306: ecstart(unit); ! 307: } ! 308: ! 309: /* ! 310: * Collision on ethernet interface. Do exponential ! 311: * backoff, and retransmit. If have backed off all ! 312: * the way print warning diagnostic, and drop packet. ! 313: */ ! 314: eccollide(unit) ! 315: int unit; ! 316: { ! 317: struct ec_softc *es = &ec_softc[unit]; ! 318: ! 319: es->es_if.if_collisions++; ! 320: if (es->es_oactive) ! 321: ecdocoll(unit); ! 322: } ! 323: ! 324: ecdocoll(unit) ! 325: int unit; ! 326: { ! 327: register struct ec_softc *es = &ec_softc[unit]; ! 328: register struct ecdevice *addr = ! 329: (struct ecdevice *)ecinfo[unit]->ui_addr; ! 330: register i; ! 331: int delay; ! 332: ! 333: /* ! 334: * Es_mask is a 16 bit number with n low zero bits, with ! 335: * n the number of backoffs. When es_mask is 0 we have ! 336: * backed off 16 times, and give up. ! 337: */ ! 338: if (es->es_mask == 0) { ! 339: es->es_if.if_oerrors++; ! 340: printf("ec%d: send error\n", unit); ! 341: /* ! 342: * Reset interface, then requeue rcv buffers. ! 343: * Some incoming packets may be lost, but that ! 344: * can't be helped. ! 345: */ ! 346: addr->ec_xcr = EC_UECLR; ! 347: for (i=ECRHBF; i>=ECRLBF; i--) ! 348: addr->ec_rcr = EC_READ|i; ! 349: /* ! 350: * Reset and transmit next packet (if any). ! 351: */ ! 352: es->es_oactive = 0; ! 353: es->es_mask = ~0; ! 354: if (es->es_if.if_snd.ifq_head) ! 355: ecstart(unit); ! 356: return; ! 357: } ! 358: /* ! 359: * Do exponential backoff. Compute delay based on low bits ! 360: * of the interval timer. Then delay for that number of ! 361: * slot times. A slot time is 51.2 microseconds (rounded to 51). ! 362: * This does not take into account the time already used to ! 363: * process the interrupt. ! 364: */ ! 365: es->es_mask <<= 1; ! 366: delay = mfpr(ICR) &~ es->es_mask; ! 367: DELAY(delay * 51); ! 368: /* ! 369: * Clear the controller's collision flag, thus enabling retransmit. ! 370: */ ! 371: addr->ec_xcr = EC_CLEAR; ! 372: } ! 373: ! 374: /* ! 375: * Ethernet interface receiver interrupt. ! 376: * If input error just drop packet. ! 377: * Otherwise purge input buffered data path and examine ! 378: * packet to determine type. If can't determine length ! 379: * from type, then have to drop packet. Othewise decapsulate ! 380: * packet based on type and pass to type specific higher-level ! 381: * input routine. ! 382: */ ! 383: ecrint(unit) ! 384: int unit; ! 385: { ! 386: struct ecdevice *addr = (struct ecdevice *)ecinfo[unit]->ui_addr; ! 387: ! 388: while (addr->ec_rcr & EC_RDONE) ! 389: ecread(unit); ! 390: } ! 391: ! 392: ecread(unit) ! 393: int unit; ! 394: { ! 395: register struct ec_softc *es = &ec_softc[unit]; ! 396: struct ecdevice *addr = (struct ecdevice *)ecinfo[unit]->ui_addr; ! 397: register struct ether_header *ec; ! 398: struct mbuf *m; ! 399: int len, off, resid, ecoff, rbuf; ! 400: register struct ifqueue *inq; ! 401: u_char *ecbuf; ! 402: ! 403: es->es_if.if_ipackets++; ! 404: rbuf = addr->ec_rcr & EC_RBN; ! 405: if (rbuf < ECRLBF || rbuf > ECRHBF) ! 406: panic("ecrint"); ! 407: ecbuf = es->es_buf[rbuf]; ! 408: ecoff = *(short *)ecbuf; ! 409: if (ecoff <= ECRDOFF || ecoff > 2046) { ! 410: es->es_if.if_ierrors++; ! 411: #ifdef notdef ! 412: if (es->es_if.if_ierrors % 100 == 0) ! 413: printf("ec%d: += 100 input errors\n", unit); ! 414: #endif ! 415: goto setup; ! 416: } ! 417: ! 418: /* ! 419: * Get input data length. ! 420: * Get pointer to ethernet header (in input buffer). ! 421: * Deal with trailer protocol: if type is PUP trailer ! 422: * get true type from first 16-bit word past data. ! 423: * Remember that type was trailer by setting off. ! 424: */ ! 425: len = ecoff - ECRDOFF - sizeof (struct ether_header); ! 426: ec = (struct ether_header *)(ecbuf + ECRDOFF); ! 427: ec->ether_type = ntohs((u_short)ec->ether_type); ! 428: #define ecdataaddr(ec, off, type) ((type)(((caddr_t)((ec)+1)+(off)))) ! 429: if (ec->ether_type >= ETHERPUP_TRAIL && ! 430: ec->ether_type < ETHERPUP_TRAIL+ETHERPUP_NTRAILER) { ! 431: off = (ec->ether_type - ETHERPUP_TRAIL) * 512; ! 432: if (off >= ETHERMTU) ! 433: goto setup; /* sanity */ ! 434: ec->ether_type = ntohs(*ecdataaddr(ec, off, u_short *)); ! 435: resid = ntohs(*(ecdataaddr(ec, off+2, u_short *))); ! 436: if (off + resid > len) ! 437: goto setup; /* sanity */ ! 438: len = off + resid; ! 439: } else ! 440: off = 0; ! 441: if (len == 0) ! 442: goto setup; ! 443: ! 444: /* ! 445: * Pull packet off interface. Off is nonzero if packet ! 446: * has trailing header; ecget will then force this header ! 447: * information to be at the front, but we still have to drop ! 448: * the type and length which are at the front of any trailer data. ! 449: */ ! 450: m = ecget(ecbuf, len, off); ! 451: if (m == 0) ! 452: goto setup; ! 453: if (off) { ! 454: m->m_off += 2 * sizeof (u_short); ! 455: m->m_len -= 2 * sizeof (u_short); ! 456: } ! 457: switch (ec->ether_type) { ! 458: ! 459: #ifdef INET ! 460: case ETHERPUP_IPTYPE: ! 461: schednetisr(NETISR_IP); ! 462: inq = &ipintrq; ! 463: break; ! 464: ! 465: case ETHERPUP_ARPTYPE: ! 466: arpinput(&es->es_ac, m); ! 467: goto setup; ! 468: #endif ! 469: default: ! 470: m_freem(m); ! 471: goto setup; ! 472: } ! 473: ! 474: if (IF_QFULL(inq)) { ! 475: IF_DROP(inq); ! 476: m_freem(m); ! 477: goto setup; ! 478: } ! 479: IF_ENQUEUE(inq, m); ! 480: ! 481: setup: ! 482: /* ! 483: * Reset for next packet. ! 484: */ ! 485: addr->ec_rcr = EC_READ|EC_RCLR|rbuf; ! 486: } ! 487: ! 488: /* ! 489: * Ethernet output routine. ! 490: * Encapsulate a packet of type family for the local net. ! 491: * Use trailer local net encapsulation if enough data in first ! 492: * packet leaves a multiple of 512 bytes of data in remainder. ! 493: * If destination is this address or broadcast, send packet to ! 494: * loop device to kludge around the fact that 3com interfaces can't ! 495: * talk to themselves. ! 496: */ ! 497: ecoutput(ifp, m0, dst) ! 498: struct ifnet *ifp; ! 499: struct mbuf *m0; ! 500: struct sockaddr *dst; ! 501: { ! 502: int type, s, error; ! 503: u_char edst[6]; ! 504: struct in_addr idst; ! 505: register struct ec_softc *es = &ec_softc[ifp->if_unit]; ! 506: register struct mbuf *m = m0; ! 507: register struct ether_header *ec; ! 508: register int off; ! 509: struct mbuf *mcopy = (struct mbuf *)0; ! 510: ! 511: switch (dst->sa_family) { ! 512: ! 513: #ifdef INET ! 514: case AF_INET: ! 515: idst = ((struct sockaddr_in *)dst)->sin_addr; ! 516: if (!arpresolve(&es->es_ac, m, &idst, edst)) ! 517: return (0); /* if not yet resolved */ ! 518: if (in_lnaof(idst) == INADDR_ANY) ! 519: mcopy = m_copy(m, 0, (int)M_COPYALL); ! 520: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; ! 521: /* need per host negotiation */ ! 522: if ((ifp->if_flags & IFF_NOTRAILERS) == 0) ! 523: if (off > 0 && (off & 0x1ff) == 0 && ! 524: m->m_off >= MMINOFF + 2 * sizeof (u_short)) { ! 525: type = ETHERPUP_TRAIL + (off>>9); ! 526: m->m_off -= 2 * sizeof (u_short); ! 527: m->m_len += 2 * sizeof (u_short); ! 528: *mtod(m, u_short *) = ntohs((u_short)ETHERPUP_IPTYPE); ! 529: *(mtod(m, u_short *) + 1) = ntohs((u_short)m->m_len); ! 530: goto gottrailertype; ! 531: } ! 532: type = ETHERPUP_IPTYPE; ! 533: off = 0; ! 534: goto gottype; ! 535: #endif ! 536: ! 537: case AF_UNSPEC: ! 538: ec = (struct ether_header *)dst->sa_data; ! 539: bcopy((caddr_t)ec->ether_dhost, (caddr_t)edst, sizeof (edst)); ! 540: type = ec->ether_type; ! 541: goto gottype; ! 542: ! 543: default: ! 544: printf("ec%d: can't handle af%d\n", ifp->if_unit, ! 545: dst->sa_family); ! 546: error = EAFNOSUPPORT; ! 547: goto bad; ! 548: } ! 549: ! 550: gottrailertype: ! 551: /* ! 552: * Packet to be sent as trailer: move first packet ! 553: * (control information) to end of chain. ! 554: */ ! 555: while (m->m_next) ! 556: m = m->m_next; ! 557: m->m_next = m0; ! 558: m = m0->m_next; ! 559: m0->m_next = 0; ! 560: m0 = m; ! 561: ! 562: gottype: ! 563: /* ! 564: * Add local net header. If no space in first mbuf, ! 565: * allocate another. ! 566: */ ! 567: if (m->m_off > MMAXOFF || ! 568: MMINOFF + sizeof (struct ether_header) > m->m_off) { ! 569: m = m_get(M_DONTWAIT, MT_HEADER); ! 570: if (m == 0) { ! 571: error = ENOBUFS; ! 572: goto bad; ! 573: } ! 574: m->m_next = m0; ! 575: m->m_off = MMINOFF; ! 576: m->m_len = sizeof (struct ether_header); ! 577: } else { ! 578: m->m_off -= sizeof (struct ether_header); ! 579: m->m_len += sizeof (struct ether_header); ! 580: } ! 581: ec = mtod(m, struct ether_header *); ! 582: bcopy((caddr_t)edst, (caddr_t)ec->ether_dhost, sizeof (edst)); ! 583: ec->ether_type = htons((u_short)type); ! 584: bcopy((caddr_t)es->es_addr, (caddr_t)ec->ether_shost, 6); ! 585: ! 586: /* ! 587: * Queue message on interface, and start output if interface ! 588: * not yet active. ! 589: */ ! 590: s = splimp(); ! 591: if (IF_QFULL(&ifp->if_snd)) { ! 592: IF_DROP(&ifp->if_snd); ! 593: error = ENOBUFS; ! 594: goto qfull; ! 595: } ! 596: IF_ENQUEUE(&ifp->if_snd, m); ! 597: if (es->es_oactive == 0) ! 598: ecstart(ifp->if_unit); ! 599: splx(s); ! 600: return (mcopy ? looutput(&loif, mcopy, dst) : 0); ! 601: ! 602: qfull: ! 603: m0 = m; ! 604: splx(s); ! 605: bad: ! 606: m_freem(m0); ! 607: return (error); ! 608: } ! 609: ! 610: /* ! 611: * Routine to copy from mbuf chain to transmit ! 612: * buffer in UNIBUS memory. ! 613: * If packet size is less than the minimum legal size, ! 614: * the buffer is expanded. We probably should zero out the extra ! 615: * bytes for security, but that would slow things down. ! 616: */ ! 617: ecput(ecbuf, m) ! 618: u_char *ecbuf; ! 619: struct mbuf *m; ! 620: { ! 621: register struct mbuf *mp; ! 622: register int off; ! 623: u_char *bp; ! 624: ! 625: for (off = 2048, mp = m; mp; mp = mp->m_next) ! 626: off -= mp->m_len; ! 627: if (2048 - off < ETHERMIN + sizeof (struct ether_header)) ! 628: off = 2048 - ETHERMIN - sizeof (struct ether_header); ! 629: *(u_short *)ecbuf = off; ! 630: bp = (u_char *)(ecbuf + off); ! 631: for (mp = m; mp; mp = mp->m_next) { ! 632: register unsigned len = mp->m_len; ! 633: u_char *mcp; ! 634: ! 635: if (len == 0) ! 636: continue; ! 637: mcp = mtod(mp, u_char *); ! 638: if ((unsigned)bp & 01) { ! 639: *bp++ = *mcp++; ! 640: len--; ! 641: } ! 642: if (off = (len >> 1)) { ! 643: register u_short *to, *from; ! 644: ! 645: to = (u_short *)bp; ! 646: from = (u_short *)mcp; ! 647: do ! 648: *to++ = *from++; ! 649: while (--off > 0); ! 650: bp = (u_char *)to, ! 651: mcp = (u_char *)from; ! 652: } ! 653: if (len & 01) ! 654: *bp++ = *mcp++; ! 655: } ! 656: m_freem(m); ! 657: } ! 658: ! 659: /* ! 660: * Routine to copy from UNIBUS memory into mbufs. ! 661: * Similar in spirit to if_rubaget. ! 662: * ! 663: * Warning: This makes the fairly safe assumption that ! 664: * mbufs have even lengths. ! 665: */ ! 666: struct mbuf * ! 667: ecget(ecbuf, totlen, off0) ! 668: u_char *ecbuf; ! 669: int totlen, off0; ! 670: { ! 671: register struct mbuf *m; ! 672: struct mbuf *top = 0, **mp = ⊤ ! 673: register int off = off0, len; ! 674: u_char *cp; ! 675: ! 676: cp = ecbuf + ECRDOFF + sizeof (struct ether_header); ! 677: while (totlen > 0) { ! 678: register int words; ! 679: u_char *mcp; ! 680: ! 681: MGET(m, M_DONTWAIT, MT_DATA); ! 682: if (m == 0) ! 683: goto bad; ! 684: if (off) { ! 685: len = totlen - off; ! 686: cp = ecbuf + ECRDOFF + ! 687: sizeof (struct ether_header) + off; ! 688: } else ! 689: len = totlen; ! 690: if (len >= CLBYTES) { ! 691: struct mbuf *p; ! 692: ! 693: MCLGET(p, 1); ! 694: if (p != 0) { ! 695: m->m_len = len = CLBYTES; ! 696: m->m_off = (int)p - (int)m; ! 697: } else { ! 698: m->m_len = len = MIN(MLEN, len); ! 699: m->m_off = MMINOFF; ! 700: } ! 701: } else { ! 702: m->m_len = len = MIN(MLEN, len); ! 703: m->m_off = MMINOFF; ! 704: } ! 705: mcp = mtod(m, u_char *); ! 706: if (words = (len >> 1)) { ! 707: register u_short *to, *from; ! 708: ! 709: to = (u_short *)mcp; ! 710: from = (u_short *)cp; ! 711: do ! 712: *to++ = *from++; ! 713: while (--words > 0); ! 714: mcp = (u_char *)to; ! 715: cp = (u_char *)from; ! 716: } ! 717: if (len & 01) ! 718: *mcp++ = *cp++; ! 719: *mp = m; ! 720: mp = &m->m_next; ! 721: if (off == 0) { ! 722: totlen -= len; ! 723: continue; ! 724: } ! 725: off += len; ! 726: if (off == totlen) { ! 727: cp = ecbuf + ECRDOFF + sizeof (struct ether_header); ! 728: off = 0; ! 729: totlen = off0; ! 730: } ! 731: } ! 732: return (top); ! 733: bad: ! 734: m_freem(top); ! 735: return (0); ! 736: } ! 737: ! 738: /* ! 739: * Process an ioctl request. ! 740: */ ! 741: ecioctl(ifp, cmd, data) ! 742: register struct ifnet *ifp; ! 743: int cmd; ! 744: caddr_t data; ! 745: { ! 746: register struct ifreq *ifr = (struct ifreq *)data; ! 747: int s = splimp(), error = 0; ! 748: ! 749: switch (cmd) { ! 750: ! 751: case SIOCSIFADDR: ! 752: if (ifp->if_flags & IFF_RUNNING) ! 753: if_rtinit(ifp, -1); /* delete previous route */ ! 754: ecsetaddr(ifp, (struct sockaddr_in *)&ifr->ifr_addr); ! 755: ecinit(ifp->if_unit); ! 756: break; ! 757: ! 758: default: ! 759: error = EINVAL; ! 760: } ! 761: splx(s); ! 762: return (error); ! 763: } ! 764: ! 765: ecsetaddr(ifp, sin) ! 766: register struct ifnet *ifp; ! 767: register struct sockaddr_in *sin; ! 768: { ! 769: ! 770: ifp->if_addr = *(struct sockaddr *)sin; ! 771: ifp->if_net = in_netof(sin->sin_addr); ! 772: ifp->if_host[0] = in_lnaof(sin->sin_addr); ! 773: sin = (struct sockaddr_in *)&ifp->if_broadaddr; ! 774: sin->sin_family = AF_INET; ! 775: sin->sin_addr = if_makeaddr(ifp->if_net, INADDR_ANY); ! 776: ifp->if_flags |= IFF_BROADCAST; ! 777: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.