1 /*- 2 * Copyright (c) 2004 Doug Rabson 3 * Copyright (c) 1982, 1989, 1993 4 * The Regents of the University of California. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 4. Neither the name of the University nor the names of its contributors 15 * may be used to endorse or promote products derived from this software 16 * without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 * $FreeBSD$ 31 */ 32 33 #include "opt_inet.h" 34 #include "opt_inet6.h" 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 #include <sys/malloc.h> 40 #include <sys/mbuf.h> 41 #include <sys/module.h> 42 #include <sys/socket.h> 43 #include <sys/sockio.h> 44 45 #include <net/if.h> 46 #include <net/if_var.h> 47 #include <net/netisr.h> 48 #include <net/route.h> 49 #include <net/if_llc.h> 50 #include <net/if_dl.h> 51 #include <net/if_types.h> 52 #include <net/bpf.h> 53 #include <net/firewire.h> 54 #include <net/if_llatbl.h> 55 56 #if defined(INET) || defined(INET6) 57 #include <netinet/in.h> 58 #include <netinet/in_var.h> 59 #include <netinet/if_ether.h> 60 #endif 61 #ifdef INET6 62 #include <netinet6/nd6.h> 63 #endif 64 65 #include <security/mac/mac_framework.h> 66 67 static MALLOC_DEFINE(M_FWCOM, "fw_com", "firewire interface internals"); 68 69 struct fw_hwaddr firewire_broadcastaddr = { 70 0xffffffff, 71 0xffffffff, 72 0xff, 73 0xff, 74 0xffff, 75 0xffffffff 76 }; 77 78 static int 79 firewire_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, 80 struct route *ro) 81 { 82 struct fw_com *fc = IFP2FWC(ifp); 83 int error, type; 84 struct m_tag *mtag; 85 union fw_encap *enc; 86 struct fw_hwaddr *destfw; 87 uint8_t speed; 88 uint16_t psize, fsize, dsize; 89 struct mbuf *mtail; 90 int unicast, dgl, foff; 91 static int next_dgl; 92 #ifdef INET 93 int is_gw; 94 #endif 95 96 #ifdef MAC 97 error = mac_ifnet_check_transmit(ifp, m); 98 if (error) 99 goto bad; 100 #endif 101 102 if (!((ifp->if_flags & IFF_UP) && 103 (ifp->if_drv_flags & IFF_DRV_RUNNING))) { 104 error = ENETDOWN; 105 goto bad; 106 } 107 108 /* 109 * For unicast, we make a tag to store the lladdr of the 110 * destination. This might not be the first time we have seen 111 * the packet (for instance, the arp code might be trying to 112 * re-send it after receiving an arp reply) so we only 113 * allocate a tag if there isn't one there already. For 114 * multicast, we will eventually use a different tag to store 115 * the channel number. 116 */ 117 unicast = !(m->m_flags & (M_BCAST | M_MCAST)); 118 if (unicast) { 119 mtag = m_tag_locate(m, MTAG_FIREWIRE, MTAG_FIREWIRE_HWADDR, NULL); 120 if (!mtag) { 121 mtag = m_tag_alloc(MTAG_FIREWIRE, MTAG_FIREWIRE_HWADDR, 122 sizeof (struct fw_hwaddr), M_NOWAIT); 123 if (!mtag) { 124 error = ENOMEM; 125 goto bad; 126 } 127 m_tag_prepend(m, mtag); 128 } 129 destfw = (struct fw_hwaddr *)(mtag + 1); 130 } else { 131 destfw = 0; 132 } 133 134 switch (dst->sa_family) { 135 #ifdef INET 136 case AF_INET: 137 /* 138 * Only bother with arp for unicast. Allocation of 139 * channels etc. for firewire is quite different and 140 * doesn't fit into the arp model. 141 */ 142 if (unicast) { 143 is_gw = 0; 144 if (ro != NULL && ro->ro_rt != NULL && 145 (ro->ro_rt->rt_flags & RTF_GATEWAY) != 0) 146 is_gw = 1; 147 error = arpresolve(ifp, is_gw, m, dst, (u_char *) destfw, NULL); 148 if (error) 149 return (error == EWOULDBLOCK ? 0 : error); 150 } 151 type = ETHERTYPE_IP; 152 break; 153 154 case AF_ARP: 155 { 156 struct arphdr *ah; 157 ah = mtod(m, struct arphdr *); 158 ah->ar_hrd = htons(ARPHRD_IEEE1394); 159 type = ETHERTYPE_ARP; 160 if (unicast) 161 *destfw = *(struct fw_hwaddr *) ar_tha(ah); 162 163 /* 164 * The standard arp code leaves a hole for the target 165 * hardware address which we need to close up. 166 */ 167 bcopy(ar_tpa(ah), ar_tha(ah), ah->ar_pln); 168 m_adj(m, -ah->ar_hln); 169 break; 170 } 171 #endif 172 173 #ifdef INET6 174 case AF_INET6: 175 if (unicast) { 176 error = nd6_storelladdr(fc->fc_ifp, m, dst, 177 (u_char *) destfw, NULL); 178 if (error) 179 return (error); 180 } 181 type = ETHERTYPE_IPV6; 182 break; 183 #endif 184 185 default: 186 if_printf(ifp, "can't handle af%d\n", dst->sa_family); 187 error = EAFNOSUPPORT; 188 goto bad; 189 } 190 191 /* 192 * Let BPF tap off a copy before we encapsulate. 193 */ 194 if (bpf_peers_present(ifp->if_bpf)) { 195 struct fw_bpfhdr h; 196 if (unicast) 197 bcopy(destfw, h.firewire_dhost, 8); 198 else 199 bcopy(&firewire_broadcastaddr, h.firewire_dhost, 8); 200 bcopy(&fc->fc_hwaddr, h.firewire_shost, 8); 201 h.firewire_type = htons(type); 202 bpf_mtap2(ifp->if_bpf, &h, sizeof(h), m); 203 } 204 205 /* 206 * Punt on MCAP for now and send all multicast packets on the 207 * broadcast channel. 208 */ 209 if (m->m_flags & M_MCAST) 210 m->m_flags |= M_BCAST; 211 212 /* 213 * Figure out what speed to use and what the largest supported 214 * packet size is. For unicast, this is the minimum of what we 215 * can speak and what they can hear. For broadcast, lets be 216 * conservative and use S100. We could possibly improve that 217 * by examining the bus manager's speed map or similar. We 218 * also reduce the packet size for broadcast to account for 219 * the GASP header. 220 */ 221 if (unicast) { 222 speed = min(fc->fc_speed, destfw->sspd); 223 psize = min(512 << speed, 2 << destfw->sender_max_rec); 224 } else { 225 speed = 0; 226 psize = 512 - 2*sizeof(uint32_t); 227 } 228 229 /* 230 * Next, we encapsulate, possibly fragmenting the original 231 * datagram if it won't fit into a single packet. 232 */ 233 if (m->m_pkthdr.len <= psize - sizeof(uint32_t)) { 234 /* 235 * No fragmentation is necessary. 236 */ 237 M_PREPEND(m, sizeof(uint32_t), M_NOWAIT); 238 if (!m) { 239 error = ENOBUFS; 240 goto bad; 241 } 242 enc = mtod(m, union fw_encap *); 243 enc->unfrag.ether_type = type; 244 enc->unfrag.lf = FW_ENCAP_UNFRAG; 245 enc->unfrag.reserved = 0; 246 247 /* 248 * Byte swap the encapsulation header manually. 249 */ 250 enc->ul[0] = htonl(enc->ul[0]); 251 252 error = (ifp->if_transmit)(ifp, m); 253 return (error); 254 } else { 255 /* 256 * Fragment the datagram, making sure to leave enough 257 * space for the encapsulation header in each packet. 258 */ 259 fsize = psize - 2*sizeof(uint32_t); 260 dgl = next_dgl++; 261 dsize = m->m_pkthdr.len; 262 foff = 0; 263 while (m) { 264 if (m->m_pkthdr.len > fsize) { 265 /* 266 * Split off the tail segment from the 267 * datagram, copying our tags over. 268 */ 269 mtail = m_split(m, fsize, M_NOWAIT); 270 m_tag_copy_chain(mtail, m, M_NOWAIT); 271 } else { 272 mtail = 0; 273 } 274 275 /* 276 * Add our encapsulation header to this 277 * fragment and hand it off to the link. 278 */ 279 M_PREPEND(m, 2*sizeof(uint32_t), M_NOWAIT); 280 if (!m) { 281 error = ENOBUFS; 282 goto bad; 283 } 284 enc = mtod(m, union fw_encap *); 285 if (foff == 0) { 286 enc->firstfrag.lf = FW_ENCAP_FIRST; 287 enc->firstfrag.reserved1 = 0; 288 enc->firstfrag.reserved2 = 0; 289 enc->firstfrag.datagram_size = dsize - 1; 290 enc->firstfrag.ether_type = type; 291 enc->firstfrag.dgl = dgl; 292 } else { 293 if (mtail) 294 enc->nextfrag.lf = FW_ENCAP_NEXT; 295 else 296 enc->nextfrag.lf = FW_ENCAP_LAST; 297 enc->nextfrag.reserved1 = 0; 298 enc->nextfrag.reserved2 = 0; 299 enc->nextfrag.reserved3 = 0; 300 enc->nextfrag.datagram_size = dsize - 1; 301 enc->nextfrag.fragment_offset = foff; 302 enc->nextfrag.dgl = dgl; 303 } 304 foff += m->m_pkthdr.len - 2*sizeof(uint32_t); 305 306 /* 307 * Byte swap the encapsulation header manually. 308 */ 309 enc->ul[0] = htonl(enc->ul[0]); 310 enc->ul[1] = htonl(enc->ul[1]); 311 312 error = (ifp->if_transmit)(ifp, m); 313 if (error) { 314 if (mtail) 315 m_freem(mtail); 316 return (ENOBUFS); 317 } 318 319 m = mtail; 320 } 321 322 return (0); 323 } 324 325 bad: 326 if (m) 327 m_freem(m); 328 return (error); 329 } 330 331 static struct mbuf * 332 firewire_input_fragment(struct fw_com *fc, struct mbuf *m, int src) 333 { 334 union fw_encap *enc; 335 struct fw_reass *r; 336 struct mbuf *mf, *mprev; 337 int dsize; 338 int fstart, fend, start, end, islast; 339 uint32_t id; 340 341 /* 342 * Find an existing reassembly buffer or create a new one. 343 */ 344 enc = mtod(m, union fw_encap *); 345 id = enc->firstfrag.dgl | (src << 16); 346 STAILQ_FOREACH(r, &fc->fc_frags, fr_link) 347 if (r->fr_id == id) 348 break; 349 if (!r) { 350 r = malloc(sizeof(struct fw_reass), M_TEMP, M_NOWAIT); 351 if (!r) { 352 m_freem(m); 353 return 0; 354 } 355 r->fr_id = id; 356 r->fr_frags = 0; 357 STAILQ_INSERT_HEAD(&fc->fc_frags, r, fr_link); 358 } 359 360 /* 361 * If this fragment overlaps any other fragment, we must discard 362 * the partial reassembly and start again. 363 */ 364 if (enc->firstfrag.lf == FW_ENCAP_FIRST) 365 fstart = 0; 366 else 367 fstart = enc->nextfrag.fragment_offset; 368 fend = fstart + m->m_pkthdr.len - 2*sizeof(uint32_t); 369 dsize = enc->nextfrag.datagram_size; 370 islast = (enc->nextfrag.lf == FW_ENCAP_LAST); 371 372 for (mf = r->fr_frags; mf; mf = mf->m_nextpkt) { 373 enc = mtod(mf, union fw_encap *); 374 if (enc->nextfrag.datagram_size != dsize) { 375 /* 376 * This fragment must be from a different 377 * packet. 378 */ 379 goto bad; 380 } 381 if (enc->firstfrag.lf == FW_ENCAP_FIRST) 382 start = 0; 383 else 384 start = enc->nextfrag.fragment_offset; 385 end = start + mf->m_pkthdr.len - 2*sizeof(uint32_t); 386 if ((fstart < end && fend > start) || 387 (islast && enc->nextfrag.lf == FW_ENCAP_LAST)) { 388 /* 389 * Overlap - discard reassembly buffer and start 390 * again with this fragment. 391 */ 392 goto bad; 393 } 394 } 395 396 /* 397 * Find where to put this fragment in the list. 398 */ 399 for (mf = r->fr_frags, mprev = NULL; mf; 400 mprev = mf, mf = mf->m_nextpkt) { 401 enc = mtod(mf, union fw_encap *); 402 if (enc->firstfrag.lf == FW_ENCAP_FIRST) 403 start = 0; 404 else 405 start = enc->nextfrag.fragment_offset; 406 if (start >= fend) 407 break; 408 } 409 410 /* 411 * If this is a last fragment and we are not adding at the end 412 * of the list, discard the buffer. 413 */ 414 if (islast && mprev && mprev->m_nextpkt) 415 goto bad; 416 417 if (mprev) { 418 m->m_nextpkt = mprev->m_nextpkt; 419 mprev->m_nextpkt = m; 420 421 /* 422 * Coalesce forwards and see if we can make a whole 423 * datagram. 424 */ 425 enc = mtod(mprev, union fw_encap *); 426 if (enc->firstfrag.lf == FW_ENCAP_FIRST) 427 start = 0; 428 else 429 start = enc->nextfrag.fragment_offset; 430 end = start + mprev->m_pkthdr.len - 2*sizeof(uint32_t); 431 while (end == fstart) { 432 /* 433 * Strip off the encap header from m and 434 * append it to mprev, freeing m. 435 */ 436 m_adj(m, 2*sizeof(uint32_t)); 437 mprev->m_nextpkt = m->m_nextpkt; 438 mprev->m_pkthdr.len += m->m_pkthdr.len; 439 m_cat(mprev, m); 440 441 if (mprev->m_pkthdr.len == dsize + 1 + 2*sizeof(uint32_t)) { 442 /* 443 * We have assembled a complete packet 444 * we must be finished. Make sure we have 445 * merged the whole chain. 446 */ 447 STAILQ_REMOVE(&fc->fc_frags, r, fw_reass, fr_link); 448 free(r, M_TEMP); 449 m = mprev->m_nextpkt; 450 while (m) { 451 mf = m->m_nextpkt; 452 m_freem(m); 453 m = mf; 454 } 455 mprev->m_nextpkt = NULL; 456 457 return (mprev); 458 } 459 460 /* 461 * See if we can continue merging forwards. 462 */ 463 end = fend; 464 m = mprev->m_nextpkt; 465 if (m) { 466 enc = mtod(m, union fw_encap *); 467 if (enc->firstfrag.lf == FW_ENCAP_FIRST) 468 fstart = 0; 469 else 470 fstart = enc->nextfrag.fragment_offset; 471 fend = fstart + m->m_pkthdr.len 472 - 2*sizeof(uint32_t); 473 } else { 474 break; 475 } 476 } 477 } else { 478 m->m_nextpkt = 0; 479 r->fr_frags = m; 480 } 481 482 return (0); 483 484 bad: 485 while (r->fr_frags) { 486 mf = r->fr_frags; 487 r->fr_frags = mf->m_nextpkt; 488 m_freem(mf); 489 } 490 m->m_nextpkt = 0; 491 r->fr_frags = m; 492 493 return (0); 494 } 495 496 void 497 firewire_input(struct ifnet *ifp, struct mbuf *m, uint16_t src) 498 { 499 struct fw_com *fc = IFP2FWC(ifp); 500 union fw_encap *enc; 501 int type, isr; 502 503 /* 504 * The caller has already stripped off the packet header 505 * (stream or wreqb) and marked the mbuf's M_BCAST flag 506 * appropriately. We de-encapsulate the IP packet and pass it 507 * up the line after handling link-level fragmentation. 508 */ 509 if (m->m_pkthdr.len < sizeof(uint32_t)) { 510 if_printf(ifp, "discarding frame without " 511 "encapsulation header (len %u pkt len %u)\n", 512 m->m_len, m->m_pkthdr.len); 513 } 514 515 m = m_pullup(m, sizeof(uint32_t)); 516 if (m == NULL) 517 return; 518 enc = mtod(m, union fw_encap *); 519 520 /* 521 * Byte swap the encapsulation header manually. 522 */ 523 enc->ul[0] = ntohl(enc->ul[0]); 524 525 if (enc->unfrag.lf != 0) { 526 m = m_pullup(m, 2*sizeof(uint32_t)); 527 if (!m) 528 return; 529 enc = mtod(m, union fw_encap *); 530 enc->ul[1] = ntohl(enc->ul[1]); 531 m = firewire_input_fragment(fc, m, src); 532 if (!m) 533 return; 534 enc = mtod(m, union fw_encap *); 535 type = enc->firstfrag.ether_type; 536 m_adj(m, 2*sizeof(uint32_t)); 537 } else { 538 type = enc->unfrag.ether_type; 539 m_adj(m, sizeof(uint32_t)); 540 } 541 542 if (m->m_pkthdr.rcvif == NULL) { 543 if_printf(ifp, "discard frame w/o interface pointer\n"); 544 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 545 m_freem(m); 546 return; 547 } 548 #ifdef DIAGNOSTIC 549 if (m->m_pkthdr.rcvif != ifp) { 550 if_printf(ifp, "Warning, frame marked as received on %s\n", 551 m->m_pkthdr.rcvif->if_xname); 552 } 553 #endif 554 555 #ifdef MAC 556 /* 557 * Tag the mbuf with an appropriate MAC label before any other 558 * consumers can get to it. 559 */ 560 mac_ifnet_create_mbuf(ifp, m); 561 #endif 562 563 /* 564 * Give bpf a chance at the packet. The link-level driver 565 * should have left us a tag with the EUID of the sender. 566 */ 567 if (bpf_peers_present(ifp->if_bpf)) { 568 struct fw_bpfhdr h; 569 struct m_tag *mtag; 570 571 mtag = m_tag_locate(m, MTAG_FIREWIRE, MTAG_FIREWIRE_SENDER_EUID, 0); 572 if (mtag) 573 bcopy(mtag + 1, h.firewire_shost, 8); 574 else 575 bcopy(&firewire_broadcastaddr, h.firewire_dhost, 8); 576 bcopy(&fc->fc_hwaddr, h.firewire_dhost, 8); 577 h.firewire_type = htons(type); 578 bpf_mtap2(ifp->if_bpf, &h, sizeof(h), m); 579 } 580 581 if (ifp->if_flags & IFF_MONITOR) { 582 /* 583 * Interface marked for monitoring; discard packet. 584 */ 585 m_freem(m); 586 return; 587 } 588 589 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len); 590 591 /* Discard packet if interface is not up */ 592 if ((ifp->if_flags & IFF_UP) == 0) { 593 m_freem(m); 594 return; 595 } 596 597 if (m->m_flags & (M_BCAST|M_MCAST)) 598 if_inc_counter(ifp, IFCOUNTER_IMCASTS, 1); 599 600 switch (type) { 601 #ifdef INET 602 case ETHERTYPE_IP: 603 if ((m = ip_fastforward(m)) == NULL) 604 return; 605 isr = NETISR_IP; 606 break; 607 608 case ETHERTYPE_ARP: 609 { 610 struct arphdr *ah; 611 ah = mtod(m, struct arphdr *); 612 613 /* 614 * Adjust the arp packet to insert an empty tha slot. 615 */ 616 m->m_len += ah->ar_hln; 617 m->m_pkthdr.len += ah->ar_hln; 618 bcopy(ar_tha(ah), ar_tpa(ah), ah->ar_pln); 619 isr = NETISR_ARP; 620 break; 621 } 622 #endif 623 624 #ifdef INET6 625 case ETHERTYPE_IPV6: 626 isr = NETISR_IPV6; 627 break; 628 #endif 629 630 default: 631 m_freem(m); 632 return; 633 } 634 635 M_SETFIB(m, ifp->if_fib); 636 netisr_dispatch(isr, m); 637 } 638 639 int 640 firewire_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 641 { 642 struct ifaddr *ifa = (struct ifaddr *) data; 643 struct ifreq *ifr = (struct ifreq *) data; 644 int error = 0; 645 646 switch (command) { 647 case SIOCSIFADDR: 648 ifp->if_flags |= IFF_UP; 649 650 switch (ifa->ifa_addr->sa_family) { 651 #ifdef INET 652 case AF_INET: 653 ifp->if_init(ifp->if_softc); /* before arpwhohas */ 654 arp_ifinit(ifp, ifa); 655 break; 656 #endif 657 default: 658 ifp->if_init(ifp->if_softc); 659 break; 660 } 661 break; 662 663 case SIOCGIFADDR: 664 { 665 struct sockaddr *sa; 666 667 sa = (struct sockaddr *) & ifr->ifr_data; 668 bcopy(&IFP2FWC(ifp)->fc_hwaddr, 669 (caddr_t) sa->sa_data, sizeof(struct fw_hwaddr)); 670 } 671 break; 672 673 case SIOCSIFMTU: 674 /* 675 * Set the interface MTU. 676 */ 677 if (ifr->ifr_mtu > 1500) { 678 error = EINVAL; 679 } else { 680 ifp->if_mtu = ifr->ifr_mtu; 681 } 682 break; 683 default: 684 error = EINVAL; /* XXX netbsd has ENOTTY??? */ 685 break; 686 } 687 return (error); 688 } 689 690 static int 691 firewire_resolvemulti(struct ifnet *ifp, struct sockaddr **llsa, 692 struct sockaddr *sa) 693 { 694 #ifdef INET 695 struct sockaddr_in *sin; 696 #endif 697 #ifdef INET6 698 struct sockaddr_in6 *sin6; 699 #endif 700 701 switch(sa->sa_family) { 702 case AF_LINK: 703 /* 704 * No mapping needed. 705 */ 706 *llsa = 0; 707 return 0; 708 709 #ifdef INET 710 case AF_INET: 711 sin = (struct sockaddr_in *)sa; 712 if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) 713 return EADDRNOTAVAIL; 714 *llsa = 0; 715 return 0; 716 #endif 717 #ifdef INET6 718 case AF_INET6: 719 sin6 = (struct sockaddr_in6 *)sa; 720 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { 721 /* 722 * An IP6 address of 0 means listen to all 723 * of the Ethernet multicast address used for IP6. 724 * (This is used for multicast routers.) 725 */ 726 ifp->if_flags |= IFF_ALLMULTI; 727 *llsa = 0; 728 return 0; 729 } 730 if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) 731 return EADDRNOTAVAIL; 732 *llsa = 0; 733 return 0; 734 #endif 735 736 default: 737 /* 738 * Well, the text isn't quite right, but it's the name 739 * that counts... 740 */ 741 return EAFNOSUPPORT; 742 } 743 } 744 745 void 746 firewire_ifattach(struct ifnet *ifp, struct fw_hwaddr *llc) 747 { 748 struct fw_com *fc = IFP2FWC(ifp); 749 struct ifaddr *ifa; 750 struct sockaddr_dl *sdl; 751 static const char* speeds[] = { 752 "S100", "S200", "S400", "S800", 753 "S1600", "S3200" 754 }; 755 756 fc->fc_speed = llc->sspd; 757 STAILQ_INIT(&fc->fc_frags); 758 759 ifp->if_addrlen = sizeof(struct fw_hwaddr); 760 ifp->if_hdrlen = 0; 761 if_attach(ifp); 762 ifp->if_mtu = 1500; /* XXX */ 763 ifp->if_output = firewire_output; 764 ifp->if_resolvemulti = firewire_resolvemulti; 765 ifp->if_broadcastaddr = (u_char *) &firewire_broadcastaddr; 766 767 ifa = ifp->if_addr; 768 KASSERT(ifa != NULL, ("%s: no lladdr!\n", __func__)); 769 sdl = (struct sockaddr_dl *)ifa->ifa_addr; 770 sdl->sdl_type = IFT_IEEE1394; 771 sdl->sdl_alen = ifp->if_addrlen; 772 bcopy(llc, LLADDR(sdl), ifp->if_addrlen); 773 774 bpfattach(ifp, DLT_APPLE_IP_OVER_IEEE1394, 775 sizeof(struct fw_hwaddr)); 776 777 if_printf(ifp, "Firewire address: %8D @ 0x%04x%08x, %s, maxrec %d\n", 778 (uint8_t *) &llc->sender_unique_ID_hi, ":", 779 ntohs(llc->sender_unicast_FIFO_hi), 780 ntohl(llc->sender_unicast_FIFO_lo), 781 speeds[llc->sspd], 782 (2 << llc->sender_max_rec)); 783 } 784 785 void 786 firewire_ifdetach(struct ifnet *ifp) 787 { 788 bpfdetach(ifp); 789 if_detach(ifp); 790 } 791 792 void 793 firewire_busreset(struct ifnet *ifp) 794 { 795 struct fw_com *fc = IFP2FWC(ifp); 796 struct fw_reass *r; 797 struct mbuf *m; 798 799 /* 800 * Discard any partial datagrams since the host ids may have changed. 801 */ 802 while ((r = STAILQ_FIRST(&fc->fc_frags))) { 803 STAILQ_REMOVE_HEAD(&fc->fc_frags, fr_link); 804 while (r->fr_frags) { 805 m = r->fr_frags; 806 r->fr_frags = m->m_nextpkt; 807 m_freem(m); 808 } 809 free(r, M_TEMP); 810 } 811 } 812 813 static void * 814 firewire_alloc(u_char type, struct ifnet *ifp) 815 { 816 struct fw_com *fc; 817 818 fc = malloc(sizeof(struct fw_com), M_FWCOM, M_WAITOK | M_ZERO); 819 fc->fc_ifp = ifp; 820 821 return (fc); 822 } 823 824 static void 825 firewire_free(void *com, u_char type) 826 { 827 828 free(com, M_FWCOM); 829 } 830 831 static int 832 firewire_modevent(module_t mod, int type, void *data) 833 { 834 835 switch (type) { 836 case MOD_LOAD: 837 if_register_com_alloc(IFT_IEEE1394, 838 firewire_alloc, firewire_free); 839 break; 840 case MOD_UNLOAD: 841 if_deregister_com_alloc(IFT_IEEE1394); 842 break; 843 default: 844 return (EOPNOTSUPP); 845 } 846 847 return (0); 848 } 849 850 static moduledata_t firewire_mod = { 851 "if_firewire", 852 firewire_modevent, 853 0 854 }; 855 856 DECLARE_MODULE(if_firewire, firewire_mod, SI_SUB_INIT_IF, SI_ORDER_ANY); 857 MODULE_VERSION(if_firewire, 1); 858