sys/dev/netif/fwe/if_fwe.c

   1 /*
   2  * Copyright (c) 2002-2003
   3  *      Hidetoshi Shimokawa. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *
  16  *      This product includes software developed by Hidetoshi Shimokawa.
  17  *
  18  * 4. Neither the name of the author nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $FreeBSD: src/sys/dev/firewire/if_fwe.c,v 1.27 2004/01/08 14:58:09 simokawa Exp $
  35  */
  36
  37 #include "opt_inet.h"
  38 #include "opt_ifpoll.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/conf.h>
  42 #include <sys/kernel.h>
  43 #include <sys/malloc.h>
  44 #include <sys/mbuf.h>
  45 #include <sys/socket.h>
  46 #include <sys/sockio.h>
  47 #include <sys/sysctl.h>
  48 #include <sys/systm.h>
  49 #include <sys/module.h>
  50 #include <sys/bus.h>
  51 #include <sys/thread2.h>
  52
  53 #include <net/bpf.h>
  54 #include <net/ethernet.h>
  55 #include <net/if.h>
  56 #include <net/if_arp.h>
  57 #ifdef __DragonFly__
  58 #include <net/ifq_var.h>
  59 #include <net/if_poll.h>
  60 #include <net/vlan/if_vlan_var.h>
  61 #include <bus/firewire/firewire.h>
  62 #include <bus/firewire/firewirereg.h>
  63 #include "if_fwevar.h"
  64 #else
  65 #include <net/if_vlan_var.h>
  66
  67 #include <dev/firewire/firewire.h>
  68 #include <dev/firewire/firewirereg.h>
  69 #include <dev/firewire/if_fwevar.h>
  70 #endif
  71
  72 #define FWEDEBUG        if (fwedebug) if_printf
  73 #define TX_MAX_QUEUE    (FWMAXQUEUE - 1)
  74
  75 /* network interface */
  76 static void fwe_start (struct ifnet *);
  77 static int fwe_ioctl (struct ifnet *, u_long, caddr_t, struct ucred *);
  78 static void fwe_init (void *);
  79
  80 static void fwe_output_callback (struct fw_xfer *);
  81 static void fwe_as_output (struct fwe_softc *, struct ifnet *);
  82 static void fwe_as_input (struct fw_xferq *);
  83
  84 static int fwedebug = 0;
  85 static int stream_ch = 1;
  86 static int tx_speed = 2;
  87 static int rx_queue_len = FWMAXQUEUE;
  88
  89 MALLOC_DEFINE(M_FWE, "if_fwe", "Ethernet over FireWire interface");
  90 SYSCTL_INT(_debug, OID_AUTO, if_fwe_debug, CTLFLAG_RW, &fwedebug, 0,
  91         "Enable debug output");
  92 SYSCTL_DECL(_hw_firewire);
  93 SYSCTL_NODE(_hw_firewire, OID_AUTO, fwe, CTLFLAG_RD, 0,
  94         "Ethernet emulation subsystem");
  95 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, stream_ch, CTLFLAG_RW, &stream_ch, 0,
  96         "Stream channel to use");
  97 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, tx_speed, CTLFLAG_RW, &tx_speed, 0,
  98         "Transmission speed");
  99 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, rx_queue_len, CTLFLAG_RW, &rx_queue_len,
 100         0, "Length of the receive queue");
 101
 102 TUNABLE_INT("hw.firewire.fwe.stream_ch", &stream_ch);
 103 TUNABLE_INT("hw.firewire.fwe.tx_speed", &tx_speed);
 104 TUNABLE_INT("hw.firewire.fwe.rx_queue_len", &rx_queue_len);
 105
 106 #ifdef IFPOLL_ENABLE
 107
 108 static void
 109 fwe_npoll_compat(struct ifnet *ifp, void *arg __unused, int count)
 110 {
 111         struct fwe_softc *fwe;
 112         struct firewire_comm *fc;
 113         int check_status = 0;
 114
 115         ASSERT_SERIALIZED(ifp->if_serializer);
 116
 117         fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
 118         fc = fwe->fd.fc;
 119
 120         if (fwe->npoll.ifpc_stcount-- == 0) {
 121                 fwe->npoll.ifpc_stcount = fwe->npoll.ifpc_stfrac;
 122                 check_status = 1;
 123         }
 124         fc->poll(fc, check_status?0:1, count);
 125 }
 126
 127 static void
 128 fwe_npoll(struct ifnet *ifp, struct ifpoll_info *info)
 129 {
 130         struct fwe_softc *fwe;
 131         struct firewire_comm *fc;
 132
 133         ASSERT_SERIALIZED(ifp->if_serializer);
 134
 135         fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
 136         fc = fwe->fd.fc;
 137
 138         if (info != NULL) {
 139                 int cpuid = fwe->npoll.ifpc_cpuid;
 140
 141                 info->ifpi_rx[cpuid].poll_func = fwe_npoll_compat;
 142                 info->ifpi_rx[cpuid].arg = NULL;
 143                 info->ifpi_rx[cpuid].serializer = ifp->if_serializer;
 144
 145                 if (ifp->if_flags & IFF_RUNNING) {
 146                         /* disable interrupts */
 147                         fc->set_intr(fc, 0);
 148                         fwe->npoll.ifpc_stcount = 0;
 149                 }
 150                 ifq_set_cpuid(&ifp->if_snd, cpuid);
 151         } else {
 152                 if (ifp->if_flags & IFF_RUNNING) {
 153                         /* enable interrupts */
 154                         fc->set_intr(fc, 1);
 155                 }
 156                 ifq_set_cpuid(&ifp->if_snd, 0 /* XXX */);
 157         }
 158 }
 159
 160 #endif  /* IFPOLL_ENABLE */
 161
 162 static int
 163 fwe_probe(device_t dev)
 164 {
 165         device_t pa;
 166
 167         pa = device_get_parent(dev);
 168         if(device_get_unit(dev) != device_get_unit(pa)){
 169                 return(ENXIO);
 170         }
 171
 172         device_set_desc(dev, "Ethernet over FireWire");
 173         return (0);
 174 }
 175
 176 static int
 177 fwe_attach(device_t dev)
 178 {
 179         struct fwe_softc *fwe;
 180         struct ifnet *ifp;
 181         uint8_t eaddr[ETHER_ADDR_LEN];
 182         struct fw_eui64 *eui;
 183
 184         fwe = ((struct fwe_softc *)device_get_softc(dev));
 185
 186         /* XXX */
 187         fwe->stream_ch = stream_ch;
 188         fwe->dma_ch = -1;
 189
 190         fwe->fd.fc = device_get_ivars(dev);
 191         if (tx_speed < 0)
 192                 tx_speed = fwe->fd.fc->speed;
 193
 194         fwe->fd.dev = dev;
 195         fwe->fd.post_explore = NULL;
 196         fwe->eth_softc.fwe = fwe;
 197
 198         fwe->pkt_hdr.mode.stream.tcode = FWTCODE_STREAM;
 199         fwe->pkt_hdr.mode.stream.sy = 0;
 200         fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
 201
 202         /* generate fake MAC address: first and last 3bytes from eui64 */
 203 #define LOCAL (0x02)
 204 #define GROUP (0x01)
 205
 206         eui = &fwe->fd.fc->eui;
 207         eaddr[0] = (FW_EUI64_BYTE(eui, 0) | LOCAL) & ~GROUP;
 208         eaddr[1] = FW_EUI64_BYTE(eui, 1);
 209         eaddr[2] = FW_EUI64_BYTE(eui, 2);
 210         eaddr[3] = FW_EUI64_BYTE(eui, 5);
 211         eaddr[4] = FW_EUI64_BYTE(eui, 6);
 212         eaddr[5] = FW_EUI64_BYTE(eui, 7);
 213
 214         /* fill the rest and attach interface */
 215         ifp = &fwe->fwe_if;
 216         ifp->if_softc = &fwe->eth_softc;
 217
 218         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
 219         ifp->if_init = fwe_init;
 220         ifp->if_start = fwe_start;
 221         ifp->if_ioctl = fwe_ioctl;
 222         ifp->if_capabilities = IFCAP_VLAN_MTU;
 223 #ifdef IFPOLL_ENABLE
 224         ifp->if_npoll = fwe_npoll;
 225 #endif
 226         ifp->if_mtu = ETHERMTU;
 227         ifp->if_flags = (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST);
 228         ifq_set_maxlen(&ifp->if_snd, TX_MAX_QUEUE);
 229         ifq_set_ready(&ifp->if_snd);
 230
 231         ether_ifattach(ifp, eaddr, NULL);
 232
 233         /* Tell the upper layer(s) we support long frames. */
 234         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
 235
 236 #ifdef IFPOLL_ENABLE
 237         ifpoll_compat_setup(&fwe->npoll, NULL, NULL, device_get_unit(dev),
 238             ifp->if_serializer);
 239 #endif
 240
 241         FWEDEBUG(ifp, "interface created\n");
 242         return 0;
 243 }
 244
 245 static void
 246 fwe_stop(struct fwe_softc *fwe)
 247 {
 248         struct firewire_comm *fc;
 249         struct fw_xferq *xferq;
 250         struct ifnet *ifp = &fwe->fwe_if;
 251         struct fw_xfer *xfer, *next;
 252         int i;
 253
 254         fc = fwe->fd.fc;
 255
 256         ifp->if_flags &= ~IFF_RUNNING;
 257         ifq_clr_oactive(&ifp->if_snd);
 258
 259         if (fwe->dma_ch >= 0) {
 260                 xferq = fc->ir[fwe->dma_ch];
 261
 262                 if (xferq->flag & FWXFERQ_RUNNING)
 263                         fc->irx_disable(fc, fwe->dma_ch);
 264                 xferq->flag &=
 265                         ~(FWXFERQ_MODEMASK | FWXFERQ_OPEN | FWXFERQ_STREAM |
 266                         FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_CHTAGMASK);
 267                 xferq->hand =  NULL;
 268
 269                 for (i = 0; i < xferq->bnchunk; i ++)
 270                         m_freem(xferq->bulkxfer[i].mbuf);
 271                 kfree(xferq->bulkxfer, M_FWE);
 272
 273                 for (xfer = STAILQ_FIRST(&fwe->xferlist); xfer != NULL;
 274                                         xfer = next) {
 275                         next = STAILQ_NEXT(xfer, link);
 276                         fw_xfer_free(xfer);
 277                 }
 278                 STAILQ_INIT(&fwe->xferlist);
 279
 280                 xferq->bulkxfer =  NULL;
 281                 fwe->dma_ch = -1;
 282         }
 283 }
 284
 285 static int
 286 fwe_detach(device_t dev)
 287 {
 288         struct fwe_softc *fwe = device_get_softc(dev);
 289
 290         lwkt_serialize_enter(fwe->fwe_if.if_serializer);
 291         fwe_stop(fwe);
 292         lwkt_serialize_exit(fwe->fwe_if.if_serializer);
 293
 294         ether_ifdetach(&fwe->fwe_if);
 295         return 0;
 296 }
 297
 298 static void
 299 fwe_init(void *arg)
 300 {
 301         struct fwe_softc *fwe = ((struct fwe_eth_softc *)arg)->fwe;
 302         struct firewire_comm *fc;
 303         struct ifnet *ifp = &fwe->fwe_if;
 304         struct fw_xferq *xferq;
 305         struct fw_xfer *xfer;
 306         struct mbuf *m;
 307         int i;
 308
 309         FWEDEBUG(ifp, "initializing\n");
 310
 311         /* XXX keep promiscoud mode */
 312         ifp->if_flags |= IFF_PROMISC;
 313
 314         fc = fwe->fd.fc;
 315 #define START 0
 316         if (fwe->dma_ch < 0) {
 317                 for (i = START; i < fc->nisodma; i ++) {
 318                         xferq = fc->ir[i];
 319                         if ((xferq->flag & FWXFERQ_OPEN) == 0)
 320                                 goto found;
 321                 }
 322                 if_printf(ifp, "no free dma channel\n");
 323                 return;
 324 found:
 325                 fwe->dma_ch = i;
 326                 fwe->stream_ch = stream_ch;
 327                 fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
 328                 /* allocate DMA channel and init packet mode */
 329                 xferq->flag |= FWXFERQ_OPEN | FWXFERQ_EXTBUF |
 330                                 FWXFERQ_HANDLER | FWXFERQ_STREAM;
 331                 xferq->flag &= ~0xff;
 332                 xferq->flag |= fwe->stream_ch & 0xff;
 333                 /* register fwe_input handler */
 334                 xferq->sc = (caddr_t) fwe;
 335                 xferq->hand = fwe_as_input;
 336                 xferq->bnchunk = rx_queue_len;
 337                 xferq->bnpacket = 1;
 338                 xferq->psize = MCLBYTES;
 339                 xferq->queued = 0;
 340                 xferq->buf = NULL;
 341                 xferq->bulkxfer = (struct fw_bulkxfer *) kmalloc(
 342                         sizeof(struct fw_bulkxfer) * xferq->bnchunk,
 343                                                         M_FWE, M_WAITOK);
 344                 STAILQ_INIT(&xferq->stvalid);
 345                 STAILQ_INIT(&xferq->stfree);
 346                 STAILQ_INIT(&xferq->stdma);
 347                 xferq->stproc = NULL;
 348                 for (i = 0; i < xferq->bnchunk; i ++) {
 349                         m = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
 350                         xferq->bulkxfer[i].mbuf = m;
 351                         if (m != NULL) {
 352                                 m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
 353                                 STAILQ_INSERT_TAIL(&xferq->stfree,
 354                                                 &xferq->bulkxfer[i], link);
 355                         } else {
 356                                 if_printf(ifp, "fwe_init: m_getcl failed\n");
 357                         }
 358                 }
 359                 STAILQ_INIT(&fwe->xferlist);
 360                 for (i = 0; i < TX_MAX_QUEUE; i++) {
 361                         xfer = fw_xfer_alloc(M_FWE);
 362                         if (xfer == NULL)
 363                                 break;
 364                         xfer->send.spd = tx_speed;
 365                         xfer->fc = fwe->fd.fc;
 366                         xfer->retry_req = fw_asybusy;
 367                         xfer->sc = (caddr_t)fwe;
 368                         xfer->act.hand = fwe_output_callback;
 369                         STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
 370                 }
 371         } else
 372                 xferq = fc->ir[fwe->dma_ch];
 373
 374 #ifdef IFPOLL_ENABLE
 375         /* Disable interrupt, if polling(4) is enabled */
 376         if (ifp->if_flags & IFF_NPOLLING) {
 377                 fc->set_intr(fc, 0);
 378                 fwe->npoll.ifpc_stcount = 0;
 379         } else
 380 #endif
 381         fc->set_intr(fc, 1);
 382
 383         /* start dma */
 384         if ((xferq->flag & FWXFERQ_RUNNING) == 0)
 385                 fc->irx_enable(fc, fwe->dma_ch);
 386
 387         ifp->if_flags |= IFF_RUNNING;
 388         ifq_clr_oactive(&ifp->if_snd);
 389 }
 390
 391
 392 static int
 393 fwe_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
 394 {
 395         struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
 396         struct ifstat *ifs = NULL;
 397         int error = 0, len;
 398
 399         switch (cmd) {
 400         case SIOCSIFFLAGS:
 401                 if (ifp->if_flags & IFF_UP) {
 402                         if (!(ifp->if_flags & IFF_RUNNING))
 403                                 fwe_init(&fwe->eth_softc);
 404                 } else {
 405                         if (ifp->if_flags & IFF_RUNNING)
 406                                 fwe_stop(fwe);
 407                 }
 408                 /* XXX keep promiscoud mode */
 409                 ifp->if_flags |= IFF_PROMISC;
 410                 break;
 411         case SIOCADDMULTI:
 412         case SIOCDELMULTI:
 413                 break;
 414
 415         case SIOCGIFSTATUS:
 416                 ifs = (struct ifstat *)data;
 417                 len = strlen(ifs->ascii);
 418                 if (len < sizeof(ifs->ascii))
 419                         ksnprintf(ifs->ascii + len,
 420                                 sizeof(ifs->ascii) - len,
 421                                 "\tch %d dma %d\n",
 422                                         fwe->stream_ch, fwe->dma_ch);
 423                 break;
 424         default:
 425                 error = ether_ioctl(ifp, cmd, data);
 426                 break;
 427         }
 428         return (error);
 429 }
 430
 431 static void
 432 fwe_output_callback(struct fw_xfer *xfer)
 433 {
 434         struct fwe_softc *fwe;
 435         struct ifnet *ifp;
 436
 437         fwe = (struct fwe_softc *)xfer->sc;
 438         ifp = &fwe->fwe_if;
 439         lwkt_serialize_enter(ifp->if_serializer);
 440         /* XXX error check */
 441         FWEDEBUG(ifp, "resp = %d\n", xfer->resp);
 442         if (xfer->resp != 0)
 443                 ifp->if_oerrors ++;
 444
 445         m_freem(xfer->mbuf);
 446         fw_xfer_unload(xfer);
 447
 448         STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
 449
 450         /* for queue full */
 451         if (!ifq_is_empty(&ifp->if_snd))
 452                 if_devstart(ifp);
 453         lwkt_serialize_exit(ifp->if_serializer);
 454 }
 455
 456 static void
 457 fwe_start(struct ifnet *ifp)
 458 {
 459         struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
 460
 461         FWEDEBUG(ifp, "starting\n");
 462
 463         if (fwe->dma_ch < 0) {
 464                 FWEDEBUG(ifp, "not ready\n");
 465
 466                 ifq_purge(&ifp->if_snd);
 467         } else {
 468                 ifq_set_oactive(&ifp->if_snd);
 469
 470                 if (!ifq_is_empty(&ifp->if_snd))
 471                         fwe_as_output(fwe, ifp);
 472
 473                 ifq_clr_oactive(&ifp->if_snd);
 474         }
 475 }
 476
 477 #define HDR_LEN 4
 478 #ifndef ETHER_ALIGN
 479 #define ETHER_ALIGN 2
 480 #endif
 481 /* Async. stream output */
 482 static void
 483 fwe_as_output(struct fwe_softc *fwe, struct ifnet *ifp)
 484 {
 485         struct mbuf *m;
 486         struct fw_xfer *xfer;
 487         struct fw_xferq *xferq;
 488         struct fw_pkt *fp;
 489         int i = 0;
 490
 491         xfer = NULL;
 492         xferq = fwe->fd.fc->atq;
 493         while (xferq->queued < xferq->maxq - 1) {
 494                 xfer = STAILQ_FIRST(&fwe->xferlist);
 495                 if (xfer == NULL) {
 496                         if_printf(ifp, "lack of xfer\n");
 497                         return;
 498                 }
 499                 m = ifq_dequeue(&ifp->if_snd, NULL);
 500                 if (m == NULL)
 501                         break;
 502                 STAILQ_REMOVE_HEAD(&fwe->xferlist, link);
 503                 BPF_MTAP(ifp, m);
 504
 505                 /* keep ip packet alignment for alpha */
 506                 M_PREPEND(m, ETHER_ALIGN, MB_DONTWAIT);
 507                 fp = &xfer->send.hdr;
 508                 *(u_int32_t *)&xfer->send.hdr = *(int32_t *)&fwe->pkt_hdr;
 509                 fp->mode.stream.len = m->m_pkthdr.len;
 510                 xfer->mbuf = m;
 511                 xfer->send.pay_len = m->m_pkthdr.len;
 512
 513                 if (fw_asyreq(fwe->fd.fc, -1, xfer) != 0) {
 514                         /* error */
 515                         ifp->if_oerrors ++;
 516                         /* XXX set error code */
 517                         fwe_output_callback(xfer);
 518                 } else {
 519                         ifp->if_opackets ++;
 520                         i++;
 521                 }
 522         }
 523 #if 0
 524         if (i > 1)
 525                 if_printf(ifp, "%d queued\n", i);
 526 #endif
 527         if (i > 0)
 528                 xferq->start(fwe->fd.fc);
 529 }
 530
 531 /* Async. stream output */
 532 static void
 533 fwe_as_input(struct fw_xferq *xferq)
 534 {
 535         struct mbuf *m, *m0;
 536         struct ifnet *ifp;
 537         struct fwe_softc *fwe;
 538         struct fw_bulkxfer *sxfer;
 539         struct fw_pkt *fp;
 540
 541         fwe = (struct fwe_softc *)xferq->sc;
 542         ifp = &fwe->fwe_if;
 543         lwkt_serialize_enter(ifp->if_serializer);
 544         while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) {
 545                 STAILQ_REMOVE_HEAD(&xferq->stvalid, link);
 546                 fp = mtod(sxfer->mbuf, struct fw_pkt *);
 547                 if (fwe->fd.fc->irx_post != NULL)
 548                         fwe->fd.fc->irx_post(fwe->fd.fc, fp->mode.ld);
 549                 m = sxfer->mbuf;
 550
 551                 /* insert new rbuf */
 552                 sxfer->mbuf = m0 = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
 553                 if (m0 != NULL) {
 554                         m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
 555                         STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
 556                 } else {
 557                         if_printf(ifp, "fwe_as_input: m_getcl failed\n");
 558                 }
 559
 560                 if (sxfer->resp != 0 || fp->mode.stream.len <
 561                     ETHER_ALIGN + sizeof(struct ether_header)) {
 562                         m_freem(m);
 563                         ifp->if_ierrors ++;
 564                         continue;
 565                 }
 566
 567                 m->m_data += HDR_LEN + ETHER_ALIGN;
 568                 m->m_len = m->m_pkthdr.len =
 569                                 fp->mode.stream.len - ETHER_ALIGN;
 570                 m->m_pkthdr.rcvif = ifp;
 571 #if 0
 572                 FWEDEBUG(ifp, "%02x %02x %02x %02x %02x %02x\n"
 573                          "%02x %02x %02x %02x %02x %02x\n"
 574                          "%02x %02x %02x %02x\n"
 575                          "%02x %02x %02x %02x\n"
 576                          "%02x %02x %02x %02x\n"
 577                          "%02x %02x %02x %02x\n",
 578                          c[0], c[1], c[2], c[3], c[4], c[5],
 579                          c[6], c[7], c[8], c[9], c[10], c[11],
 580                          c[12], c[13], c[14], c[15],
 581                          c[16], c[17], c[18], c[19],
 582                          c[20], c[21], c[22], c[23],
 583                          c[20], c[21], c[22], c[23]
 584                  );
 585 #endif
 586                 ifp->if_input(ifp, m);
 587                 ifp->if_ipackets ++;
 588         }
 589         if (STAILQ_FIRST(&xferq->stfree) != NULL)
 590                 fwe->fd.fc->irx_enable(fwe->fd.fc, fwe->dma_ch);
 591         lwkt_serialize_exit(ifp->if_serializer);
 592 }
 593
 594
 595 static devclass_t fwe_devclass;
 596
 597 /*
 598  * Because fwe is a static device that always exists under any attached
 599  * firewire device, and not scanned by the firewire device, we need an
 600  * identify function to install the device.
 601  */
 602 static device_method_t fwe_methods[] = {
 603         /* device interface */
 604         DEVMETHOD(device_identify,      bus_generic_identify_sameunit),
 605         DEVMETHOD(device_probe,         fwe_probe),
 606         DEVMETHOD(device_attach,        fwe_attach),
 607         DEVMETHOD(device_detach,        fwe_detach),
 608         { 0, 0 }
 609 };
 610
 611 static driver_t fwe_driver = {
 612         "fwe",
 613         fwe_methods,
 614         sizeof(struct fwe_softc),
 615 };
 616
 617
 618 DECLARE_DUMMY_MODULE(fwe);
 619 DRIVER_MODULE(fwe, firewire, fwe_driver, fwe_devclass, NULL, NULL);
 620 MODULE_VERSION(fwe, 1);
 621 MODULE_DEPEND(fwe, firewire, 1, 1, 1);