1098ca2bdSWarner Losh /*- 277ee030bSHidetoshi Shimokawa * Copyright (c) 2002-2003 33c60ba66SKatsushi Kobayashi * Hidetoshi Shimokawa. All rights reserved. 43c60ba66SKatsushi Kobayashi * 53c60ba66SKatsushi Kobayashi * Redistribution and use in source and binary forms, with or without 63c60ba66SKatsushi Kobayashi * modification, are permitted provided that the following conditions 73c60ba66SKatsushi Kobayashi * are met: 83c60ba66SKatsushi Kobayashi * 1. Redistributions of source code must retain the above copyright 93c60ba66SKatsushi Kobayashi * notice, this list of conditions and the following disclaimer. 103c60ba66SKatsushi Kobayashi * 2. Redistributions in binary form must reproduce the above copyright 113c60ba66SKatsushi Kobayashi * notice, this list of conditions and the following disclaimer in the 123c60ba66SKatsushi Kobayashi * documentation and/or other materials provided with the distribution. 133c60ba66SKatsushi Kobayashi * 3. All advertising materials mentioning features or use of this software 143c60ba66SKatsushi Kobayashi * must display the following acknowledgement: 153c60ba66SKatsushi Kobayashi * 163c60ba66SKatsushi Kobayashi * This product includes software developed by Hidetoshi Shimokawa. 173c60ba66SKatsushi Kobayashi * 183c60ba66SKatsushi Kobayashi * 4. Neither the name of the author nor the names of its contributors 193c60ba66SKatsushi Kobayashi * may be used to endorse or promote products derived from this software 203c60ba66SKatsushi Kobayashi * without specific prior written permission. 213c60ba66SKatsushi Kobayashi * 223c60ba66SKatsushi Kobayashi * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 233c60ba66SKatsushi Kobayashi * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 243c60ba66SKatsushi Kobayashi * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 253c60ba66SKatsushi Kobayashi * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 263c60ba66SKatsushi Kobayashi * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 273c60ba66SKatsushi Kobayashi * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 283c60ba66SKatsushi Kobayashi * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 293c60ba66SKatsushi Kobayashi * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 303c60ba66SKatsushi Kobayashi * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 313c60ba66SKatsushi Kobayashi * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 323c60ba66SKatsushi Kobayashi * SUCH DAMAGE. 333c60ba66SKatsushi Kobayashi * 343c60ba66SKatsushi Kobayashi * $FreeBSD$ 353c60ba66SKatsushi Kobayashi */ 363c60ba66SKatsushi Kobayashi 37f0796cd2SGleb Smirnoff #ifdef HAVE_KERNEL_OPTION_HEADERS 38f0796cd2SGleb Smirnoff #include "opt_device_polling.h" 393c60ba66SKatsushi Kobayashi #include "opt_inet.h" 40f0796cd2SGleb Smirnoff #endif 413c60ba66SKatsushi Kobayashi 423c60ba66SKatsushi Kobayashi #include <sys/param.h> 433c60ba66SKatsushi Kobayashi #include <sys/kernel.h> 443c60ba66SKatsushi Kobayashi #include <sys/malloc.h> 453c60ba66SKatsushi Kobayashi #include <sys/mbuf.h> 463c60ba66SKatsushi Kobayashi #include <sys/socket.h> 473c60ba66SKatsushi Kobayashi #include <sys/sockio.h> 483c60ba66SKatsushi Kobayashi #include <sys/sysctl.h> 493c60ba66SKatsushi Kobayashi #include <sys/systm.h> 503c60ba66SKatsushi Kobayashi #include <sys/module.h> 513c60ba66SKatsushi Kobayashi #include <sys/bus.h> 5277ee030bSHidetoshi Shimokawa #include <machine/bus.h> 533c60ba66SKatsushi Kobayashi 543c60ba66SKatsushi Kobayashi #include <net/bpf.h> 553c60ba66SKatsushi Kobayashi #include <net/ethernet.h> 563c60ba66SKatsushi Kobayashi #include <net/if.h> 573c60ba66SKatsushi Kobayashi #include <net/if_arp.h> 58fc74a9f9SBrooks Davis #include <net/if_types.h> 5910d3ed64SHidetoshi Shimokawa #ifdef __DragonFly__ 6010d3ed64SHidetoshi Shimokawa #include <net/vlan/if_vlan_var.h> 6110d3ed64SHidetoshi Shimokawa #include <bus/firewire/firewire.h> 6210d3ed64SHidetoshi Shimokawa #include <bus/firewire/firewirereg.h> 6310d3ed64SHidetoshi Shimokawa #include "if_fwevar.h" 6410d3ed64SHidetoshi Shimokawa #else 653c60ba66SKatsushi Kobayashi #include <net/if_vlan_var.h> 663c60ba66SKatsushi Kobayashi 673c60ba66SKatsushi Kobayashi #include <dev/firewire/firewire.h> 683c60ba66SKatsushi Kobayashi #include <dev/firewire/firewirereg.h> 693c60ba66SKatsushi Kobayashi #include <dev/firewire/if_fwevar.h> 7010d3ed64SHidetoshi Shimokawa #endif 713c60ba66SKatsushi Kobayashi 72ed32ba83SHidetoshi Shimokawa #define FWEDEBUG if (fwedebug) if_printf 732b4601d1SHidetoshi Shimokawa #define TX_MAX_QUEUE (FWMAXQUEUE - 1) 743c60ba66SKatsushi Kobayashi 753c60ba66SKatsushi Kobayashi /* network interface */ 76d09a5d6fSHidetoshi Shimokawa static void fwe_start (struct ifnet *); 77d09a5d6fSHidetoshi Shimokawa static int fwe_ioctl (struct ifnet *, u_long, caddr_t); 78d09a5d6fSHidetoshi Shimokawa static void fwe_init (void *); 793c60ba66SKatsushi Kobayashi 80d09a5d6fSHidetoshi Shimokawa static void fwe_output_callback (struct fw_xfer *); 81d09a5d6fSHidetoshi Shimokawa static void fwe_as_output (struct fwe_softc *, struct ifnet *); 82d09a5d6fSHidetoshi Shimokawa static void fwe_as_input (struct fw_xferq *); 833c60ba66SKatsushi Kobayashi 843c60ba66SKatsushi Kobayashi static int fwedebug = 0; 853c60ba66SKatsushi Kobayashi static int stream_ch = 1; 86efd4a0c1SHidetoshi Shimokawa static int tx_speed = 2; 8786224a57SHidetoshi Shimokawa static int rx_queue_len = FWMAXQUEUE; 883c60ba66SKatsushi Kobayashi 89ee126d67SHidetoshi Shimokawa MALLOC_DEFINE(M_FWE, "if_fwe", "Ethernet over FireWire interface"); 903c60ba66SKatsushi Kobayashi SYSCTL_INT(_debug, OID_AUTO, if_fwe_debug, CTLFLAG_RW, &fwedebug, 0, ""); 913c60ba66SKatsushi Kobayashi SYSCTL_DECL(_hw_firewire); 923c60ba66SKatsushi Kobayashi SYSCTL_NODE(_hw_firewire, OID_AUTO, fwe, CTLFLAG_RD, 0, 9386224a57SHidetoshi Shimokawa "Ethernet emulation subsystem"); 943c60ba66SKatsushi Kobayashi SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, stream_ch, CTLFLAG_RW, &stream_ch, 0, 953c60ba66SKatsushi Kobayashi "Stream channel to use"); 96efd4a0c1SHidetoshi Shimokawa SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, tx_speed, CTLFLAG_RW, &tx_speed, 0, 9786224a57SHidetoshi Shimokawa "Transmission speed"); 9886224a57SHidetoshi Shimokawa SYSCTL_INT(_hw_firewire_fwe, OID_AUTO, rx_queue_len, CTLFLAG_RW, &rx_queue_len, 9986224a57SHidetoshi Shimokawa 0, "Length of the receive queue"); 10086224a57SHidetoshi Shimokawa 10186224a57SHidetoshi Shimokawa TUNABLE_INT("hw.firewire.fwe.stream_ch", &stream_ch); 10286224a57SHidetoshi Shimokawa TUNABLE_INT("hw.firewire.fwe.tx_speed", &tx_speed); 10386224a57SHidetoshi Shimokawa TUNABLE_INT("hw.firewire.fwe.rx_queue_len", &rx_queue_len); 1043c60ba66SKatsushi Kobayashi 1053c60ba66SKatsushi Kobayashi #ifdef DEVICE_POLLING 1063c60ba66SKatsushi Kobayashi static poll_handler_t fwe_poll; 1073c60ba66SKatsushi Kobayashi 1083c60ba66SKatsushi Kobayashi static void 1093c60ba66SKatsushi Kobayashi fwe_poll(struct ifnet *ifp, enum poll_cmd cmd, int count) 1103c60ba66SKatsushi Kobayashi { 1113c60ba66SKatsushi Kobayashi struct fwe_softc *fwe; 1123c60ba66SKatsushi Kobayashi struct firewire_comm *fc; 1133c60ba66SKatsushi Kobayashi 11440929967SGleb Smirnoff if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 11540929967SGleb Smirnoff return; 11640929967SGleb Smirnoff 1173c60ba66SKatsushi Kobayashi fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe; 1183c60ba66SKatsushi Kobayashi fc = fwe->fd.fc; 1193c60ba66SKatsushi Kobayashi fc->poll(fc, (cmd == POLL_AND_CHECK_STATUS)?0:1, count); 1203c60ba66SKatsushi Kobayashi } 12140929967SGleb Smirnoff #endif /* DEVICE_POLLING */ 12240929967SGleb Smirnoff 1233c60ba66SKatsushi Kobayashi static void 1243c60ba66SKatsushi Kobayashi fwe_identify(driver_t *driver, device_t parent) 1253c60ba66SKatsushi Kobayashi { 1265e7c89e4SHidetoshi Shimokawa BUS_ADD_CHILD(parent, 0, "fwe", device_get_unit(parent)); 1273c60ba66SKatsushi Kobayashi } 1283c60ba66SKatsushi Kobayashi 1293c60ba66SKatsushi Kobayashi static int 1303c60ba66SKatsushi Kobayashi fwe_probe(device_t dev) 1313c60ba66SKatsushi Kobayashi { 1323c60ba66SKatsushi Kobayashi device_t pa; 1333c60ba66SKatsushi Kobayashi 1343c60ba66SKatsushi Kobayashi pa = device_get_parent(dev); 1353c60ba66SKatsushi Kobayashi if(device_get_unit(dev) != device_get_unit(pa)){ 1363c60ba66SKatsushi Kobayashi return(ENXIO); 1373c60ba66SKatsushi Kobayashi } 1383c60ba66SKatsushi Kobayashi 139ee126d67SHidetoshi Shimokawa device_set_desc(dev, "Ethernet over FireWire"); 1403c60ba66SKatsushi Kobayashi return (0); 1413c60ba66SKatsushi Kobayashi } 1423c60ba66SKatsushi Kobayashi 1433c60ba66SKatsushi Kobayashi static int 1443c60ba66SKatsushi Kobayashi fwe_attach(device_t dev) 1453c60ba66SKatsushi Kobayashi { 1463c60ba66SKatsushi Kobayashi struct fwe_softc *fwe; 1473c60ba66SKatsushi Kobayashi struct ifnet *ifp; 1483c60ba66SKatsushi Kobayashi int unit, s; 149fc74a9f9SBrooks Davis #if defined(__DragonFly__) || __FreeBSD_version < 500000 1503c60ba66SKatsushi Kobayashi u_char *eaddr; 151fc74a9f9SBrooks Davis #else 152fc74a9f9SBrooks Davis u_char eaddr[6]; 153fc74a9f9SBrooks Davis #endif 154c547b896SHidetoshi Shimokawa struct fw_eui64 *eui; 1553c60ba66SKatsushi Kobayashi 1563c60ba66SKatsushi Kobayashi fwe = ((struct fwe_softc *)device_get_softc(dev)); 1573c60ba66SKatsushi Kobayashi unit = device_get_unit(dev); 1583c60ba66SKatsushi Kobayashi 1593c60ba66SKatsushi Kobayashi bzero(fwe, sizeof(struct fwe_softc)); 1609950b741SHidetoshi Shimokawa mtx_init(&fwe->mtx, "fwe", NULL, MTX_DEF); 1613c60ba66SKatsushi Kobayashi /* XXX */ 1623c60ba66SKatsushi Kobayashi fwe->stream_ch = stream_ch; 1633c60ba66SKatsushi Kobayashi fwe->dma_ch = -1; 1643c60ba66SKatsushi Kobayashi 1653c60ba66SKatsushi Kobayashi fwe->fd.fc = device_get_ivars(dev); 16611fe2492SHidetoshi Shimokawa if (tx_speed < 0) 16711fe2492SHidetoshi Shimokawa tx_speed = fwe->fd.fc->speed; 16811fe2492SHidetoshi Shimokawa 1693c60ba66SKatsushi Kobayashi fwe->fd.dev = dev; 1703c60ba66SKatsushi Kobayashi fwe->fd.post_explore = NULL; 1713c60ba66SKatsushi Kobayashi fwe->eth_softc.fwe = fwe; 1723c60ba66SKatsushi Kobayashi 1733c60ba66SKatsushi Kobayashi fwe->pkt_hdr.mode.stream.tcode = FWTCODE_STREAM; 1743c60ba66SKatsushi Kobayashi fwe->pkt_hdr.mode.stream.sy = 0; 1753c60ba66SKatsushi Kobayashi fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch; 1763c60ba66SKatsushi Kobayashi 1773c60ba66SKatsushi Kobayashi /* generate fake MAC address: first and last 3bytes from eui64 */ 1783c60ba66SKatsushi Kobayashi #define LOCAL (0x02) 1793c60ba66SKatsushi Kobayashi #define GROUP (0x01) 180fc74a9f9SBrooks Davis #if defined(__DragonFly__) || __FreeBSD_version < 500000 181fc74a9f9SBrooks Davis eaddr = &IFP2ENADDR(fwe->eth_softc.ifp)[0]; 182fc74a9f9SBrooks Davis #endif 183fc74a9f9SBrooks Davis 184c547b896SHidetoshi Shimokawa 185c547b896SHidetoshi Shimokawa eui = &fwe->fd.fc->eui; 186c547b896SHidetoshi Shimokawa eaddr[0] = (FW_EUI64_BYTE(eui, 0) | LOCAL) & ~GROUP; 187c547b896SHidetoshi Shimokawa eaddr[1] = FW_EUI64_BYTE(eui, 1); 188c547b896SHidetoshi Shimokawa eaddr[2] = FW_EUI64_BYTE(eui, 2); 189c547b896SHidetoshi Shimokawa eaddr[3] = FW_EUI64_BYTE(eui, 5); 190c547b896SHidetoshi Shimokawa eaddr[4] = FW_EUI64_BYTE(eui, 6); 191c547b896SHidetoshi Shimokawa eaddr[5] = FW_EUI64_BYTE(eui, 7); 19217c3d42cSHidetoshi Shimokawa printf("if_fwe%d: Fake Ethernet address: " 19317c3d42cSHidetoshi Shimokawa "%02x:%02x:%02x:%02x:%02x:%02x\n", unit, 1943c60ba66SKatsushi Kobayashi eaddr[0], eaddr[1], eaddr[2], eaddr[3], eaddr[4], eaddr[5]); 1953c60ba66SKatsushi Kobayashi 1963c60ba66SKatsushi Kobayashi /* fill the rest and attach interface */ 197fc74a9f9SBrooks Davis ifp = fwe->eth_softc.ifp = if_alloc(IFT_ETHER); 198fc74a9f9SBrooks Davis if (ifp == NULL) { 199fc74a9f9SBrooks Davis device_printf(dev, "can not if_alloc()\n"); 200fc74a9f9SBrooks Davis return (ENOSPC); 201fc74a9f9SBrooks Davis } 2023c60ba66SKatsushi Kobayashi ifp->if_softc = &fwe->eth_softc; 2033c60ba66SKatsushi Kobayashi 20410d3ed64SHidetoshi Shimokawa #if __FreeBSD_version >= 501113 || defined(__DragonFly__) 2055e7c89e4SHidetoshi Shimokawa if_initname(ifp, device_get_name(dev), unit); 20634ea46a7SHidetoshi Shimokawa #else 20734ea46a7SHidetoshi Shimokawa ifp->if_unit = unit; 20834ea46a7SHidetoshi Shimokawa ifp->if_name = "fwe"; 20934ea46a7SHidetoshi Shimokawa #endif 2103c60ba66SKatsushi Kobayashi ifp->if_init = fwe_init; 211f77993e5SHidetoshi Shimokawa #if defined(__DragonFly__) || __FreeBSD_version < 500000 212f77993e5SHidetoshi Shimokawa ifp->if_output = ether_output; 213f77993e5SHidetoshi Shimokawa #endif 2143c60ba66SKatsushi Kobayashi ifp->if_start = fwe_start; 2153c60ba66SKatsushi Kobayashi ifp->if_ioctl = fwe_ioctl; 2163c60ba66SKatsushi Kobayashi ifp->if_mtu = ETHERMTU; 2179950b741SHidetoshi Shimokawa ifp->if_flags = (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST); 2182b4601d1SHidetoshi Shimokawa ifp->if_snd.ifq_maxlen = TX_MAX_QUEUE; 2193c60ba66SKatsushi Kobayashi 2203c60ba66SKatsushi Kobayashi s = splimp(); 22110d3ed64SHidetoshi Shimokawa #if defined(__DragonFly__) || __FreeBSD_version < 500000 222a4239576SHidetoshi Shimokawa ether_ifattach(ifp, 1); 22310d3ed64SHidetoshi Shimokawa #else 22410d3ed64SHidetoshi Shimokawa ether_ifattach(ifp, eaddr); 225a4239576SHidetoshi Shimokawa #endif 2263c60ba66SKatsushi Kobayashi splx(s); 2273c60ba66SKatsushi Kobayashi 2283c60ba66SKatsushi Kobayashi /* Tell the upper layer(s) we support long frames. */ 2293c60ba66SKatsushi Kobayashi ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header); 23010d3ed64SHidetoshi Shimokawa #if defined(__FreeBSD__) && __FreeBSD_version >= 500000 231b7d59baaSGleb Smirnoff ifp->if_capabilities |= IFCAP_VLAN_MTU | IFCAP_POLLING; 2327560265cSYaroslav Tykhiy ifp->if_capenable |= IFCAP_VLAN_MTU; 233a4239576SHidetoshi Shimokawa #endif 2343c60ba66SKatsushi Kobayashi 2353c60ba66SKatsushi Kobayashi 236ed32ba83SHidetoshi Shimokawa FWEDEBUG(ifp, "interface created\n"); 2373c60ba66SKatsushi Kobayashi return 0; 2383c60ba66SKatsushi Kobayashi } 2393c60ba66SKatsushi Kobayashi 2403c60ba66SKatsushi Kobayashi static void 2413c60ba66SKatsushi Kobayashi fwe_stop(struct fwe_softc *fwe) 2423c60ba66SKatsushi Kobayashi { 2433c60ba66SKatsushi Kobayashi struct firewire_comm *fc; 2443c60ba66SKatsushi Kobayashi struct fw_xferq *xferq; 245fc74a9f9SBrooks Davis struct ifnet *ifp = fwe->eth_softc.ifp; 2462b4601d1SHidetoshi Shimokawa struct fw_xfer *xfer, *next; 2472b4601d1SHidetoshi Shimokawa int i; 2483c60ba66SKatsushi Kobayashi 2493c60ba66SKatsushi Kobayashi fc = fwe->fd.fc; 2503c60ba66SKatsushi Kobayashi 2513c60ba66SKatsushi Kobayashi if (fwe->dma_ch >= 0) { 2523c60ba66SKatsushi Kobayashi xferq = fc->ir[fwe->dma_ch]; 2533c60ba66SKatsushi Kobayashi 2543c60ba66SKatsushi Kobayashi if (xferq->flag & FWXFERQ_RUNNING) 2553c60ba66SKatsushi Kobayashi fc->irx_disable(fc, fwe->dma_ch); 2563c60ba66SKatsushi Kobayashi xferq->flag &= 25777ee030bSHidetoshi Shimokawa ~(FWXFERQ_MODEMASK | FWXFERQ_OPEN | FWXFERQ_STREAM | 25877ee030bSHidetoshi Shimokawa FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_CHTAGMASK); 2592b4601d1SHidetoshi Shimokawa xferq->hand = NULL; 2602b4601d1SHidetoshi Shimokawa 2612b4601d1SHidetoshi Shimokawa for (i = 0; i < xferq->bnchunk; i ++) 2622b4601d1SHidetoshi Shimokawa m_freem(xferq->bulkxfer[i].mbuf); 2632b4601d1SHidetoshi Shimokawa free(xferq->bulkxfer, M_FWE); 2642b4601d1SHidetoshi Shimokawa 2652b4601d1SHidetoshi Shimokawa for (xfer = STAILQ_FIRST(&fwe->xferlist); xfer != NULL; 2662b4601d1SHidetoshi Shimokawa xfer = next) { 2672b4601d1SHidetoshi Shimokawa next = STAILQ_NEXT(xfer, link); 2682b4601d1SHidetoshi Shimokawa fw_xfer_free(xfer); 2692b4601d1SHidetoshi Shimokawa } 2702b4601d1SHidetoshi Shimokawa STAILQ_INIT(&fwe->xferlist); 2712b4601d1SHidetoshi Shimokawa 2722b4601d1SHidetoshi Shimokawa xferq->bulkxfer = NULL; 2733c60ba66SKatsushi Kobayashi fwe->dma_ch = -1; 2743c60ba66SKatsushi Kobayashi } 2753c60ba66SKatsushi Kobayashi 27613f4c340SRobert Watson #if defined(__FreeBSD__) 27713f4c340SRobert Watson ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 27813f4c340SRobert Watson #else 2793c60ba66SKatsushi Kobayashi ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 28013f4c340SRobert Watson #endif 2813c60ba66SKatsushi Kobayashi } 2823c60ba66SKatsushi Kobayashi 2833c60ba66SKatsushi Kobayashi static int 2843c60ba66SKatsushi Kobayashi fwe_detach(device_t dev) 2853c60ba66SKatsushi Kobayashi { 2863c60ba66SKatsushi Kobayashi struct fwe_softc *fwe; 287fc74a9f9SBrooks Davis struct ifnet *ifp; 2883c60ba66SKatsushi Kobayashi int s; 2893c60ba66SKatsushi Kobayashi 290fc74a9f9SBrooks Davis fwe = device_get_softc(dev); 291fc74a9f9SBrooks Davis ifp = fwe->eth_softc.ifp; 29240929967SGleb Smirnoff 29340929967SGleb Smirnoff #ifdef DEVICE_POLLING 29440929967SGleb Smirnoff if (ifp->if_capenable & IFCAP_POLLING) 29540929967SGleb Smirnoff ether_poll_deregister(ifp); 29640929967SGleb Smirnoff #endif 2973c60ba66SKatsushi Kobayashi s = splimp(); 2983c60ba66SKatsushi Kobayashi 2993c60ba66SKatsushi Kobayashi fwe_stop(fwe); 30010d3ed64SHidetoshi Shimokawa #if defined(__DragonFly__) || __FreeBSD_version < 500000 301fc74a9f9SBrooks Davis ether_ifdetach(ifp, 1); 30210d3ed64SHidetoshi Shimokawa #else 303fc74a9f9SBrooks Davis ether_ifdetach(ifp); 304fc74a9f9SBrooks Davis if_free(ifp); 305a4239576SHidetoshi Shimokawa #endif 3063c60ba66SKatsushi Kobayashi 3073c60ba66SKatsushi Kobayashi splx(s); 3089950b741SHidetoshi Shimokawa mtx_destroy(&fwe->mtx); 3093c60ba66SKatsushi Kobayashi return 0; 3103c60ba66SKatsushi Kobayashi } 3113c60ba66SKatsushi Kobayashi 3123c60ba66SKatsushi Kobayashi static void 3133c60ba66SKatsushi Kobayashi fwe_init(void *arg) 3143c60ba66SKatsushi Kobayashi { 3153c60ba66SKatsushi Kobayashi struct fwe_softc *fwe = ((struct fwe_eth_softc *)arg)->fwe; 3163c60ba66SKatsushi Kobayashi struct firewire_comm *fc; 317fc74a9f9SBrooks Davis struct ifnet *ifp = fwe->eth_softc.ifp; 3183c60ba66SKatsushi Kobayashi struct fw_xferq *xferq; 3192b4601d1SHidetoshi Shimokawa struct fw_xfer *xfer; 32077ee030bSHidetoshi Shimokawa struct mbuf *m; 3213c60ba66SKatsushi Kobayashi int i; 3223c60ba66SKatsushi Kobayashi 323ed32ba83SHidetoshi Shimokawa FWEDEBUG(ifp, "initializing\n"); 3243c60ba66SKatsushi Kobayashi 3253c60ba66SKatsushi Kobayashi /* XXX keep promiscoud mode */ 3263c60ba66SKatsushi Kobayashi ifp->if_flags |= IFF_PROMISC; 3273c60ba66SKatsushi Kobayashi 3283c60ba66SKatsushi Kobayashi fc = fwe->fd.fc; 3293c60ba66SKatsushi Kobayashi if (fwe->dma_ch < 0) { 3309950b741SHidetoshi Shimokawa fwe->dma_ch = fw_open_isodma(fc, /* tx */0); 3319950b741SHidetoshi Shimokawa if (fwe->dma_ch < 0) 3323c60ba66SKatsushi Kobayashi return; 3339950b741SHidetoshi Shimokawa xferq = fc->ir[fwe->dma_ch]; 3349950b741SHidetoshi Shimokawa xferq->flag |= FWXFERQ_EXTBUF | 3359950b741SHidetoshi Shimokawa FWXFERQ_HANDLER | FWXFERQ_STREAM; 3363c60ba66SKatsushi Kobayashi fwe->stream_ch = stream_ch; 3373c60ba66SKatsushi Kobayashi fwe->pkt_hdr.mode.stream.chtag = fwe->stream_ch; 33858089a20SHidetoshi Shimokawa xferq->flag &= ~0xff; 3393c60ba66SKatsushi Kobayashi xferq->flag |= fwe->stream_ch & 0xff; 3403c60ba66SKatsushi Kobayashi /* register fwe_input handler */ 3413c60ba66SKatsushi Kobayashi xferq->sc = (caddr_t) fwe; 3423c60ba66SKatsushi Kobayashi xferq->hand = fwe_as_input; 34386224a57SHidetoshi Shimokawa xferq->bnchunk = rx_queue_len; 3442b4601d1SHidetoshi Shimokawa xferq->bnpacket = 1; 3452b4601d1SHidetoshi Shimokawa xferq->psize = MCLBYTES; 3462b4601d1SHidetoshi Shimokawa xferq->queued = 0; 34777ee030bSHidetoshi Shimokawa xferq->buf = NULL; 3482b4601d1SHidetoshi Shimokawa xferq->bulkxfer = (struct fw_bulkxfer *) malloc( 34977ee030bSHidetoshi Shimokawa sizeof(struct fw_bulkxfer) * xferq->bnchunk, 35077ee030bSHidetoshi Shimokawa M_FWE, M_WAITOK); 3512b4601d1SHidetoshi Shimokawa if (xferq->bulkxfer == NULL) { 3522b4601d1SHidetoshi Shimokawa printf("if_fwe: malloc failed\n"); 3532b4601d1SHidetoshi Shimokawa return; 3542b4601d1SHidetoshi Shimokawa } 3552b4601d1SHidetoshi Shimokawa STAILQ_INIT(&xferq->stvalid); 3562b4601d1SHidetoshi Shimokawa STAILQ_INIT(&xferq->stfree); 3572b4601d1SHidetoshi Shimokawa STAILQ_INIT(&xferq->stdma); 3582b4601d1SHidetoshi Shimokawa xferq->stproc = NULL; 3592b4601d1SHidetoshi Shimokawa for (i = 0; i < xferq->bnchunk; i ++) { 36077ee030bSHidetoshi Shimokawa m = 36110d3ed64SHidetoshi Shimokawa #if defined(__DragonFly__) || __FreeBSD_version < 500000 3622b4601d1SHidetoshi Shimokawa m_getcl(M_WAIT, MT_DATA, M_PKTHDR); 36310d3ed64SHidetoshi Shimokawa #else 36410d3ed64SHidetoshi Shimokawa m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR); 3652b4601d1SHidetoshi Shimokawa #endif 36677ee030bSHidetoshi Shimokawa xferq->bulkxfer[i].mbuf = m; 36777ee030bSHidetoshi Shimokawa if (m != NULL) { 36877ee030bSHidetoshi Shimokawa m->m_len = m->m_pkthdr.len = m->m_ext.ext_size; 3692b4601d1SHidetoshi Shimokawa STAILQ_INSERT_TAIL(&xferq->stfree, 3702b4601d1SHidetoshi Shimokawa &xferq->bulkxfer[i], link); 37177ee030bSHidetoshi Shimokawa } else 3729950b741SHidetoshi Shimokawa printf("%s: m_getcl failed\n", __FUNCTION__); 3732b4601d1SHidetoshi Shimokawa } 3742b4601d1SHidetoshi Shimokawa STAILQ_INIT(&fwe->xferlist); 3752b4601d1SHidetoshi Shimokawa for (i = 0; i < TX_MAX_QUEUE; i++) { 3762b4601d1SHidetoshi Shimokawa xfer = fw_xfer_alloc(M_FWE); 3772b4601d1SHidetoshi Shimokawa if (xfer == NULL) 3782b4601d1SHidetoshi Shimokawa break; 379c4778b5dSHidetoshi Shimokawa xfer->send.spd = tx_speed; 3802b4601d1SHidetoshi Shimokawa xfer->fc = fwe->fd.fc; 3812b4601d1SHidetoshi Shimokawa xfer->sc = (caddr_t)fwe; 382801167a8SHidetoshi Shimokawa xfer->hand = fwe_output_callback; 3832b4601d1SHidetoshi Shimokawa STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link); 3842b4601d1SHidetoshi Shimokawa } 3853c60ba66SKatsushi Kobayashi } else 3863c60ba66SKatsushi Kobayashi xferq = fc->ir[fwe->dma_ch]; 3873c60ba66SKatsushi Kobayashi 3883c60ba66SKatsushi Kobayashi 3893c60ba66SKatsushi Kobayashi /* start dma */ 3903c60ba66SKatsushi Kobayashi if ((xferq->flag & FWXFERQ_RUNNING) == 0) 3913c60ba66SKatsushi Kobayashi fc->irx_enable(fc, fwe->dma_ch); 3923c60ba66SKatsushi Kobayashi 39313f4c340SRobert Watson #if defined(__FreeBSD__) 39413f4c340SRobert Watson ifp->if_drv_flags |= IFF_DRV_RUNNING; 39513f4c340SRobert Watson ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 39613f4c340SRobert Watson #else 3973c60ba66SKatsushi Kobayashi ifp->if_flags |= IFF_RUNNING; 3983c60ba66SKatsushi Kobayashi ifp->if_flags &= ~IFF_OACTIVE; 39913f4c340SRobert Watson #endif 4003c60ba66SKatsushi Kobayashi 4013c60ba66SKatsushi Kobayashi #if 0 4023c60ba66SKatsushi Kobayashi /* attempt to start output */ 4033c60ba66SKatsushi Kobayashi fwe_start(ifp); 4043c60ba66SKatsushi Kobayashi #endif 4053c60ba66SKatsushi Kobayashi } 4063c60ba66SKatsushi Kobayashi 4073c60ba66SKatsushi Kobayashi 4083c60ba66SKatsushi Kobayashi static int 4093c60ba66SKatsushi Kobayashi fwe_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 4103c60ba66SKatsushi Kobayashi { 4113c60ba66SKatsushi Kobayashi struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe; 4123c60ba66SKatsushi Kobayashi struct ifstat *ifs = NULL; 4133c60ba66SKatsushi Kobayashi int s, error, len; 4143c60ba66SKatsushi Kobayashi 4153c60ba66SKatsushi Kobayashi switch (cmd) { 4163c60ba66SKatsushi Kobayashi case SIOCSIFFLAGS: 4173c60ba66SKatsushi Kobayashi s = splimp(); 4183c60ba66SKatsushi Kobayashi if (ifp->if_flags & IFF_UP) { 41913f4c340SRobert Watson #if defined(__FreeBSD__) 42013f4c340SRobert Watson if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 42113f4c340SRobert Watson #else 4223c60ba66SKatsushi Kobayashi if (!(ifp->if_flags & IFF_RUNNING)) 42313f4c340SRobert Watson #endif 4243c60ba66SKatsushi Kobayashi fwe_init(&fwe->eth_softc); 4253c60ba66SKatsushi Kobayashi } else { 42613f4c340SRobert Watson #if defined(__FreeBSD__) 42713f4c340SRobert Watson if (ifp->if_drv_flags & IFF_DRV_RUNNING) 42813f4c340SRobert Watson #else 4293c60ba66SKatsushi Kobayashi if (ifp->if_flags & IFF_RUNNING) 43013f4c340SRobert Watson #endif 4313c60ba66SKatsushi Kobayashi fwe_stop(fwe); 4323c60ba66SKatsushi Kobayashi } 4333c60ba66SKatsushi Kobayashi /* XXX keep promiscoud mode */ 4343c60ba66SKatsushi Kobayashi ifp->if_flags |= IFF_PROMISC; 4353c60ba66SKatsushi Kobayashi splx(s); 4363c60ba66SKatsushi Kobayashi break; 4373c60ba66SKatsushi Kobayashi case SIOCADDMULTI: 4383c60ba66SKatsushi Kobayashi case SIOCDELMULTI: 4393c60ba66SKatsushi Kobayashi break; 4403c60ba66SKatsushi Kobayashi 4413c60ba66SKatsushi Kobayashi case SIOCGIFSTATUS: 4423c60ba66SKatsushi Kobayashi s = splimp(); 4433c60ba66SKatsushi Kobayashi ifs = (struct ifstat *)data; 4443c60ba66SKatsushi Kobayashi len = strlen(ifs->ascii); 4453c60ba66SKatsushi Kobayashi if (len < sizeof(ifs->ascii)) 4463c60ba66SKatsushi Kobayashi snprintf(ifs->ascii + len, 4473c60ba66SKatsushi Kobayashi sizeof(ifs->ascii) - len, 4483c60ba66SKatsushi Kobayashi "\tch %d dma %d\n", 4493c60ba66SKatsushi Kobayashi fwe->stream_ch, fwe->dma_ch); 4503c60ba66SKatsushi Kobayashi splx(s); 4513c60ba66SKatsushi Kobayashi break; 45240929967SGleb Smirnoff case SIOCSIFCAP: 45340929967SGleb Smirnoff #ifdef DEVICE_POLLING 45440929967SGleb Smirnoff { 45540929967SGleb Smirnoff struct ifreq *ifr = (struct ifreq *) data; 45640929967SGleb Smirnoff struct firewire_comm *fc = fc = fwe->fd.fc; 45740929967SGleb Smirnoff 45840929967SGleb Smirnoff if (ifr->ifr_reqcap & IFCAP_POLLING && 45940929967SGleb Smirnoff !(ifp->if_capenable & IFCAP_POLLING)) { 46040929967SGleb Smirnoff error = ether_poll_register(fwe_poll, ifp); 46140929967SGleb Smirnoff if (error) 46240929967SGleb Smirnoff return(error); 46340929967SGleb Smirnoff /* Disable interrupts */ 46440929967SGleb Smirnoff fc->set_intr(fc, 0); 46540929967SGleb Smirnoff ifp->if_capenable |= IFCAP_POLLING; 46640929967SGleb Smirnoff return (error); 46740929967SGleb Smirnoff } 46840929967SGleb Smirnoff if (!(ifr->ifr_reqcap & IFCAP_POLLING) && 46940929967SGleb Smirnoff ifp->if_capenable & IFCAP_POLLING) { 47040929967SGleb Smirnoff error = ether_poll_deregister(ifp); 47140929967SGleb Smirnoff /* Enable interrupts. */ 47240929967SGleb Smirnoff fc->set_intr(fc, 1); 47340929967SGleb Smirnoff ifp->if_capenable &= ~IFCAP_POLLING; 47440929967SGleb Smirnoff return (error); 47540929967SGleb Smirnoff } 47640929967SGleb Smirnoff } 47740929967SGleb Smirnoff #endif /* DEVICE_POLLING */ 47840929967SGleb Smirnoff break; 47910d3ed64SHidetoshi Shimokawa #if defined(__FreeBSD__) && __FreeBSD_version >= 500000 4803c60ba66SKatsushi Kobayashi default: 481a4239576SHidetoshi Shimokawa #else 482a4239576SHidetoshi Shimokawa case SIOCSIFADDR: 483a4239576SHidetoshi Shimokawa case SIOCGIFADDR: 484a4239576SHidetoshi Shimokawa case SIOCSIFMTU: 485a4239576SHidetoshi Shimokawa #endif 486673d9191SSam Leffler s = splimp(); 487673d9191SSam Leffler error = ether_ioctl(ifp, cmd, data); 488673d9191SSam Leffler splx(s); 489673d9191SSam Leffler return (error); 49010d3ed64SHidetoshi Shimokawa #if defined(__DragonFly__) || __FreeBSD_version < 500000 491a4239576SHidetoshi Shimokawa default: 492a4239576SHidetoshi Shimokawa return (EINVAL); 493a4239576SHidetoshi Shimokawa #endif 4943c60ba66SKatsushi Kobayashi } 4953c60ba66SKatsushi Kobayashi 4963c60ba66SKatsushi Kobayashi return (0); 4973c60ba66SKatsushi Kobayashi } 4983c60ba66SKatsushi Kobayashi 4993c60ba66SKatsushi Kobayashi static void 5002b4601d1SHidetoshi Shimokawa fwe_output_callback(struct fw_xfer *xfer) 5012b4601d1SHidetoshi Shimokawa { 5022b4601d1SHidetoshi Shimokawa struct fwe_softc *fwe; 5032b4601d1SHidetoshi Shimokawa struct ifnet *ifp; 5042b4601d1SHidetoshi Shimokawa int s; 5052b4601d1SHidetoshi Shimokawa 5062b4601d1SHidetoshi Shimokawa fwe = (struct fwe_softc *)xfer->sc; 507fc74a9f9SBrooks Davis ifp = fwe->eth_softc.ifp; 5082b4601d1SHidetoshi Shimokawa /* XXX error check */ 509ed32ba83SHidetoshi Shimokawa FWEDEBUG(ifp, "resp = %d\n", xfer->resp); 5102b4601d1SHidetoshi Shimokawa if (xfer->resp != 0) 5112b4601d1SHidetoshi Shimokawa ifp->if_oerrors ++; 5122b4601d1SHidetoshi Shimokawa 5132b4601d1SHidetoshi Shimokawa m_freem(xfer->mbuf); 5142b4601d1SHidetoshi Shimokawa fw_xfer_unload(xfer); 51577ee030bSHidetoshi Shimokawa 5162b4601d1SHidetoshi Shimokawa s = splimp(); 5179950b741SHidetoshi Shimokawa FWE_LOCK(fwe); 5182b4601d1SHidetoshi Shimokawa STAILQ_INSERT_TAIL(&fwe->xferlist, xfer, link); 5199950b741SHidetoshi Shimokawa FWE_UNLOCK(fwe); 5202b4601d1SHidetoshi Shimokawa splx(s); 52177ee030bSHidetoshi Shimokawa 52277ee030bSHidetoshi Shimokawa /* for queue full */ 5232b4601d1SHidetoshi Shimokawa if (ifp->if_snd.ifq_head != NULL) 5242b4601d1SHidetoshi Shimokawa fwe_start(ifp); 5252b4601d1SHidetoshi Shimokawa } 5262b4601d1SHidetoshi Shimokawa 5272b4601d1SHidetoshi Shimokawa static void 5283c60ba66SKatsushi Kobayashi fwe_start(struct ifnet *ifp) 5293c60ba66SKatsushi Kobayashi { 5303c60ba66SKatsushi Kobayashi struct fwe_softc *fwe = ((struct fwe_eth_softc *)ifp->if_softc)->fwe; 5313c60ba66SKatsushi Kobayashi int s; 5323c60ba66SKatsushi Kobayashi 533ed32ba83SHidetoshi Shimokawa FWEDEBUG(ifp, "starting\n"); 5343c60ba66SKatsushi Kobayashi 5353c60ba66SKatsushi Kobayashi if (fwe->dma_ch < 0) { 5363c60ba66SKatsushi Kobayashi struct mbuf *m = NULL; 5373c60ba66SKatsushi Kobayashi 538ed32ba83SHidetoshi Shimokawa FWEDEBUG(ifp, "not ready\n"); 5393c60ba66SKatsushi Kobayashi 5403c60ba66SKatsushi Kobayashi s = splimp(); 5413c60ba66SKatsushi Kobayashi do { 5423c60ba66SKatsushi Kobayashi IF_DEQUEUE(&ifp->if_snd, m); 5433c60ba66SKatsushi Kobayashi if (m != NULL) 5443c60ba66SKatsushi Kobayashi m_freem(m); 5453c60ba66SKatsushi Kobayashi ifp->if_oerrors ++; 5463c60ba66SKatsushi Kobayashi } while (m != NULL); 5473c60ba66SKatsushi Kobayashi splx(s); 5483c60ba66SKatsushi Kobayashi 5493c60ba66SKatsushi Kobayashi return; 5503c60ba66SKatsushi Kobayashi } 5513c60ba66SKatsushi Kobayashi 5523c60ba66SKatsushi Kobayashi s = splimp(); 55313f4c340SRobert Watson #if defined(__FreeBSD__) 55413f4c340SRobert Watson ifp->if_drv_flags |= IFF_DRV_OACTIVE; 55513f4c340SRobert Watson #else 5563c60ba66SKatsushi Kobayashi ifp->if_flags |= IFF_OACTIVE; 55713f4c340SRobert Watson #endif 5583c60ba66SKatsushi Kobayashi 5593c60ba66SKatsushi Kobayashi if (ifp->if_snd.ifq_len != 0) 5603c60ba66SKatsushi Kobayashi fwe_as_output(fwe, ifp); 5613c60ba66SKatsushi Kobayashi 56213f4c340SRobert Watson #if defined(__FreeBSD__) 56313f4c340SRobert Watson ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 56413f4c340SRobert Watson #else 5653c60ba66SKatsushi Kobayashi ifp->if_flags &= ~IFF_OACTIVE; 56613f4c340SRobert Watson #endif 5673c60ba66SKatsushi Kobayashi splx(s); 5683c60ba66SKatsushi Kobayashi } 5693c60ba66SKatsushi Kobayashi 5703c60ba66SKatsushi Kobayashi #define HDR_LEN 4 5712b4601d1SHidetoshi Shimokawa #ifndef ETHER_ALIGN 5722b4601d1SHidetoshi Shimokawa #define ETHER_ALIGN 2 5732b4601d1SHidetoshi Shimokawa #endif 5743c60ba66SKatsushi Kobayashi /* Async. stream output */ 5753c60ba66SKatsushi Kobayashi static void 5763c60ba66SKatsushi Kobayashi fwe_as_output(struct fwe_softc *fwe, struct ifnet *ifp) 5773c60ba66SKatsushi Kobayashi { 5783c60ba66SKatsushi Kobayashi struct mbuf *m; 5793c60ba66SKatsushi Kobayashi struct fw_xfer *xfer; 5803c60ba66SKatsushi Kobayashi struct fw_xferq *xferq; 5813c60ba66SKatsushi Kobayashi struct fw_pkt *fp; 5823c60ba66SKatsushi Kobayashi int i = 0; 5833c60ba66SKatsushi Kobayashi 5843c60ba66SKatsushi Kobayashi xfer = NULL; 5853c60ba66SKatsushi Kobayashi xferq = fwe->fd.fc->atq; 5869950b741SHidetoshi Shimokawa while ((xferq->queued < xferq->maxq - 1) && 5879950b741SHidetoshi Shimokawa (ifp->if_snd.ifq_head != NULL)) { 5889950b741SHidetoshi Shimokawa FWE_LOCK(fwe); 5892b4601d1SHidetoshi Shimokawa xfer = STAILQ_FIRST(&fwe->xferlist); 5902b4601d1SHidetoshi Shimokawa if (xfer == NULL) { 5919950b741SHidetoshi Shimokawa #if 0 5922b4601d1SHidetoshi Shimokawa printf("if_fwe: lack of xfer\n"); 5939950b741SHidetoshi Shimokawa #endif 5949950b741SHidetoshi Shimokawa FWE_UNLOCK(fwe); 5953c60ba66SKatsushi Kobayashi break; 5969950b741SHidetoshi Shimokawa } 5972b4601d1SHidetoshi Shimokawa STAILQ_REMOVE_HEAD(&fwe->xferlist, link); 5989950b741SHidetoshi Shimokawa FWE_UNLOCK(fwe); 5999950b741SHidetoshi Shimokawa 6009950b741SHidetoshi Shimokawa IF_DEQUEUE(&ifp->if_snd, m); 6019950b741SHidetoshi Shimokawa if (m == NULL) { 6029950b741SHidetoshi Shimokawa FWE_LOCK(fwe); 6039950b741SHidetoshi Shimokawa STAILQ_INSERT_HEAD(&fwe->xferlist, xfer, link); 6049950b741SHidetoshi Shimokawa FWE_UNLOCK(fwe); 6059950b741SHidetoshi Shimokawa break; 6069950b741SHidetoshi Shimokawa } 60710d3ed64SHidetoshi Shimokawa #if defined(__DragonFly__) || __FreeBSD_version < 500000 608a4239576SHidetoshi Shimokawa if (ifp->if_bpf != NULL) 609a4239576SHidetoshi Shimokawa bpf_mtap(ifp, m); 61010d3ed64SHidetoshi Shimokawa #else 61110d3ed64SHidetoshi Shimokawa BPF_MTAP(ifp, m); 612a4239576SHidetoshi Shimokawa #endif 6133c60ba66SKatsushi Kobayashi 6143c60ba66SKatsushi Kobayashi /* keep ip packet alignment for alpha */ 6152b4601d1SHidetoshi Shimokawa M_PREPEND(m, ETHER_ALIGN, M_DONTWAIT); 616c4778b5dSHidetoshi Shimokawa fp = &xfer->send.hdr; 61703161bbcSDoug Rabson *(uint32_t *)&xfer->send.hdr = *(int32_t *)&fwe->pkt_hdr; 61877ee030bSHidetoshi Shimokawa fp->mode.stream.len = m->m_pkthdr.len; 6193c60ba66SKatsushi Kobayashi xfer->mbuf = m; 620c4778b5dSHidetoshi Shimokawa xfer->send.pay_len = m->m_pkthdr.len; 6213c60ba66SKatsushi Kobayashi 6222b4601d1SHidetoshi Shimokawa if (fw_asyreq(fwe->fd.fc, -1, xfer) != 0) { 6233c60ba66SKatsushi Kobayashi /* error */ 6243c60ba66SKatsushi Kobayashi ifp->if_oerrors ++; 6253c60ba66SKatsushi Kobayashi /* XXX set error code */ 6263c60ba66SKatsushi Kobayashi fwe_output_callback(xfer); 6273c60ba66SKatsushi Kobayashi } else { 6283c60ba66SKatsushi Kobayashi ifp->if_opackets ++; 6292b4601d1SHidetoshi Shimokawa i++; 6303c60ba66SKatsushi Kobayashi } 6313c60ba66SKatsushi Kobayashi } 6323c60ba66SKatsushi Kobayashi #if 0 6333c60ba66SKatsushi Kobayashi if (i > 1) 6343c60ba66SKatsushi Kobayashi printf("%d queued\n", i); 6353c60ba66SKatsushi Kobayashi #endif 6362b4601d1SHidetoshi Shimokawa if (i > 0) 6372b4601d1SHidetoshi Shimokawa xferq->start(fwe->fd.fc); 6383c60ba66SKatsushi Kobayashi } 6393c60ba66SKatsushi Kobayashi 6403c60ba66SKatsushi Kobayashi /* Async. stream output */ 6413c60ba66SKatsushi Kobayashi static void 6423c60ba66SKatsushi Kobayashi fwe_as_input(struct fw_xferq *xferq) 6433c60ba66SKatsushi Kobayashi { 64477ee030bSHidetoshi Shimokawa struct mbuf *m, *m0; 6453c60ba66SKatsushi Kobayashi struct ifnet *ifp; 6463c60ba66SKatsushi Kobayashi struct fwe_softc *fwe; 6472b4601d1SHidetoshi Shimokawa struct fw_bulkxfer *sxfer; 6482b4601d1SHidetoshi Shimokawa struct fw_pkt *fp; 6493c60ba66SKatsushi Kobayashi u_char *c; 65010d3ed64SHidetoshi Shimokawa #if defined(__DragonFly__) || __FreeBSD_version < 500000 6512b4601d1SHidetoshi Shimokawa struct ether_header *eh; 6522b4601d1SHidetoshi Shimokawa #endif 6533c60ba66SKatsushi Kobayashi 6543c60ba66SKatsushi Kobayashi fwe = (struct fwe_softc *)xferq->sc; 655fc74a9f9SBrooks Davis ifp = fwe->eth_softc.ifp; 65640929967SGleb Smirnoff 6579950b741SHidetoshi Shimokawa /* We do not need a lock here because the bottom half is serialized */ 6582b4601d1SHidetoshi Shimokawa while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) { 6592b4601d1SHidetoshi Shimokawa STAILQ_REMOVE_HEAD(&xferq->stvalid, link); 66077ee030bSHidetoshi Shimokawa fp = mtod(sxfer->mbuf, struct fw_pkt *); 6612b4601d1SHidetoshi Shimokawa if (fwe->fd.fc->irx_post != NULL) 6622b4601d1SHidetoshi Shimokawa fwe->fd.fc->irx_post(fwe->fd.fc, fp->mode.ld); 6632b4601d1SHidetoshi Shimokawa m = sxfer->mbuf; 6642b4601d1SHidetoshi Shimokawa 66529b187dcSHidetoshi Shimokawa /* insert new rbuf */ 66677ee030bSHidetoshi Shimokawa sxfer->mbuf = m0 = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 66777ee030bSHidetoshi Shimokawa if (m0 != NULL) { 66877ee030bSHidetoshi Shimokawa m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size; 6692b4601d1SHidetoshi Shimokawa STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link); 67077ee030bSHidetoshi Shimokawa } else 6719950b741SHidetoshi Shimokawa printf("%s: m_getcl failed\n", __FUNCTION__); 6722b4601d1SHidetoshi Shimokawa 67329b187dcSHidetoshi Shimokawa if (sxfer->resp != 0 || fp->mode.stream.len < 67429b187dcSHidetoshi Shimokawa ETHER_ALIGN + sizeof(struct ether_header)) { 67529b187dcSHidetoshi Shimokawa m_freem(m); 67629b187dcSHidetoshi Shimokawa ifp->if_ierrors ++; 67729b187dcSHidetoshi Shimokawa continue; 67829b187dcSHidetoshi Shimokawa } 67929b187dcSHidetoshi Shimokawa 6802b4601d1SHidetoshi Shimokawa m->m_data += HDR_LEN + ETHER_ALIGN; 6819950b741SHidetoshi Shimokawa c = mtod(m, u_char *); 68210d3ed64SHidetoshi Shimokawa #if defined(__DragonFly__) || __FreeBSD_version < 500000 6832b4601d1SHidetoshi Shimokawa eh = (struct ether_header *)c; 6842b4601d1SHidetoshi Shimokawa m->m_data += sizeof(struct ether_header); 685af21fc11SHidetoshi Shimokawa m->m_len = m->m_pkthdr.len = fp->mode.stream.len - ETHER_ALIGN 686af21fc11SHidetoshi Shimokawa - sizeof(struct ether_header); 687af21fc11SHidetoshi Shimokawa #else 688af21fc11SHidetoshi Shimokawa m->m_len = m->m_pkthdr.len = fp->mode.stream.len - ETHER_ALIGN; 689a4239576SHidetoshi Shimokawa #endif 6903c60ba66SKatsushi Kobayashi m->m_pkthdr.rcvif = ifp; 6913c60ba66SKatsushi Kobayashi #if 0 692ed32ba83SHidetoshi Shimokawa FWEDEBUG(ifp, "%02x %02x %02x %02x %02x %02x\n" 6933c60ba66SKatsushi Kobayashi "%02x %02x %02x %02x %02x %02x\n" 6943c60ba66SKatsushi Kobayashi "%02x %02x %02x %02x\n" 6953c60ba66SKatsushi Kobayashi "%02x %02x %02x %02x\n" 6963c60ba66SKatsushi Kobayashi "%02x %02x %02x %02x\n" 6973c60ba66SKatsushi Kobayashi "%02x %02x %02x %02x\n", 6983c60ba66SKatsushi Kobayashi c[0], c[1], c[2], c[3], c[4], c[5], 6993c60ba66SKatsushi Kobayashi c[6], c[7], c[8], c[9], c[10], c[11], 7003c60ba66SKatsushi Kobayashi c[12], c[13], c[14], c[15], 7013c60ba66SKatsushi Kobayashi c[16], c[17], c[18], c[19], 7023c60ba66SKatsushi Kobayashi c[20], c[21], c[22], c[23], 7033c60ba66SKatsushi Kobayashi c[20], c[21], c[22], c[23] 7043c60ba66SKatsushi Kobayashi ); 7053c60ba66SKatsushi Kobayashi #endif 70610d3ed64SHidetoshi Shimokawa #if defined(__DragonFly__) || __FreeBSD_version < 500000 707a4239576SHidetoshi Shimokawa ether_input(ifp, eh, m); 70810d3ed64SHidetoshi Shimokawa #else 70910d3ed64SHidetoshi Shimokawa (*ifp->if_input)(ifp, m); 710a4239576SHidetoshi Shimokawa #endif 7113c60ba66SKatsushi Kobayashi ifp->if_ipackets ++; 7123c60ba66SKatsushi Kobayashi } 7132b4601d1SHidetoshi Shimokawa if (STAILQ_FIRST(&xferq->stfree) != NULL) 7142b4601d1SHidetoshi Shimokawa fwe->fd.fc->irx_enable(fwe->fd.fc, fwe->dma_ch); 7153c60ba66SKatsushi Kobayashi } 7163c60ba66SKatsushi Kobayashi 7173c60ba66SKatsushi Kobayashi 7183c60ba66SKatsushi Kobayashi static devclass_t fwe_devclass; 7193c60ba66SKatsushi Kobayashi 7203c60ba66SKatsushi Kobayashi static device_method_t fwe_methods[] = { 7213c60ba66SKatsushi Kobayashi /* device interface */ 7223c60ba66SKatsushi Kobayashi DEVMETHOD(device_identify, fwe_identify), 7233c60ba66SKatsushi Kobayashi DEVMETHOD(device_probe, fwe_probe), 7243c60ba66SKatsushi Kobayashi DEVMETHOD(device_attach, fwe_attach), 7253c60ba66SKatsushi Kobayashi DEVMETHOD(device_detach, fwe_detach), 7263c60ba66SKatsushi Kobayashi { 0, 0 } 7273c60ba66SKatsushi Kobayashi }; 7283c60ba66SKatsushi Kobayashi 7293c60ba66SKatsushi Kobayashi static driver_t fwe_driver = { 7305e7c89e4SHidetoshi Shimokawa "fwe", 7313c60ba66SKatsushi Kobayashi fwe_methods, 7323c60ba66SKatsushi Kobayashi sizeof(struct fwe_softc), 7333c60ba66SKatsushi Kobayashi }; 7343c60ba66SKatsushi Kobayashi 7353c60ba66SKatsushi Kobayashi 73610d3ed64SHidetoshi Shimokawa #ifdef __DragonFly__ 73710d3ed64SHidetoshi Shimokawa DECLARE_DUMMY_MODULE(fwe); 73810d3ed64SHidetoshi Shimokawa #endif 739f246e4a1SMatthew N. Dodd DRIVER_MODULE(fwe, firewire, fwe_driver, fwe_devclass, 0, 0); 740f246e4a1SMatthew N. Dodd MODULE_VERSION(fwe, 1); 741f246e4a1SMatthew N. Dodd MODULE_DEPEND(fwe, firewire, 1, 1, 1); 742