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