xref: /freebsd/sys/dev/firewire/if_fwe.c (revision bb15ca603fa442c72dde3f3cb8b46db6970e3950)
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$
35  */
36 
37 #ifdef HAVE_KERNEL_OPTION_HEADERS
38 #include "opt_device_polling.h"
39 #include "opt_inet.h"
40 #endif
41 
42 #include <sys/param.h>
43 #include <sys/kernel.h>
44 #include <sys/malloc.h>
45 #include <sys/mbuf.h>
46 #include <sys/socket.h>
47 #include <sys/sockio.h>
48 #include <sys/sysctl.h>
49 #include <sys/systm.h>
50 #include <sys/module.h>
51 #include <sys/bus.h>
52 #include <machine/bus.h>
53 
54 #include <net/bpf.h>
55 #include <net/ethernet.h>
56 #include <net/if.h>
57 #include <net/if_arp.h>
58 #include <net/if_types.h>
59 #ifdef __DragonFly__
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);
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 static MALLOC_DEFINE(M_FWE, "if_fwe", "Ethernet over FireWire interface");
90 SYSCTL_INT(_debug, OID_AUTO, if_fwe_debug, CTLFLAG_RW, &fwedebug, 0, "");
91 SYSCTL_DECL(_hw_firewire);
92 static SYSCTL_NODE(_hw_firewire, OID_AUTO, fwe, CTLFLAG_RD, 0,
93 	"Ethernet emulation subsystem");
94 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, stream_ch, CTLFLAG_RW, &stream_ch, 0,
95 	"Stream channel to use");
96 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, tx_speed, CTLFLAG_RW, &tx_speed, 0,
97 	"Transmission speed");
98 SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, rx_queue_len, CTLFLAG_RW, &rx_queue_len,
99 	0, "Length of the receive queue");
100 
101 TUNABLE_INT("hw.firewire.fwe.stream_ch", &stream_ch);
102 TUNABLE_INT("hw.firewire.fwe.tx_speed", &tx_speed);
103 TUNABLE_INT("hw.firewire.fwe.rx_queue_len", &rx_queue_len);
104 
105 #ifdef DEVICE_POLLING
106 static poll_handler_t fwe_poll;
107 
108 static int
109 fwe_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
110 {
111 	struct fwe_softc *fwe;
112 	struct firewire_comm *fc;
113 
114 	if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
115 		return (0);
116 
117 	fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
118 	fc = fwe->fd.fc;
119 	fc->poll(fc, (cmd == POLL_AND_CHECK_STATUS)?0:1, count);
120 	return (0);
121 }
122 #endif /* DEVICE_POLLING */
123 
124 static void
125 fwe_identify(driver_t *driver, device_t parent)
126 {
127 	BUS_ADD_CHILD(parent, 0, "fwe", device_get_unit(parent));
128 }
129 
130 static int
131 fwe_probe(device_t dev)
132 {
133 	device_t pa;
134 
135 	pa = device_get_parent(dev);
136 	if(device_get_unit(dev) != device_get_unit(pa)){
137 		return(ENXIO);
138 	}
139 
140 	device_set_desc(dev, "Ethernet over FireWire");
141 	return (0);
142 }
143 
144 static int
145 fwe_attach(device_t dev)
146 {
147 	struct fwe_softc *fwe;
148 	struct ifnet *ifp;
149 	int unit, s;
150 #if defined(__DragonFly__) || __FreeBSD_version < 500000
151 	u_char *eaddr;
152 #else
153 	u_char eaddr[6];
154 #endif
155 	struct fw_eui64 *eui;
156 
157 	fwe = ((struct fwe_softc *)device_get_softc(dev));
158 	unit = device_get_unit(dev);
159 
160 	bzero(fwe, sizeof(struct fwe_softc));
161 	mtx_init(&fwe->mtx, "fwe", NULL, MTX_DEF);
162 	/* XXX */
163 	fwe->stream_ch = stream_ch;
164 	fwe->dma_ch = -1;
165 
166 	fwe->fd.fc = device_get_ivars(dev);
167 	if (tx_speed < 0)
168 		tx_speed = fwe->fd.fc->speed;
169 
170 	fwe->fd.dev = dev;
171 	fwe->fd.post_explore = NULL;
172 	fwe->eth_softc.fwe = fwe;
173 
174 	fwe->pkt_hdr.mode.stream.tcode = FWTCODE_STREAM;
175 	fwe->pkt_hdr.mode.stream.sy = 0;
176 	fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
177 
178 	/* generate fake MAC address: first and last 3bytes from eui64 */
179 #define LOCAL (0x02)
180 #define GROUP (0x01)
181 #if defined(__DragonFly__) || __FreeBSD_version < 500000
182 	eaddr = &IFP2ENADDR(fwe->eth_softc.ifp)[0];
183 #endif
184 
185 
186 	eui = &fwe->fd.fc->eui;
187 	eaddr[0] = (FW_EUI64_BYTE(eui, 0) | LOCAL) & ~GROUP;
188 	eaddr[1] = FW_EUI64_BYTE(eui, 1);
189 	eaddr[2] = FW_EUI64_BYTE(eui, 2);
190 	eaddr[3] = FW_EUI64_BYTE(eui, 5);
191 	eaddr[4] = FW_EUI64_BYTE(eui, 6);
192 	eaddr[5] = FW_EUI64_BYTE(eui, 7);
193 	printf("if_fwe%d: Fake Ethernet address: "
194 		"%02x:%02x:%02x:%02x:%02x:%02x\n", unit,
195 		eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]);
196 
197 	/* fill the rest and attach interface */
198 	ifp = fwe->eth_softc.ifp = if_alloc(IFT_ETHER);
199 	if (ifp == NULL) {
200 		device_printf(dev, "can not if_alloc()\n");
201 		return (ENOSPC);
202 	}
203 	ifp->if_softc = &fwe->eth_softc;
204 
205 #if __FreeBSD_version >= 501113 || defined(__DragonFly__)
206 	if_initname(ifp, device_get_name(dev), unit);
207 #else
208 	ifp->if_unit = unit;
209 	ifp->if_name = "fwe";
210 #endif
211 	ifp->if_init = fwe_init;
212 #if defined(__DragonFly__) || __FreeBSD_version < 500000
213 	ifp->if_output = ether_output;
214 #endif
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 | IFCAP_POLLING;
233 	ifp->if_capenable |= IFCAP_VLAN_MTU;
234 #endif
235 
236 
237 	FWEDEBUG(ifp, "interface created\n");
238 	return 0;
239 }
240 
241 static void
242 fwe_stop(struct fwe_softc *fwe)
243 {
244 	struct firewire_comm *fc;
245 	struct fw_xferq *xferq;
246 	struct ifnet *ifp = fwe->eth_softc.ifp;
247 	struct fw_xfer *xfer, *next;
248 	int i;
249 
250 	fc = fwe->fd.fc;
251 
252 	if (fwe->dma_ch >= 0) {
253 		xferq = fc->ir[fwe->dma_ch];
254 
255 		if (xferq->flag & FWXFERQ_RUNNING)
256 			fc->irx_disable(fc, fwe->dma_ch);
257 		xferq->flag &=
258 			~(FWXFERQ_MODEMASK | FWXFERQ_OPEN | FWXFERQ_STREAM |
259 			FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_CHTAGMASK);
260 		xferq->hand =  NULL;
261 
262 		for (i = 0; i < xferq->bnchunk; i ++)
263 			m_freem(xferq->bulkxfer[i].mbuf);
264 		free(xferq->bulkxfer, M_FWE);
265 
266 		for (xfer = STAILQ_FIRST(&fwe->xferlist); xfer != NULL;
267 					xfer = next) {
268 			next = STAILQ_NEXT(xfer, link);
269 			fw_xfer_free(xfer);
270 		}
271 		STAILQ_INIT(&fwe->xferlist);
272 
273 		xferq->bulkxfer =  NULL;
274 		fwe->dma_ch = -1;
275 	}
276 
277 #if defined(__FreeBSD__)
278 	ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
279 #else
280 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
281 #endif
282 }
283 
284 static int
285 fwe_detach(device_t dev)
286 {
287 	struct fwe_softc *fwe;
288 	struct ifnet *ifp;
289 	int s;
290 
291 	fwe = device_get_softc(dev);
292 	ifp = fwe->eth_softc.ifp;
293 
294 #ifdef DEVICE_POLLING
295 	if (ifp->if_capenable & IFCAP_POLLING)
296 		ether_poll_deregister(ifp);
297 #endif
298 	s = splimp();
299 
300 	fwe_stop(fwe);
301 #if defined(__DragonFly__) || __FreeBSD_version < 500000
302 	ether_ifdetach(ifp, 1);
303 #else
304 	ether_ifdetach(ifp);
305 	if_free(ifp);
306 #endif
307 
308 	splx(s);
309 	mtx_destroy(&fwe->mtx);
310 	return 0;
311 }
312 
313 static void
314 fwe_init(void *arg)
315 {
316 	struct fwe_softc *fwe = ((struct fwe_eth_softc *)arg)->fwe;
317 	struct firewire_comm *fc;
318 	struct ifnet *ifp = fwe->eth_softc.ifp;
319 	struct fw_xferq *xferq;
320 	struct fw_xfer *xfer;
321 	struct mbuf *m;
322 	int i;
323 
324 	FWEDEBUG(ifp, "initializing\n");
325 
326 	/* XXX keep promiscoud mode */
327 	ifp->if_flags |= IFF_PROMISC;
328 
329 	fc = fwe->fd.fc;
330 	if (fwe->dma_ch < 0) {
331 		fwe->dma_ch = fw_open_isodma(fc, /* tx */0);
332 		if (fwe->dma_ch < 0)
333 			return;
334 		xferq = fc->ir[fwe->dma_ch];
335 		xferq->flag |= FWXFERQ_EXTBUF |
336 				FWXFERQ_HANDLER | FWXFERQ_STREAM;
337 		fwe->stream_ch = stream_ch;
338 		fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
339 		xferq->flag &= ~0xff;
340 		xferq->flag |= fwe->stream_ch & 0xff;
341 		/* register fwe_input handler */
342 		xferq->sc = (caddr_t) fwe;
343 		xferq->hand = fwe_as_input;
344 		xferq->bnchunk = rx_queue_len;
345 		xferq->bnpacket = 1;
346 		xferq->psize = MCLBYTES;
347 		xferq->queued = 0;
348 		xferq->buf = NULL;
349 		xferq->bulkxfer = (struct fw_bulkxfer *) malloc(
350 			sizeof(struct fw_bulkxfer) * xferq->bnchunk,
351 							M_FWE, M_WAITOK);
352 		if (xferq->bulkxfer == NULL) {
353 			printf("if_fwe: malloc failed\n");
354 			return;
355 		}
356 		STAILQ_INIT(&xferq->stvalid);
357 		STAILQ_INIT(&xferq->stfree);
358 		STAILQ_INIT(&xferq->stdma);
359 		xferq->stproc = NULL;
360 		for (i = 0; i < xferq->bnchunk; i ++) {
361 			m = m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
362 			xferq->bulkxfer[i].mbuf = m;
363 			m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
364 			STAILQ_INSERT_TAIL(&xferq->stfree,
365 					&xferq->bulkxfer[i], link);
366 		}
367 		STAILQ_INIT(&fwe->xferlist);
368 		for (i = 0; i < TX_MAX_QUEUE; i++) {
369 			xfer = fw_xfer_alloc(M_FWE);
370 			if (xfer == NULL)
371 				break;
372 			xfer->send.spd = tx_speed;
373 			xfer->fc = fwe->fd.fc;
374 			xfer->sc = (caddr_t)fwe;
375 			xfer->hand = fwe_output_callback;
376 			STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
377 		}
378 	} else
379 		xferq = fc->ir[fwe->dma_ch];
380 
381 
382 	/* start dma */
383 	if ((xferq->flag & FWXFERQ_RUNNING) == 0)
384 		fc->irx_enable(fc, fwe->dma_ch);
385 
386 #if defined(__FreeBSD__)
387 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
388 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
389 #else
390 	ifp->if_flags |= IFF_RUNNING;
391 	ifp->if_flags &= ~IFF_OACTIVE;
392 #endif
393 
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 defined(__FreeBSD__)
413 				if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
414 #else
415 				if (!(ifp->if_flags & IFF_RUNNING))
416 #endif
417 					fwe_init(&fwe->eth_softc);
418 			} else {
419 #if defined(__FreeBSD__)
420 				if (ifp->if_drv_flags & IFF_DRV_RUNNING)
421 #else
422 				if (ifp->if_flags & IFF_RUNNING)
423 #endif
424 					fwe_stop(fwe);
425 			}
426 			/* XXX keep promiscoud mode */
427 			ifp->if_flags |= IFF_PROMISC;
428 			splx(s);
429 			break;
430 		case SIOCADDMULTI:
431 		case SIOCDELMULTI:
432 			break;
433 
434 		case SIOCGIFSTATUS:
435 			s = splimp();
436 			ifs = (struct ifstat *)data;
437 			len = strlen(ifs->ascii);
438 			if (len < sizeof(ifs->ascii))
439 				snprintf(ifs->ascii + len,
440 					sizeof(ifs->ascii) - len,
441 					"\tch %d dma %d\n",
442 						fwe->stream_ch, fwe->dma_ch);
443 			splx(s);
444 			break;
445 		case SIOCSIFCAP:
446 #ifdef DEVICE_POLLING
447 		    {
448 			struct ifreq *ifr = (struct ifreq *) data;
449 			struct firewire_comm *fc = fwe->fd.fc;
450 
451 			if (ifr->ifr_reqcap & IFCAP_POLLING &&
452 			    !(ifp->if_capenable & IFCAP_POLLING)) {
453 				error = ether_poll_register(fwe_poll, ifp);
454 				if (error)
455 					return(error);
456 				/* Disable interrupts */
457 				fc->set_intr(fc, 0);
458 				ifp->if_capenable |= IFCAP_POLLING;
459 				ifp->if_capenable |= IFCAP_POLLING_NOCOUNT;
460 				return (error);
461 			}
462 			if (!(ifr->ifr_reqcap & IFCAP_POLLING) &&
463 			    ifp->if_capenable & IFCAP_POLLING) {
464 				error = ether_poll_deregister(ifp);
465 				/* Enable interrupts. */
466 				fc->set_intr(fc, 1);
467 				ifp->if_capenable &= ~IFCAP_POLLING;
468 				ifp->if_capenable &= ~IFCAP_POLLING_NOCOUNT;
469 				return (error);
470 			}
471 		    }
472 #endif /* DEVICE_POLLING */
473 			break;
474 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
475 		default:
476 #else
477 		case SIOCSIFADDR:
478 		case SIOCGIFADDR:
479 		case SIOCSIFMTU:
480 #endif
481 			s = splimp();
482 			error = ether_ioctl(ifp, cmd, data);
483 			splx(s);
484 			return (error);
485 #if defined(__DragonFly__) || __FreeBSD_version < 500000
486 		default:
487 			return (EINVAL);
488 #endif
489 	}
490 
491 	return (0);
492 }
493 
494 static void
495 fwe_output_callback(struct fw_xfer *xfer)
496 {
497 	struct fwe_softc *fwe;
498 	struct ifnet *ifp;
499 	int s;
500 
501 	fwe = (struct fwe_softc *)xfer->sc;
502 	ifp = fwe->eth_softc.ifp;
503 	/* XXX error check */
504 	FWEDEBUG(ifp, "resp = %d\n", xfer->resp);
505 	if (xfer->resp != 0)
506 		ifp->if_oerrors ++;
507 
508 	m_freem(xfer->mbuf);
509 	fw_xfer_unload(xfer);
510 
511 	s = splimp();
512 	FWE_LOCK(fwe);
513 	STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
514 	FWE_UNLOCK(fwe);
515 	splx(s);
516 
517 	/* for queue full */
518 	if (ifp->if_snd.ifq_head != NULL)
519 		fwe_start(ifp);
520 }
521 
522 static void
523 fwe_start(struct ifnet *ifp)
524 {
525 	struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
526 	int s;
527 
528 	FWEDEBUG(ifp, "starting\n");
529 
530 	if (fwe->dma_ch < 0) {
531 		struct mbuf	*m = NULL;
532 
533 		FWEDEBUG(ifp, "not ready\n");
534 
535 		s = splimp();
536 		do {
537 			IF_DEQUEUE(&ifp->if_snd, m);
538 			if (m != NULL)
539 				m_freem(m);
540 			ifp->if_oerrors ++;
541 		} while (m != NULL);
542 		splx(s);
543 
544 		return;
545 	}
546 
547 	s = splimp();
548 #if defined(__FreeBSD__)
549 	ifp->if_drv_flags |= IFF_DRV_OACTIVE;
550 #else
551 	ifp->if_flags |= IFF_OACTIVE;
552 #endif
553 
554 	if (ifp->if_snd.ifq_len != 0)
555 		fwe_as_output(fwe, ifp);
556 
557 #if defined(__FreeBSD__)
558 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
559 #else
560 	ifp->if_flags &= ~IFF_OACTIVE;
561 #endif
562 	splx(s);
563 }
564 
565 #define HDR_LEN 4
566 #ifndef ETHER_ALIGN
567 #define ETHER_ALIGN 2
568 #endif
569 /* Async. stream output */
570 static void
571 fwe_as_output(struct fwe_softc *fwe, struct ifnet *ifp)
572 {
573 	struct mbuf *m;
574 	struct fw_xfer *xfer;
575 	struct fw_xferq *xferq;
576 	struct fw_pkt *fp;
577 	int i = 0;
578 
579 	xfer = NULL;
580 	xferq = fwe->fd.fc->atq;
581 	while ((xferq->queued < xferq->maxq - 1) &&
582 			(ifp->if_snd.ifq_head != NULL)) {
583 		FWE_LOCK(fwe);
584 		xfer = STAILQ_FIRST(&fwe->xferlist);
585 		if (xfer == NULL) {
586 #if 0
587 			printf("if_fwe: lack of xfer\n");
588 #endif
589 			FWE_UNLOCK(fwe);
590 			break;
591 		}
592 		STAILQ_REMOVE_HEAD(&fwe->xferlist, link);
593 		FWE_UNLOCK(fwe);
594 
595 		IF_DEQUEUE(&ifp->if_snd, m);
596 		if (m == NULL) {
597 			FWE_LOCK(fwe);
598 			STAILQ_INSERT_HEAD(&fwe->xferlist, xfer, link);
599 			FWE_UNLOCK(fwe);
600 			break;
601 		}
602 #if defined(__DragonFly__) || __FreeBSD_version < 500000
603 		if (ifp->if_bpf != NULL)
604 			bpf_mtap(ifp, m);
605 #else
606 		BPF_MTAP(ifp, m);
607 #endif
608 
609 		/* keep ip packet alignment for alpha */
610 		M_PREPEND(m, ETHER_ALIGN, M_DONTWAIT);
611 		fp = &xfer->send.hdr;
612 		*(uint32_t *)&xfer->send.hdr = *(int32_t *)&fwe->pkt_hdr;
613 		fp->mode.stream.len = m->m_pkthdr.len;
614 		xfer->mbuf = m;
615 		xfer->send.pay_len = m->m_pkthdr.len;
616 
617 		if (fw_asyreq(fwe->fd.fc, -1, xfer) != 0) {
618 			/* error */
619 			ifp->if_oerrors ++;
620 			/* XXX set error code */
621 			fwe_output_callback(xfer);
622 		} else {
623 			ifp->if_opackets ++;
624 			i++;
625 		}
626 	}
627 #if 0
628 	if (i > 1)
629 		printf("%d queued\n", i);
630 #endif
631 	if (i > 0)
632 		xferq->start(fwe->fd.fc);
633 }
634 
635 /* Async. stream output */
636 static void
637 fwe_as_input(struct fw_xferq *xferq)
638 {
639 	struct mbuf *m, *m0;
640 	struct ifnet *ifp;
641 	struct fwe_softc *fwe;
642 	struct fw_bulkxfer *sxfer;
643 	struct fw_pkt *fp;
644 	u_char *c;
645 #if defined(__DragonFly__) || __FreeBSD_version < 500000
646 	struct ether_header *eh;
647 #endif
648 
649 	fwe = (struct fwe_softc *)xferq->sc;
650 	ifp = fwe->eth_softc.ifp;
651 
652 	/* We do not need a lock here because the bottom half is serialized */
653 	while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) {
654 		STAILQ_REMOVE_HEAD(&xferq->stvalid, link);
655 		fp = mtod(sxfer->mbuf, struct fw_pkt *);
656 		if (fwe->fd.fc->irx_post != NULL)
657 			fwe->fd.fc->irx_post(fwe->fd.fc, fp->mode.ld);
658 		m = sxfer->mbuf;
659 
660 		/* insert new rbuf */
661 		sxfer->mbuf = m0 = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
662 		if (m0 != NULL) {
663 			m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
664 			STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
665 		} else
666 			printf("%s: m_getcl failed\n", __FUNCTION__);
667 
668 		if (sxfer->resp != 0 || fp->mode.stream.len <
669 		    ETHER_ALIGN + sizeof(struct ether_header)) {
670 			m_freem(m);
671 			ifp->if_ierrors ++;
672 			continue;
673 		}
674 
675 		m->m_data += HDR_LEN + ETHER_ALIGN;
676 		c = mtod(m, u_char *);
677 #if defined(__DragonFly__) || __FreeBSD_version < 500000
678 		eh = (struct ether_header *)c;
679 		m->m_data += sizeof(struct ether_header);
680 		m->m_len = m->m_pkthdr.len = fp->mode.stream.len - ETHER_ALIGN
681 		    - sizeof(struct ether_header);
682 #else
683 		m->m_len = m->m_pkthdr.len = fp->mode.stream.len - ETHER_ALIGN;
684 #endif
685 		m->m_pkthdr.rcvif = ifp;
686 #if 0
687 		FWEDEBUG(ifp, "%02x %02x %02x %02x %02x %02x\n"
688 			 "%02x %02x %02x %02x %02x %02x\n"
689 			 "%02x %02x %02x %02x\n"
690 			 "%02x %02x %02x %02x\n"
691 			 "%02x %02x %02x %02x\n"
692 			 "%02x %02x %02x %02x\n",
693 			 c[0], c[1], c[2], c[3], c[4], c[5],
694 			 c[6], c[7], c[8], c[9], c[10], c[11],
695 			 c[12], c[13], c[14], c[15],
696 			 c[16], c[17], c[18], c[19],
697 			 c[20], c[21], c[22], c[23],
698 			 c[20], c[21], c[22], c[23]
699 		 );
700 #endif
701 #if defined(__DragonFly__) || __FreeBSD_version < 500000
702 		ether_input(ifp, eh, m);
703 #else
704 		(*ifp->if_input)(ifp, m);
705 #endif
706 		ifp->if_ipackets ++;
707 	}
708 	if (STAILQ_FIRST(&xferq->stfree) != NULL)
709 		fwe->fd.fc->irx_enable(fwe->fd.fc, fwe->dma_ch);
710 }
711 
712 
713 static devclass_t fwe_devclass;
714 
715 static device_method_t fwe_methods[] = {
716 	/* device interface */
717 	DEVMETHOD(device_identify,	fwe_identify),
718 	DEVMETHOD(device_probe,		fwe_probe),
719 	DEVMETHOD(device_attach,	fwe_attach),
720 	DEVMETHOD(device_detach,	fwe_detach),
721 	{ 0, 0 }
722 };
723 
724 static driver_t fwe_driver = {
725         "fwe",
726 	fwe_methods,
727 	sizeof(struct fwe_softc),
728 };
729 
730 
731 #ifdef __DragonFly__
732 DECLARE_DUMMY_MODULE(fwe);
733 #endif
734 DRIVER_MODULE(fwe, firewire, fwe_driver, fwe_devclass, 0, 0);
735 MODULE_VERSION(fwe, 1);
736 MODULE_DEPEND(fwe, firewire, 1, 1, 1);
737