Second part of the firewire sync. Add defined(__DragonFly__) or
[dragonfly.git] / 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  * $DragonFly: src/sys/dev/netif/fwe/if_fwe.c,v 1.8 2004/02/05 17:51:44 joerg Exp $
36  */
37
38 #include "opt_inet.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 <machine/bus.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/vlan/if_vlan_var.h>
59 #include <bus/firewire/firewire.h>
60 #include <bus/firewire/firewirereg.h>
61 #include "if_fwevar.h"
62 #else
63 #include <net/if_vlan_var.h>
64
65 #include <dev/firewire/firewire.h>
66 #include <dev/firewire/firewirereg.h>
67 #include <dev/firewire/if_fwevar.h>
68 #endif
69
70 #define FWEDEBUG        if (fwedebug) if_printf
71 #define TX_MAX_QUEUE    (FWMAXQUEUE - 1)
72
73 /* network interface */
74 static void fwe_start (struct ifnet *);
75 static int fwe_ioctl (struct ifnet *, u_long, caddr_t);
76 static void fwe_init (void *);
77
78 static void fwe_output_callback (struct fw_xfer *);
79 static void fwe_as_output (struct fwe_softc *, struct ifnet *);
80 static void fwe_as_input (struct fw_xferq *);
81
82 static int fwedebug = 0;
83 static int stream_ch = 1;
84 static int tx_speed = 2;
85 static int rx_queue_len = FWMAXQUEUE;
86
87 MALLOC_DEFINE(M_FWE, "if_fwe", "Ethernet over FireWire interface");
88 SYSCTL_INT(_debug, OID_AUTO, if_fwe_debug, CTLFLAG_RW, &fwedebug, 0, "");
89 SYSCTL_DECL(_hw_firewire);
90 SYSCTL_NODE(_hw_firewire, OID_AUTO, fwe, CTLFLAG_RD, 0,
91         "Ethernet emulation subsystem");
92 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, stream_ch, CTLFLAG_RW, &stream_ch, 0,
93         "Stream channel to use");
94 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, tx_speed, CTLFLAG_RW, &tx_speed, 0,
95         "Transmission speed");
96 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, rx_queue_len, CTLFLAG_RW, &rx_queue_len,
97         0, "Length of the receive queue");
98
99 TUNABLE_INT("hw.firewire.fwe.stream_ch", &stream_ch);
100 TUNABLE_INT("hw.firewire.fwe.tx_speed", &tx_speed);
101 TUNABLE_INT("hw.firewire.fwe.rx_queue_len", &rx_queue_len);
102
103 #ifdef DEVICE_POLLING
104 #define FWE_POLL_REGISTER(func, fwe, ifp)                       \
105         if (ether_poll_register(func, ifp)) {                   \
106                 struct firewire_comm *fc = (fwe)->fd.fc;        \
107                 fc->set_intr(fc, 0);                            \
108         }
109
110 #define FWE_POLL_DEREGISTER(fwe, ifp)                           \
111         do {                                                    \
112                 struct firewire_comm *fc = (fwe)->fd.fc;        \
113                 ether_poll_deregister(ifp);                     \
114                 fc->set_intr(fc, 1);                            \
115         } while(0)                                              \
116
117 static poll_handler_t fwe_poll;
118
119 static void
120 fwe_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
121 {
122         struct fwe_softc *fwe;
123         struct firewire_comm *fc;
124
125         fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
126         fc = fwe->fd.fc;
127         if (cmd == POLL_DEREGISTER) {
128                 /* enable interrupts */
129                 fc->set_intr(fc, 1);
130                 return;
131         }
132         fc->poll(fc, (cmd == POLL_AND_CHECK_STATUS)?0:1, count);
133 }
134 #else
135 #define FWE_POLL_REGISTER(func, fwe, ifp)
136 #define FWE_POLL_DEREGISTER(fwe, ifp)
137 #endif
138 static void
139 fwe_identify(driver_t *driver, device_t parent)
140 {
141         BUS_ADD_CHILD(parent, 0, "fwe", device_get_unit(parent));
142 }
143
144 static int
145 fwe_probe(device_t dev)
146 {
147         device_t pa;
148
149         pa = device_get_parent(dev);
150         if(device_get_unit(dev) != device_get_unit(pa)){
151                 return(ENXIO);
152         }
153
154         device_set_desc(dev, "Ethernet over FireWire");
155         return (0);
156 }
157
158 static int
159 fwe_attach(device_t dev)
160 {
161         struct fwe_softc *fwe;
162         struct ifnet *ifp;
163         int unit, s;
164         u_char *eaddr;
165         struct fw_eui64 *eui;
166
167         fwe = ((struct fwe_softc *)device_get_softc(dev));
168         unit = device_get_unit(dev);
169
170         bzero(fwe, sizeof(struct fwe_softc));
171         /* XXX */
172         fwe->stream_ch = stream_ch;
173         fwe->dma_ch = -1;
174
175         fwe->fd.fc = device_get_ivars(dev);
176         if (tx_speed < 0)
177                 tx_speed = fwe->fd.fc->speed;
178
179         fwe->fd.dev = dev;
180         fwe->fd.post_explore = NULL;
181         fwe->eth_softc.fwe = fwe;
182
183         fwe->pkt_hdr.mode.stream.tcode = FWTCODE_STREAM;
184         fwe->pkt_hdr.mode.stream.sy = 0;
185         fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
186
187         /* generate fake MAC address: first and last 3bytes from eui64 */
188 #define LOCAL (0x02)
189 #define GROUP (0x01)
190         eaddr = &fwe->eth_softc.arpcom.ac_enaddr[0];
191
192         eui = &fwe->fd.fc->eui;
193         eaddr[0] = (FW_EUI64_BYTE(eui, 0) | LOCAL) & ~GROUP;
194         eaddr[1] = FW_EUI64_BYTE(eui, 1);
195         eaddr[2] = FW_EUI64_BYTE(eui, 2);
196         eaddr[3] = FW_EUI64_BYTE(eui, 5);
197         eaddr[4] = FW_EUI64_BYTE(eui, 6);
198         eaddr[5] = FW_EUI64_BYTE(eui, 7);
199         printf("if_fwe%d: Fake Ethernet address: "
200                 "%02x:%02x:%02x:%02x:%02x:%02x\n", unit,
201                 eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]);
202
203         /* fill the rest and attach interface */        
204         ifp = &fwe->fwe_if;
205         ifp->if_softc = &fwe->eth_softc;
206
207 #if __FreeBSD_version >= 501113 || defined(__DragonFly__)
208         if_initname(ifp, device_get_name(dev), unit);
209 #else
210         ifp->if_unit = unit;
211         ifp->if_name = "fwe";
212 #endif
213         ifp->if_init = fwe_init;
214         ifp->if_output = ether_output;
215         ifp->if_start = fwe_start;
216         ifp->if_ioctl = fwe_ioctl;
217         ifp->if_mtu = ETHERMTU;
218         ifp->if_flags = (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST);
219         ifp->if_snd.ifq_maxlen = TX_MAX_QUEUE;
220
221         s = splimp();
222 #if defined(__DragonFly__) || __FreeBSD_version < 500000
223         ether_ifattach(ifp, 1);
224 #else
225         ether_ifattach(ifp, eaddr);
226 #endif
227         splx(s);
228
229         /* Tell the upper layer(s) we support long frames. */
230         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
231 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
232         ifp->if_capabilities |= IFCAP_VLAN_MTU;
233 #endif
234
235
236         FWEDEBUG(ifp, "interface created\n");
237         return 0;
238 }
239
240 static void
241 fwe_stop(struct fwe_softc *fwe)
242 {
243         struct firewire_comm *fc;
244         struct fw_xferq *xferq;
245         struct ifnet *ifp = &fwe->fwe_if;
246         struct fw_xfer *xfer, *next;
247         int i;
248
249         fc = fwe->fd.fc;
250
251         FWE_POLL_DEREGISTER(fwe, ifp);
252
253         if (fwe->dma_ch >= 0) {
254                 xferq = fc->ir[fwe->dma_ch];
255
256                 if (xferq->flag & FWXFERQ_RUNNING)
257                         fc->irx_disable(fc, fwe->dma_ch);
258                 xferq->flag &= 
259                         ~(FWXFERQ_MODEMASK | FWXFERQ_OPEN | FWXFERQ_STREAM |
260                         FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_CHTAGMASK);
261                 xferq->hand =  NULL;
262
263                 for (i = 0; i < xferq->bnchunk; i ++)
264                         m_freem(xferq->bulkxfer[i].mbuf);
265                 free(xferq->bulkxfer, M_FWE);
266
267                 for (xfer = STAILQ_FIRST(&fwe->xferlist); xfer != NULL;
268                                         xfer = next) {
269                         next = STAILQ_NEXT(xfer, link);
270                         fw_xfer_free(xfer);
271                 }
272                 STAILQ_INIT(&fwe->xferlist);
273
274                 xferq->bulkxfer =  NULL;
275                 fwe->dma_ch = -1;
276         }
277
278         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
279 }
280
281 static int
282 fwe_detach(device_t dev)
283 {
284         struct fwe_softc *fwe;
285         int s;
286
287         fwe = (struct fwe_softc *)device_get_softc(dev);
288         s = splimp();
289
290         fwe_stop(fwe);
291 #if defined(__DragonFly__) || __FreeBSD_version < 500000
292         ether_ifdetach(&fwe->fwe_if, 1);
293 #else
294         ether_ifdetach(&fwe->fwe_if);
295 #endif
296
297         splx(s);
298         return 0;
299 }
300
301 static void
302 fwe_init(void *arg)
303 {
304         struct fwe_softc *fwe = ((struct fwe_eth_softc *)arg)->fwe;
305         struct firewire_comm *fc;
306         struct ifnet *ifp = &fwe->fwe_if;
307         struct fw_xferq *xferq;
308         struct fw_xfer *xfer;
309         struct mbuf *m;
310         int i;
311
312         FWEDEBUG(ifp, "initializing\n");
313
314         /* XXX keep promiscoud mode */
315         ifp->if_flags |= IFF_PROMISC;
316
317         fc = fwe->fd.fc;
318 #define START 0
319         if (fwe->dma_ch < 0) {
320                 for (i = START; i < fc->nisodma; i ++) {
321                         xferq = fc->ir[i];
322                         if ((xferq->flag & FWXFERQ_OPEN) == 0)
323                                 goto found;
324                 }
325                 printf("no free dma channel\n");
326                 return;
327 found:
328                 fwe->dma_ch = i;
329                 fwe->stream_ch = stream_ch;
330                 fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
331                 /* allocate DMA channel and init packet mode */
332                 xferq->flag |= FWXFERQ_OPEN | FWXFERQ_EXTBUF |
333                                 FWXFERQ_HANDLER | FWXFERQ_STREAM;
334                 xferq->flag &= ~0xff;
335                 xferq->flag |= fwe->stream_ch & 0xff;
336                 /* register fwe_input handler */
337                 xferq->sc = (caddr_t) fwe;
338                 xferq->hand = fwe_as_input;
339                 xferq->bnchunk = rx_queue_len;
340                 xferq->bnpacket = 1;
341                 xferq->psize = MCLBYTES;
342                 xferq->queued = 0;
343                 xferq->buf = NULL;
344                 xferq->bulkxfer = (struct fw_bulkxfer *) malloc(
345                         sizeof(struct fw_bulkxfer) * xferq->bnchunk,
346                                                         M_FWE, M_WAITOK);
347                 if (xferq->bulkxfer == NULL) {
348                         printf("if_fwe: malloc failed\n");
349                         return;
350                 }
351                 STAILQ_INIT(&xferq->stvalid);
352                 STAILQ_INIT(&xferq->stfree);
353                 STAILQ_INIT(&xferq->stdma);
354                 xferq->stproc = NULL;
355                 for (i = 0; i < xferq->bnchunk; i ++) {
356                         m =
357 #if defined(__DragonFly__) || __FreeBSD_version < 500000
358                                 m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
359 #else
360                                 m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
361 #endif
362                         xferq->bulkxfer[i].mbuf = m;
363                         if (m != NULL) {
364                                 m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
365                                 STAILQ_INSERT_TAIL(&xferq->stfree,
366                                                 &xferq->bulkxfer[i], link);
367                         } else
368                                 printf("fwe_as_input: m_getcl failed\n");
369                 }
370                 STAILQ_INIT(&fwe->xferlist);
371                 for (i = 0; i < TX_MAX_QUEUE; i++) {
372                         xfer = fw_xfer_alloc(M_FWE);
373                         if (xfer == NULL)
374                                 break;
375                         xfer->send.spd = tx_speed;
376                         xfer->fc = fwe->fd.fc;
377                         xfer->retry_req = fw_asybusy;
378                         xfer->sc = (caddr_t)fwe;
379                         xfer->act.hand = fwe_output_callback;
380                         STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
381                 }
382         } else
383                 xferq = fc->ir[fwe->dma_ch];
384
385
386         /* start dma */
387         if ((xferq->flag & FWXFERQ_RUNNING) == 0)
388                 fc->irx_enable(fc, fwe->dma_ch);
389
390         ifp->if_flags |= IFF_RUNNING;
391         ifp->if_flags &= ~IFF_OACTIVE;
392
393         FWE_POLL_REGISTER(fwe_poll, fwe, ifp);
394 #if 0
395         /* attempt to start output */
396         fwe_start(ifp);
397 #endif
398 }
399
400
401 static int
402 fwe_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
403 {
404         struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
405         struct ifstat *ifs = NULL;
406         int s, error, len;
407
408         switch (cmd) {
409                 case SIOCSIFFLAGS:
410                         s = splimp();
411                         if (ifp->if_flags & IFF_UP) {
412                                 if (!(ifp->if_flags & IFF_RUNNING))
413                                         fwe_init(&fwe->eth_softc);
414                         } else {
415                                 if (ifp->if_flags & IFF_RUNNING)
416                                         fwe_stop(fwe);
417                         }
418                         /* XXX keep promiscoud mode */
419                         ifp->if_flags |= IFF_PROMISC;
420                         splx(s);
421                         break;
422                 case SIOCADDMULTI:
423                 case SIOCDELMULTI:
424                         break;
425
426                 case SIOCGIFSTATUS:
427                         s = splimp();
428                         ifs = (struct ifstat *)data;
429                         len = strlen(ifs->ascii);
430                         if (len < sizeof(ifs->ascii))
431                                 snprintf(ifs->ascii + len,
432                                         sizeof(ifs->ascii) - len,
433                                         "\tch %d dma %d\n",
434                                                 fwe->stream_ch, fwe->dma_ch);
435                         splx(s);
436                         break;
437 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
438                 default:
439 #else
440                 case SIOCSIFADDR:
441                 case SIOCGIFADDR:
442                 case SIOCSIFMTU:
443 #endif
444                         s = splimp();
445                         error = ether_ioctl(ifp, cmd, data);
446                         splx(s);
447                         return (error);
448 #if defined(__DragonFly__) || __FreeBSD_version < 500000
449                 default:
450                         return (EINVAL);
451 #endif
452         }
453
454         return (0);
455 }
456
457 static void
458 fwe_output_callback(struct fw_xfer *xfer)
459 {
460         struct fwe_softc *fwe;
461         struct ifnet *ifp;
462         int s;
463
464         fwe = (struct fwe_softc *)xfer->sc;
465         ifp = &fwe->fwe_if;
466         /* XXX error check */
467         FWEDEBUG(ifp, "resp = %d\n", xfer->resp);
468         if (xfer->resp != 0)
469                 ifp->if_oerrors ++;
470                 
471         m_freem(xfer->mbuf);
472         fw_xfer_unload(xfer);
473
474         s = splimp();
475         STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
476         splx(s);
477
478         /* for queue full */
479         if (ifp->if_snd.ifq_head != NULL)
480                 fwe_start(ifp);
481 }
482
483 static void
484 fwe_start(struct ifnet *ifp)
485 {
486         struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
487         int s;
488
489         FWEDEBUG(ifp, "starting\n");
490
491         if (fwe->dma_ch < 0) {
492                 struct mbuf     *m = NULL;
493
494                 FWEDEBUG(ifp, "not ready\n");
495
496                 s = splimp();
497                 do {
498                         IF_DEQUEUE(&ifp->if_snd, m);
499                         if (m != NULL)
500                                 m_freem(m);
501                         ifp->if_oerrors ++;
502                 } while (m != NULL);
503                 splx(s);
504
505                 return;
506         }
507
508         s = splimp();
509         ifp->if_flags |= IFF_OACTIVE;
510
511         if (ifp->if_snd.ifq_len != 0)
512                 fwe_as_output(fwe, ifp);
513
514         ifp->if_flags &= ~IFF_OACTIVE;
515         splx(s);
516 }
517
518 #define HDR_LEN 4
519 #ifndef ETHER_ALIGN
520 #define ETHER_ALIGN 2
521 #endif
522 /* Async. stream output */
523 static void
524 fwe_as_output(struct fwe_softc *fwe, struct ifnet *ifp)
525 {
526         struct mbuf *m;
527         struct fw_xfer *xfer;
528         struct fw_xferq *xferq;
529         struct fw_pkt *fp;
530         int i = 0;
531
532         xfer = NULL;
533         xferq = fwe->fd.fc->atq;
534         while (xferq->queued < xferq->maxq - 1) {
535                 xfer = STAILQ_FIRST(&fwe->xferlist);
536                 if (xfer == NULL) {
537                         printf("if_fwe: lack of xfer\n");
538                         return;
539                 }
540                 IF_DEQUEUE(&ifp->if_snd, m);
541                 if (m == NULL)
542                         break;
543                 STAILQ_REMOVE_HEAD(&fwe->xferlist, link);
544 #if defined(__DragonFly__) || __FreeBSD_version < 500000
545                 if (ifp->if_bpf != NULL)
546                         bpf_mtap(ifp, m);
547 #else
548                 BPF_MTAP(ifp, m);
549 #endif
550
551                 /* keep ip packet alignment for alpha */
552                 M_PREPEND(m, ETHER_ALIGN, M_DONTWAIT);
553                 fp = &xfer->send.hdr;
554                 *(u_int32_t *)&xfer->send.hdr = *(int32_t *)&fwe->pkt_hdr;
555                 fp->mode.stream.len = m->m_pkthdr.len;
556                 xfer->mbuf = m;
557                 xfer->send.pay_len = m->m_pkthdr.len;
558
559                 if (fw_asyreq(fwe->fd.fc, -1, xfer) != 0) {
560                         /* error */
561                         ifp->if_oerrors ++;
562                         /* XXX set error code */
563                         fwe_output_callback(xfer);
564                 } else {
565                         ifp->if_opackets ++;
566                         i++;
567                 }
568         }
569 #if 0
570         if (i > 1)
571                 printf("%d queued\n", i);
572 #endif
573         if (i > 0)
574                 xferq->start(fwe->fd.fc);
575 }
576
577 /* Async. stream output */
578 static void
579 fwe_as_input(struct fw_xferq *xferq)
580 {
581         struct mbuf *m, *m0;
582         struct ifnet *ifp;
583         struct fwe_softc *fwe;
584         struct fw_bulkxfer *sxfer;
585         struct fw_pkt *fp;
586         u_char *c;
587 #if defined(__DragonFly__) || __FreeBSD_version < 500000
588         struct ether_header *eh;
589 #endif
590
591         fwe = (struct fwe_softc *)xferq->sc;
592         ifp = &fwe->fwe_if;
593 #if 0
594         FWE_POLL_REGISTER(fwe_poll, fwe, ifp);
595 #endif
596         while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) {
597                 STAILQ_REMOVE_HEAD(&xferq->stvalid, link);
598                 fp = mtod(sxfer->mbuf, struct fw_pkt *);
599                 if (fwe->fd.fc->irx_post != NULL)
600                         fwe->fd.fc->irx_post(fwe->fd.fc, fp->mode.ld);
601                 m = sxfer->mbuf;
602
603                 /* insert new rbuf */
604                 sxfer->mbuf = m0 = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
605                 if (m0 != NULL) {
606                         m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
607                         STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
608                 } else
609                         printf("fwe_as_input: m_getcl failed\n");
610
611                 if (sxfer->resp != 0 || fp->mode.stream.len <
612                     ETHER_ALIGN + sizeof(struct ether_header)) {
613                         m_freem(m);
614                         ifp->if_ierrors ++;
615                         continue;
616                 }
617
618                 m->m_data += HDR_LEN + ETHER_ALIGN;
619                 c = mtod(m, char *);
620 #if defined(__DragonFly__) || __FreeBSD_version < 500000
621                 eh = (struct ether_header *)c;
622                 m->m_data += sizeof(struct ether_header);
623 #endif
624                 m->m_len = m->m_pkthdr.len =
625                                 fp->mode.stream.len - ETHER_ALIGN;
626                 m->m_pkthdr.rcvif = ifp;
627 #if 0
628                 FWEDEBUG(ifp, "%02x %02x %02x %02x %02x %02x\n"
629                          "%02x %02x %02x %02x %02x %02x\n"
630                          "%02x %02x %02x %02x\n"
631                          "%02x %02x %02x %02x\n"
632                          "%02x %02x %02x %02x\n"
633                          "%02x %02x %02x %02x\n",
634                          c[0], c[1], c[2], c[3], c[4], c[5],
635                          c[6], c[7], c[8], c[9], c[10], c[11],
636                          c[12], c[13], c[14], c[15],
637                          c[16], c[17], c[18], c[19],
638                          c[20], c[21], c[22], c[23],
639                          c[20], c[21], c[22], c[23]
640                  );
641 #endif
642 #if defined(__DragonFly__) || __FreeBSD_version < 500000
643                 ether_input(ifp, eh, m);
644 #else
645                 (*ifp->if_input)(ifp, m);
646 #endif
647                 ifp->if_ipackets ++;
648         }
649         if (STAILQ_FIRST(&xferq->stfree) != NULL)
650                 fwe->fd.fc->irx_enable(fwe->fd.fc, fwe->dma_ch);
651 }
652
653
654 static devclass_t fwe_devclass;
655
656 static device_method_t fwe_methods[] = {
657         /* device interface */
658         DEVMETHOD(device_identify,      fwe_identify),
659         DEVMETHOD(device_probe,         fwe_probe),
660         DEVMETHOD(device_attach,        fwe_attach),
661         DEVMETHOD(device_detach,        fwe_detach),
662         { 0, 0 }
663 };
664
665 static driver_t fwe_driver = {
666         "fwe",
667         fwe_methods,
668         sizeof(struct fwe_softc),
669 };
670
671
672 DECLARE_DUMMY_MODULE(fwe);
673 DRIVER_MODULE(fwe, firewire, fwe_driver, fwe_devclass, 0, 0);
674 MODULE_VERSION(fwe, 1);
675 MODULE_DEPEND(fwe, firewire, 1, 1, 1);