Make all network interrupt service routines MPSAFE part 1/3.
[dragonfly.git] / sys / dev / netif / fwe / if_fwe.c
CommitLineData
984263bc
MD
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 *
78748771 34 * $FreeBSD: src/sys/dev/firewire/if_fwe.c,v 1.27 2004/01/08 14:58:09 simokawa Exp $
78195a76 35 * $DragonFly: src/sys/dev/netif/fwe/if_fwe.c,v 1.23 2005/11/28 17:13:42 dillon Exp $
984263bc
MD
36 */
37
38#include "opt_inet.h"
2b71c8f1 39#include "opt_polling.h"
984263bc
MD
40
41#include <sys/param.h>
42#include <sys/conf.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>
07f992ed 52#include <sys/thread2.h>
984263bc
MD
53#include <machine/bus.h>
54
55#include <net/bpf.h>
56#include <net/ethernet.h>
57#include <net/if.h>
58#include <net/if_arp.h>
78748771 59#ifdef __DragonFly__
efa919fe 60#include <net/ifq_var.h>
1f2de5d4 61#include <net/vlan/if_vlan_var.h>
1f2de5d4
MD
62#include <bus/firewire/firewire.h>
63#include <bus/firewire/firewirereg.h>
64#include "if_fwevar.h"
78748771
JS
65#else
66#include <net/if_vlan_var.h>
67
68#include <dev/firewire/firewire.h>
69#include <dev/firewire/firewirereg.h>
70#include <dev/firewire/if_fwevar.h>
71#endif
984263bc 72
78748771 73#define FWEDEBUG if (fwedebug) if_printf
984263bc 74#define TX_MAX_QUEUE (FWMAXQUEUE - 1)
984263bc
MD
75
76/* network interface */
b5101a88 77static void fwe_start (struct ifnet *);
bd4539cc 78static int fwe_ioctl (struct ifnet *, u_long, caddr_t, struct ucred *);
b5101a88 79static void fwe_init (void *);
984263bc 80
b5101a88
RG
81static void fwe_output_callback (struct fw_xfer *);
82static void fwe_as_output (struct fwe_softc *, struct ifnet *);
83static void fwe_as_input (struct fw_xferq *);
984263bc
MD
84
85static int fwedebug = 0;
86static int stream_ch = 1;
78748771
JS
87static int tx_speed = 2;
88static int rx_queue_len = FWMAXQUEUE;
984263bc
MD
89
90MALLOC_DEFINE(M_FWE, "if_fwe", "Ethernet over FireWire interface");
91SYSCTL_INT(_debug, OID_AUTO, if_fwe_debug, CTLFLAG_RW, &fwedebug, 0, "");
92SYSCTL_DECL(_hw_firewire);
93SYSCTL_NODE(_hw_firewire, OID_AUTO, fwe, CTLFLAG_RD, 0,
78748771 94 "Ethernet emulation subsystem");
984263bc
MD
95SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, stream_ch, CTLFLAG_RW, &stream_ch, 0,
96 "Stream channel to use");
78748771
JS
97SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, tx_speed, CTLFLAG_RW, &tx_speed, 0,
98 "Transmission speed");
99SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, rx_queue_len, CTLFLAG_RW, &rx_queue_len,
100 0, "Length of the receive queue");
101
102TUNABLE_INT("hw.firewire.fwe.stream_ch", &stream_ch);
103TUNABLE_INT("hw.firewire.fwe.tx_speed", &tx_speed);
104TUNABLE_INT("hw.firewire.fwe.rx_queue_len", &rx_queue_len);
984263bc
MD
105
106#ifdef DEVICE_POLLING
984263bc
MD
107
108static void
109fwe_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
110{
111 struct fwe_softc *fwe;
112 struct firewire_comm *fc;
113
114 fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
115 fc = fwe->fd.fc;
9c095379
MD
116 switch(cmd) {
117 case POLL_REGISTER:
118 /* disable interrupts */
119 fc->set_intr(fc, 0);
120 break;
121 case POLL_DEREGISTER:
984263bc
MD
122 /* enable interrupts */
123 fc->set_intr(fc, 1);
9c095379
MD
124 break;
125 default:
126 fc->poll(fc, (cmd == POLL_AND_CHECK_STATUS)?0:1, count);
127 break;
984263bc 128 }
984263bc 129}
9c095379 130
984263bc 131#endif
9c095379 132
984263bc
MD
133static int
134fwe_probe(device_t dev)
135{
136 device_t pa;
137
138 pa = device_get_parent(dev);
139 if(device_get_unit(dev) != device_get_unit(pa)){
140 return(ENXIO);
141 }
142
143 device_set_desc(dev, "Ethernet over FireWire");
144 return (0);
145}
146
147static int
148fwe_attach(device_t dev)
149{
150 struct fwe_softc *fwe;
151 struct ifnet *ifp;
18618b5e 152 uint8_t eaddr[ETHER_ADDR_LEN];
984263bc
MD
153 struct fw_eui64 *eui;
154
155 fwe = ((struct fwe_softc *)device_get_softc(dev));
984263bc 156
984263bc
MD
157 /* XXX */
158 fwe->stream_ch = stream_ch;
159 fwe->dma_ch = -1;
160
161 fwe->fd.fc = device_get_ivars(dev);
78748771
JS
162 if (tx_speed < 0)
163 tx_speed = fwe->fd.fc->speed;
164
984263bc
MD
165 fwe->fd.dev = dev;
166 fwe->fd.post_explore = NULL;
167 fwe->eth_softc.fwe = fwe;
168
169 fwe->pkt_hdr.mode.stream.tcode = FWTCODE_STREAM;
170 fwe->pkt_hdr.mode.stream.sy = 0;
171 fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
172
173 /* generate fake MAC address: first and last 3bytes from eui64 */
174#define LOCAL (0x02)
175#define GROUP (0x01)
984263bc
MD
176
177 eui = &fwe->fd.fc->eui;
178 eaddr[0] = (FW_EUI64_BYTE(eui, 0) | LOCAL) & ~GROUP;
179 eaddr[1] = FW_EUI64_BYTE(eui, 1);
180 eaddr[2] = FW_EUI64_BYTE(eui, 2);
181 eaddr[3] = FW_EUI64_BYTE(eui, 5);
182 eaddr[4] = FW_EUI64_BYTE(eui, 6);
183 eaddr[5] = FW_EUI64_BYTE(eui, 7);
984263bc
MD
184
185 /* fill the rest and attach interface */
186 ifp = &fwe->fwe_if;
187 ifp->if_softc = &fwe->eth_softc;
188
18618b5e 189 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
984263bc 190 ifp->if_init = fwe_init;
984263bc
MD
191 ifp->if_start = fwe_start;
192 ifp->if_ioctl = fwe_ioctl;
ba924435 193 ifp->if_capabilities = IFCAP_VLAN_MTU;
9c095379
MD
194#ifdef DEVICE_POLLING
195 ifp->if_poll = fwe_poll;
196#endif
984263bc
MD
197 ifp->if_mtu = ETHERMTU;
198 ifp->if_flags = (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST);
efa919fe
JS
199 ifq_set_maxlen(&ifp->if_snd, TX_MAX_QUEUE);
200 ifq_set_ready(&ifp->if_snd);
984263bc 201
78195a76 202 ether_ifattach(ifp, eaddr, NULL);
984263bc
MD
203
204 /* Tell the upper layer(s) we support long frames. */
205 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
984263bc
MD
206
207
78748771 208 FWEDEBUG(ifp, "interface created\n");
984263bc
MD
209 return 0;
210}
211
212static void
213fwe_stop(struct fwe_softc *fwe)
214{
215 struct firewire_comm *fc;
216 struct fw_xferq *xferq;
217 struct ifnet *ifp = &fwe->fwe_if;
218 struct fw_xfer *xfer, *next;
219 int i;
220
221 fc = fwe->fd.fc;
222
9c095379 223 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
984263bc
MD
224
225 if (fwe->dma_ch >= 0) {
226 xferq = fc->ir[fwe->dma_ch];
227
228 if (xferq->flag & FWXFERQ_RUNNING)
229 fc->irx_disable(fc, fwe->dma_ch);
230 xferq->flag &=
231 ~(FWXFERQ_MODEMASK | FWXFERQ_OPEN | FWXFERQ_STREAM |
232 FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_CHTAGMASK);
233 xferq->hand = NULL;
234
235 for (i = 0; i < xferq->bnchunk; i ++)
236 m_freem(xferq->bulkxfer[i].mbuf);
237 free(xferq->bulkxfer, M_FWE);
238
239 for (xfer = STAILQ_FIRST(&fwe->xferlist); xfer != NULL;
240 xfer = next) {
241 next = STAILQ_NEXT(xfer, link);
242 fw_xfer_free(xfer);
243 }
244 STAILQ_INIT(&fwe->xferlist);
245
246 xferq->bulkxfer = NULL;
247 fwe->dma_ch = -1;
248 }
984263bc
MD
249}
250
251static int
252fwe_detach(device_t dev)
253{
07f992ed 254 struct fwe_softc *fwe = device_get_softc(dev);
984263bc 255
78195a76 256 lwkt_serialize_enter(fwe->fwe_if.if_serializer);
984263bc 257 fwe_stop(fwe);
90dec0df 258 ether_ifdetach(&fwe->fwe_if);
78195a76 259 lwkt_serialize_exit(fwe->fwe_if.if_serializer);
984263bc
MD
260 return 0;
261}
262
263static void
264fwe_init(void *arg)
265{
266 struct fwe_softc *fwe = ((struct fwe_eth_softc *)arg)->fwe;
267 struct firewire_comm *fc;
268 struct ifnet *ifp = &fwe->fwe_if;
269 struct fw_xferq *xferq;
270 struct fw_xfer *xfer;
271 struct mbuf *m;
272 int i;
273
78748771 274 FWEDEBUG(ifp, "initializing\n");
984263bc
MD
275
276 /* XXX keep promiscoud mode */
277 ifp->if_flags |= IFF_PROMISC;
278
279 fc = fwe->fd.fc;
280#define START 0
281 if (fwe->dma_ch < 0) {
984263bc
MD
282 for (i = START; i < fc->nisodma; i ++) {
283 xferq = fc->ir[i];
284 if ((xferq->flag & FWXFERQ_OPEN) == 0)
78748771 285 goto found;
984263bc 286 }
18618b5e 287 if_printf(ifp, "no free dma channel\n");
78748771
JS
288 return;
289found:
984263bc
MD
290 fwe->dma_ch = i;
291 fwe->stream_ch = stream_ch;
292 fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
293 /* allocate DMA channel and init packet mode */
294 xferq->flag |= FWXFERQ_OPEN | FWXFERQ_EXTBUF |
295 FWXFERQ_HANDLER | FWXFERQ_STREAM;
296 xferq->flag &= ~0xff;
297 xferq->flag |= fwe->stream_ch & 0xff;
298 /* register fwe_input handler */
299 xferq->sc = (caddr_t) fwe;
300 xferq->hand = fwe_as_input;
78748771 301 xferq->bnchunk = rx_queue_len;
984263bc
MD
302 xferq->bnpacket = 1;
303 xferq->psize = MCLBYTES;
304 xferq->queued = 0;
305 xferq->buf = NULL;
306 xferq->bulkxfer = (struct fw_bulkxfer *) malloc(
307 sizeof(struct fw_bulkxfer) * xferq->bnchunk,
308 M_FWE, M_WAITOK);
309 if (xferq->bulkxfer == NULL) {
18618b5e 310 if_printf(ifp, "malloc failed\n");
984263bc
MD
311 return;
312 }
313 STAILQ_INIT(&xferq->stvalid);
314 STAILQ_INIT(&xferq->stfree);
315 STAILQ_INIT(&xferq->stdma);
316 xferq->stproc = NULL;
317 for (i = 0; i < xferq->bnchunk; i ++) {
ba924435 318 m = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
984263bc
MD
319 xferq->bulkxfer[i].mbuf = m;
320 if (m != NULL) {
321 m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
322 STAILQ_INSERT_TAIL(&xferq->stfree,
323 &xferq->bulkxfer[i], link);
18618b5e
JS
324 } else {
325 if_printf(ifp, "fwe_init: m_getcl failed\n");
326 }
984263bc
MD
327 }
328 STAILQ_INIT(&fwe->xferlist);
329 for (i = 0; i < TX_MAX_QUEUE; i++) {
330 xfer = fw_xfer_alloc(M_FWE);
331 if (xfer == NULL)
332 break;
78748771 333 xfer->send.spd = tx_speed;
984263bc
MD
334 xfer->fc = fwe->fd.fc;
335 xfer->retry_req = fw_asybusy;
336 xfer->sc = (caddr_t)fwe;
337 xfer->act.hand = fwe_output_callback;
338 STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
339 }
340 } else
341 xferq = fc->ir[fwe->dma_ch];
342
343
344 /* start dma */
345 if ((xferq->flag & FWXFERQ_RUNNING) == 0)
346 fc->irx_enable(fc, fwe->dma_ch);
347
348 ifp->if_flags |= IFF_RUNNING;
349 ifp->if_flags &= ~IFF_OACTIVE;
984263bc
MD
350}
351
352
353static int
bd4539cc 354fwe_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
984263bc
MD
355{
356 struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
357 struct ifstat *ifs = NULL;
07f992ed
JS
358 int error = 0, len;
359
984263bc 360 switch (cmd) {
ba924435 361 case SIOCSIFFLAGS:
ba924435
JS
362 if (ifp->if_flags & IFF_UP) {
363 if (!(ifp->if_flags & IFF_RUNNING))
364 fwe_init(&fwe->eth_softc);
365 } else {
366 if (ifp->if_flags & IFF_RUNNING)
367 fwe_stop(fwe);
368 }
369 /* XXX keep promiscoud mode */
370 ifp->if_flags |= IFF_PROMISC;
ba924435
JS
371 break;
372 case SIOCADDMULTI:
373 case SIOCDELMULTI:
374 break;
375
376 case SIOCGIFSTATUS:
ba924435
JS
377 ifs = (struct ifstat *)data;
378 len = strlen(ifs->ascii);
379 if (len < sizeof(ifs->ascii))
380 snprintf(ifs->ascii + len,
381 sizeof(ifs->ascii) - len,
382 "\tch %d dma %d\n",
383 fwe->stream_ch, fwe->dma_ch);
ba924435
JS
384 break;
385 default:
ba924435 386 error = ether_ioctl(ifp, cmd, data);
07f992ed 387 break;
984263bc 388 }
07f992ed 389 return (error);
984263bc
MD
390}
391
392static void
393fwe_output_callback(struct fw_xfer *xfer)
394{
395 struct fwe_softc *fwe;
396 struct ifnet *ifp;
984263bc
MD
397
398 fwe = (struct fwe_softc *)xfer->sc;
399 ifp = &fwe->fwe_if;
78195a76 400 lwkt_serialize_enter(ifp->if_serializer);
984263bc 401 /* XXX error check */
78748771 402 FWEDEBUG(ifp, "resp = %d\n", xfer->resp);
984263bc
MD
403 if (xfer->resp != 0)
404 ifp->if_oerrors ++;
405
406 m_freem(xfer->mbuf);
984263bc
MD
407 fw_xfer_unload(xfer);
408
984263bc 409 STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
07f992ed 410
984263bc 411 /* for queue full */
efa919fe 412 if (!ifq_is_empty(&ifp->if_snd))
984263bc 413 fwe_start(ifp);
78195a76 414 lwkt_serialize_exit(ifp->if_serializer);
984263bc
MD
415}
416
417static void
418fwe_start(struct ifnet *ifp)
419{
420 struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
984263bc 421
78748771 422 FWEDEBUG(ifp, "starting\n");
984263bc
MD
423
424 if (fwe->dma_ch < 0) {
78748771 425 FWEDEBUG(ifp, "not ready\n");
984263bc 426
efa919fe 427 ifq_purge(&ifp->if_snd);
07f992ed
JS
428 } else {
429 ifp->if_flags |= IFF_OACTIVE;
984263bc 430
07f992ed
JS
431 if (!ifq_is_empty(&ifp->if_snd))
432 fwe_as_output(fwe, ifp);
984263bc 433
07f992ed
JS
434 ifp->if_flags &= ~IFF_OACTIVE;
435 }
984263bc
MD
436}
437
438#define HDR_LEN 4
439#ifndef ETHER_ALIGN
440#define ETHER_ALIGN 2
441#endif
442/* Async. stream output */
443static void
444fwe_as_output(struct fwe_softc *fwe, struct ifnet *ifp)
445{
446 struct mbuf *m;
447 struct fw_xfer *xfer;
448 struct fw_xferq *xferq;
449 struct fw_pkt *fp;
450 int i = 0;
451
452 xfer = NULL;
453 xferq = fwe->fd.fc->atq;
454 while (xferq->queued < xferq->maxq - 1) {
455 xfer = STAILQ_FIRST(&fwe->xferlist);
456 if (xfer == NULL) {
18618b5e 457 if_printf(ifp, "lack of xfer\n");
984263bc
MD
458 return;
459 }
d2c71fa0 460 m = ifq_dequeue(&ifp->if_snd, NULL);
984263bc
MD
461 if (m == NULL)
462 break;
463 STAILQ_REMOVE_HEAD(&fwe->xferlist, link);
90dec0df 464 BPF_MTAP(ifp, m);
984263bc
MD
465
466 /* keep ip packet alignment for alpha */
74f1caca 467 M_PREPEND(m, ETHER_ALIGN, MB_DONTWAIT);
78748771
JS
468 fp = &xfer->send.hdr;
469 *(u_int32_t *)&xfer->send.hdr = *(int32_t *)&fwe->pkt_hdr;
984263bc 470 fp->mode.stream.len = m->m_pkthdr.len;
984263bc 471 xfer->mbuf = m;
78748771 472 xfer->send.pay_len = m->m_pkthdr.len;
984263bc
MD
473
474 if (fw_asyreq(fwe->fd.fc, -1, xfer) != 0) {
475 /* error */
476 ifp->if_oerrors ++;
477 /* XXX set error code */
478 fwe_output_callback(xfer);
479 } else {
480 ifp->if_opackets ++;
481 i++;
482 }
483 }
484#if 0
485 if (i > 1)
18618b5e 486 if_printf(ifp, "%d queued\n", i);
984263bc
MD
487#endif
488 if (i > 0)
489 xferq->start(fwe->fd.fc);
490}
491
492/* Async. stream output */
493static void
494fwe_as_input(struct fw_xferq *xferq)
495{
496 struct mbuf *m, *m0;
497 struct ifnet *ifp;
498 struct fwe_softc *fwe;
499 struct fw_bulkxfer *sxfer;
500 struct fw_pkt *fp;
501 u_char *c;
984263bc
MD
502
503 fwe = (struct fwe_softc *)xferq->sc;
504 ifp = &fwe->fwe_if;
78195a76 505 lwkt_serialize_enter(ifp->if_serializer);
984263bc
MD
506 while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) {
507 STAILQ_REMOVE_HEAD(&xferq->stvalid, link);
984263bc 508 fp = mtod(sxfer->mbuf, struct fw_pkt *);
984263bc
MD
509 if (fwe->fd.fc->irx_post != NULL)
510 fwe->fd.fc->irx_post(fwe->fd.fc, fp->mode.ld);
511 m = sxfer->mbuf;
512
78748771 513 /* insert new rbuf */
74f1caca 514 sxfer->mbuf = m0 = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
984263bc
MD
515 if (m0 != NULL) {
516 m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
517 STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
18618b5e
JS
518 } else {
519 if_printf(ifp, "fwe_as_input: m_getcl failed\n");
520 }
984263bc 521
78748771
JS
522 if (sxfer->resp != 0 || fp->mode.stream.len <
523 ETHER_ALIGN + sizeof(struct ether_header)) {
524 m_freem(m);
525 ifp->if_ierrors ++;
526 continue;
527 }
528
984263bc
MD
529 m->m_data += HDR_LEN + ETHER_ALIGN;
530 c = mtod(m, char *);
984263bc
MD
531 m->m_len = m->m_pkthdr.len =
532 fp->mode.stream.len - ETHER_ALIGN;
533 m->m_pkthdr.rcvif = ifp;
534#if 0
78748771 535 FWEDEBUG(ifp, "%02x %02x %02x %02x %02x %02x\n"
984263bc
MD
536 "%02x %02x %02x %02x %02x %02x\n"
537 "%02x %02x %02x %02x\n"
538 "%02x %02x %02x %02x\n"
539 "%02x %02x %02x %02x\n"
540 "%02x %02x %02x %02x\n",
541 c[0], c[1], c[2], c[3], c[4], c[5],
542 c[6], c[7], c[8], c[9], c[10], c[11],
543 c[12], c[13], c[14], c[15],
544 c[16], c[17], c[18], c[19],
545 c[20], c[21], c[22], c[23],
546 c[20], c[21], c[22], c[23]
547 );
548#endif
78195a76 549 ifp->if_input(ifp, m);
984263bc
MD
550 ifp->if_ipackets ++;
551 }
552 if (STAILQ_FIRST(&xferq->stfree) != NULL)
553 fwe->fd.fc->irx_enable(fwe->fd.fc, fwe->dma_ch);
78195a76 554 lwkt_serialize_exit(ifp->if_serializer);
984263bc
MD
555}
556
557
558static devclass_t fwe_devclass;
559
39b5d600
MD
560/*
561 * Because fwe is a static device that always exists under any attached
562 * firewire device, and not scanned by the firewire device, we need an
563 * identify function to install the device.
564 */
984263bc
MD
565static device_method_t fwe_methods[] = {
566 /* device interface */
39b5d600 567 DEVMETHOD(device_identify, bus_generic_identify_sameunit),
984263bc
MD
568 DEVMETHOD(device_probe, fwe_probe),
569 DEVMETHOD(device_attach, fwe_attach),
570 DEVMETHOD(device_detach, fwe_detach),
571 { 0, 0 }
572};
573
574static driver_t fwe_driver = {
78748771 575 "fwe",
984263bc
MD
576 fwe_methods,
577 sizeof(struct fwe_softc),
578};
579
580
78748771
JS
581DECLARE_DUMMY_MODULE(fwe);
582DRIVER_MODULE(fwe, firewire, fwe_driver, fwe_devclass, 0, 0);
583MODULE_VERSION(fwe, 1);
584MODULE_DEPEND(fwe, firewire, 1, 1, 1);