![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ace.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / tahoeif|
Return to if_ace.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / tahoeif |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted ! 6: * provided that the above copyright notice and this paragraph are ! 7: * duplicated in all such forms and that any documentation, ! 8: * advertising materials, and other materials related to such ! 9: * distribution and use acknowledge that the software was developed ! 10: * by the University of California, Berkeley. The name of the ! 11: * University may not be used to endorse or promote products derived ! 12: * from this software without specific prior written permission. ! 13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 16: * ! 17: * @(#)if_ace.c 7.2 (Berkeley) 6/29/88 ! 18: */ ! 19: ! 20: /* ! 21: * ACC VERSAbus Ethernet controller ! 22: */ ! 23: #include "ace.h" ! 24: #if NACE > 0 ! 25: ! 26: #include "param.h" ! 27: #include "systm.h" ! 28: #include "mbuf.h" ! 29: #include "buf.h" ! 30: #include "protosw.h" ! 31: #include "socket.h" ! 32: #include "vmmac.h" ! 33: #include "ioctl.h" ! 34: #include "errno.h" ! 35: #include "vmparam.h" ! 36: #include "syslog.h" ! 37: ! 38: #include "../net/if.h" ! 39: #include "../net/netisr.h" ! 40: #include "../net/route.h" ! 41: #ifdef INET ! 42: #include "../netinet/in.h" ! 43: #include "../netinet/in_systm.h" ! 44: #include "../netinet/in_var.h" ! 45: #include "../netinet/ip.h" ! 46: #include "../netinet/ip_var.h" ! 47: #include "../netinet/if_ether.h" ! 48: #endif ! 49: #ifdef NS ! 50: #include "../netns/ns.h" ! 51: #include "../netns/ns_if.h" ! 52: #endif ! 53: ! 54: #include "../machine/cpu.h" ! 55: #include "../machine/pte.h" ! 56: ! 57: #include "../tahoe/mtpr.h" ! 58: #include "../tahoeif/if_acereg.h" ! 59: #include "../tahoevba/vbavar.h" ! 60: ! 61: int aceprobe(), aceattach(), acerint(), acecint(); ! 62: struct vba_device *aceinfo[NACE]; ! 63: long acestd[] = { 0 }; ! 64: struct vba_driver acedriver = ! 65: { aceprobe, 0, aceattach, 0, acestd, "ace", aceinfo, "v/eiu", 0 }; ! 66: ! 67: int aceinit(), aceoutput(), aceioctl(), acereset(); ! 68: struct mbuf *aceget(); ! 69: ! 70: /* ! 71: * Ethernet software status per interface. ! 72: * ! 73: * Each interface is referenced by a network interface structure, ! 74: * is_if, which the routing code uses to locate the interface. ! 75: * This structure contains the output queue for the interface, its address, ... ! 76: */ ! 77: struct ace_softc { ! 78: struct arpcom is_ac; /* Ethernet common part */ ! 79: #define is_if is_ac.ac_if /* network-visible interface */ ! 80: #define is_addr is_ac.ac_enaddr /* hardware Ethernet address */ ! 81: short is_flags; ! 82: #define ACEF_OACTIVE 0x1 /* output is active */ ! 83: #define ACEF_RCVPENDING 0x2 /* start rcv in acecint */ ! 84: short is_promiscuous; /* true is enabled */ ! 85: short is_segboundry; /* first TX Seg in dpm */ ! 86: short is_eictr; /* Rx segment tracking ctr */ ! 87: short is_eoctr; /* Tx segment tracking ctr */ ! 88: short is_txnext; /* Next available Tx segment */ ! 89: short is_currnd; /* current random backoff */ ! 90: struct ace_stats is_stats; /* holds board statistics */ ! 91: short is_xcnt; /* count xmitted segments to be acked ! 92: by the controller */ ! 93: long is_ivec; /* autoconfig interrupt vector base */ ! 94: struct pte *is_map; /* pte map for dual ported memory */ ! 95: caddr_t is_dpm; /* address of mapped memory */ ! 96: } ace_softc[NACE]; ! 97: extern struct ifnet loif; ! 98: ! 99: aceprobe(reg, vi) ! 100: caddr_t reg; ! 101: struct vba_device *vi; ! 102: { ! 103: register br, cvec; /* must be r12, r11 */ ! 104: struct acedevice *ap = (struct acedevice *)reg; ! 105: struct ace_softc *is = &ace_softc[vi->ui_unit]; ! 106: ! 107: #ifdef lint ! 108: br = 0; cvec = br; br = cvec; ! 109: acerint(0); acecint(0); ! 110: #endif ! 111: if (badaddr(reg, 2)) ! 112: return (0); ! 113: movow(&ap->csr, CSR_RESET); ! 114: DELAY(10000); ! 115: #ifdef notdef ! 116: /* ! 117: * Select two spaces for the interrupts aligned to an ! 118: * eight vector boundary and fitting in 8 bits (as ! 119: * required by the controller) -- YECH. The controller ! 120: * will be notified later at initialization time. ! 121: */ ! 122: if ((vi->ui_hd->vh_lastiv -= 2) > 0xff) ! 123: vi->ui_hd->vh_lastiv = 0x200; ! 124: is->is_ivec = vi->ui_hd->vh_lastiv = vi->ui_hd->vh_lastiv &~ 0x7; ! 125: #else ! 126: is->is_ivec = 0x90+vi->ui_unit*8; ! 127: #endif ! 128: br = 0x14, cvec = is->is_ivec; /* XXX */ ! 129: return (sizeof (*ap)); ! 130: } ! 131: ! 132: /* ! 133: * Interface exists: make available by filling in network interface ! 134: * record. System will initialize the interface when it is ready ! 135: * to accept packets. ! 136: */ ! 137: aceattach(ui) ! 138: struct vba_device *ui; ! 139: { ! 140: register short unit = ui->ui_unit; ! 141: register struct ace_softc *is = &ace_softc[unit]; ! 142: register struct ifnet *ifp = &is->is_if; ! 143: register struct acedevice *addr = (struct acedevice *)ui->ui_addr; ! 144: register short *wp, i; ! 145: ! 146: ifp->if_unit = unit; ! 147: ifp->if_name = "ace"; ! 148: ifp->if_mtu = ETHERMTU; ! 149: /* ! 150: * Get station's addresses and set multicast hash table. ! 151: */ ! 152: for (wp = (short *)addr->station, i = 0; i < 6; i++) ! 153: is->is_addr[i] = ~*wp++; ! 154: printf("ace%d: hardware address %s\n", unit, ! 155: ether_sprintf(is->is_addr)); ! 156: is->is_promiscuous = 0; ! 157: for (wp = (short *)addr->hash, i = 0; i < 8; i++) ! 158: movow(wp++, ~0xf); ! 159: movow(&addr->bcastena[0], ~0xffff); ! 160: movow(&addr->bcastena[1], ~0xffff); ! 161: /* ! 162: * Allocate and map dual ported VERSAbus memory. ! 163: */ ! 164: if (vbmemalloc(32, (caddr_t)ui->ui_flags, ! 165: &is->is_map, &is->is_dpm) == 0) { ! 166: printf("ace%d: can't allocate VERSAbus memory map\n", unit); ! 167: return; ! 168: } ! 169: ! 170: ifp->if_init = aceinit; ! 171: ifp->if_output = aceoutput; ! 172: ifp->if_ioctl = aceioctl; ! 173: ifp->if_reset = acereset; ! 174: ifp->if_flags = IFF_BROADCAST; ! 175: if_attach(ifp); ! 176: } ! 177: ! 178: /* ! 179: * Reset of interface after "system" reset. ! 180: */ ! 181: acereset(unit, vban) ! 182: int unit, vban; ! 183: { ! 184: register struct vba_device *ui; ! 185: ! 186: if (unit >= NACE || (ui = aceinfo[unit]) == 0 || ui->ui_alive == 0 || ! 187: ui->ui_vbanum != vban) ! 188: return; ! 189: printf(" ace%d", unit); ! 190: aceinit(unit); ! 191: } ! 192: ! 193: /* ! 194: * Initialization of interface; clear recorded pending operations ! 195: */ ! 196: aceinit(unit) ! 197: int unit; ! 198: { ! 199: register struct ace_softc *is = &ace_softc[unit]; ! 200: register struct vba_device *ui = aceinfo[unit]; ! 201: register struct acedevice *addr; ! 202: register struct ifnet *ifp = &is->is_if; ! 203: register short Csr; ! 204: register int s; ! 205: ! 206: if (ifp->if_addrlist == (struct ifaddr *)0) ! 207: return; ! 208: if ((ifp->if_flags & IFF_RUNNING) == 0) { ! 209: /* ! 210: * Reset the controller, initialize the recieve buffers, ! 211: * and turn the controller on again and set board online. ! 212: */ ! 213: addr = (struct acedevice *)ui->ui_addr; ! 214: s = splimp(); ! 215: movow(&addr->csr, CSR_RESET); ! 216: DELAY(10000); ! 217: ! 218: /* ! 219: * Clean up dpm since the controller might ! 220: * jumble dpm after reset. ! 221: */ ! 222: acesetup(unit); ! 223: movow(&addr->csr, CSR_GO); ! 224: Csr = addr->csr; ! 225: if (Csr & CSR_ACTIVE) { ! 226: movow(&addr->ivct, is->is_ivec); ! 227: Csr |= CSR_IENA | is->is_promiscuous; ! 228: movow(&addr->csr, Csr); ! 229: is->is_flags = 0; ! 230: is->is_xcnt = 0; ! 231: is->is_if.if_flags |= IFF_RUNNING; ! 232: } ! 233: splx(s); ! 234: } ! 235: if (is->is_if.if_snd.ifq_head) ! 236: acestart(unit); ! 237: } ! 238: ! 239: /* ! 240: * Start output on interface. ! 241: * Get another datagram to send off of the interface queue, ! 242: * and map it to the interface before starting the output. ! 243: */ ! 244: acestart(unit) ! 245: int unit; ! 246: { ! 247: register struct tx_segment *txs; ! 248: register long len; ! 249: register int s; ! 250: register struct ace_softc *is = &ace_softc[unit]; ! 251: struct mbuf *m; ! 252: short retries; ! 253: ! 254: if (is->is_flags & ACEF_OACTIVE) ! 255: return; ! 256: is->is_flags |= ACEF_OACTIVE; ! 257: again: ! 258: txs = (struct tx_segment*)(is->is_dpm + (is->is_txnext << 11)); ! 259: if (txs->tx_csr & TCS_TBFULL) { ! 260: is->is_stats.tx_busy++; ! 261: is->is_flags &= ~ACEF_OACTIVE; ! 262: return; ! 263: } ! 264: s = splimp(); ! 265: IF_DEQUEUE(&is->is_if.if_snd, m); ! 266: splx(s); ! 267: if (m == 0) { ! 268: is->is_flags &= ~ACEF_OACTIVE; ! 269: return; ! 270: } ! 271: len = aceput(unit, txs->tx_data, m); ! 272: retries = txs->tx_csr & TCS_RTC; ! 273: if (retries > 0) ! 274: acebakoff(is, txs, retries); ! 275: ! 276: /* ! 277: * Ensure minimum packet length. ! 278: * This makes the safe assumtion that there are no virtual holes ! 279: * after the data. ! 280: * For security, it might be wise to zero out the added bytes, ! 281: * but we're mainly interested in speed at the moment. ! 282: */ ! 283: if (len - sizeof (struct ether_header) < ETHERMIN) ! 284: len = ETHERMIN + sizeof (struct ether_header); ! 285: if (++is->is_txnext > SEG_MAX) ! 286: is->is_txnext = is->is_segboundry; ! 287: is->is_if.if_opackets++; ! 288: is->is_xcnt++; ! 289: len = (len & 0x7fff) | TCS_TBFULL; ! 290: movow(txs, len); ! 291: goto again; ! 292: } ! 293: ! 294: /* ! 295: * Transmit done interrupt. ! 296: */ ! 297: acecint(unit) ! 298: int unit; ! 299: { ! 300: register struct ace_softc *is = &ace_softc[unit]; ! 301: register struct tx_segment *txseg; ! 302: short eostat; ! 303: ! 304: if (is->is_xcnt <= 0) { ! 305: log(LOG_ERR, "ace%d: stray xmit interrupt, xcnt %d\n", ! 306: unit, is->is_xcnt); ! 307: is->is_xcnt = 0; ! 308: if (is->is_if.if_snd.ifq_head) ! 309: acestart(unit); ! 310: return; ! 311: } ! 312: is->is_xcnt--; ! 313: txseg = (struct tx_segment *)((is->is_eoctr << 11) + is->is_dpm); ! 314: eostat = txseg->tx_csr; ! 315: if ((eostat & TCS_TBFULL) == 0) { ! 316: is->is_stats.tx_retries += eostat & TCS_RTC; ! 317: if (eostat & TCS_RTFAIL) { ! 318: is->is_stats.tx_discarded++; ! 319: is->is_if.if_oerrors++; ! 320: } else ! 321: is->is_stats.tx_datagrams++; ! 322: if (++is->is_eoctr >= 16) ! 323: is->is_eoctr = is->is_segboundry; ! 324: } ! 325: if (is->is_if.if_snd.ifq_head) ! 326: acestart(unit); ! 327: } ! 328: ! 329: /* ! 330: * Ethernet interface receiver interrupt. ! 331: * If input error just drop packet. ! 332: * Otherwise purge input buffered data path and examine ! 333: * packet to determine type. If can't determine length ! 334: * from type, then have to drop packet. Othewise decapsulate ! 335: * packet based on type and pass to type specific higher-level ! 336: * input routine. ! 337: */ ! 338: acerint(unit) ! 339: int unit; ! 340: { ! 341: register struct ace_softc *is = &ace_softc[unit]; ! 342: register struct ifqueue *inq; ! 343: register struct ether_header *ace; ! 344: register struct rx_segment *rxseg; ! 345: int len, s, off, resid; ! 346: struct mbuf *m; ! 347: short eistat; ! 348: ! 349: if ((is->is_if.if_flags&IFF_RUNNING) == 0) ! 350: return; ! 351: again: ! 352: rxseg = (struct rx_segment *)((is->is_eictr << 11) + is->is_dpm); ! 353: eistat = rxseg->rx_csr; ! 354: if ((eistat & RCS_RBFULL) == 0) ! 355: return; ! 356: is->is_if.if_ipackets++; ! 357: if (++is->is_eictr >= is->is_segboundry) ! 358: is->is_eictr = 0; ! 359: len = eistat & RCS_RBC; ! 360: if ((eistat & (RCS_ROVRN | RCS_RCRC | RCS_RODD)) || ! 361: len < ET_MINLEN || len > ET_MAXLEN+CRC_SIZE) { ! 362: if (eistat & RCS_ROVRN) ! 363: is->is_stats.rx_overruns++; ! 364: if (eistat & RCS_RCRC) ! 365: is->is_stats.rx_crc_errors++; ! 366: if (eistat & RCS_RODD) ! 367: is->is_stats.rx_align_errors++; ! 368: if (len < ET_MINLEN) ! 369: is->is_stats.rx_underruns++; ! 370: if (len > ET_MAXLEN+CRC_SIZE) ! 371: is->is_stats.rx_overruns++; ! 372: is->is_if.if_ierrors++; ! 373: rxseg->rx_csr = 0; ! 374: return; ! 375: } else ! 376: is->is_stats.rx_datagrams++; ! 377: ace = (struct ether_header *)rxseg->rx_data; ! 378: len -= sizeof (struct ether_header); ! 379: /* ! 380: * Deal with trailer protocol: if type is trailer ! 381: * get true type from first 16-bit word past data. ! 382: * Remember that type was trailer by setting off. ! 383: */ ! 384: ace->ether_type = ntohs((u_short)ace->ether_type); ! 385: #define acedataaddr(ace, off, type) \ ! 386: ((type)(((caddr_t)(((char *)ace)+sizeof (struct ether_header))+(off)))) ! 387: if (ace->ether_type >= ETHERTYPE_TRAIL && ! 388: ace->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) { ! 389: off = (ace->ether_type - ETHERTYPE_TRAIL) * 512; ! 390: if (off >= ETHERMTU) ! 391: goto setup; /* sanity */ ! 392: ace->ether_type = ntohs(*acedataaddr(ace, off, u_short *)); ! 393: resid = ntohs(*(acedataaddr(ace, off+2, u_short *))); ! 394: if (off + resid > len) ! 395: goto setup; /* sanity */ ! 396: len = off + resid; ! 397: } else ! 398: off = 0; ! 399: if (len == 0) ! 400: goto setup; ! 401: ! 402: /* ! 403: * Pull packet off interface. Off is nonzero if packet ! 404: * has trailing header; aceget will then force this header ! 405: * information to be at the front, but we still have to drop ! 406: * the type and length which are at the front of any trailer data. ! 407: */ ! 408: m = aceget((u_char *)rxseg->rx_data, len, off, &is->is_if); ! 409: if (m == 0) ! 410: goto setup; ! 411: if (off) { ! 412: struct ifnet *ifp; ! 413: ! 414: ifp = *(mtod(m, struct ifnet **)); ! 415: m->m_off += 2 * sizeof (u_short); ! 416: m->m_len -= 2 * sizeof (u_short); ! 417: *(mtod(m, struct ifnet **)) = ifp; ! 418: } ! 419: switch (ace->ether_type) { ! 420: ! 421: #ifdef INET ! 422: case ETHERTYPE_IP: ! 423: schednetisr(NETISR_IP); ! 424: inq = &ipintrq; ! 425: break; ! 426: #endif ! 427: ! 428: case ETHERTYPE_ARP: ! 429: arpinput(&is->is_ac, m); ! 430: goto setup; ! 431: #ifdef NS ! 432: case ETHERTYPE_NS: ! 433: schednetisr(NETISR_NS); ! 434: inq = &nsintrq; ! 435: break; ! 436: ! 437: #endif ! 438: default: ! 439: m_freem(m); ! 440: goto setup; ! 441: } ! 442: if (IF_QFULL(inq)) { ! 443: IF_DROP(inq); ! 444: m_freem(m); ! 445: goto setup; ! 446: } ! 447: s = splimp(); ! 448: IF_ENQUEUE(inq, m); ! 449: splx(s); ! 450: setup: ! 451: rxseg->rx_csr = 0; ! 452: goto again; ! 453: } ! 454: ! 455: /* ! 456: * Ethernet output routine. ! 457: * Encapsulate a packet of type family for the local net. ! 458: * Use trailer local net encapsulation if enough data in first ! 459: * packet leaves a multiple of 512 bytes of data in remainder. ! 460: */ ! 461: aceoutput(ifp, m0, dst) ! 462: struct ifnet *ifp; ! 463: struct mbuf *m0; ! 464: struct sockaddr *dst; ! 465: { ! 466: register struct ace_softc *is = &ace_softc[ifp->if_unit]; ! 467: register struct mbuf *m = m0; ! 468: register struct ether_header *ace; ! 469: register int off; ! 470: struct mbuf *mcopy = (struct mbuf *)0; ! 471: int type, s, error, usetrailers; ! 472: u_char edst[6]; ! 473: struct in_addr idst; ! 474: ! 475: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) { ! 476: error = ENETDOWN; ! 477: goto bad; ! 478: } ! 479: switch (dst->sa_family) { ! 480: ! 481: #ifdef INET ! 482: case AF_INET: ! 483: idst = ((struct sockaddr_in *)dst)->sin_addr; ! 484: if (!arpresolve(&is->is_ac, m, &idst, edst, &usetrailers)) ! 485: return (0); /* if not yet resolved */ ! 486: if (!bcmp((caddr_t)edst, (caddr_t)etherbroadcastaddr, ! 487: sizeof (edst))) ! 488: mcopy = m_copy(m, 0, (int)M_COPYALL); ! 489: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; ! 490: if (usetrailers && off > 0 && (off & 0x1ff) == 0 && ! 491: m->m_off >= MMINOFF + 2 * sizeof (u_short)) { ! 492: type = ETHERTYPE_TRAIL + (off>>9); ! 493: m->m_off -= 2 * sizeof (u_short); ! 494: m->m_len += 2 * sizeof (u_short); ! 495: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP); ! 496: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len); ! 497: goto gottrailertype; ! 498: } ! 499: type = ETHERTYPE_IP; ! 500: off = 0; ! 501: goto gottype; ! 502: #endif ! 503: #ifdef NS ! 504: case AF_NS: ! 505: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host), ! 506: (caddr_t)edst, sizeof (edst)); ! 507: if (!bcmp((caddr_t)edst, (caddr_t)&ns_broadhost,sizeof(edst))) ! 508: mcopy = m_copy(m, 0, (int)M_COPYALL); ! 509: else if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost, ! 510: sizeof(edst))) ! 511: return(looutput(&loif, m, dst)); ! 512: type = ETHERTYPE_NS; ! 513: off = 0; ! 514: goto gottype; ! 515: #endif ! 516: case AF_UNSPEC: ! 517: ace = (struct ether_header *)dst->sa_data; ! 518: bcopy((caddr_t)ace->ether_dhost, (caddr_t)edst, sizeof (edst)); ! 519: type = ace->ether_type; ! 520: goto gottype; ! 521: ! 522: default: ! 523: log(LOG_ERR, "ace%d: can't handle af%d\n", ! 524: ifp->if_unit, dst->sa_family); ! 525: error = EAFNOSUPPORT; ! 526: goto bad; ! 527: } ! 528: ! 529: gottrailertype: ! 530: /* ! 531: * Packet to be sent as trailer: move first packet ! 532: * (control information) to end of chain. ! 533: */ ! 534: while (m->m_next) ! 535: m = m->m_next; ! 536: m->m_next = m0; ! 537: m = m0->m_next; ! 538: m0->m_next = 0; ! 539: m0 = m; ! 540: ! 541: gottype: ! 542: /* ! 543: * Add local net header. If no space in first mbuf, ! 544: * allocate another. ! 545: */ ! 546: if (m->m_off > MMAXOFF || ! 547: MMINOFF + sizeof (struct ether_header) > m->m_off) { ! 548: m = m_get(M_DONTWAIT, MT_HEADER); ! 549: if (m == 0) { ! 550: error = ENOBUFS; ! 551: goto bad; ! 552: } ! 553: m->m_next = m0; ! 554: m->m_off = MMINOFF; ! 555: m->m_len = sizeof (struct ether_header); ! 556: } else { ! 557: m->m_off -= sizeof (struct ether_header); ! 558: m->m_len += sizeof (struct ether_header); ! 559: } ! 560: ace = mtod(m, struct ether_header *); ! 561: bcopy((caddr_t)edst, (caddr_t)ace->ether_dhost, sizeof (edst)); ! 562: bcopy((caddr_t)is->is_addr, (caddr_t)ace->ether_shost, ! 563: sizeof (is->is_addr)); ! 564: ace->ether_type = htons((u_short)type); ! 565: ! 566: /* ! 567: * Queue message on interface, and start output if interface ! 568: * not yet active. ! 569: */ ! 570: s = splimp(); ! 571: if (IF_QFULL(&ifp->if_snd)) { ! 572: IF_DROP(&ifp->if_snd); ! 573: error = ENOBUFS; ! 574: goto qfull; ! 575: } ! 576: IF_ENQUEUE(&ifp->if_snd, m); ! 577: splx(s); ! 578: acestart(ifp->if_unit); ! 579: return (mcopy ? looutput(&loif, mcopy, dst) : 0); ! 580: qfull: ! 581: m0 = m; ! 582: splx(s); ! 583: bad: ! 584: m_freem(m0); ! 585: if (mcopy) ! 586: m_freem(mcopy); ! 587: return (error); ! 588: } ! 589: ! 590: /* ! 591: * Routine to copy from mbuf chain to transmit buffer on the VERSAbus ! 592: * If packet size is less than the minimum legal size, ! 593: * the buffer is expanded. We probably should zero out the extra ! 594: * bytes for security, but that would slow things down. ! 595: */ ! 596: /*ARGSUSED*/ ! 597: aceput(unit, txbuf, m) ! 598: int unit; ! 599: char *txbuf; ! 600: struct mbuf *m; ! 601: { ! 602: register u_char *bp, *mcp; ! 603: register short *s1, *s2; ! 604: register u_int len; ! 605: register struct mbuf *mp; ! 606: int total; ! 607: ! 608: total = 0; ! 609: bp = (u_char *)txbuf; ! 610: for (mp = m; (mp); mp = mp->m_next) { ! 611: len = mp->m_len; ! 612: if (len == 0) ! 613: continue; ! 614: total += len; ! 615: mcp = mtod(mp, u_char *); ! 616: if (((int)mcp & 01) && ((int)bp & 01)) { ! 617: /* source & destination at odd addresses */ ! 618: movob(bp++, *mcp++); ! 619: --len; ! 620: } ! 621: if (len > 1 && (((int)mcp & 01)==0) && (((int)bp & 01)==0)) { ! 622: register u_int l; ! 623: ! 624: s1 = (short *)bp; ! 625: s2 = (short *)mcp; ! 626: l = len >> 1; /* count # of shorts */ ! 627: while (l-- != 0) ! 628: movow(s1++, *s2++); ! 629: len &= 1; /* # remaining bytes */ ! 630: bp = (u_char *)s1; ! 631: mcp = (u_char *)s2; ! 632: } ! 633: while (len-- != 0) ! 634: movob(bp++, *mcp++); ! 635: } ! 636: m_freem(m); ! 637: return (total); ! 638: } ! 639: ! 640: /* ! 641: * Routine to copy from VERSAbus memory into mbufs. ! 642: * ! 643: * Warning: This makes the fairly safe assumption that ! 644: * mbufs have even lengths. ! 645: */ ! 646: /*ARGSUSED*/ ! 647: struct mbuf * ! 648: aceget(rxbuf, totlen, off0, ifp) ! 649: u_char *rxbuf; ! 650: int totlen, off0; ! 651: struct ifnet *ifp; ! 652: { ! 653: register u_char *cp, *mcp; ! 654: register int tlen; ! 655: register struct mbuf *m; ! 656: struct mbuf *top = 0, **mp = ⊤ ! 657: int len, off = off0; ! 658: ! 659: cp = rxbuf + sizeof (struct ether_header); ! 660: while (totlen > 0) { ! 661: MGET(m, M_DONTWAIT, MT_DATA); ! 662: if (m == 0) ! 663: goto bad; ! 664: if (off) { ! 665: len = totlen - off; ! 666: cp = rxbuf + sizeof (struct ether_header) + off; ! 667: } else ! 668: len = totlen; ! 669: if (ifp) ! 670: len += sizeof(ifp); ! 671: if (len >= NBPG) { ! 672: MCLGET(m); ! 673: if (m->m_len == CLBYTES) ! 674: m->m_len = len = MIN(len, CLBYTES); ! 675: else ! 676: m->m_len = len = MIN(MLEN, len); ! 677: } else { ! 678: m->m_len = len = MIN(MLEN, len); ! 679: m->m_off = MMINOFF; ! 680: } ! 681: mcp = mtod(m, u_char *); ! 682: if (ifp) { ! 683: /* ! 684: * Prepend interface pointer to first mbuf. ! 685: */ ! 686: *(mtod(m, struct ifnet **)) = ifp; ! 687: mcp += sizeof(ifp); ! 688: len -= sizeof(ifp); ! 689: ifp = (struct ifnet *)0; ! 690: } ! 691: /*bcopy((caddr_t)cp, (caddr_t)mcp, len);*/ ! 692: /*cp += len; mcp += len;*/ ! 693: tlen = len; ! 694: if (((int)mcp & 01) && ((int)cp & 01)) { ! 695: /* source & destination at odd addresses */ ! 696: *mcp++ = *cp++; ! 697: --tlen; ! 698: } ! 699: if (tlen > 1 && (((int)mcp&01) == 0) && (((int)cp&01) == 0)) { ! 700: register short *s1, *s2; ! 701: register int l; ! 702: ! 703: s1 = (short *)mcp; ! 704: s2 = (short *)cp; ! 705: l = tlen >> 1; /* count # of shorts */ ! 706: while (l-- > 0) /* copy shorts */ ! 707: *s1++ = *s2++; ! 708: tlen &= 1; /* # remaining bytes */ ! 709: mcp = (u_char *)s1; ! 710: cp = (u_char *)s2; ! 711: } ! 712: while (tlen-- > 0) ! 713: *mcp++ = *cp++; ! 714: *mp = m; ! 715: mp = &m->m_next; ! 716: if (off == 0) { ! 717: totlen -= len; ! 718: continue; ! 719: } ! 720: off += len; ! 721: if (off == totlen) { ! 722: cp = rxbuf + sizeof (struct ether_header); ! 723: off = 0; ! 724: totlen = off0; ! 725: } ! 726: } ! 727: return (top); ! 728: bad: ! 729: m_freem(top); ! 730: return (0); ! 731: } ! 732: ! 733: /* backoff table masks */ ! 734: short random_mask_tbl[16] = { ! 735: 0x0040, 0x00c0, 0x01c0, 0x03c0, 0x07c0, 0x0fc0, 0x1fc0, 0x3fc0, ! 736: 0x7fc0, 0xffc0, 0xffc0, 0xffc0, 0xffc0, 0xffc0, 0xffc0, 0xffc0 ! 737: }; ! 738: ! 739: acebakoff(is, txseg, retries) ! 740: struct ace_softc *is; ! 741: struct tx_segment *txseg; ! 742: register int retries; ! 743: { ! 744: register short *pBakNum, random_num; ! 745: short *pMask; ! 746: ! 747: pMask = &random_mask_tbl[0]; ! 748: pBakNum = &txseg->tx_backoff[0]; ! 749: while (--retries >= 0) { ! 750: random_num = (is->is_currnd = (is->is_currnd * 18741)-13849); ! 751: random_num &= *pMask++; ! 752: *pBakNum++ = random_num ^ (short)(0xff00 | 0x00fc); ! 753: } ! 754: } ! 755: ! 756: /* ! 757: * Process an ioctl request. ! 758: */ ! 759: aceioctl(ifp, cmd, data) ! 760: register struct ifnet *ifp; ! 761: int cmd; ! 762: caddr_t data; ! 763: { ! 764: register struct ifaddr *ifa = (struct ifaddr *)data; ! 765: struct acedevice *addr; ! 766: int s = splimp(), error = 0; ! 767: ! 768: switch (cmd) { ! 769: ! 770: case SIOCSIFADDR: ! 771: ifp->if_flags |= IFF_UP; ! 772: switch (ifa->ifa_addr.sa_family) { ! 773: #ifdef INET ! 774: case AF_INET: ! 775: aceinit(ifp->if_unit); /* before arpwhohas */ ! 776: ((struct arpcom *)ifp)->ac_ipaddr = ! 777: IA_SIN(ifa)->sin_addr; ! 778: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr); ! 779: break; ! 780: #endif ! 781: #ifdef NS ! 782: case AF_NS: { ! 783: struct ns_addr *ina = &IA_SNS(ifa)->sns_addr; ! 784: struct ace_softc *is = &ace_softc[ifp->if_unit]; ! 785: ! 786: if (!ns_nullhost(*ina)) { ! 787: ifp->if_flags &= ~IFF_RUNNING; ! 788: addr = (struct acedevice *) ! 789: aceinfo[ifp->if_unit]->ui_addr; ! 790: movow(&addr->csr, CSR_RESET); ! 791: DELAY(10000); ! 792: /* set station address & copy addr to arp */ ! 793: acesetaddr(ifp->if_unit, addr, ! 794: ina->x_host.c_host); ! 795: } else ! 796: ina->x_host = *(union ns_host *)is->is_addr; ! 797: aceinit(ifp->if_unit); ! 798: break; ! 799: } ! 800: #endif ! 801: default: ! 802: aceinit(ifp->if_unit); ! 803: break; ! 804: } ! 805: break; ! 806: ! 807: case SIOCSIFFLAGS: ! 808: if ((ifp->if_flags&IFF_UP) == 0 && ifp->if_flags&IFF_RUNNING) { ! 809: addr = (struct acedevice *) ! 810: (aceinfo[ifp->if_unit]->ui_addr); ! 811: movow(&addr->csr, CSR_RESET); ! 812: ifp->if_flags &= ~IFF_RUNNING; ! 813: } else if (ifp->if_flags&IFF_UP && ! 814: (ifp->if_flags&IFF_RUNNING) == 0) ! 815: aceinit(ifp->if_unit); ! 816: break; ! 817: ! 818: default: ! 819: error = EINVAL; ! 820: } ! 821: splx(s); ! 822: return (error); ! 823: } ! 824: ! 825: /* ! 826: * Set the on-board station address, then read it back ! 827: * to initialize the address used by ARP (among others). ! 828: */ ! 829: acesetaddr(unit, addr, station) ! 830: short unit; ! 831: struct acedevice *addr; ! 832: u_char *station; ! 833: { ! 834: struct ace_softc *is = &ace_softc[unit]; ! 835: register short *wp, i; ! 836: ! 837: for (wp = (short *)addr->station, i = 0; i < 6; i++) ! 838: movow(wp++, ~*station++); ! 839: for (wp = (short *)addr->station, i = 0; i < 6; i++) ! 840: is->is_addr[i] = ~*wp++; ! 841: printf("ace%d: hardware address %s\n", unit, ! 842: ether_sprintf(is->is_addr)); ! 843: } ! 844: ! 845: /* ! 846: * Setup the device for use. Initialize dual-ported memory, ! 847: * backoff parameters, and various other software state. ! 848: */ ! 849: acesetup(unit) ! 850: int unit; ! 851: { ! 852: register struct ace_softc *is = &ace_softc[unit]; ! 853: register char *pData1; ! 854: register short i; ! 855: struct acedevice *addr; ! 856: ! 857: bzero(is->is_dpm, 16384*2); ! 858: is->is_currnd = 49123; ! 859: addr = (struct acedevice *)aceinfo[unit]->ui_addr; ! 860: is->is_segboundry = (addr->segb >> 11) & 0xf; ! 861: pData1 = is->is_dpm + (is->is_segboundry << 11); ! 862: for (i = SEG_MAX + 1 - is->is_segboundry; --i >= 0;) { ! 863: acebakoff(is, (struct tx_segment *)pData1, 15); ! 864: pData1 += sizeof (struct tx_segment); ! 865: } ! 866: is->is_eictr = 0; ! 867: is->is_eoctr = is->is_txnext = is->is_segboundry; ! 868: bzero((char *)&is->is_stats, sizeof (is->is_stats)); ! 869: } ! 870: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.