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