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