Cleanup some of the newbus infrastructure.
[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 $
39b5d600 35 * $DragonFly: src/sys/dev/netif/fwe/if_fwe.c,v 1.21 2005/10/28 03:25:53 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
90dec0df 202 ether_ifattach(ifp, eaddr);
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
07f992ed 256 crit_enter();
984263bc
MD
257
258 fwe_stop(fwe);
90dec0df 259 ether_ifdetach(&fwe->fwe_if);
984263bc 260
07f992ed 261 crit_exit();
984263bc
MD
262 return 0;
263}
264
265static void
266fwe_init(void *arg)
267{
268 struct fwe_softc *fwe = ((struct fwe_eth_softc *)arg)->fwe;
269 struct firewire_comm *fc;
270 struct ifnet *ifp = &fwe->fwe_if;
271 struct fw_xferq *xferq;
272 struct fw_xfer *xfer;
273 struct mbuf *m;
274 int i;
275
78748771 276 FWEDEBUG(ifp, "initializing\n");
984263bc
MD
277
278 /* XXX keep promiscoud mode */
279 ifp->if_flags |= IFF_PROMISC;
280
281 fc = fwe->fd.fc;
282#define START 0
283 if (fwe->dma_ch < 0) {
984263bc
MD
284 for (i = START; i < fc->nisodma; i ++) {
285 xferq = fc->ir[i];
286 if ((xferq->flag & FWXFERQ_OPEN) == 0)
78748771 287 goto found;
984263bc 288 }
18618b5e 289 if_printf(ifp, "no free dma channel\n");
78748771
JS
290 return;
291found:
984263bc
MD
292 fwe->dma_ch = i;
293 fwe->stream_ch = stream_ch;
294 fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch;
295 /* allocate DMA channel and init packet mode */
296 xferq->flag |= FWXFERQ_OPEN | FWXFERQ_EXTBUF |
297 FWXFERQ_HANDLER | FWXFERQ_STREAM;
298 xferq->flag &= ~0xff;
299 xferq->flag |= fwe->stream_ch & 0xff;
300 /* register fwe_input handler */
301 xferq->sc = (caddr_t) fwe;
302 xferq->hand = fwe_as_input;
78748771 303 xferq->bnchunk = rx_queue_len;
984263bc
MD
304 xferq->bnpacket = 1;
305 xferq->psize = MCLBYTES;
306 xferq->queued = 0;
307 xferq->buf = NULL;
308 xferq->bulkxfer = (struct fw_bulkxfer *) malloc(
309 sizeof(struct fw_bulkxfer) * xferq->bnchunk,
310 M_FWE, M_WAITOK);
311 if (xferq->bulkxfer == NULL) {
18618b5e 312 if_printf(ifp, "malloc failed\n");
984263bc
MD
313 return;
314 }
315 STAILQ_INIT(&xferq->stvalid);
316 STAILQ_INIT(&xferq->stfree);
317 STAILQ_INIT(&xferq->stdma);
318 xferq->stproc = NULL;
319 for (i = 0; i < xferq->bnchunk; i ++) {
ba924435 320 m = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
984263bc
MD
321 xferq->bulkxfer[i].mbuf = m;
322 if (m != NULL) {
323 m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
324 STAILQ_INSERT_TAIL(&xferq->stfree,
325 &xferq->bulkxfer[i], link);
18618b5e
JS
326 } else {
327 if_printf(ifp, "fwe_init: m_getcl failed\n");
328 }
984263bc
MD
329 }
330 STAILQ_INIT(&fwe->xferlist);
331 for (i = 0; i < TX_MAX_QUEUE; i++) {
332 xfer = fw_xfer_alloc(M_FWE);
333 if (xfer == NULL)
334 break;
78748771 335 xfer->send.spd = tx_speed;
984263bc
MD
336 xfer->fc = fwe->fd.fc;
337 xfer->retry_req = fw_asybusy;
338 xfer->sc = (caddr_t)fwe;
339 xfer->act.hand = fwe_output_callback;
340 STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
341 }
342 } else
343 xferq = fc->ir[fwe->dma_ch];
344
345
346 /* start dma */
347 if ((xferq->flag & FWXFERQ_RUNNING) == 0)
348 fc->irx_enable(fc, fwe->dma_ch);
349
350 ifp->if_flags |= IFF_RUNNING;
351 ifp->if_flags &= ~IFF_OACTIVE;
984263bc
MD
352}
353
354
355static int
bd4539cc 356fwe_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
984263bc
MD
357{
358 struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
359 struct ifstat *ifs = NULL;
07f992ed
JS
360 int error = 0, len;
361
362 crit_enter();
984263bc
MD
363
364 switch (cmd) {
ba924435 365 case SIOCSIFFLAGS:
ba924435
JS
366 if (ifp->if_flags & IFF_UP) {
367 if (!(ifp->if_flags & IFF_RUNNING))
368 fwe_init(&fwe->eth_softc);
369 } else {
370 if (ifp->if_flags & IFF_RUNNING)
371 fwe_stop(fwe);
372 }
373 /* XXX keep promiscoud mode */
374 ifp->if_flags |= IFF_PROMISC;
ba924435
JS
375 break;
376 case SIOCADDMULTI:
377 case SIOCDELMULTI:
378 break;
379
380 case SIOCGIFSTATUS:
ba924435
JS
381 ifs = (struct ifstat *)data;
382 len = strlen(ifs->ascii);
383 if (len < sizeof(ifs->ascii))
384 snprintf(ifs->ascii + len,
385 sizeof(ifs->ascii) - len,
386 "\tch %d dma %d\n",
387 fwe->stream_ch, fwe->dma_ch);
ba924435
JS
388 break;
389 default:
ba924435 390 error = ether_ioctl(ifp, cmd, data);
07f992ed 391 break;
984263bc
MD
392 }
393
07f992ed
JS
394 crit_exit();
395
396 return (error);
984263bc
MD
397}
398
399static void
400fwe_output_callback(struct fw_xfer *xfer)
401{
402 struct fwe_softc *fwe;
403 struct ifnet *ifp;
984263bc
MD
404
405 fwe = (struct fwe_softc *)xfer->sc;
406 ifp = &fwe->fwe_if;
407 /* XXX error check */
78748771 408 FWEDEBUG(ifp, "resp = %d\n", xfer->resp);
984263bc
MD
409 if (xfer->resp != 0)
410 ifp->if_oerrors ++;
411
412 m_freem(xfer->mbuf);
984263bc
MD
413 fw_xfer_unload(xfer);
414
07f992ed
JS
415 crit_enter();
416
984263bc 417 STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link);
07f992ed
JS
418
419 crit_exit();
984263bc
MD
420
421 /* for queue full */
efa919fe 422 if (!ifq_is_empty(&ifp->if_snd))
984263bc
MD
423 fwe_start(ifp);
424}
425
426static void
427fwe_start(struct ifnet *ifp)
428{
429 struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe;
984263bc 430
78748771 431 FWEDEBUG(ifp, "starting\n");
984263bc 432
07f992ed
JS
433 crit_enter();
434
984263bc 435 if (fwe->dma_ch < 0) {
78748771 436 FWEDEBUG(ifp, "not ready\n");
984263bc 437
efa919fe 438 ifq_purge(&ifp->if_snd);
07f992ed
JS
439 } else {
440 ifp->if_flags |= IFF_OACTIVE;
984263bc 441
07f992ed
JS
442 if (!ifq_is_empty(&ifp->if_snd))
443 fwe_as_output(fwe, ifp);
984263bc 444
07f992ed
JS
445 ifp->if_flags &= ~IFF_OACTIVE;
446 }
984263bc 447
07f992ed 448 crit_exit();
984263bc
MD
449}
450
451#define HDR_LEN 4
452#ifndef ETHER_ALIGN
453#define ETHER_ALIGN 2
454#endif
455/* Async. stream output */
456static void
457fwe_as_output(struct fwe_softc *fwe, struct ifnet *ifp)
458{
459 struct mbuf *m;
460 struct fw_xfer *xfer;
461 struct fw_xferq *xferq;
462 struct fw_pkt *fp;
463 int i = 0;
464
465 xfer = NULL;
466 xferq = fwe->fd.fc->atq;
467 while (xferq->queued < xferq->maxq - 1) {
468 xfer = STAILQ_FIRST(&fwe->xferlist);
469 if (xfer == NULL) {
18618b5e 470 if_printf(ifp, "lack of xfer\n");
984263bc
MD
471 return;
472 }
efa919fe 473 m = ifq_dequeue(&ifp->if_snd);
984263bc
MD
474 if (m == NULL)
475 break;
476 STAILQ_REMOVE_HEAD(&fwe->xferlist, link);
90dec0df 477 BPF_MTAP(ifp, m);
984263bc
MD
478
479 /* keep ip packet alignment for alpha */
74f1caca 480 M_PREPEND(m, ETHER_ALIGN, MB_DONTWAIT);
78748771
JS
481 fp = &xfer->send.hdr;
482 *(u_int32_t *)&xfer->send.hdr = *(int32_t *)&fwe->pkt_hdr;
984263bc 483 fp->mode.stream.len = m->m_pkthdr.len;
984263bc 484 xfer->mbuf = m;
78748771 485 xfer->send.pay_len = m->m_pkthdr.len;
984263bc
MD
486
487 if (fw_asyreq(fwe->fd.fc, -1, xfer) != 0) {
488 /* error */
489 ifp->if_oerrors ++;
490 /* XXX set error code */
491 fwe_output_callback(xfer);
492 } else {
493 ifp->if_opackets ++;
494 i++;
495 }
496 }
497#if 0
498 if (i > 1)
18618b5e 499 if_printf(ifp, "%d queued\n", i);
984263bc
MD
500#endif
501 if (i > 0)
502 xferq->start(fwe->fd.fc);
503}
504
505/* Async. stream output */
506static void
507fwe_as_input(struct fw_xferq *xferq)
508{
509 struct mbuf *m, *m0;
510 struct ifnet *ifp;
511 struct fwe_softc *fwe;
512 struct fw_bulkxfer *sxfer;
513 struct fw_pkt *fp;
514 u_char *c;
984263bc
MD
515
516 fwe = (struct fwe_softc *)xferq->sc;
517 ifp = &fwe->fwe_if;
984263bc
MD
518 while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) {
519 STAILQ_REMOVE_HEAD(&xferq->stvalid, link);
984263bc 520 fp = mtod(sxfer->mbuf, struct fw_pkt *);
984263bc
MD
521 if (fwe->fd.fc->irx_post != NULL)
522 fwe->fd.fc->irx_post(fwe->fd.fc, fp->mode.ld);
523 m = sxfer->mbuf;
524
78748771 525 /* insert new rbuf */
74f1caca 526 sxfer->mbuf = m0 = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
984263bc
MD
527 if (m0 != NULL) {
528 m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
529 STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
18618b5e
JS
530 } else {
531 if_printf(ifp, "fwe_as_input: m_getcl failed\n");
532 }
984263bc 533
78748771
JS
534 if (sxfer->resp != 0 || fp->mode.stream.len <
535 ETHER_ALIGN + sizeof(struct ether_header)) {
536 m_freem(m);
537 ifp->if_ierrors ++;
538 continue;
539 }
540
984263bc
MD
541 m->m_data += HDR_LEN + ETHER_ALIGN;
542 c = mtod(m, char *);
984263bc
MD
543 m->m_len = m->m_pkthdr.len =
544 fp->mode.stream.len - ETHER_ALIGN;
545 m->m_pkthdr.rcvif = ifp;
546#if 0
78748771 547 FWEDEBUG(ifp, "%02x %02x %02x %02x %02x %02x\n"
984263bc
MD
548 "%02x %02x %02x %02x %02x %02x\n"
549 "%02x %02x %02x %02x\n"
550 "%02x %02x %02x %02x\n"
551 "%02x %02x %02x %02x\n"
552 "%02x %02x %02x %02x\n",
553 c[0], c[1], c[2], c[3], c[4], c[5],
554 c[6], c[7], c[8], c[9], c[10], c[11],
555 c[12], c[13], c[14], c[15],
556 c[16], c[17], c[18], c[19],
557 c[20], c[21], c[22], c[23],
558 c[20], c[21], c[22], c[23]
559 );
560#endif
90dec0df 561 (*ifp->if_input)(ifp, m);
984263bc
MD
562 ifp->if_ipackets ++;
563 }
564 if (STAILQ_FIRST(&xferq->stfree) != NULL)
565 fwe->fd.fc->irx_enable(fwe->fd.fc, fwe->dma_ch);
566}
567
568
569static devclass_t fwe_devclass;
570
39b5d600
MD
571/*
572 * Because fwe is a static device that always exists under any attached
573 * firewire device, and not scanned by the firewire device, we need an
574 * identify function to install the device.
575 */
984263bc
MD
576static device_method_t fwe_methods[] = {
577 /* device interface */
39b5d600 578 DEVMETHOD(device_identify, bus_generic_identify_sameunit),
984263bc
MD
579 DEVMETHOD(device_probe, fwe_probe),
580 DEVMETHOD(device_attach, fwe_attach),
581 DEVMETHOD(device_detach, fwe_detach),
582 { 0, 0 }
583};
584
585static driver_t fwe_driver = {
78748771 586 "fwe",
984263bc
MD
587 fwe_methods,
588 sizeof(struct fwe_softc),
589};
590
591
78748771
JS
592DECLARE_DUMMY_MODULE(fwe);
593DRIVER_MODULE(fwe, firewire, fwe_driver, fwe_devclass, 0, 0);
594MODULE_VERSION(fwe, 1);
595MODULE_DEPEND(fwe, firewire, 1, 1, 1);