1 /* if_ec.c 4.28 82/10/31 */ 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 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 u_char ec_iltop[3] = { 0x02, 0x07, 0x01 }; 45 #define ECUNIT(x) minor(x) 46 47 int ecinit(),ecoutput(),ecreset(); 48 struct mbuf *ecget(); 49 50 extern struct ifnet loif; 51 52 /* 53 * Ethernet software status per interface. 54 * 55 * Each interface is referenced by a network interface structure, 56 * es_if, which the routing code uses to locate the interface. 57 * This structure contains the output queue for the interface, its address, ... 58 * We also have, for each interface, a UBA interface structure, which 59 * contains information about the UNIBUS resources held by the interface: 60 * map registers, buffered data paths, etc. Information is cached in this 61 * structure for use by the if_uba.c routines in running the interface 62 * efficiently. 63 */ 64 struct ec_softc { 65 struct ifnet es_if; /* network-visible interface */ 66 struct ifuba es_ifuba; /* UNIBUS resources */ 67 short es_mask; /* mask for current output delay */ 68 short es_oactive; /* is output active? */ 69 u_char *es_buf[16]; /* virtual addresses of buffers */ 70 u_char es_enaddr[6]; /* board's ethernet address */ 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 = ECMTU; 165 ifp->if_net = ui->ui_flags; 166 167 /* 168 * Read the ethernet address off the board, one nibble at a time. 169 */ 170 addr->ec_xcr = EC_UECLR; 171 addr->ec_rcr = EC_AROM; 172 cp = es->es_enaddr; 173 #define NEXTBIT addr->ec_rcr = EC_AROM|EC_ASTEP; addr->ec_rcr = EC_AROM 174 for (i=0; i<6; i++) { 175 *cp = 0; 176 for (j=0; j<=4; j+=4) { 177 *cp |= ((addr->ec_rcr >> 8) & 0xf) << j; 178 NEXTBIT; NEXTBIT; NEXTBIT; NEXTBIT; 179 } 180 cp++; 181 } 182 #ifdef notdef 183 printf("ec%d: addr=%x:%x:%x:%x:%x:%x\n", ui->ui_unit, 184 es->es_enaddr[0]&0xff, es->es_enaddr[1]&0xff, 185 es->es_enaddr[2]&0xff, es->es_enaddr[3]&0xff, 186 es->es_enaddr[4]&0xff, es->es_enaddr[5]&0xff); 187 #endif 188 ifp->if_host[0] = ((es->es_enaddr[3]&0xff)<<16) | 189 ((es->es_enaddr[4]&0xff)<<8) | (es->es_enaddr[5]&0xff); 190 sin = (struct sockaddr_in *)&es->es_if.if_addr; 191 sin->sin_family = AF_INET; 192 sin->sin_addr = if_makeaddr(ifp->if_net, ifp->if_host[0]); 193 194 sin = (struct sockaddr_in *)&ifp->if_broadaddr; 195 sin->sin_family = AF_INET; 196 sin->sin_addr = if_makeaddr(ifp->if_net, INADDR_ANY); 197 ifp->if_flags = IFF_BROADCAST; 198 199 ifp->if_init = ecinit; 200 ifp->if_output = ecoutput; 201 ifp->if_reset = ecreset; 202 for (i=0; i<16; i++) 203 es->es_buf[i] = (u_char *)&umem[ui->ui_ubanum][ECMEM+2048*i]; 204 if_attach(ifp); 205 } 206 207 /* 208 * Reset of interface after UNIBUS reset. 209 * If interface is on specified uba, reset its state. 210 */ 211 ecreset(unit, uban) 212 int unit, uban; 213 { 214 register struct uba_device *ui; 215 216 if (unit >= NEC || (ui = ecinfo[unit]) == 0 || ui->ui_alive == 0 || 217 ui->ui_ubanum != uban) 218 return; 219 printf(" ec%d", unit); 220 (void) ubamem(uban, ECMEM, 32*2, 0); /* mr disable (no alloc) */ 221 ecinit(unit); 222 } 223 224 /* 225 * Initialization of interface; clear recorded pending 226 * operations, and reinitialize UNIBUS usage. 227 */ 228 ecinit(unit) 229 int unit; 230 { 231 struct ec_softc *es = &ec_softc[unit]; 232 struct ecdevice *addr; 233 int i, s; 234 235 /* 236 * Hang receive buffers and start any pending writes. 237 * Writing into the rcr also makes sure the memory 238 * is turned on. 239 */ 240 addr = (struct ecdevice *)ecinfo[unit]->ui_addr; 241 s = splimp(); 242 for (i=ECRHBF; i>=ECRLBF; i--) 243 addr->ec_rcr = EC_READ|i; 244 es->es_oactive = 0; 245 es->es_mask = ~0; 246 es->es_if.if_flags |= IFF_UP; 247 if (es->es_if.if_snd.ifq_head) 248 ecstart(unit); 249 splx(s); 250 if_rtinit(&es->es_if, RTF_UP); 251 } 252 253 /* 254 * Start or restart output on interface. 255 * If interface is already active, then this is a retransmit 256 * after a collision, and just restuff registers. 257 * If interface is not already active, get another datagram 258 * to send off of the interface queue, and map it to the interface 259 * before starting the output. 260 */ 261 ecstart(dev) 262 dev_t dev; 263 { 264 int unit = ECUNIT(dev); 265 struct ec_softc *es = &ec_softc[unit]; 266 struct ecdevice *addr; 267 struct mbuf *m; 268 269 if (es->es_oactive) 270 goto restart; 271 272 IF_DEQUEUE(&es->es_if.if_snd, m); 273 if (m == 0) { 274 es->es_oactive = 0; 275 return; 276 } 277 ecput(es->es_buf[ECTBF], m); 278 279 restart: 280 addr = (struct ecdevice *)ecinfo[unit]->ui_addr; 281 addr->ec_xcr = EC_WRITE|ECTBF; 282 es->es_oactive = 1; 283 } 284 285 /* 286 * Ethernet interface transmitter interrupt. 287 * Start another output if more data to send. 288 */ 289 ecxint(unit) 290 int unit; 291 { 292 register struct ec_softc *es = &ec_softc[unit]; 293 register struct ecdevice *addr = 294 (struct ecdevice *)ecinfo[unit]->ui_addr; 295 296 if (es->es_oactive == 0) 297 return; 298 if ((addr->ec_xcr&EC_XDONE) == 0 || (addr->ec_xcr&EC_XBN) != ECTBF) { 299 printf("ec%d: stray xmit interrupt, xcr=%b\n", unit, 300 addr->ec_xcr, EC_XBITS); 301 es->es_oactive = 0; 302 addr->ec_xcr = EC_XCLR; 303 return; 304 } 305 es->es_if.if_opackets++; 306 es->es_oactive = 0; 307 es->es_mask = ~0; 308 addr->ec_xcr = EC_XCLR; 309 if (es->es_if.if_snd.ifq_head) 310 ecstart(unit); 311 } 312 313 /* 314 * Collision on ethernet interface. Do exponential 315 * backoff, and retransmit. If have backed off all 316 * the way print warning diagnostic, and drop packet. 317 */ 318 eccollide(unit) 319 int unit; 320 { 321 struct ec_softc *es = &ec_softc[unit]; 322 323 es->es_if.if_collisions++; 324 if (es->es_oactive) 325 ecdocoll(unit); 326 } 327 328 ecdocoll(unit) 329 int unit; 330 { 331 register struct ec_softc *es = &ec_softc[unit]; 332 register struct ecdevice *addr = 333 (struct ecdevice *)ecinfo[unit]->ui_addr; 334 register i; 335 int delay; 336 337 /* 338 * Es_mask is a 16 bit number with n low zero bits, with 339 * n the number of backoffs. When es_mask is 0 we have 340 * backed off 16 times, and give up. 341 */ 342 if (es->es_mask == 0) { 343 es->es_if.if_oerrors++; 344 printf("ec%d: send error\n", unit); 345 /* 346 * Reset interface, then requeue rcv buffers. 347 * Some incoming packets may be lost, but that 348 * can't be helped. 349 */ 350 addr->ec_xcr = EC_UECLR; 351 for (i=ECRHBF; i>=ECRLBF; i--) 352 addr->ec_rcr = EC_READ|i; 353 /* 354 * Reset and transmit next packet (if any). 355 */ 356 es->es_oactive = 0; 357 es->es_mask = ~0; 358 if (es->es_if.if_snd.ifq_head) 359 ecstart(unit); 360 return; 361 } 362 /* 363 * Do exponential backoff. Compute delay based on low bits 364 * of the interval timer. Then delay for that number of 365 * slot times. A slot time is 51.2 microseconds (rounded to 51). 366 * This does not take into account the time already used to 367 * process the interrupt. 368 */ 369 es->es_mask <<= 1; 370 delay = mfpr(ICR) &~ es->es_mask; 371 DELAY(delay * 51); 372 /* 373 * Clear the controller's collision flag, thus enabling retransmit. 374 */ 375 addr->ec_xcr = EC_CLEAR; 376 } 377 378 /* 379 * Ethernet interface receiver interrupt. 380 * If input error just drop packet. 381 * Otherwise purge input buffered data path and examine 382 * packet to determine type. If can't determine length 383 * from type, then have to drop packet. Othewise decapsulate 384 * packet based on type and pass to type specific higher-level 385 * input routine. 386 */ 387 ecrint(unit) 388 int unit; 389 { 390 struct ecdevice *addr = (struct ecdevice *)ecinfo[unit]->ui_addr; 391 392 while (addr->ec_rcr & EC_RDONE) 393 ecread(unit); 394 } 395 396 ecread(unit) 397 int unit; 398 { 399 register struct ec_softc *es = &ec_softc[unit]; 400 struct ecdevice *addr = (struct ecdevice *)ecinfo[unit]->ui_addr; 401 register struct ec_header *ec; 402 struct mbuf *m; 403 int len, off, resid, ecoff, rbuf; 404 register struct ifqueue *inq; 405 u_char *ecbuf; 406 407 es->es_if.if_ipackets++; 408 rbuf = addr->ec_rcr & EC_RBN; 409 if (rbuf < ECRLBF || rbuf > ECRHBF) 410 panic("ecrint"); 411 ecbuf = es->es_buf[rbuf]; 412 ecoff = *(short *)ecbuf; 413 if (ecoff <= ECRDOFF || ecoff > 2046) { 414 es->es_if.if_ierrors++; 415 #ifdef notdef 416 if (es->es_if.if_ierrors % 100 == 0) 417 printf("ec%d: += 100 input errors\n", unit); 418 #endif 419 goto setup; 420 } 421 422 /* 423 * Get input data length. 424 * Get pointer to ethernet header (in input buffer). 425 * Deal with trailer protocol: if type is PUP trailer 426 * get true type from first 16-bit word past data. 427 * Remember that type was trailer by setting off. 428 */ 429 len = ecoff - ECRDOFF - sizeof (struct ec_header); 430 ec = (struct ec_header *)(ecbuf + ECRDOFF); 431 #define ecdataaddr(ec, off, type) ((type)(((caddr_t)((ec)+1)+(off)))) 432 if (ec->ec_type >= ECPUP_TRAIL && 433 ec->ec_type < ECPUP_TRAIL+ECPUP_NTRAILER) { 434 off = (ec->ec_type - ECPUP_TRAIL) * 512; 435 if (off >= ECMTU) 436 goto setup; /* sanity */ 437 ec->ec_type = *ecdataaddr(ec, off, u_short *); 438 resid = *(ecdataaddr(ec, off+2, u_short *)); 439 if (off + resid > len) 440 goto setup; /* sanity */ 441 len = off + resid; 442 } else 443 off = 0; 444 if (len == 0) 445 goto setup; 446 447 /* 448 * Pull packet off interface. Off is nonzero if packet 449 * has trailing header; ecget will then force this header 450 * information to be at the front, but we still have to drop 451 * the type and length which are at the front of any trailer data. 452 */ 453 m = ecget(ecbuf, len, off); 454 if (m == 0) 455 goto setup; 456 if (off) { 457 m->m_off += 2 * sizeof (u_short); 458 m->m_len -= 2 * sizeof (u_short); 459 } 460 switch (ec->ec_type) { 461 462 #ifdef INET 463 case ECPUP_IPTYPE: 464 schednetisr(NETISR_IP); 465 inq = &ipintrq; 466 break; 467 #endif 468 default: 469 m_freem(m); 470 goto setup; 471 } 472 473 if (IF_QFULL(inq)) { 474 IF_DROP(inq); 475 m_freem(m); 476 goto setup; 477 } 478 IF_ENQUEUE(inq, m); 479 480 setup: 481 /* 482 * Reset for next packet. 483 */ 484 addr->ec_rcr = EC_READ|EC_RCLR|rbuf; 485 } 486 487 /* 488 * Ethernet output routine. 489 * Encapsulate a packet of type family for the local net. 490 * Use trailer local net encapsulation if enough data in first 491 * packet leaves a multiple of 512 bytes of data in remainder. 492 * If destination is this address or broadcast, send packet to 493 * loop device to kludge around the fact that 3com interfaces can't 494 * talk to themselves. 495 */ 496 ecoutput(ifp, m0, dst) 497 struct ifnet *ifp; 498 struct mbuf *m0; 499 struct sockaddr *dst; 500 { 501 int type, dest, s, error; 502 register struct ec_softc *es = &ec_softc[ifp->if_unit]; 503 register struct mbuf *m = m0; 504 register struct ec_header *ec; 505 register int off, i; 506 struct mbuf *mcopy = (struct mbuf *) 0; /* Null */ 507 508 switch (dst->sa_family) { 509 510 #ifdef INET 511 case AF_INET: 512 dest = ((struct sockaddr_in *)dst)->sin_addr.s_addr; 513 if ((dest &~ 0xff) == 0) 514 mcopy = m_copy(m, 0, (int)M_COPYALL); 515 else if (dest == ((struct sockaddr_in *)&es->es_if.if_addr)-> 516 sin_addr.s_addr) { 517 mcopy = m; 518 goto gotlocal; 519 } 520 off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; 521 if (off > 0 && (off & 0x1ff) == 0 && 522 m->m_off >= MMINOFF + 2 * sizeof (u_short)) { 523 type = ECPUP_TRAIL + (off>>9); 524 m->m_off -= 2 * sizeof (u_short); 525 m->m_len += 2 * sizeof (u_short); 526 *mtod(m, u_short *) = ECPUP_IPTYPE; 527 *(mtod(m, u_short *) + 1) = m->m_len; 528 goto gottrailertype; 529 } 530 type = ECPUP_IPTYPE; 531 off = 0; 532 goto gottype; 533 #endif 534 535 default: 536 printf("ec%d: can't handle af%d\n", ifp->if_unit, 537 dst->sa_family); 538 error = EAFNOSUPPORT; 539 goto bad; 540 } 541 542 gottrailertype: 543 /* 544 * Packet to be sent as trailer: move first packet 545 * (control information) to end of chain. 546 */ 547 while (m->m_next) 548 m = m->m_next; 549 m->m_next = m0; 550 m = m0->m_next; 551 m0->m_next = 0; 552 m0 = m; 553 554 gottype: 555 /* 556 * Add local net header. If no space in first mbuf, 557 * allocate another. 558 */ 559 if (m->m_off > MMAXOFF || 560 MMINOFF + sizeof (struct ec_header) > m->m_off) { 561 m = m_get(M_DONTWAIT); 562 if (m == 0) { 563 error = ENOBUFS; 564 goto bad; 565 } 566 m->m_next = m0; 567 m->m_off = MMINOFF; 568 m->m_len = sizeof (struct ec_header); 569 } else { 570 m->m_off -= sizeof (struct ec_header); 571 m->m_len += sizeof (struct ec_header); 572 } 573 ec = mtod(m, struct ec_header *); 574 for (i=0; i<6; i++) 575 ec->ec_shost[i] = es->es_enaddr[i]; 576 if ((dest &~ 0xff) == 0) 577 /* broadcast address */ 578 for (i=0; i<6; i++) 579 ec->ec_dhost[i] = 0xff; 580 else { 581 if (dest & 0x8000) { 582 ec->ec_dhost[0] = ec_iltop[0]; 583 ec->ec_dhost[1] = ec_iltop[1]; 584 ec->ec_dhost[2] = ec_iltop[2]; 585 } else { 586 ec->ec_dhost[0] = es->es_enaddr[0]; 587 ec->ec_dhost[1] = es->es_enaddr[1]; 588 ec->ec_dhost[2] = es->es_enaddr[2]; 589 } 590 ec->ec_dhost[3] = (dest>>8) & 0x7f; 591 ec->ec_dhost[4] = (dest>>16) & 0xff; 592 ec->ec_dhost[5] = (dest>>24) & 0xff; 593 } 594 ec->ec_type = type; 595 596 /* 597 * Queue message on interface, and start output if interface 598 * not yet active. 599 */ 600 s = splimp(); 601 if (IF_QFULL(&ifp->if_snd)) { 602 IF_DROP(&ifp->if_snd); 603 error = ENOBUFS; 604 goto qfull; 605 } 606 IF_ENQUEUE(&ifp->if_snd, m); 607 if (es->es_oactive == 0) 608 ecstart(ifp->if_unit); 609 splx(s); 610 611 gotlocal: 612 return(mcopy ? looutput(&loif, mcopy, dst) : 0); 613 614 qfull: 615 m0 = m; 616 splx(s); 617 bad: 618 m_freem(m0); 619 return(error); 620 } 621 622 /* 623 * Routine to copy from mbuf chain to transmitter 624 * buffer in UNIBUS memory. 625 */ 626 ecput(ecbuf, m) 627 u_char *ecbuf; 628 struct mbuf *m; 629 { 630 register struct mbuf *mp; 631 register int off; 632 u_char *bp; 633 634 for (off = 2048, mp = m; mp; mp = mp->m_next) 635 off -= mp->m_len; 636 *(u_short *)ecbuf = off; 637 bp = (u_char *)(ecbuf + off); 638 for (mp = m; mp; mp = mp->m_next) { 639 register unsigned len = mp->m_len; 640 u_char *mcp; 641 642 if (len == 0) 643 continue; 644 mcp = mtod(mp, u_char *); 645 if ((unsigned)bp & 01) { 646 *bp++ = *mcp++; 647 len--; 648 } 649 if (off = (len >> 1)) { 650 register u_short *to, *from; 651 652 to = (u_short *)bp; 653 from = (u_short *)mcp; 654 do 655 *to++ = *from++; 656 while (--off > 0); 657 bp = (u_char *)to, 658 mcp = (u_char *)from; 659 } 660 if (len & 01) 661 *bp++ = *mcp++; 662 } 663 #ifdef notdef 664 if (bp - ecbuf != 2048) 665 printf("ec: bad ecput, diff=%d\n", bp-ecbuf); 666 #endif 667 m_freem(m); 668 } 669 670 /* 671 * Routine to copy from UNIBUS memory into mbufs. 672 * Similar in spirit to if_rubaget. 673 * 674 * Warning: This makes the fairly safe assumption that 675 * mbufs have even lengths. 676 */ 677 struct mbuf * 678 ecget(ecbuf, totlen, off0) 679 u_char *ecbuf; 680 int totlen, off0; 681 { 682 register struct mbuf *m; 683 struct mbuf *top = 0, **mp = ⊤ 684 register int off = off0, len; 685 u_char *cp; 686 687 cp = ecbuf + ECRDOFF + sizeof (struct ec_header); 688 while (totlen > 0) { 689 register int words; 690 u_char *mcp; 691 692 MGET(m, 0); 693 if (m == 0) 694 goto bad; 695 if (off) { 696 len = totlen - off; 697 cp = ecbuf + ECRDOFF + sizeof (struct ec_header) + off; 698 } else 699 len = totlen; 700 if (len >= CLBYTES) { 701 struct mbuf *p; 702 703 MCLGET(p, 1); 704 if (p != 0) { 705 m->m_len = len = CLBYTES; 706 m->m_off = (int)p - (int)m; 707 } else { 708 m->m_len = len = MIN(MLEN, len); 709 m->m_off = MMINOFF; 710 } 711 } else { 712 m->m_len = len = MIN(MLEN, len); 713 m->m_off = MMINOFF; 714 } 715 mcp = mtod(m, u_char *); 716 if (words = (len >> 1)) { 717 register u_short *to, *from; 718 719 to = (u_short *)mcp; 720 from = (u_short *)cp; 721 do 722 *to++ = *from++; 723 while (--words > 0); 724 mcp = (u_char *)to; 725 cp = (u_char *)from; 726 } 727 if (len & 01) 728 *mcp++ = *cp++; 729 *mp = m; 730 mp = &m->m_next; 731 if (off == 0) { 732 totlen -= len; 733 continue; 734 } 735 off += len; 736 if (off == totlen) { 737 cp = ecbuf + ECRDOFF + sizeof (struct ec_header); 738 off = 0; 739 totlen = off0; 740 } 741 } 742 return (top); 743 bad: 744 m_freem(top); 745 return (0); 746 } 747