Home | History | Annotate | Line # | Download | only in ieee1394
if_fwip.c revision 1.9
      1  1.9        ad /*	$NetBSD: if_fwip.c,v 1.9 2007/10/19 12:00:13 ad Exp $	*/
      2  1.1  kiyohara /*-
      3  1.1  kiyohara  * Copyright (c) 2004
      4  1.1  kiyohara  *	Doug Rabson
      5  1.1  kiyohara  * Copyright (c) 2002-2003
      6  1.1  kiyohara  * 	Hidetoshi Shimokawa. All rights reserved.
      7  1.1  kiyohara  *
      8  1.1  kiyohara  * Redistribution and use in source and binary forms, with or without
      9  1.1  kiyohara  * modification, are permitted provided that the following conditions
     10  1.1  kiyohara  * are met:
     11  1.1  kiyohara  * 1. Redistributions of source code must retain the above copyright
     12  1.1  kiyohara  *    notice, this list of conditions and the following disclaimer.
     13  1.1  kiyohara  * 2. Redistributions in binary form must reproduce the above copyright
     14  1.1  kiyohara  *    notice, this list of conditions and the following disclaimer in the
     15  1.1  kiyohara  *    documentation and/or other materials provided with the distribution.
     16  1.1  kiyohara  * 3. All advertising materials mentioning features or use of this software
     17  1.1  kiyohara  *    must display the following acknowledgement:
     18  1.1  kiyohara  *
     19  1.1  kiyohara  *	This product includes software developed by Hidetoshi Shimokawa.
     20  1.1  kiyohara  *
     21  1.1  kiyohara  * 4. Neither the name of the author nor the names of its contributors
     22  1.1  kiyohara  *    may be used to endorse or promote products derived from this software
     23  1.1  kiyohara  *    without specific prior written permission.
     24  1.1  kiyohara  *
     25  1.1  kiyohara  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     26  1.1  kiyohara  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     27  1.1  kiyohara  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     28  1.1  kiyohara  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     29  1.1  kiyohara  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     30  1.1  kiyohara  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     31  1.1  kiyohara  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     32  1.1  kiyohara  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     33  1.1  kiyohara  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     34  1.1  kiyohara  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     35  1.1  kiyohara  * SUCH DAMAGE.
     36  1.1  kiyohara  *
     37  1.8  kiyohara  * $FreeBSD: /repoman/r/ncvs/src/sys/dev/firewire/if_fwip.c,v 1.14 2007/03/16 05:39:33 simokawa Exp $
     38  1.1  kiyohara  */
     39  1.1  kiyohara 
     40  1.8  kiyohara #ifdef HAVE_KERNEL_OPTION_HEADERS
     41  1.8  kiyohara #include "opt_device_polling.h"
     42  1.1  kiyohara #include "opt_inet.h"
     43  1.8  kiyohara #endif
     44  1.1  kiyohara 
     45  1.1  kiyohara #if defined(__FreeBSD__)
     46  1.1  kiyohara #include <sys/param.h>
     47  1.1  kiyohara #include <sys/kernel.h>
     48  1.1  kiyohara #include <sys/malloc.h>
     49  1.1  kiyohara #include <sys/mbuf.h>
     50  1.1  kiyohara #include <sys/socket.h>
     51  1.1  kiyohara #include <sys/sockio.h>
     52  1.1  kiyohara #include <sys/sysctl.h>
     53  1.1  kiyohara #include <sys/systm.h>
     54  1.1  kiyohara #include <sys/taskqueue.h>
     55  1.1  kiyohara #include <sys/module.h>
     56  1.1  kiyohara #include <sys/bus.h>
     57  1.9        ad #include <sys/bus.h>
     58  1.1  kiyohara 
     59  1.1  kiyohara #include <net/bpf.h>
     60  1.1  kiyohara #include <net/if.h>
     61  1.1  kiyohara #include <net/firewire.h>
     62  1.1  kiyohara #include <net/if_arp.h>
     63  1.8  kiyohara #include <net/if_types.h>
     64  1.1  kiyohara #ifdef __DragonFly__
     65  1.1  kiyohara #include <bus/firewire/fw_port.h>
     66  1.1  kiyohara #include <bus/firewire/firewire.h>
     67  1.1  kiyohara #include <bus/firewire/firewirereg.h>
     68  1.1  kiyohara #include "if_fwipvar.h"
     69  1.1  kiyohara #else
     70  1.1  kiyohara #include <dev/firewire/fw_port.h>
     71  1.1  kiyohara #include <dev/firewire/firewire.h>
     72  1.1  kiyohara #include <dev/firewire/firewirereg.h>
     73  1.1  kiyohara #include <dev/firewire/iec13213.h>
     74  1.1  kiyohara #include <dev/firewire/if_fwipvar.h>
     75  1.1  kiyohara #endif
     76  1.1  kiyohara #elif defined(__NetBSD__)
     77  1.1  kiyohara #include <sys/param.h>
     78  1.1  kiyohara #include <sys/device.h>
     79  1.1  kiyohara #include <sys/errno.h>
     80  1.1  kiyohara #include <sys/malloc.h>
     81  1.1  kiyohara #include <sys/mbuf.h>
     82  1.1  kiyohara #include <sys/sysctl.h>
     83  1.1  kiyohara 
     84  1.9        ad #include <sys/bus.h>
     85  1.1  kiyohara 
     86  1.1  kiyohara #include <net/if.h>
     87  1.1  kiyohara #include <net/if_ieee1394.h>
     88  1.8  kiyohara #include <net/if_types.h>
     89  1.1  kiyohara 
     90  1.1  kiyohara #include <dev/ieee1394/fw_port.h>
     91  1.1  kiyohara #include <dev/ieee1394/firewire.h>
     92  1.1  kiyohara #include <dev/ieee1394/firewirereg.h>
     93  1.1  kiyohara #include <dev/ieee1394/iec13213.h>
     94  1.1  kiyohara #include <dev/ieee1394/if_fwipvar.h>
     95  1.1  kiyohara #endif
     96  1.1  kiyohara 
     97  1.1  kiyohara /*
     98  1.1  kiyohara  * We really need a mechanism for allocating regions in the FIFO
     99  1.1  kiyohara  * address space. We pick a address in the OHCI controller's 'middle'
    100  1.1  kiyohara  * address space. This means that the controller will automatically
    101  1.1  kiyohara  * send responses for us, which is fine since we don't have any
    102  1.1  kiyohara  * important information to put in the response anyway.
    103  1.1  kiyohara  */
    104  1.1  kiyohara #define INET_FIFO	0xfffe00000000LL
    105  1.1  kiyohara 
    106  1.1  kiyohara #if defined(__FreeBSD__)
    107  1.1  kiyohara #define FWIPDEBUG	if (fwipdebug) if_printf
    108  1.1  kiyohara #elif defined(__NetBSD__)
    109  1.1  kiyohara #define FWIPDEBUG(ifp, fmt, ...) \
    110  1.1  kiyohara 	if (fwipdebug) {\
    111  1.1  kiyohara 		aprint_normal("%s: ", (ifp)->if_xname); \
    112  1.1  kiyohara 		aprint_normal((fmt) ,##__VA_ARGS__); \
    113  1.1  kiyohara 	}
    114  1.1  kiyohara #endif
    115  1.1  kiyohara #define TX_MAX_QUEUE	(FWMAXQUEUE - 1)
    116  1.1  kiyohara 
    117  1.1  kiyohara #if defined(__NetBSD__)
    118  1.1  kiyohara int fwipmatch (struct device *, struct cfdata *, void *);
    119  1.1  kiyohara void fwipattach (struct device *, struct device *, void *);
    120  1.1  kiyohara int fwipdetach (struct device *, int);
    121  1.1  kiyohara int fwipactivate (struct device *, enum devact);
    122  1.1  kiyohara 
    123  1.1  kiyohara #endif
    124  1.1  kiyohara /* network interface */
    125  1.1  kiyohara static void fwip_start (struct ifnet *);
    126  1.7  christos static int fwip_ioctl (struct ifnet *, u_long, void *);
    127  1.1  kiyohara IF_INIT(fwip);
    128  1.1  kiyohara IF_STOP(fwip);
    129  1.1  kiyohara 
    130  1.1  kiyohara static void fwip_post_busreset (void *);
    131  1.1  kiyohara static void fwip_output_callback (struct fw_xfer *);
    132  1.1  kiyohara static void fwip_async_output (struct fwip_softc *, struct ifnet *);
    133  1.1  kiyohara #if defined(__FreeBSD__)
    134  1.1  kiyohara static void fwip_start_send (void *, int);
    135  1.1  kiyohara #endif
    136  1.1  kiyohara static void fwip_stream_input (struct fw_xferq *);
    137  1.1  kiyohara static void fwip_unicast_input(struct fw_xfer *);
    138  1.1  kiyohara 
    139  1.1  kiyohara static int fwipdebug = 0;
    140  1.1  kiyohara static int broadcast_channel = 0xc0 | 0x1f; /*  tag | channel(XXX) */
    141  1.1  kiyohara static int tx_speed = 2;
    142  1.1  kiyohara static int rx_queue_len = FWMAXQUEUE;
    143  1.1  kiyohara 
    144  1.1  kiyohara #if defined(__FreeBSD__)
    145  1.1  kiyohara MALLOC_DEFINE(M_FWIP, "if_fwip", "IP over FireWire interface");
    146  1.1  kiyohara SYSCTL_INT(_debug, OID_AUTO, if_fwip_debug, CTLFLAG_RW, &fwipdebug, 0, "");
    147  1.1  kiyohara SYSCTL_DECL(_hw_firewire);
    148  1.1  kiyohara SYSCTL_NODE(_hw_firewire, OID_AUTO, fwip, CTLFLAG_RD, 0,
    149  1.1  kiyohara 	"Firewire ip subsystem");
    150  1.1  kiyohara SYSCTL_INT(_hw_firewire_fwip, OID_AUTO, rx_queue_len, CTLFLAG_RW, &rx_queue_len,
    151  1.1  kiyohara 	0, "Length of the receive queue");
    152  1.1  kiyohara 
    153  1.1  kiyohara TUNABLE_INT("hw.firewire.fwip.rx_queue_len", &rx_queue_len);
    154  1.1  kiyohara #elif defined(__NetBSD__)
    155  1.1  kiyohara MALLOC_DEFINE(M_FWIP, "if_fwip", "IP over IEEE1394 interface");
    156  1.1  kiyohara /*
    157  1.1  kiyohara  * Setup sysctl(3) MIB, hw.fwip.*
    158  1.1  kiyohara  *
    159  1.1  kiyohara  * TBD condition CTLFLAG_PERMANENT on being an LKM or not
    160  1.1  kiyohara  */
    161  1.1  kiyohara SYSCTL_SETUP(sysctl_fwip, "sysctl fwip(4) subtree setup")
    162  1.1  kiyohara {
    163  1.1  kiyohara 	int rc, fwip_node_num;
    164  1.1  kiyohara 	const struct sysctlnode *node;
    165  1.1  kiyohara 
    166  1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, NULL,
    167  1.1  kiyohara 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw", NULL,
    168  1.1  kiyohara 	    NULL, 0, NULL, 0, CTL_HW, CTL_EOL)) != 0) {
    169  1.1  kiyohara 		goto err;
    170  1.1  kiyohara 	}
    171  1.1  kiyohara 
    172  1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    173  1.1  kiyohara 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "fwip",
    174  1.1  kiyohara 	    SYSCTL_DESCR("fwip controls"),
    175  1.1  kiyohara 	    NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) {
    176  1.1  kiyohara 		goto err;
    177  1.1  kiyohara 	}
    178  1.1  kiyohara 	fwip_node_num = node->sysctl_num;
    179  1.1  kiyohara 
    180  1.1  kiyohara 	/* fwip RX queue length */
    181  1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    182  1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    183  1.1  kiyohara 	    "rx_queue_len", SYSCTL_DESCR("Length of the receive queue"),
    184  1.1  kiyohara 	    NULL, 0, &rx_queue_len,
    185  1.1  kiyohara 	    0, CTL_HW, fwip_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    186  1.1  kiyohara 		goto err;
    187  1.1  kiyohara 	}
    188  1.1  kiyohara 
    189  1.1  kiyohara 	/* fwip RX queue length */
    190  1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    191  1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    192  1.1  kiyohara 	    "if_fwip_debug", SYSCTL_DESCR("fwip driver debug flag"),
    193  1.1  kiyohara 	    NULL, 0, &fwipdebug,
    194  1.1  kiyohara 	    0, CTL_HW, fwip_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    195  1.1  kiyohara 		goto err;
    196  1.1  kiyohara 	}
    197  1.1  kiyohara 
    198  1.1  kiyohara 	return;
    199  1.1  kiyohara 
    200  1.1  kiyohara err:
    201  1.1  kiyohara 	printf("%s: sysctl_createv failed (rc = %d)\n", __func__, rc);
    202  1.1  kiyohara }
    203  1.1  kiyohara #endif
    204  1.1  kiyohara 
    205  1.1  kiyohara #ifdef DEVICE_POLLING
    206  1.1  kiyohara static poll_handler_t fwip_poll;
    207  1.1  kiyohara 
    208  1.1  kiyohara static void
    209  1.1  kiyohara fwip_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
    210  1.1  kiyohara {
    211  1.1  kiyohara 	struct fwip_softc *fwip;
    212  1.1  kiyohara 	struct firewire_comm *fc;
    213  1.1  kiyohara 
    214  1.8  kiyohara 	if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
    215  1.8  kiyohara 		return;
    216  1.8  kiyohara 
    217  1.1  kiyohara 	fwip = ((struct fwip_eth_softc *)ifp->if_softc)->fwip;
    218  1.1  kiyohara 	fc = fwip->fd.fc;
    219  1.1  kiyohara 	fc->poll(fc, (cmd == POLL_AND_CHECK_STATUS)?0:1, count);
    220  1.1  kiyohara }
    221  1.8  kiyohara #endif /* DEVICE_POLLING */
    222  1.1  kiyohara #if defined(__FreeBSD__)
    223  1.1  kiyohara static void
    224  1.1  kiyohara fwip_identify(driver_t *driver, device_t parent)
    225  1.1  kiyohara {
    226  1.1  kiyohara 	BUS_ADD_CHILD(parent, 0, "fwip", device_get_unit(parent));
    227  1.1  kiyohara }
    228  1.1  kiyohara 
    229  1.1  kiyohara static int
    230  1.1  kiyohara fwip_probe(device_t dev)
    231  1.1  kiyohara {
    232  1.1  kiyohara 	device_t pa;
    233  1.1  kiyohara 
    234  1.1  kiyohara 	pa = device_get_parent(dev);
    235  1.1  kiyohara 	if(device_get_unit(dev) != device_get_unit(pa)){
    236  1.1  kiyohara 		return(ENXIO);
    237  1.1  kiyohara 	}
    238  1.1  kiyohara 
    239  1.1  kiyohara 	device_set_desc(dev, "IP over FireWire");
    240  1.1  kiyohara 	return (0);
    241  1.1  kiyohara }
    242  1.1  kiyohara #elif defined(__NetBSD__)
    243  1.1  kiyohara int
    244  1.6  christos fwipmatch(struct device *parent, struct cfdata *cf, void *aux)
    245  1.1  kiyohara {
    246  1.1  kiyohara 	struct fw_attach_args *fwa = aux;
    247  1.1  kiyohara 
    248  1.1  kiyohara 	if (strcmp(fwa->name, "fwip") == 0)
    249  1.1  kiyohara 		return (1);
    250  1.1  kiyohara 	return (0);
    251  1.1  kiyohara }
    252  1.1  kiyohara #endif
    253  1.1  kiyohara 
    254  1.1  kiyohara FW_ATTACH(fwip)
    255  1.1  kiyohara {
    256  1.1  kiyohara 	FW_ATTACH_START(fwip, fwip, fwa);
    257  1.1  kiyohara 	FWIP_ATTACH_START;
    258  1.1  kiyohara 	struct ifnet *ifp;
    259  1.1  kiyohara 	int s;
    260  1.1  kiyohara 
    261  1.1  kiyohara 	FWIP_ATTACH_SETUP;
    262  1.1  kiyohara 
    263  1.8  kiyohara 	ifp = fwip->fw_softc.fwip_ifp;
    264  1.8  kiyohara 	if (ifp == NULL)
    265  1.8  kiyohara 		FW_ATTACH_RETURN(ENOSPC);
    266  1.8  kiyohara 
    267  1.1  kiyohara 	/* XXX */
    268  1.1  kiyohara 	fwip->dma_ch = -1;
    269  1.1  kiyohara 
    270  1.1  kiyohara 	fwip->fd.fc = fwa->fc;
    271  1.1  kiyohara 	if (tx_speed < 0)
    272  1.1  kiyohara 		tx_speed = fwip->fd.fc->speed;
    273  1.1  kiyohara 
    274  1.1  kiyohara 	fwip->fd.post_explore = NULL;
    275  1.1  kiyohara 	fwip->fd.post_busreset = fwip_post_busreset;
    276  1.1  kiyohara 	fwip->fw_softc.fwip = fwip;
    277  1.1  kiyohara 	TASK_INIT(&fwip->start_send, 0, fwip_start_send, fwip);
    278  1.1  kiyohara 
    279  1.1  kiyohara 	/*
    280  1.1  kiyohara 	 * Encode our hardware the way that arp likes it.
    281  1.1  kiyohara 	 */
    282  1.1  kiyohara 	hwaddr->sender_unique_ID_hi = htonl(fwip->fd.fc->eui.hi);
    283  1.1  kiyohara 	hwaddr->sender_unique_ID_lo = htonl(fwip->fd.fc->eui.lo);
    284  1.1  kiyohara 	hwaddr->sender_max_rec = fwip->fd.fc->maxrec;
    285  1.1  kiyohara 	hwaddr->sspd = fwip->fd.fc->speed;
    286  1.1  kiyohara 	hwaddr->sender_unicast_FIFO_hi = htons((uint16_t)(INET_FIFO >> 32));
    287  1.1  kiyohara 	hwaddr->sender_unicast_FIFO_lo = htonl((uint32_t)INET_FIFO);
    288  1.1  kiyohara 
    289  1.1  kiyohara 	/* fill the rest and attach interface */
    290  1.1  kiyohara 	ifp->if_softc = &fwip->fw_softc;
    291  1.1  kiyohara 
    292  1.1  kiyohara #if __FreeBSD_version >= 501113 || defined(__DragonFly__) || defined(__NetBSD__)
    293  1.1  kiyohara 	IF_INITNAME(ifp, dev, unit);
    294  1.1  kiyohara #else
    295  1.1  kiyohara 	ifp->if_unit = unit;
    296  1.1  kiyohara 	ifp->if_name = "fwip";
    297  1.1  kiyohara #endif
    298  1.1  kiyohara #if defined(__NetBSD__)
    299  1.1  kiyohara 	IFQ_SET_READY(&ifp->if_snd);
    300  1.1  kiyohara #endif
    301  1.1  kiyohara 	SET_IFFUNC(ifp, fwip_start, fwip_ioctl, fwip_init, fwip_stop);
    302  1.1  kiyohara 	ifp->if_flags = (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST|
    303  1.1  kiyohara 	    IFF_NEEDSGIANT);
    304  1.1  kiyohara 	ifp->if_snd.ifq_maxlen = TX_MAX_QUEUE;
    305  1.8  kiyohara #ifdef DEVICE_POLLING
    306  1.8  kiyohara 	ifp->if_capabilities |= IFCAP_POLLING;
    307  1.8  kiyohara #endif
    308  1.1  kiyohara 
    309  1.1  kiyohara 	s = splfwnet();
    310  1.1  kiyohara 	FIREWIRE_IFATTACH(ifp, hwaddr);
    311  1.1  kiyohara 	splx(s);
    312  1.1  kiyohara 
    313  1.1  kiyohara 	FWIPDEBUG(ifp, "interface created\n");
    314  1.1  kiyohara 	FW_ATTACH_RETURN(0);
    315  1.1  kiyohara }
    316  1.1  kiyohara 
    317  1.1  kiyohara IF_STOP(fwip)
    318  1.1  kiyohara {
    319  1.1  kiyohara 	IF_STOP_START(fwip, ifp, fwip);
    320  1.1  kiyohara 	struct firewire_comm *fc;
    321  1.1  kiyohara 	struct fw_xferq *xferq;
    322  1.1  kiyohara 	struct fw_xfer *xfer, *next;
    323  1.1  kiyohara 	int i;
    324  1.1  kiyohara 
    325  1.1  kiyohara 	fc = fwip->fd.fc;
    326  1.1  kiyohara 
    327  1.1  kiyohara 	if (fwip->dma_ch >= 0) {
    328  1.1  kiyohara 		xferq = fc->ir[fwip->dma_ch];
    329  1.1  kiyohara 
    330  1.1  kiyohara 		if (xferq->flag & FWXFERQ_RUNNING)
    331  1.1  kiyohara 			fc->irx_disable(fc, fwip->dma_ch);
    332  1.1  kiyohara 		xferq->flag &=
    333  1.1  kiyohara 			~(FWXFERQ_MODEMASK | FWXFERQ_OPEN | FWXFERQ_STREAM |
    334  1.1  kiyohara 			FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_CHTAGMASK);
    335  1.1  kiyohara 		xferq->hand =  NULL;
    336  1.1  kiyohara 
    337  1.1  kiyohara 		for (i = 0; i < xferq->bnchunk; i ++)
    338  1.1  kiyohara 			m_freem(xferq->bulkxfer[i].mbuf);
    339  1.1  kiyohara 		free(xferq->bulkxfer, M_FWIP);
    340  1.1  kiyohara 
    341  1.1  kiyohara 		fw_bindremove(fc, &fwip->fwb);
    342  1.1  kiyohara 		for (xfer = STAILQ_FIRST(&fwip->fwb.xferlist); xfer != NULL;
    343  1.1  kiyohara 					xfer = next) {
    344  1.1  kiyohara 			next = STAILQ_NEXT(xfer, link);
    345  1.1  kiyohara 			fw_xfer_free(xfer);
    346  1.1  kiyohara 		}
    347  1.1  kiyohara 
    348  1.1  kiyohara 		for (xfer = STAILQ_FIRST(&fwip->xferlist); xfer != NULL;
    349  1.1  kiyohara 					xfer = next) {
    350  1.1  kiyohara 			next = STAILQ_NEXT(xfer, link);
    351  1.1  kiyohara 			fw_xfer_free(xfer);
    352  1.1  kiyohara 		}
    353  1.1  kiyohara 		STAILQ_INIT(&fwip->xferlist);
    354  1.1  kiyohara 
    355  1.1  kiyohara 		xferq->bulkxfer =  NULL;
    356  1.1  kiyohara 		fwip->dma_ch = -1;
    357  1.1  kiyohara 	}
    358  1.1  kiyohara 
    359  1.8  kiyohara #if defined(__FreeBSD__)
    360  1.8  kiyohara 	ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
    361  1.8  kiyohara #elif defined(__NetBSD__)
    362  1.1  kiyohara 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
    363  1.8  kiyohara #endif
    364  1.1  kiyohara }
    365  1.1  kiyohara 
    366  1.1  kiyohara FW_DETACH(fwip)
    367  1.1  kiyohara {
    368  1.1  kiyohara 	IF_DETACH_START(fwip, fwip);
    369  1.8  kiyohara 	struct ifnet *ifp;
    370  1.1  kiyohara 	int s;
    371  1.1  kiyohara 
    372  1.8  kiyohara 	ifp = fwip->fw_softc.fwip_ifp;
    373  1.8  kiyohara 
    374  1.8  kiyohara #ifdef DEVICE_POLLING
    375  1.8  kiyohara 	if (ifp->if_capenable & IFCAP_POLLING)
    376  1.8  kiyohara 		ether_poll_deregister(ifp);
    377  1.8  kiyohara #endif
    378  1.8  kiyohara 
    379  1.1  kiyohara 	s = splfwnet();
    380  1.1  kiyohara 
    381  1.1  kiyohara 	FWIP_STOP(fwip);
    382  1.8  kiyohara 	FIREWIRE_IFDETACH(ifp);
    383  1.1  kiyohara 
    384  1.1  kiyohara 	splx(s);
    385  1.1  kiyohara 	return 0;
    386  1.1  kiyohara }
    387  1.1  kiyohara 
    388  1.1  kiyohara #if defined(__NetBSD__)
    389  1.1  kiyohara int
    390  1.1  kiyohara fwipactivate(struct device *self, enum devact act)
    391  1.1  kiyohara {
    392  1.1  kiyohara 	struct fwip_softc *fwip = (struct fwip_softc *)self;
    393  1.1  kiyohara 	int s, error = 0;
    394  1.1  kiyohara 
    395  1.1  kiyohara 	s = splfwnet();
    396  1.1  kiyohara 	switch (act) {
    397  1.1  kiyohara 	case DVACT_ACTIVATE:
    398  1.1  kiyohara 		error = EOPNOTSUPP;
    399  1.1  kiyohara 		break;
    400  1.1  kiyohara 
    401  1.1  kiyohara 	case DVACT_DEACTIVATE:
    402  1.8  kiyohara 		if_deactivate(fwip->fw_softc.fwip_ifp);
    403  1.1  kiyohara 			break;
    404  1.1  kiyohara 	}
    405  1.1  kiyohara 	splx(s);
    406  1.1  kiyohara 
    407  1.1  kiyohara 	return (error);
    408  1.1  kiyohara }
    409  1.1  kiyohara 
    410  1.1  kiyohara #endif
    411  1.1  kiyohara IF_INIT(fwip)
    412  1.1  kiyohara {
    413  1.1  kiyohara 	IF_INIT_START(fwip, fwip, ifp);
    414  1.1  kiyohara 	struct firewire_comm *fc;
    415  1.1  kiyohara 	struct fw_xferq *xferq;
    416  1.1  kiyohara 	struct fw_xfer *xfer;
    417  1.1  kiyohara 	struct mbuf *m;
    418  1.1  kiyohara 	int i;
    419  1.1  kiyohara 
    420  1.1  kiyohara 	FWIPDEBUG(ifp, "initializing\n");
    421  1.1  kiyohara 
    422  1.1  kiyohara 	fc = fwip->fd.fc;
    423  1.1  kiyohara #define START 0
    424  1.1  kiyohara 	if (fwip->dma_ch < 0) {
    425  1.1  kiyohara 		for (i = START; i < fc->nisodma; i ++) {
    426  1.1  kiyohara 			xferq = fc->ir[i];
    427  1.1  kiyohara 			if ((xferq->flag & FWXFERQ_OPEN) == 0)
    428  1.1  kiyohara 				goto found;
    429  1.1  kiyohara 		}
    430  1.1  kiyohara 		printf("no free dma channel\n");
    431  1.1  kiyohara 		IF_INIT_RETURN(ENXIO);
    432  1.1  kiyohara found:
    433  1.1  kiyohara 		fwip->dma_ch = i;
    434  1.1  kiyohara 		/* allocate DMA channel and init packet mode */
    435  1.1  kiyohara 		xferq->flag |= FWXFERQ_OPEN | FWXFERQ_EXTBUF |
    436  1.1  kiyohara 				FWXFERQ_HANDLER | FWXFERQ_STREAM;
    437  1.1  kiyohara 		xferq->flag &= ~0xff;
    438  1.1  kiyohara 		xferq->flag |= broadcast_channel & 0xff;
    439  1.1  kiyohara 		/* register fwip_input handler */
    440  1.7  christos 		xferq->sc = (void *) fwip;
    441  1.1  kiyohara 		xferq->hand = fwip_stream_input;
    442  1.1  kiyohara 		xferq->bnchunk = rx_queue_len;
    443  1.1  kiyohara 		xferq->bnpacket = 1;
    444  1.1  kiyohara 		xferq->psize = MCLBYTES;
    445  1.1  kiyohara 		xferq->queued = 0;
    446  1.1  kiyohara 		xferq->buf = NULL;
    447  1.1  kiyohara 		xferq->bulkxfer = (struct fw_bulkxfer *) malloc(
    448  1.1  kiyohara 			sizeof(struct fw_bulkxfer) * xferq->bnchunk,
    449  1.1  kiyohara 							M_FWIP, M_WAITOK);
    450  1.1  kiyohara 		if (xferq->bulkxfer == NULL) {
    451  1.1  kiyohara 			printf("if_fwip: malloc failed\n");
    452  1.1  kiyohara 			IF_INIT_RETURN(ENOMEM);
    453  1.1  kiyohara 		}
    454  1.1  kiyohara 		STAILQ_INIT(&xferq->stvalid);
    455  1.1  kiyohara 		STAILQ_INIT(&xferq->stfree);
    456  1.1  kiyohara 		STAILQ_INIT(&xferq->stdma);
    457  1.1  kiyohara 		xferq->stproc = NULL;
    458  1.1  kiyohara 		for (i = 0; i < xferq->bnchunk; i ++) {
    459  1.1  kiyohara 			m =
    460  1.1  kiyohara #if defined(__DragonFly__) || __FreeBSD_version < 500000
    461  1.1  kiyohara 				m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
    462  1.1  kiyohara #else
    463  1.1  kiyohara 				m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
    464  1.1  kiyohara #endif
    465  1.1  kiyohara 			xferq->bulkxfer[i].mbuf = m;
    466  1.1  kiyohara 			if (m != NULL) {
    467  1.1  kiyohara 				m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
    468  1.1  kiyohara 				STAILQ_INSERT_TAIL(&xferq->stfree,
    469  1.1  kiyohara 						&xferq->bulkxfer[i], link);
    470  1.1  kiyohara 			} else
    471  1.1  kiyohara 				printf("fwip_as_input: m_getcl failed\n");
    472  1.1  kiyohara 		}
    473  1.1  kiyohara 
    474  1.1  kiyohara 		fwip->fwb.start = INET_FIFO;
    475  1.1  kiyohara 		fwip->fwb.end = INET_FIFO + 16384; /* S3200 packet size */
    476  1.1  kiyohara 
    477  1.1  kiyohara 		/* pre-allocate xfer */
    478  1.1  kiyohara 		STAILQ_INIT(&fwip->fwb.xferlist);
    479  1.1  kiyohara 		for (i = 0; i < rx_queue_len; i ++) {
    480  1.1  kiyohara 			xfer = fw_xfer_alloc(M_FWIP);
    481  1.1  kiyohara 			if (xfer == NULL)
    482  1.1  kiyohara 				break;
    483  1.1  kiyohara 			m = m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
    484  1.1  kiyohara 			xfer->recv.payload = mtod(m, uint32_t *);
    485  1.1  kiyohara 			xfer->recv.pay_len = MCLBYTES;
    486  1.1  kiyohara 			xfer->hand = fwip_unicast_input;
    487  1.1  kiyohara 			xfer->fc = fc;
    488  1.7  christos 			xfer->sc = (void *)fwip;
    489  1.1  kiyohara 			xfer->mbuf = m;
    490  1.1  kiyohara 			STAILQ_INSERT_TAIL(&fwip->fwb.xferlist, xfer, link);
    491  1.1  kiyohara 		}
    492  1.1  kiyohara 		fw_bindadd(fc, &fwip->fwb);
    493  1.1  kiyohara 
    494  1.1  kiyohara 		STAILQ_INIT(&fwip->xferlist);
    495  1.1  kiyohara 		for (i = 0; i < TX_MAX_QUEUE; i++) {
    496  1.1  kiyohara 			xfer = fw_xfer_alloc(M_FWIP);
    497  1.1  kiyohara 			if (xfer == NULL)
    498  1.1  kiyohara 				break;
    499  1.1  kiyohara 			xfer->send.spd = tx_speed;
    500  1.1  kiyohara 			xfer->fc = fwip->fd.fc;
    501  1.7  christos 			xfer->sc = (void *)fwip;
    502  1.1  kiyohara 			xfer->hand = fwip_output_callback;
    503  1.1  kiyohara 			STAILQ_INSERT_TAIL(&fwip->xferlist, xfer, link);
    504  1.1  kiyohara 		}
    505  1.1  kiyohara 	} else
    506  1.1  kiyohara 		xferq = fc->ir[fwip->dma_ch];
    507  1.1  kiyohara 
    508  1.1  kiyohara 	fwip->last_dest.hi = 0;
    509  1.1  kiyohara 	fwip->last_dest.lo = 0;
    510  1.1  kiyohara 
    511  1.1  kiyohara 	/* start dma */
    512  1.1  kiyohara 	if ((xferq->flag & FWXFERQ_RUNNING) == 0)
    513  1.1  kiyohara 		fc->irx_enable(fc, fwip->dma_ch);
    514  1.1  kiyohara 
    515  1.8  kiyohara #if defined(__FreeBSD__)
    516  1.8  kiyohara 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
    517  1.8  kiyohara 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
    518  1.8  kiyohara #elif defined(__NetBSD__)
    519  1.1  kiyohara 	ifp->if_flags |= IFF_RUNNING;
    520  1.1  kiyohara 	ifp->if_flags &= ~IFF_OACTIVE;
    521  1.8  kiyohara #endif
    522  1.1  kiyohara 
    523  1.1  kiyohara #if 0
    524  1.1  kiyohara 	/* attempt to start output */
    525  1.1  kiyohara 	fwip_start(ifp);
    526  1.1  kiyohara #endif
    527  1.1  kiyohara 	IF_INIT_RETURN(0);
    528  1.1  kiyohara }
    529  1.1  kiyohara 
    530  1.1  kiyohara static int
    531  1.7  christos fwip_ioctl(struct ifnet *ifp, u_long cmd, void *data)
    532  1.1  kiyohara {
    533  1.1  kiyohara 	IF_IOCTL_START(fwip, fwip);
    534  1.1  kiyohara 	int s, error;
    535  1.1  kiyohara 
    536  1.1  kiyohara 	switch (cmd) {
    537  1.1  kiyohara 	case SIOCSIFFLAGS:
    538  1.1  kiyohara 		s = splfwnet();
    539  1.1  kiyohara 		if (ifp->if_flags & IFF_UP) {
    540  1.8  kiyohara #if defined(__FreeBSD__)
    541  1.8  kiyohara 			if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
    542  1.8  kiyohara #elif defined(__NetBSD__)
    543  1.1  kiyohara 			if (!(ifp->if_flags & IFF_RUNNING))
    544  1.8  kiyohara #endif
    545  1.1  kiyohara 				FWIP_INIT(fwip);
    546  1.1  kiyohara 		} else {
    547  1.8  kiyohara #if defined(__FreeBSD__)
    548  1.8  kiyohara 			if (ifp->if_drv_flags & IFF_DRV_RUNNING)
    549  1.8  kiyohara #elif defined(__NetBSD__)
    550  1.1  kiyohara 			if (ifp->if_flags & IFF_RUNNING)
    551  1.8  kiyohara #endif
    552  1.1  kiyohara 				FWIP_STOP(fwip);
    553  1.1  kiyohara 		}
    554  1.1  kiyohara 		splx(s);
    555  1.1  kiyohara 		break;
    556  1.1  kiyohara 	case SIOCADDMULTI:
    557  1.1  kiyohara 	case SIOCDELMULTI:
    558  1.1  kiyohara 		break;
    559  1.8  kiyohara 	case SIOCSIFCAP:
    560  1.8  kiyohara #ifdef DEVICE_POLLING
    561  1.8  kiyohara 	    {
    562  1.8  kiyohara 		struct ifreq *ifr = (struct ifreq *) data;
    563  1.8  kiyohara 		struct firewire_comm *fc = fc = fwip->fd.fc;
    564  1.8  kiyohara 
    565  1.8  kiyohara 		if (ifr->ifr_reqcap & IFCAP_POLLING &&
    566  1.8  kiyohara 		    !(ifp->if_capenable & IFCAP_POLLING)) {
    567  1.8  kiyohara 			error = ether_poll_register(fwip_poll, ifp);
    568  1.8  kiyohara 			if (error)
    569  1.8  kiyohara 				return(error);
    570  1.8  kiyohara 			/* Disable interrupts */
    571  1.8  kiyohara 			fc->set_intr(fc, 0);
    572  1.8  kiyohara 			ifp->if_capenable |= IFCAP_POLLING;
    573  1.8  kiyohara 			return (error);
    574  1.8  kiyohara 
    575  1.8  kiyohara 		}
    576  1.8  kiyohara 		if (!(ifr->ifr_reqcap & IFCAP_POLLING) &&
    577  1.8  kiyohara 		    ifp->if_capenable & IFCAP_POLLING) {
    578  1.8  kiyohara 			error = ether_poll_deregister(ifp);
    579  1.8  kiyohara 			/* Enable interrupts. */
    580  1.8  kiyohara 			fc->set_intr(fc, 1);
    581  1.8  kiyohara 			ifp->if_capenable &= ~IFCAP_POLLING;
    582  1.8  kiyohara 			return (error);
    583  1.8  kiyohara 		}
    584  1.8  kiyohara 	    }
    585  1.8  kiyohara #endif /* DEVICE_POLLING */
    586  1.8  kiyohara 		break;
    587  1.1  kiyohara 
    588  1.1  kiyohara #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__NetBSD__)
    589  1.1  kiyohara 	default:
    590  1.1  kiyohara #else
    591  1.1  kiyohara 	case SIOCSIFADDR:
    592  1.1  kiyohara 	case SIOCGIFADDR:
    593  1.1  kiyohara 	case SIOCSIFMTU:
    594  1.1  kiyohara #endif
    595  1.1  kiyohara 		s = splfwnet();
    596  1.1  kiyohara 		error = FIREWIRE_IOCTL(ifp, cmd, data);
    597  1.1  kiyohara 		splx(s);
    598  1.1  kiyohara 		return (error);
    599  1.1  kiyohara #if defined(__DragonFly__) || \
    600  1.1  kiyohara     (defined(__FreeBSD__) && __FreeBSD_version < 500000)
    601  1.1  kiyohara 	default:
    602  1.1  kiyohara 		return (EINVAL);
    603  1.1  kiyohara #endif
    604  1.1  kiyohara 	}
    605  1.1  kiyohara 
    606  1.1  kiyohara 	return (0);
    607  1.1  kiyohara }
    608  1.1  kiyohara 
    609  1.1  kiyohara static void
    610  1.1  kiyohara fwip_post_busreset(void *arg)
    611  1.1  kiyohara {
    612  1.1  kiyohara 	struct fwip_softc *fwip = arg;
    613  1.1  kiyohara 	struct crom_src *src;
    614  1.1  kiyohara 	struct crom_chunk *root;
    615  1.1  kiyohara 
    616  1.1  kiyohara 	src = fwip->fd.fc->crom_src;
    617  1.1  kiyohara 	root = fwip->fd.fc->crom_root;
    618  1.1  kiyohara 
    619  1.1  kiyohara 	/* RFC2734 IPv4 over IEEE1394 */
    620  1.1  kiyohara 	bzero(&fwip->unit4, sizeof(struct crom_chunk));
    621  1.1  kiyohara 	crom_add_chunk(src, root, &fwip->unit4, CROM_UDIR);
    622  1.1  kiyohara 	crom_add_entry(&fwip->unit4, CSRKEY_SPEC, CSRVAL_IETF);
    623  1.1  kiyohara 	crom_add_simple_text(src, &fwip->unit4, &fwip->spec4, "IANA");
    624  1.1  kiyohara 	crom_add_entry(&fwip->unit4, CSRKEY_VER, 1);
    625  1.1  kiyohara 	crom_add_simple_text(src, &fwip->unit4, &fwip->ver4, "IPv4");
    626  1.1  kiyohara 
    627  1.1  kiyohara 	/* RFC3146 IPv6 over IEEE1394 */
    628  1.1  kiyohara 	bzero(&fwip->unit6, sizeof(struct crom_chunk));
    629  1.1  kiyohara 	crom_add_chunk(src, root, &fwip->unit6, CROM_UDIR);
    630  1.1  kiyohara 	crom_add_entry(&fwip->unit6, CSRKEY_SPEC, CSRVAL_IETF);
    631  1.1  kiyohara 	crom_add_simple_text(src, &fwip->unit6, &fwip->spec6, "IANA");
    632  1.1  kiyohara 	crom_add_entry(&fwip->unit6, CSRKEY_VER, 2);
    633  1.1  kiyohara 	crom_add_simple_text(src, &fwip->unit6, &fwip->ver6, "IPv6");
    634  1.1  kiyohara 
    635  1.1  kiyohara 	fwip->last_dest.hi = 0;
    636  1.1  kiyohara 	fwip->last_dest.lo = 0;
    637  1.8  kiyohara 	FIREWIRE_BUSRESET(fwip->fw_softc.fwip_ifp);
    638  1.1  kiyohara }
    639  1.1  kiyohara 
    640  1.1  kiyohara static void
    641  1.1  kiyohara fwip_output_callback(struct fw_xfer *xfer)
    642  1.1  kiyohara {
    643  1.1  kiyohara 	struct fwip_softc *fwip;
    644  1.1  kiyohara 	struct ifnet *ifp;
    645  1.1  kiyohara 	int s;
    646  1.1  kiyohara 
    647  1.1  kiyohara 	GIANT_REQUIRED;
    648  1.1  kiyohara 
    649  1.1  kiyohara 	fwip = (struct fwip_softc *)xfer->sc;
    650  1.8  kiyohara 	ifp = fwip->fw_softc.fwip_ifp;
    651  1.1  kiyohara 	/* XXX error check */
    652  1.1  kiyohara 	FWIPDEBUG(ifp, "resp = %d\n", xfer->resp);
    653  1.1  kiyohara 	if (xfer->resp != 0)
    654  1.1  kiyohara 		ifp->if_oerrors ++;
    655  1.1  kiyohara 
    656  1.1  kiyohara 	m_freem(xfer->mbuf);
    657  1.1  kiyohara 	fw_xfer_unload(xfer);
    658  1.1  kiyohara 
    659  1.1  kiyohara 	s = splfwnet();
    660  1.1  kiyohara 	STAILQ_INSERT_TAIL(&fwip->xferlist, xfer, link);
    661  1.1  kiyohara 	splx(s);
    662  1.1  kiyohara 
    663  1.1  kiyohara 	/* for queue full */
    664  1.1  kiyohara 	if (ifp->if_snd.ifq_head != NULL)
    665  1.1  kiyohara 		fwip_start(ifp);
    666  1.1  kiyohara }
    667  1.1  kiyohara 
    668  1.1  kiyohara static void
    669  1.1  kiyohara fwip_start(struct ifnet *ifp)
    670  1.1  kiyohara {
    671  1.8  kiyohara 	struct fwip_softc *fwip =
    672  1.8  kiyohara 	    ((struct fwip_eth_softc *)ifp->if_softc)->fwip;
    673  1.1  kiyohara 	int s;
    674  1.1  kiyohara 
    675  1.1  kiyohara 	GIANT_REQUIRED;
    676  1.1  kiyohara 
    677  1.1  kiyohara 	FWIPDEBUG(ifp, "starting\n");
    678  1.1  kiyohara 
    679  1.1  kiyohara 	if (fwip->dma_ch < 0) {
    680  1.1  kiyohara 		struct mbuf	*m = NULL;
    681  1.1  kiyohara 
    682  1.1  kiyohara 		FWIPDEBUG(ifp, "not ready\n");
    683  1.1  kiyohara 
    684  1.1  kiyohara 		s = splfwnet();
    685  1.1  kiyohara 		do {
    686  1.1  kiyohara 			IF_DEQUEUE(&ifp->if_snd, m);
    687  1.1  kiyohara 			if (m != NULL)
    688  1.1  kiyohara 				m_freem(m);
    689  1.1  kiyohara 			ifp->if_oerrors ++;
    690  1.1  kiyohara 		} while (m != NULL);
    691  1.1  kiyohara 		splx(s);
    692  1.1  kiyohara 
    693  1.1  kiyohara 		return;
    694  1.1  kiyohara 	}
    695  1.1  kiyohara 
    696  1.1  kiyohara 	s = splfwnet();
    697  1.8  kiyohara #if defined(__FreeBSD__)
    698  1.8  kiyohara 	ifp->if_drv_flags |= IFF_DRV_OACTIVE;
    699  1.8  kiyohara #elif defined(__NetBSD__)
    700  1.1  kiyohara 	ifp->if_flags |= IFF_OACTIVE;
    701  1.8  kiyohara #endif
    702  1.1  kiyohara 
    703  1.1  kiyohara 	if (ifp->if_snd.ifq_len != 0)
    704  1.1  kiyohara 		fwip_async_output(fwip, ifp);
    705  1.1  kiyohara 
    706  1.8  kiyohara #if defined(__FreeBSD__)
    707  1.8  kiyohara 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
    708  1.8  kiyohara #elif defined(__NetBSD__)
    709  1.1  kiyohara 	ifp->if_flags &= ~IFF_OACTIVE;
    710  1.8  kiyohara #endif
    711  1.1  kiyohara 	splx(s);
    712  1.1  kiyohara }
    713  1.1  kiyohara 
    714  1.1  kiyohara /* Async. stream output */
    715  1.1  kiyohara static void
    716  1.1  kiyohara fwip_async_output(struct fwip_softc *fwip, struct ifnet *ifp)
    717  1.1  kiyohara {
    718  1.1  kiyohara 	struct firewire_comm *fc = fwip->fd.fc;
    719  1.1  kiyohara 	struct mbuf *m;
    720  1.1  kiyohara 	struct m_tag *mtag;
    721  1.1  kiyohara 	struct fw_hwaddr *destfw;
    722  1.1  kiyohara 	struct fw_xfer *xfer;
    723  1.1  kiyohara 	struct fw_xferq *xferq;
    724  1.1  kiyohara 	struct fw_pkt *fp;
    725  1.1  kiyohara 	uint16_t nodeid;
    726  1.1  kiyohara 	int error;
    727  1.1  kiyohara 	int i = 0;
    728  1.1  kiyohara 
    729  1.1  kiyohara 	GIANT_REQUIRED;
    730  1.1  kiyohara 
    731  1.1  kiyohara 	xfer = NULL;
    732  1.1  kiyohara 	xferq = fwip->fd.fc->atq;
    733  1.1  kiyohara 	while (xferq->queued < xferq->maxq - 1) {
    734  1.1  kiyohara 		xfer = STAILQ_FIRST(&fwip->xferlist);
    735  1.1  kiyohara 		if (xfer == NULL) {
    736  1.1  kiyohara 			printf("if_fwip: lack of xfer\n");
    737  1.1  kiyohara 			return;
    738  1.1  kiyohara 		}
    739  1.1  kiyohara 		IF_DEQUEUE(&ifp->if_snd, m);
    740  1.1  kiyohara 		if (m == NULL)
    741  1.1  kiyohara 			break;
    742  1.1  kiyohara 
    743  1.1  kiyohara 		/*
    744  1.1  kiyohara 		 * Dig out the link-level address which
    745  1.1  kiyohara 		 * firewire_output got via arp or neighbour
    746  1.1  kiyohara 		 * discovery. If we don't have a link-level address,
    747  1.1  kiyohara 		 * just stick the thing on the broadcast channel.
    748  1.1  kiyohara 		 */
    749  1.1  kiyohara 		mtag = m_tag_locate(m, MTAG_FIREWIRE, MTAG_FIREWIRE_HWADDR, 0);
    750  1.1  kiyohara 		if (mtag == NULL)
    751  1.1  kiyohara 			destfw = 0;
    752  1.1  kiyohara 		else
    753  1.1  kiyohara 			destfw = (struct fw_hwaddr *) (mtag + 1);
    754  1.1  kiyohara 
    755  1.1  kiyohara 		STAILQ_REMOVE_HEAD(&fwip->xferlist, link);
    756  1.1  kiyohara 
    757  1.1  kiyohara 		/*
    758  1.1  kiyohara 		 * We don't do any bpf stuff here - the generic code
    759  1.1  kiyohara 		 * in firewire_output gives the packet to bpf before
    760  1.1  kiyohara 		 * it adds the link-level encapsulation.
    761  1.1  kiyohara 		 */
    762  1.1  kiyohara 
    763  1.1  kiyohara 		/*
    764  1.1  kiyohara 		 * Put the mbuf in the xfer early in case we hit an
    765  1.1  kiyohara 		 * error case below - fwip_output_callback will free
    766  1.1  kiyohara 		 * the mbuf.
    767  1.1  kiyohara 		 */
    768  1.1  kiyohara 		xfer->mbuf = m;
    769  1.1  kiyohara 
    770  1.1  kiyohara 		/*
    771  1.1  kiyohara 		 * We use the arp result (if any) to add a suitable firewire
    772  1.1  kiyohara 		 * packet header before handing off to the bus.
    773  1.1  kiyohara 		 */
    774  1.1  kiyohara 		fp = &xfer->send.hdr;
    775  1.1  kiyohara 		nodeid = FWLOCALBUS | fc->nodeid;
    776  1.1  kiyohara 		if ((m->m_flags & M_BCAST) || !destfw) {
    777  1.1  kiyohara 			/*
    778  1.1  kiyohara 			 * Broadcast packets are sent as GASP packets with
    779  1.1  kiyohara 			 * specifier ID 0x00005e, version 1 on the broadcast
    780  1.1  kiyohara 			 * channel. To be conservative, we send at the
    781  1.1  kiyohara 			 * slowest possible speed.
    782  1.1  kiyohara 			 */
    783  1.1  kiyohara 			uint32_t *p;
    784  1.1  kiyohara 
    785  1.1  kiyohara 			M_PREPEND(m, 2*sizeof(uint32_t), M_DONTWAIT);
    786  1.1  kiyohara 			p = mtod(m, uint32_t *);
    787  1.1  kiyohara 			fp->mode.stream.len = m->m_pkthdr.len;
    788  1.1  kiyohara 			fp->mode.stream.chtag = broadcast_channel;
    789  1.1  kiyohara 			fp->mode.stream.tcode = FWTCODE_STREAM;
    790  1.1  kiyohara 			fp->mode.stream.sy = 0;
    791  1.1  kiyohara 			xfer->send.spd = 0;
    792  1.1  kiyohara 			p[0] = htonl(nodeid << 16);
    793  1.1  kiyohara 			p[1] = htonl((0x5e << 24) | 1);
    794  1.1  kiyohara 		} else {
    795  1.1  kiyohara 			/*
    796  1.1  kiyohara 			 * Unicast packets are sent as block writes to the
    797  1.1  kiyohara 			 * target's unicast fifo address. If we can't
    798  1.1  kiyohara 			 * find the node address, we just give up. We
    799  1.1  kiyohara 			 * could broadcast it but that might overflow
    800  1.1  kiyohara 			 * the packet size limitations due to the
    801  1.1  kiyohara 			 * extra GASP header. Note: the hardware
    802  1.1  kiyohara 			 * address is stored in network byte order to
    803  1.1  kiyohara 			 * make life easier for ARP.
    804  1.1  kiyohara 			 */
    805  1.1  kiyohara 			struct fw_device *fd;
    806  1.1  kiyohara 			struct fw_eui64 eui;
    807  1.1  kiyohara 
    808  1.1  kiyohara 			eui.hi = ntohl(destfw->sender_unique_ID_hi);
    809  1.1  kiyohara 			eui.lo = ntohl(destfw->sender_unique_ID_lo);
    810  1.1  kiyohara 			if (fwip->last_dest.hi != eui.hi ||
    811  1.1  kiyohara 			    fwip->last_dest.lo != eui.lo) {
    812  1.1  kiyohara 				fd = fw_noderesolve_eui64(fc, &eui);
    813  1.1  kiyohara 				if (!fd) {
    814  1.1  kiyohara 					/* error */
    815  1.1  kiyohara 					ifp->if_oerrors ++;
    816  1.1  kiyohara 					/* XXX set error code */
    817  1.1  kiyohara 					fwip_output_callback(xfer);
    818  1.1  kiyohara 					continue;
    819  1.1  kiyohara 
    820  1.1  kiyohara 				}
    821  1.1  kiyohara 				fwip->last_hdr.mode.wreqb.dst = FWLOCALBUS | fd->dst;
    822  1.1  kiyohara 				fwip->last_hdr.mode.wreqb.tlrt = 0;
    823  1.1  kiyohara 				fwip->last_hdr.mode.wreqb.tcode = FWTCODE_WREQB;
    824  1.1  kiyohara 				fwip->last_hdr.mode.wreqb.pri = 0;
    825  1.1  kiyohara 				fwip->last_hdr.mode.wreqb.src = nodeid;
    826  1.1  kiyohara 				fwip->last_hdr.mode.wreqb.dest_hi =
    827  1.1  kiyohara 					ntohs(destfw->sender_unicast_FIFO_hi);
    828  1.1  kiyohara 				fwip->last_hdr.mode.wreqb.dest_lo =
    829  1.1  kiyohara 					ntohl(destfw->sender_unicast_FIFO_lo);
    830  1.1  kiyohara 				fwip->last_hdr.mode.wreqb.extcode = 0;
    831  1.1  kiyohara 				fwip->last_dest = eui;
    832  1.1  kiyohara 			}
    833  1.1  kiyohara 
    834  1.1  kiyohara 			fp->mode.wreqb = fwip->last_hdr.mode.wreqb;
    835  1.1  kiyohara 			fp->mode.wreqb.len = m->m_pkthdr.len;
    836  1.1  kiyohara 			xfer->send.spd = min(destfw->sspd, fc->speed);
    837  1.1  kiyohara 		}
    838  1.1  kiyohara 
    839  1.1  kiyohara 		xfer->send.pay_len = m->m_pkthdr.len;
    840  1.1  kiyohara 
    841  1.1  kiyohara 		error = fw_asyreq(fc, -1, xfer);
    842  1.1  kiyohara 		if (error == EAGAIN) {
    843  1.1  kiyohara 			/*
    844  1.1  kiyohara 			 * We ran out of tlabels - requeue the packet
    845  1.1  kiyohara 			 * for later transmission.
    846  1.1  kiyohara 			 */
    847  1.1  kiyohara 			xfer->mbuf = 0;
    848  1.1  kiyohara 			STAILQ_INSERT_TAIL(&fwip->xferlist, xfer, link);
    849  1.1  kiyohara 			IF_PREPEND(&ifp->if_snd, m);
    850  1.1  kiyohara 			break;
    851  1.1  kiyohara 		}
    852  1.1  kiyohara 		if (error) {
    853  1.1  kiyohara 			/* error */
    854  1.1  kiyohara 			ifp->if_oerrors ++;
    855  1.1  kiyohara 			/* XXX set error code */
    856  1.1  kiyohara 			fwip_output_callback(xfer);
    857  1.1  kiyohara 			continue;
    858  1.1  kiyohara 		} else {
    859  1.1  kiyohara 			ifp->if_opackets ++;
    860  1.1  kiyohara 			i++;
    861  1.1  kiyohara 		}
    862  1.1  kiyohara 	}
    863  1.1  kiyohara #if 0
    864  1.1  kiyohara 	if (i > 1)
    865  1.1  kiyohara 		printf("%d queued\n", i);
    866  1.1  kiyohara #endif
    867  1.1  kiyohara 	if (i > 0) {
    868  1.1  kiyohara #if 1
    869  1.1  kiyohara 		xferq->start(fc);
    870  1.1  kiyohara #else
    871  1.1  kiyohara 		taskqueue_enqueue(taskqueue_swi_giant, &fwip->start_send);
    872  1.1  kiyohara #endif
    873  1.1  kiyohara 	}
    874  1.1  kiyohara }
    875  1.1  kiyohara 
    876  1.1  kiyohara #if defined(__FreeBSD__)
    877  1.1  kiyohara static void
    878  1.1  kiyohara fwip_start_send (void *arg, int count)
    879  1.1  kiyohara {
    880  1.1  kiyohara 	struct fwip_softc *fwip = arg;
    881  1.1  kiyohara 
    882  1.1  kiyohara 	GIANT_REQUIRED;
    883  1.1  kiyohara 	fwip->fd.fc->atq->start(fwip->fd.fc);
    884  1.1  kiyohara }
    885  1.1  kiyohara #endif
    886  1.1  kiyohara 
    887  1.1  kiyohara /* Async. stream output */
    888  1.1  kiyohara static void
    889  1.1  kiyohara fwip_stream_input(struct fw_xferq *xferq)
    890  1.1  kiyohara {
    891  1.1  kiyohara 	struct mbuf *m, *m0;
    892  1.1  kiyohara 	struct m_tag *mtag;
    893  1.1  kiyohara 	struct ifnet *ifp;
    894  1.1  kiyohara 	struct fwip_softc *fwip;
    895  1.1  kiyohara 	struct fw_bulkxfer *sxfer;
    896  1.1  kiyohara 	struct fw_pkt *fp;
    897  1.1  kiyohara 	uint16_t src;
    898  1.1  kiyohara 	uint32_t *p;
    899  1.1  kiyohara 
    900  1.1  kiyohara 	GIANT_REQUIRED;
    901  1.1  kiyohara 
    902  1.1  kiyohara 	fwip = (struct fwip_softc *)xferq->sc;
    903  1.8  kiyohara 	ifp = fwip->fw_softc.fwip_ifp;
    904  1.1  kiyohara 	while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) {
    905  1.1  kiyohara 		STAILQ_REMOVE_HEAD(&xferq->stvalid, link);
    906  1.1  kiyohara 		fp = mtod(sxfer->mbuf, struct fw_pkt *);
    907  1.1  kiyohara 		if (fwip->fd.fc->irx_post != NULL)
    908  1.1  kiyohara 			fwip->fd.fc->irx_post(fwip->fd.fc, fp->mode.ld);
    909  1.1  kiyohara 		m = sxfer->mbuf;
    910  1.1  kiyohara 
    911  1.1  kiyohara 		/* insert new rbuf */
    912  1.1  kiyohara 		sxfer->mbuf = m0 = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
    913  1.1  kiyohara 		if (m0 != NULL) {
    914  1.1  kiyohara 			m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
    915  1.1  kiyohara 			STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
    916  1.1  kiyohara 		} else
    917  1.1  kiyohara 			printf("fwip_as_input: m_getcl failed\n");
    918  1.1  kiyohara 
    919  1.1  kiyohara 		/*
    920  1.1  kiyohara 		 * We must have a GASP header - leave the
    921  1.1  kiyohara 		 * encapsulation sanity checks to the generic
    922  1.1  kiyohara 		 * code. Remeber that we also have the firewire async
    923  1.1  kiyohara 		 * stream header even though that isn't accounted for
    924  1.1  kiyohara 		 * in mode.stream.len.
    925  1.1  kiyohara 		 */
    926  1.1  kiyohara 		if (sxfer->resp != 0 || fp->mode.stream.len <
    927  1.1  kiyohara 		    2*sizeof(uint32_t)) {
    928  1.1  kiyohara 			m_freem(m);
    929  1.1  kiyohara 			ifp->if_ierrors ++;
    930  1.1  kiyohara 			continue;
    931  1.1  kiyohara 		}
    932  1.1  kiyohara 		m->m_len = m->m_pkthdr.len = fp->mode.stream.len
    933  1.1  kiyohara 			+ sizeof(fp->mode.stream);
    934  1.1  kiyohara 
    935  1.1  kiyohara 		/*
    936  1.1  kiyohara 		 * If we received the packet on the broadcast channel,
    937  1.1  kiyohara 		 * mark it as broadcast, otherwise we assume it must
    938  1.1  kiyohara 		 * be multicast.
    939  1.1  kiyohara 		 */
    940  1.1  kiyohara 		if (fp->mode.stream.chtag == broadcast_channel)
    941  1.1  kiyohara 			m->m_flags |= M_BCAST;
    942  1.1  kiyohara 		else
    943  1.1  kiyohara 			m->m_flags |= M_MCAST;
    944  1.1  kiyohara 
    945  1.1  kiyohara 		/*
    946  1.1  kiyohara 		 * Make sure we recognise the GASP specifier and
    947  1.1  kiyohara 		 * version.
    948  1.1  kiyohara 		 */
    949  1.1  kiyohara 		p = mtod(m, uint32_t *);
    950  1.1  kiyohara 		if ((((ntohl(p[1]) & 0xffff) << 8) | ntohl(p[2]) >> 24) != 0x00005e
    951  1.1  kiyohara 		    || (ntohl(p[2]) & 0xffffff) != 1) {
    952  1.1  kiyohara 			FWIPDEBUG(ifp, "Unrecognised GASP header %#08x %#08x\n",
    953  1.1  kiyohara 			    ntohl(p[1]), ntohl(p[2]));
    954  1.1  kiyohara 			m_freem(m);
    955  1.1  kiyohara 			ifp->if_ierrors ++;
    956  1.1  kiyohara 			continue;
    957  1.1  kiyohara 		}
    958  1.1  kiyohara 
    959  1.1  kiyohara 		/*
    960  1.1  kiyohara 		 * Record the sender ID for possible BPF usage.
    961  1.1  kiyohara 		 */
    962  1.1  kiyohara 		src = ntohl(p[1]) >> 16;
    963  1.8  kiyohara 		if (bpf_peers_present(ifp->if_bpf)) {
    964  1.1  kiyohara 			mtag = m_tag_alloc(MTAG_FIREWIRE,
    965  1.1  kiyohara 			    MTAG_FIREWIRE_SENDER_EUID,
    966  1.1  kiyohara 			    2*sizeof(uint32_t), M_NOWAIT);
    967  1.1  kiyohara 			if (mtag) {
    968  1.1  kiyohara 				/* bpf wants it in network byte order */
    969  1.1  kiyohara 				struct fw_device *fd;
    970  1.1  kiyohara 				uint32_t *p2 = (uint32_t *) (mtag + 1);
    971  1.1  kiyohara 				fd = fw_noderesolve_nodeid(fwip->fd.fc,
    972  1.1  kiyohara 				    src & 0x3f);
    973  1.1  kiyohara 				if (fd) {
    974  1.1  kiyohara 					p2[0] = htonl(fd->eui.hi);
    975  1.1  kiyohara 					p2[1] = htonl(fd->eui.lo);
    976  1.1  kiyohara 				} else {
    977  1.1  kiyohara 					p2[0] = 0;
    978  1.1  kiyohara 					p2[1] = 0;
    979  1.1  kiyohara 				}
    980  1.1  kiyohara 				m_tag_prepend(m, mtag);
    981  1.1  kiyohara 			}
    982  1.1  kiyohara 		}
    983  1.1  kiyohara 
    984  1.1  kiyohara 		/*
    985  1.1  kiyohara 		 * Trim off the GASP header
    986  1.1  kiyohara 		 */
    987  1.1  kiyohara 		m_adj(m, 3*sizeof(uint32_t));
    988  1.1  kiyohara 		m->m_pkthdr.rcvif = ifp;
    989  1.1  kiyohara 		FIREWIRE_INPUT(ifp, m, src);
    990  1.1  kiyohara 		ifp->if_ipackets ++;
    991  1.1  kiyohara 	}
    992  1.1  kiyohara 	if (STAILQ_FIRST(&xferq->stfree) != NULL)
    993  1.1  kiyohara 		fwip->fd.fc->irx_enable(fwip->fd.fc, fwip->dma_ch);
    994  1.1  kiyohara }
    995  1.1  kiyohara 
    996  1.4     perry static inline void
    997  1.1  kiyohara fwip_unicast_input_recycle(struct fwip_softc *fwip, struct fw_xfer *xfer)
    998  1.1  kiyohara {
    999  1.1  kiyohara 	struct mbuf *m;
   1000  1.1  kiyohara 
   1001  1.1  kiyohara 	GIANT_REQUIRED;
   1002  1.1  kiyohara 
   1003  1.1  kiyohara 	/*
   1004  1.1  kiyohara 	 * We have finished with a unicast xfer. Allocate a new
   1005  1.1  kiyohara 	 * cluster and stick it on the back of the input queue.
   1006  1.1  kiyohara 	 */
   1007  1.2  kiyohara 	m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
   1008  1.2  kiyohara 	if (m == NULL)
   1009  1.2  kiyohara 		printf("fwip_unicast_input_recycle: m_getcl failed\n");
   1010  1.1  kiyohara 	xfer->mbuf = m;
   1011  1.1  kiyohara 	xfer->recv.payload = mtod(m, uint32_t *);
   1012  1.1  kiyohara 	xfer->recv.pay_len = MCLBYTES;
   1013  1.1  kiyohara 	xfer->mbuf = m;
   1014  1.1  kiyohara 	STAILQ_INSERT_TAIL(&fwip->fwb.xferlist, xfer, link);
   1015  1.1  kiyohara }
   1016  1.1  kiyohara 
   1017  1.1  kiyohara static void
   1018  1.1  kiyohara fwip_unicast_input(struct fw_xfer *xfer)
   1019  1.1  kiyohara {
   1020  1.1  kiyohara 	uint64_t address;
   1021  1.1  kiyohara 	struct mbuf *m;
   1022  1.1  kiyohara 	struct m_tag *mtag;
   1023  1.1  kiyohara 	struct ifnet *ifp;
   1024  1.1  kiyohara 	struct fwip_softc *fwip;
   1025  1.1  kiyohara 	struct fw_pkt *fp;
   1026  1.1  kiyohara 	//struct fw_pkt *sfp;
   1027  1.1  kiyohara 	int rtcode;
   1028  1.1  kiyohara 
   1029  1.1  kiyohara 	GIANT_REQUIRED;
   1030  1.1  kiyohara 
   1031  1.1  kiyohara 	fwip = (struct fwip_softc *)xfer->sc;
   1032  1.8  kiyohara 	ifp = fwip->fw_softc.fwip_ifp;
   1033  1.1  kiyohara 	m = xfer->mbuf;
   1034  1.1  kiyohara 	xfer->mbuf = 0;
   1035  1.1  kiyohara 	fp = &xfer->recv.hdr;
   1036  1.1  kiyohara 
   1037  1.1  kiyohara 	/*
   1038  1.1  kiyohara 	 * Check the fifo address - we only accept addresses of
   1039  1.1  kiyohara 	 * exactly INET_FIFO.
   1040  1.1  kiyohara 	 */
   1041  1.1  kiyohara 	address = ((uint64_t)fp->mode.wreqb.dest_hi << 32)
   1042  1.1  kiyohara 		| fp->mode.wreqb.dest_lo;
   1043  1.1  kiyohara 	if (fp->mode.wreqb.tcode != FWTCODE_WREQB) {
   1044  1.1  kiyohara 		rtcode = FWRCODE_ER_TYPE;
   1045  1.1  kiyohara 	} else if (address != INET_FIFO) {
   1046  1.1  kiyohara 		rtcode = FWRCODE_ER_ADDR;
   1047  1.1  kiyohara 	} else {
   1048  1.1  kiyohara 		rtcode = FWRCODE_COMPLETE;
   1049  1.1  kiyohara 	}
   1050  1.1  kiyohara 
   1051  1.1  kiyohara 	/*
   1052  1.1  kiyohara 	 * Pick up a new mbuf and stick it on the back of the receive
   1053  1.1  kiyohara 	 * queue.
   1054  1.1  kiyohara 	 */
   1055  1.1  kiyohara 	fwip_unicast_input_recycle(fwip, xfer);
   1056  1.1  kiyohara 
   1057  1.1  kiyohara 	/*
   1058  1.1  kiyohara 	 * If we've already rejected the packet, give up now.
   1059  1.1  kiyohara 	 */
   1060  1.1  kiyohara 	if (rtcode != FWRCODE_COMPLETE) {
   1061  1.1  kiyohara 		m_freem(m);
   1062  1.1  kiyohara 		ifp->if_ierrors ++;
   1063  1.1  kiyohara 		return;
   1064  1.1  kiyohara 	}
   1065  1.1  kiyohara 
   1066  1.8  kiyohara 	if (bpf_peers_present(ifp->if_bpf)) {
   1067  1.1  kiyohara 		/*
   1068  1.1  kiyohara 		 * Record the sender ID for possible BPF usage.
   1069  1.1  kiyohara 		 */
   1070  1.1  kiyohara 		mtag = m_tag_alloc(MTAG_FIREWIRE, MTAG_FIREWIRE_SENDER_EUID,
   1071  1.1  kiyohara 		    2*sizeof(uint32_t), M_NOWAIT);
   1072  1.1  kiyohara 		if (mtag) {
   1073  1.1  kiyohara 			/* bpf wants it in network byte order */
   1074  1.1  kiyohara 			struct fw_device *fd;
   1075  1.1  kiyohara 			uint32_t *p = (uint32_t *) (mtag + 1);
   1076  1.1  kiyohara 			fd = fw_noderesolve_nodeid(fwip->fd.fc,
   1077  1.1  kiyohara 			    fp->mode.wreqb.src & 0x3f);
   1078  1.1  kiyohara 			if (fd) {
   1079  1.1  kiyohara 				p[0] = htonl(fd->eui.hi);
   1080  1.1  kiyohara 				p[1] = htonl(fd->eui.lo);
   1081  1.1  kiyohara 			} else {
   1082  1.1  kiyohara 				p[0] = 0;
   1083  1.1  kiyohara 				p[1] = 0;
   1084  1.1  kiyohara 			}
   1085  1.1  kiyohara 			m_tag_prepend(m, mtag);
   1086  1.1  kiyohara 		}
   1087  1.1  kiyohara 	}
   1088  1.1  kiyohara 
   1089  1.1  kiyohara 	/*
   1090  1.1  kiyohara 	 * Hand off to the generic encapsulation code. We don't use
   1091  1.1  kiyohara 	 * ifp->if_input so that we can pass the source nodeid as an
   1092  1.1  kiyohara 	 * argument to facilitate link-level fragment reassembly.
   1093  1.1  kiyohara 	 */
   1094  1.1  kiyohara 	m->m_len = m->m_pkthdr.len = fp->mode.wreqb.len;
   1095  1.1  kiyohara 	m->m_pkthdr.rcvif = ifp;
   1096  1.1  kiyohara 	FIREWIRE_INPUT(ifp, m, fp->mode.wreqb.src);
   1097  1.1  kiyohara 	ifp->if_ipackets ++;
   1098  1.1  kiyohara }
   1099  1.1  kiyohara 
   1100  1.1  kiyohara #if defined(__FreeBSD__)
   1101  1.1  kiyohara static devclass_t fwip_devclass;
   1102  1.1  kiyohara 
   1103  1.1  kiyohara static device_method_t fwip_methods[] = {
   1104  1.1  kiyohara 	/* device interface */
   1105  1.1  kiyohara 	DEVMETHOD(device_identify,	fwip_identify),
   1106  1.1  kiyohara 	DEVMETHOD(device_probe,		fwip_probe),
   1107  1.1  kiyohara 	DEVMETHOD(device_attach,	fwip_attach),
   1108  1.1  kiyohara 	DEVMETHOD(device_detach,	fwip_detach),
   1109  1.1  kiyohara 	{ 0, 0 }
   1110  1.1  kiyohara };
   1111  1.1  kiyohara 
   1112  1.1  kiyohara static driver_t fwip_driver = {
   1113  1.1  kiyohara         "fwip",
   1114  1.1  kiyohara 	fwip_methods,
   1115  1.1  kiyohara 	sizeof(struct fwip_softc),
   1116  1.1  kiyohara };
   1117  1.1  kiyohara 
   1118  1.1  kiyohara 
   1119  1.1  kiyohara #ifdef __DragonFly__
   1120  1.1  kiyohara DECLARE_DUMMY_MODULE(fwip);
   1121  1.1  kiyohara #endif
   1122  1.1  kiyohara DRIVER_MODULE(fwip, firewire, fwip_driver, fwip_devclass, 0, 0);
   1123  1.1  kiyohara MODULE_VERSION(fwip, 1);
   1124  1.1  kiyohara MODULE_DEPEND(fwip, firewire, 1, 1, 1);
   1125  1.1  kiyohara #elif defined(__NetBSD__)
   1126  1.1  kiyohara CFATTACH_DECL(fwip, sizeof (struct fwip_softc),
   1127  1.1  kiyohara     fwipmatch, fwipattach, fwipdetach, NULL);
   1128  1.1  kiyohara #endif
   1129