/*      $NetBSD: vnet.c,v 1.10 2023/12/14 20:17:18 andvar Exp $ */
/*      $OpenBSD: vnet.c,v 1.62 2020/07/10 13:26:36 patrick Exp $       */
/*
 * Copyright (c) 2009, 2015 Mark Kettenis
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/kmem.h>
#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/callout.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/pool.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/systm.h>

#include <machine/autoconf.h>
#include <machine/hypervisor.h>
#include <machine/openfirm.h>

#include <net/if.h>
#include <net/if_media.h>

#include <netinet/in.h>
#include <net/if_ether.h>

#if NBPFILTER > 0
#include <net/bpf.h>
#endif

#include <uvm/uvm_extern.h>

#include <sparc64/dev/cbusvar.h>
#include <sparc64/dev/ldcvar.h>
#include <sparc64/dev/viovar.h>

#ifdef VNET_DEBUG
#define DPRINTF(x)      printf x
#else
#define DPRINTF(x)
#endif

#define VNET_TX_ENTRIES         32
#define VNET_RX_ENTRIES         32

struct vnet_attr_info {
        struct vio_msg_tag      tag;
        uint8_t                 xfer_mode;
        uint8_t                 addr_type;
        uint16_t                ack_freq;
        uint32_t                _reserved1;
        uint64_t                addr;
        uint64_t                mtu;
        uint64_t                _reserved2[3];
};

/* Address types. */
#define VNET_ADDR_ETHERMAC      0x01

/* Sub-Type envelopes. */
#define VNET_MCAST_INFO         0x0101

#define VNET_NUM_MCAST          7

struct vnet_mcast_info {
        struct vio_msg_tag      tag;
        uint8_t                 set;
        uint8_t                 count;
        uint8_t                 mcast_addr[VNET_NUM_MCAST][ETHER_ADDR_LEN];
        uint32_t                _reserved;
};

struct vnet_desc {
        struct vio_dring_hdr    hdr;
        uint32_t                nbytes;
        uint32_t                ncookies;
        struct ldc_cookie       cookie[2];
};

struct vnet_desc_msg {
        struct vio_msg_tag      tag;
        uint64_t                seq_no;
        uint64_t                desc_handle;
        uint32_t                nbytes;
        uint32_t                ncookies;
        struct ldc_cookie       cookie[1];
};

struct vnet_dring {
        bus_dmamap_t            vd_map;
        bus_dma_segment_t       vd_seg;
        struct vnet_desc        *vd_desc;
        int                     vd_nentries;
};

struct vnet_dring *vnet_dring_alloc(bus_dma_tag_t, int);
void    vnet_dring_free(bus_dma_tag_t, struct vnet_dring *);

/*
 * For now, we only support vNet 1.0.
 */
#define VNET_MAJOR      1
#define VNET_MINOR      0

/*
 * The vNet protocol wants the IP header to be 64-bit aligned, so
 * define out own variant of ETHER_ALIGN.
 */
#define VNET_ETHER_ALIGN        6

struct vnet_soft_desc {
        int             vsd_map_idx;
        unsigned char *vsd_buf;
};

struct vnet_softc {
        device_t        sc_dv;
        bus_space_tag_t sc_bustag;
        bus_dma_tag_t   sc_dmatag;

        uint64_t        sc_tx_ino;
        uint64_t        sc_rx_ino;
        void            *sc_tx_ih;
        void            *sc_rx_ih;

        struct ldc_conn sc_lc;

        uint16_t        sc_vio_state;
#define VIO_SND_VER_INFO        0x0001
#define VIO_ACK_VER_INFO        0x0002
#define VIO_RCV_VER_INFO        0x0004
#define VIO_SND_ATTR_INFO       0x0008
#define VIO_ACK_ATTR_INFO       0x0010
#define VIO_RCV_ATTR_INFO       0x0020
#define VIO_SND_DRING_REG       0x0040
#define VIO_ACK_DRING_REG       0x0080
#define VIO_RCV_DRING_REG       0x0100
#define VIO_SND_RDX             0x0200
#define VIO_ACK_RDX             0x0400
#define VIO_RCV_RDX             0x0800

        struct callout  sc_handshake_co;

        uint8_t         sc_xfer_mode;

        uint32_t        sc_local_sid;
        uint64_t        sc_dring_ident;
        uint64_t        sc_seq_no;

        u_int           sc_tx_prod;
        u_int           sc_tx_cons;

        u_int           sc_peer_state;

        struct ldc_map  *sc_lm;
        struct vnet_dring *sc_vd;
        struct vnet_soft_desc *sc_vsd;
#define VNET_NUM_SOFT_DESC      128

        size_t          sc_peer_desc_size;
        struct ldc_cookie sc_peer_dring_cookie;
        int             sc_peer_dring_nentries;

        struct pool     sc_pool;

        struct ethercom sc_ethercom;
        struct ifmedia  sc_media;
        u_int8_t sc_macaddr[ETHER_ADDR_LEN];
};

int vnet_match (device_t, cfdata_t, void *);
void vnet_attach (device_t, device_t, void *);

CFATTACH_DECL_NEW(vnet, sizeof(struct vnet_softc),
    vnet_match, vnet_attach, NULL, NULL);

int     vnet_tx_intr(void *);
int     vnet_rx_intr(void *);
void    vnet_handshake(void *);

void    vio_rx_data(struct ldc_conn *, struct ldc_pkt *);
void    vnet_rx_vio_ctrl(struct vnet_softc *, struct vio_msg *);
void    vnet_rx_vio_ver_info(struct vnet_softc *, struct vio_msg_tag *);
void    vnet_rx_vio_attr_info(struct vnet_softc *, struct vio_msg_tag *);
void    vnet_rx_vio_dring_reg(struct vnet_softc *, struct vio_msg_tag *);
void    vnet_rx_vio_rdx(struct vnet_softc *sc, struct vio_msg_tag *);
void    vnet_rx_vio_mcast_info(struct vnet_softc *sc, struct vio_msg_tag *);
void    vnet_rx_vio_data(struct vnet_softc *sc, struct vio_msg *);
void    vnet_rx_vio_desc_data(struct vnet_softc *sc, struct vio_msg_tag *);
void    vnet_rx_vio_dring_data(struct vnet_softc *sc, struct vio_msg_tag *);

void    vnet_ldc_reset(struct ldc_conn *);
void    vnet_ldc_start(struct ldc_conn *);

void    vnet_sendmsg(struct vnet_softc *, void *, size_t);
void    vnet_send_ver_info(struct vnet_softc *, uint16_t, uint16_t);
void    vnet_send_attr_info(struct vnet_softc *);
void    vnet_send_dring_reg(struct vnet_softc *);
void    vio_send_rdx(struct vnet_softc *);
void    vnet_send_dring_data(struct vnet_softc *, uint32_t);

void    vnet_start(struct ifnet *);
void    vnet_start_desc(struct ifnet *);
int             vnet_ioctl(struct ifnet *, u_long, void *);
void    vnet_watchdog(struct ifnet *);

int             vnet_media_change(struct ifnet *);
void    vnet_media_status(struct ifnet *, struct ifmediareq *);

void    vnet_link_state(struct vnet_softc *sc);

void    vnet_setmulti(struct vnet_softc *, int);

int             vnet_init(struct ifnet *);
void    vnet_stop(struct ifnet *, int);

int vnet_match(device_t parent, cfdata_t match, void *aux)
{

        struct cbus_attach_args *ca = aux;
        
        if (strcmp(ca->ca_name, "network") == 0)
                return (1);

        return (0);
}

void
vnet_attach(struct device *parent, struct device *self, void *aux)
{
        struct vnet_softc *sc = device_private(self);
        struct cbus_attach_args *ca = aux;
        struct ldc_conn *lc;
        struct ifnet *ifp;

        sc->sc_dv = self;
        sc->sc_bustag = ca->ca_bustag;
        sc->sc_dmatag = ca->ca_dmatag;
        sc->sc_tx_ino = ca->ca_tx_ino;
        sc->sc_rx_ino = ca->ca_rx_ino;

        printf(": ivec 0x%" PRIx64 ", 0x%" PRIx64, sc->sc_tx_ino, sc->sc_rx_ino);

        /*
         * Un-configure queues before registering interrupt handlers,
         * such that we dont get any stale LDC packets or events.
         */
        hv_ldc_tx_qconf(ca->ca_id, 0, 0);
        hv_ldc_rx_qconf(ca->ca_id, 0, 0);

        sc->sc_tx_ih = bus_intr_establish(ca->ca_bustag, sc->sc_tx_ino,
            IPL_NET, vnet_tx_intr, sc);
        sc->sc_rx_ih = bus_intr_establish(ca->ca_bustag, sc->sc_rx_ino,
            IPL_NET, vnet_rx_intr, sc);
        if (sc->sc_tx_ih == NULL || sc->sc_rx_ih == NULL) {
                printf(", can't establish interrupts\n");
                return;
        }

        lc = &sc->sc_lc;
        lc->lc_id = ca->ca_id;
        lc->lc_sc = sc;
        lc->lc_reset = vnet_ldc_reset;
        lc->lc_start = vnet_ldc_start;
        lc->lc_rx_data = vio_rx_data;

        callout_init(&sc->sc_handshake_co, 0);

        sc->sc_peer_state = VIO_DP_STOPPED;

        lc->lc_txq = ldc_queue_alloc(VNET_TX_ENTRIES);
        if (lc->lc_txq == NULL) {
                printf(", can't allocate tx queue\n");
                return;
        }

        lc->lc_rxq = ldc_queue_alloc(VNET_RX_ENTRIES);
        if (lc->lc_rxq == NULL) {
                printf(", can't allocate rx queue\n");
                goto free_txqueue;
        }
        
        if (OF_getprop(ca->ca_node, "local-mac-address",
                                   sc->sc_macaddr, ETHER_ADDR_LEN) > 0) {
                printf(", address %s", ether_sprintf(sc->sc_macaddr));
        } else {
                printf(", cannot retrieve local mac address\n");
                return;
        }

        /*
         * Each interface gets its own pool.
         */
        pool_init(&sc->sc_pool, /*size*/2048, /*align*/0, /*align_offset*/0,
            /*flags*/0, /*wchan*/device_xname(sc->sc_dv), /*palloc*/NULL,
            IPL_NET);

        ifp = &sc->sc_ethercom.ec_if;
        ifp->if_softc = sc;
        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
        ifp->if_init = vnet_init;
        ifp->if_ioctl = vnet_ioctl;
        ifp->if_start = vnet_start;
        ifp->if_stop = vnet_stop;
        ifp->if_watchdog = vnet_watchdog;
        strlcpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
        IFQ_SET_MAXLEN(&ifp->if_snd, 31); /* XXX */

        ifmedia_init(&sc->sc_media, 0, vnet_media_change, vnet_media_status);
        ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_AUTO, 0, NULL);
        ifmedia_set(&sc->sc_media, IFM_ETHER | IFM_AUTO);

        if_attach(ifp);
        ether_ifattach(ifp, sc->sc_macaddr);

        printf("\n");
        return;
free_txqueue:
        ldc_queue_free(lc->lc_txq);
}

int
vnet_tx_intr(void *arg)
{
        struct vnet_softc *sc = arg;
        struct ldc_conn *lc = &sc->sc_lc;
        uint64_t tx_head, tx_tail, tx_state;

        hv_ldc_tx_get_state(lc->lc_id, &tx_head, &tx_tail, &tx_state);
        if (tx_state != lc->lc_tx_state) {
                switch (tx_state) {
                case LDC_CHANNEL_DOWN:
                        DPRINTF(("%s: Tx link down\n", __func__));
                        break;
                case LDC_CHANNEL_UP:
                        DPRINTF(("%s: Tx link up\n", __func__));
                        break;
                case LDC_CHANNEL_RESET:
                        DPRINTF(("%s: Tx link reset\n", __func__));
                        break;
                }
                lc->lc_tx_state = tx_state;
        }

        return (1);
}
 
int
vnet_rx_intr(void *arg)
{
        struct vnet_softc *sc = arg;
        struct ldc_conn *lc = &sc->sc_lc;
        uint64_t rx_head, rx_tail, rx_state;
        struct ldc_pkt *lp;
        int err;

        err = hv_ldc_rx_get_state(lc->lc_id, &rx_head, &rx_tail, &rx_state);
        if (err == H_EINVAL) {
                printf("hv_ldc_rx_get_state failed\n");
                return (0);
        }
        if (err != H_EOK) {
                printf("hv_ldc_rx_get_state %d\n", err);
                return (0);
        }

        if (rx_state != lc->lc_rx_state) {
                switch (rx_state) {
                case LDC_CHANNEL_DOWN:
                        lc->lc_tx_seqid = 0;
                        lc->lc_state = 0;
                        lc->lc_reset(lc);
                        if (rx_head == rx_tail)
                                break;
                        /* Discard and ack pending I/O. */
                        DPRINTF(("setting rx qhead to %" PRId64 "\n", rx_tail));
                        err = hv_ldc_rx_set_qhead(lc->lc_id, rx_tail);
                        if (err == H_EOK)
                                break;
                        printf("%s: hv_ldc_rx_set_qhead %d\n", __func__, err);
                        break;
                case LDC_CHANNEL_UP:
                        callout_reset(&sc->sc_handshake_co, hz / 2, vnet_handshake, sc);
                        break;
                case LDC_CHANNEL_RESET:
                        DPRINTF(("%s: Rx link reset\n", __func__));
                        lc->lc_tx_seqid = 0;
                        lc->lc_state = 0;
                        lc->lc_reset(lc);
                        callout_reset(&sc->sc_handshake_co, hz / 2, vnet_handshake, sc);
                        if (rx_head == rx_tail) {
                                break;
                        }
                        /* Discard and ack pending I/O. */
                        DPRINTF(("setting rx qhead to %" PRId64 "\n", rx_tail));
                        err = hv_ldc_rx_set_qhead(lc->lc_id, rx_tail);
                        if (err == H_EOK)
                                break;
                        printf("%s: hv_ldc_rx_set_qhead %d\n", __func__, err);
                        break;
                default:        
                        DPRINTF(("%s: unhandled rx_state %" PRIx64 "\n", __func__, rx_state));
                        break;
                }
                lc->lc_rx_state = rx_state;
                return (1);
        } else {
        }

        if (rx_head == rx_tail)
        {
                DPRINTF(("%s: head eq tail\n", __func__));
                return (0);
        }
        lp = (struct ldc_pkt *)(uintptr_t)(lc->lc_rxq->lq_va + rx_head);
        switch (lp->type) {
        case LDC_CTRL:
                DPRINTF(("%s: LDC_CTRL\n", __func__));
                ldc_rx_ctrl(lc, lp);
                break;

        case LDC_DATA:
                DPRINTF(("%s: LDC_DATA\n", __func__));
                ldc_rx_data(lc, lp);
                break;

        default:
                DPRINTF(("%s: unhandled type %0x02/%0x02/%0x02\n",
                                 __func__, lp->type, lp->stype, lp->ctrl));
                console_debugger();
                ldc_reset(lc);
                break;
        }

        if (lc->lc_state == 0)
                return (1);

        rx_head += sizeof(*lp);
        rx_head &= ((lc->lc_rxq->lq_nentries * sizeof(*lp)) - 1);
        err = hv_ldc_rx_set_qhead(lc->lc_id, rx_head);
        if (err != H_EOK)
                printf("%s: hv_ldc_rx_set_qhead %d\n", __func__, err);
        return (1);
}
 
void
vnet_handshake(void *arg)
{
        struct vnet_softc *sc = arg;

        ldc_send_vers(&sc->sc_lc);
}
 
void
vio_rx_data(struct ldc_conn *lc, struct ldc_pkt *lp)
{
        struct vio_msg *vm = (struct vio_msg *)lp;

        switch (vm->type) {
        case VIO_TYPE_CTRL:
                if ((lp->env & LDC_FRAG_START) == 0 &&
                    (lp->env & LDC_FRAG_STOP) == 0) {
                        DPRINTF(("%s: FRAG_START==0 and FRAG_STOP==0\n", __func__));
                        return;
                }
                vnet_rx_vio_ctrl(lc->lc_sc, vm);
                break;

        case VIO_TYPE_DATA:
                if((lp->env & LDC_FRAG_START) == 0) {
                        DPRINTF(("%s: FRAG_START==0\n", __func__));
                        return;
                }
                vnet_rx_vio_data(lc->lc_sc, vm);
                break;

        default:
                DPRINTF(("Unhandled packet type 0x%02x\n", vm->type));
                ldc_reset(lc);
                break;
        }
}

void
vnet_rx_vio_ctrl(struct vnet_softc *sc, struct vio_msg *vm)
{
        struct vio_msg_tag *tag = (struct vio_msg_tag *)&vm->type;

        switch (tag->stype_env) {
        case VIO_VER_INFO:
                vnet_rx_vio_ver_info(sc, tag);
                break;
        case VIO_ATTR_INFO:
                vnet_rx_vio_attr_info(sc, tag);
                break;
        case VIO_DRING_REG:
                vnet_rx_vio_dring_reg(sc, tag);
                break;
        case VIO_RDX:
                vnet_rx_vio_rdx(sc, tag);
                break;
        case VNET_MCAST_INFO:
                vnet_rx_vio_mcast_info(sc, tag);
                break;
        default:
                printf("%s: CTRL/0x%02x/0x%04x FIXME\n",
                                 __func__, tag->stype, tag->stype_env);
                break;
        }
}

void
vnet_rx_vio_ver_info(struct vnet_softc *sc, struct vio_msg_tag *tag)
{
        struct vio_ver_info *vi = (struct vio_ver_info *)tag;

        switch (vi->tag.stype) {
        case VIO_SUBTYPE_INFO:
                DPRINTF(("CTRL/INFO/VER_INFO\n"));

                /* Make sure we're talking to a virtual network device. */
                if (vi->dev_class != VDEV_NETWORK &&
                    vi->dev_class != VDEV_NETWORK_SWITCH) {
                        DPRINTF(("Class is not network or network switch\n"));
                        /* Huh, we're not talking to a network device? */
                        printf("Not a network device\n");
                        vi->tag.stype = VIO_SUBTYPE_NACK;
                        vnet_sendmsg(sc, vi, sizeof(*vi));
                        return;
                }

                if (vi->major != VNET_MAJOR) {
                        DPRINTF(("Major mismatch %" PRId8 " vs %" PRId8 "\n",
                                         vi->major, VNET_MAJOR));
                        vi->tag.stype = VIO_SUBTYPE_NACK;
                        vi->major = VNET_MAJOR;
                        vi->minor = VNET_MINOR;
                        vnet_sendmsg(sc, vi, sizeof(*vi));
                        return;
                }

                vi->tag.stype = VIO_SUBTYPE_ACK;
                vi->tag.sid = sc->sc_local_sid;
                vi->minor = VNET_MINOR;
                vnet_sendmsg(sc, vi, sizeof(*vi));
                sc->sc_vio_state |= VIO_RCV_VER_INFO;
                break;

        case VIO_SUBTYPE_ACK:
                DPRINTF(("CTRL/ACK/VER_INFO\n"));
                if (!ISSET(sc->sc_vio_state, VIO_SND_VER_INFO)) {
                        ldc_reset(&sc->sc_lc);
                        break;
                }
                sc->sc_vio_state |= VIO_ACK_VER_INFO;
                break;

        default:
                DPRINTF(("CTRL/0x%02x/VER_INFO\n", vi->tag.stype));
                break;
        }

        if (ISSET(sc->sc_vio_state, VIO_RCV_VER_INFO) &&
            ISSET(sc->sc_vio_state, VIO_ACK_VER_INFO))
                vnet_send_attr_info(sc);
}

void
vnet_rx_vio_attr_info(struct vnet_softc *sc, struct vio_msg_tag *tag)
{
        struct vnet_attr_info *ai = (struct vnet_attr_info *)tag;

        switch (ai->tag.stype) {
        case VIO_SUBTYPE_INFO:
                DPRINTF(("CTRL/INFO/ATTR_INFO\n"));
                sc->sc_xfer_mode = ai->xfer_mode;
                ai->tag.stype = VIO_SUBTYPE_ACK;
                ai->tag.sid = sc->sc_local_sid;
                vnet_sendmsg(sc, ai, sizeof(*ai));
                sc->sc_vio_state |= VIO_RCV_ATTR_INFO;
                break;

        case VIO_SUBTYPE_ACK:
                DPRINTF(("CTRL/ACK/ATTR_INFO\n"));
                if (!ISSET(sc->sc_vio_state, VIO_SND_ATTR_INFO)) {
                        ldc_reset(&sc->sc_lc);
                        break;
                }
                sc->sc_vio_state |= VIO_ACK_ATTR_INFO;
                break;

        default:
                DPRINTF(("CTRL/0x%02x/ATTR_INFO\n", ai->tag.stype));
                break;
        }

        if (ISSET(sc->sc_vio_state, VIO_RCV_ATTR_INFO) &&
            ISSET(sc->sc_vio_state, VIO_ACK_ATTR_INFO)) {
                if (sc->sc_xfer_mode == VIO_DRING_MODE)
                        vnet_send_dring_reg(sc);
                else
                        vio_send_rdx(sc);
        }
}

void
vnet_rx_vio_dring_reg(struct vnet_softc *sc, struct vio_msg_tag *tag)
{
        struct vio_dring_reg *dr = (struct vio_dring_reg *)tag;

        switch (dr->tag.stype) {
        case VIO_SUBTYPE_INFO:
                DPRINTF(("CTRL/INFO/DRING_REG\n"));
                sc->sc_peer_dring_nentries = dr->num_descriptors;
                sc->sc_peer_desc_size = dr->descriptor_size;
                sc->sc_peer_dring_cookie = dr->cookie[0];

                dr->tag.stype = VIO_SUBTYPE_ACK;
                dr->tag.sid = sc->sc_local_sid;
                vnet_sendmsg(sc, dr, sizeof(*dr));
                sc->sc_vio_state |= VIO_RCV_DRING_REG;
                break;

        case VIO_SUBTYPE_ACK:
                DPRINTF(("CTRL/ACK/DRING_REG\n"));
                if (!ISSET(sc->sc_vio_state, VIO_SND_DRING_REG)) {
                        ldc_reset(&sc->sc_lc);
                        break;
                }

                sc->sc_dring_ident = dr->dring_ident;
                sc->sc_seq_no = 1;

                sc->sc_vio_state |= VIO_ACK_DRING_REG;
                break;

        default:
                DPRINTF(("CTRL/0x%02x/DRING_REG\n", dr->tag.stype));
                break;
        }

        if (ISSET(sc->sc_vio_state, VIO_RCV_DRING_REG) &&
            ISSET(sc->sc_vio_state, VIO_ACK_DRING_REG))
                vio_send_rdx(sc);
}

void
vnet_rx_vio_rdx(struct vnet_softc *sc, struct vio_msg_tag *tag)
{
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;

        switch(tag->stype) {
        case VIO_SUBTYPE_INFO:
                DPRINTF(("CTRL/INFO/RDX\n"));
                tag->stype = VIO_SUBTYPE_ACK;
                tag->sid = sc->sc_local_sid;
                vnet_sendmsg(sc, tag, sizeof(*tag));
                sc->sc_vio_state |= VIO_RCV_RDX;
                break;

        case VIO_SUBTYPE_ACK:
                DPRINTF(("CTRL/ACK/RDX\n"));
                if (!ISSET(sc->sc_vio_state, VIO_SND_RDX)) {
                        ldc_reset(&sc->sc_lc);
                        break;
                }
                sc->sc_vio_state |= VIO_ACK_RDX;
                break;

        default:
                DPRINTF(("CTRL/0x%02x/RDX (VIO)\n", tag->stype));
                break;
        }

        if (ISSET(sc->sc_vio_state, VIO_RCV_RDX) &&
            ISSET(sc->sc_vio_state, VIO_ACK_RDX)) {
                /* Link is up! */
                vnet_link_state(sc);

                /* Configure multicast now that we can. */
                vnet_setmulti(sc, 1);

                KERNEL_LOCK(1, curlwp);
                vnet_start(ifp);
                KERNEL_UNLOCK_ONE(curlwp);
        }
}

void
vnet_rx_vio_mcast_info(struct vnet_softc *sc, struct vio_msg_tag *tag)
{
        switch(tag->stype) {
                        
                case VIO_SUBTYPE_INFO:
                        DPRINTF(("CTRL/INFO/MCAST_INFO\n"));
                        break;

                case VIO_SUBTYPE_ACK:
                        DPRINTF(("CTRL/ACK/MCAST_INFO\n"));
                        break;

                case VIO_SUBTYPE_NACK:
                        DPRINTF(("CTRL/NACK/MCAST_INFO\n"));
                        break;
                        
                default:
                        printf("%s: CTRL/0x%02x/0x%04x\n",
                                   __func__, tag->stype, tag->stype_env);
                        break;
        }
}

void
vnet_rx_vio_data(struct vnet_softc *sc, struct vio_msg *vm)
{
        struct vio_msg_tag *tag = (struct vio_msg_tag *)&vm->type;

        if (!ISSET(sc->sc_vio_state, VIO_RCV_RDX) ||
            !ISSET(sc->sc_vio_state, VIO_ACK_RDX)) {
                DPRINTF(("Spurious DATA/0x%02x/0x%04x\n", tag->stype,
                    tag->stype_env));
                return;
        }

        switch(tag->stype_env) {
        case VIO_DESC_DATA:
                vnet_rx_vio_desc_data(sc, tag);
                break;

        case VIO_DRING_DATA:
                vnet_rx_vio_dring_data(sc, tag);
                break;

        default:
                DPRINTF(("DATA/0x%02x/0x%04x\n", tag->stype, tag->stype_env));
                break;
        }
}

void
vnet_rx_vio_desc_data(struct vnet_softc *sc, struct vio_msg_tag *tag)
{

        struct vnet_desc_msg *dm = (struct vnet_desc_msg *)tag;
        struct ldc_conn *lc = &sc->sc_lc;
        struct ldc_map *map = sc->sc_lm;
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        struct mbuf *m;
        unsigned char *buf;
        paddr_t pa;
        psize_t nbytes;
        u_int cons;
        int err;

        switch(tag->stype) {
        case VIO_SUBTYPE_INFO:
                buf = pool_get(&sc->sc_pool, PR_NOWAIT|PR_ZERO);
                if (buf == NULL) {
                        if_statinc(ifp, if_ierrors);
                        goto skip;
                }
                nbytes = roundup(dm->nbytes, 8);

                if (dm->nbytes > (ETHER_MAX_LEN - ETHER_CRC_LEN)) {
                        if_statinc(ifp, if_ierrors);
                        goto skip;
                }

                pmap_extract(pmap_kernel(), (vaddr_t)buf, &pa);
                err = hv_ldc_copy(lc->lc_id, LDC_COPY_IN,
                    dm->cookie[0].addr, pa, nbytes, &nbytes);
                if (err != H_EOK) {
                        pool_put(&sc->sc_pool, buf);
                        if_statinc(ifp, if_ierrors);
                        goto skip;
                }

                /* Stupid OBP doesn't align properly. */
                m = m_devget(buf, dm->nbytes, 0, ifp);
                pool_put(&sc->sc_pool, buf);
                if (m == NULL) {
                        if_statinc(ifp, if_ierrors);
                        goto skip;
                }

                /* Pass it on. */
                if_percpuq_enqueue(ifp->if_percpuq, m);
        skip:
                dm->tag.stype = VIO_SUBTYPE_ACK;
                dm->tag.sid = sc->sc_local_sid;
                vnet_sendmsg(sc, dm, sizeof(*dm));
                break;

        case VIO_SUBTYPE_ACK:
                DPRINTF(("DATA/ACK/DESC_DATA\n"));

                if (dm->desc_handle != sc->sc_tx_cons) {
                        printf("out of order\n");
                        return;
                }

                cons = sc->sc_tx_cons & (sc->sc_vd->vd_nentries - 1);

                map->lm_slot[sc->sc_vsd[cons].vsd_map_idx].entry = 0;
                atomic_dec_32(&map->lm_count);

                pool_put(&sc->sc_pool, sc->sc_vsd[cons].vsd_buf);
                sc->sc_vsd[cons].vsd_buf = NULL;

                sc->sc_tx_cons++;
                break;

        case VIO_SUBTYPE_NACK:
                DPRINTF(("DATA/NACK/DESC_DATA\n"));
                break;

        default:
                DPRINTF(("DATA/0x%02x/DESC_DATA\n", tag->stype));
                break;
        }
}

void
vnet_rx_vio_dring_data(struct vnet_softc *sc, struct vio_msg_tag *tag)
{
        struct vio_dring_msg *dm = (struct vio_dring_msg *)tag;
        struct ldc_conn *lc = &sc->sc_lc;
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        struct mbuf *m = NULL;
        paddr_t pa;
        psize_t nbytes;
        int err;

        switch(tag->stype) {
        case VIO_SUBTYPE_INFO:
        {
                DPRINTF(("%s: VIO_SUBTYPE_INFO\n", __func__));
                struct vnet_desc desc;
                uint64_t cookie;
                paddr_t desc_pa;
                int idx, ack_end_idx = -1;

                idx = dm->start_idx;
                for (;;) {
                        cookie = sc->sc_peer_dring_cookie.addr;
                        cookie += idx * sc->sc_peer_desc_size;
                        nbytes = sc->sc_peer_desc_size;
                        pmap_extract(pmap_kernel(), (vaddr_t)&desc, &desc_pa);
                        err = hv_ldc_copy(lc->lc_id, LDC_COPY_IN, cookie,
                            desc_pa, nbytes, &nbytes);
                        if (err != H_EOK) {
                                printf("hv_ldc_copy_in %d\n", err);
                                break;
                        }

                        if (desc.hdr.dstate != VIO_DESC_READY)
                                break;

                        if (desc.nbytes > (ETHER_MAX_LEN - ETHER_CRC_LEN)) {
                                if_statinc(ifp, if_ierrors);
                                goto skip;
                        }
                        
                        MGETHDR(m, M_DONTWAIT, MT_DATA);
                        if (m == NULL) {
                                DPRINTF(("%s: MGETHDR failed\n", __func__));
                                if_statinc(ifp, if_ierrors);
                                goto skip;
                        }
                        MCLGET(m, M_DONTWAIT);
                        if ((m->m_flags & M_EXT) == 0)
                                break;
                        m->m_len = m->m_pkthdr.len = desc.nbytes;
                        nbytes = roundup(desc.nbytes + VNET_ETHER_ALIGN, 8);

                        pmap_extract(pmap_kernel(), (vaddr_t)m->m_data, &pa);
                        err = hv_ldc_copy(lc->lc_id, LDC_COPY_IN,
                            desc.cookie[0].addr, pa, nbytes, &nbytes);
                        if (err != H_EOK) {
                                m_freem(m);
                                goto skip;
                        }
                        m->m_data += VNET_ETHER_ALIGN;
                        m_set_rcvif(m, ifp);

                        if_percpuq_enqueue(ifp->if_percpuq, m);

                skip:
                        desc.hdr.dstate = VIO_DESC_DONE;
                        nbytes = sc->sc_peer_desc_size;
                        err = hv_ldc_copy(lc->lc_id, LDC_COPY_OUT, cookie,
                            desc_pa, nbytes, &nbytes);
                        if (err != H_EOK)
                                printf("hv_ldc_copy_out %d\n", err);

                        ack_end_idx = idx;
                        if (++idx == sc->sc_peer_dring_nentries)
                                idx = 0;
                }

                if (ack_end_idx == -1) {
                        dm->tag.stype = VIO_SUBTYPE_NACK;
                } else {
                        dm->tag.stype = VIO_SUBTYPE_ACK;
                        dm->end_idx = ack_end_idx;
                }
                dm->tag.sid = sc->sc_local_sid;
                dm->proc_state = VIO_DP_STOPPED;
                vnet_sendmsg(sc, dm, sizeof(*dm));
                break;
        }

        case VIO_SUBTYPE_ACK:
        {
                DPRINTF(("%s: VIO_SUBTYPE_ACK\n", __func__));
                struct ldc_map *map = sc->sc_lm;
                u_int cons, count;

                sc->sc_peer_state = dm->proc_state;

                cons = sc->sc_tx_cons & (sc->sc_vd->vd_nentries - 1);
                while (sc->sc_vd->vd_desc[cons].hdr.dstate == VIO_DESC_DONE) {
                        map->lm_slot[sc->sc_vsd[cons].vsd_map_idx].entry = 0;
                        atomic_dec_32(&map->lm_count);

                        pool_put(&sc->sc_pool, sc->sc_vsd[cons].vsd_buf);
                        sc->sc_vsd[cons].vsd_buf = NULL;

                        sc->sc_vd->vd_desc[cons].hdr.dstate = VIO_DESC_FREE;
                        sc->sc_tx_cons++;
                        cons = sc->sc_tx_cons & (sc->sc_vd->vd_nentries - 1);
                }

                count = sc->sc_tx_prod - sc->sc_tx_cons;
                if (count > 0 && sc->sc_peer_state != VIO_DP_ACTIVE)
                        vnet_send_dring_data(sc, cons);

                KERNEL_LOCK(1, curlwp);
                if (count == 0)
                        ifp->if_timer = 0;

                vnet_start(ifp);
                KERNEL_UNLOCK_ONE(curlwp);
                break;
        }

        case VIO_SUBTYPE_NACK:
                DPRINTF(("DATA/NACK/DRING_DATA\n"));
                sc->sc_peer_state = VIO_DP_STOPPED;
                break;

        default:
                DPRINTF(("DATA/0x%02x/DRING_DATA\n", tag->stype));
                break;
        }
}

void
vnet_ldc_reset(struct ldc_conn *lc)
{

        struct vnet_softc *sc = lc->lc_sc;
        int i;
        
        callout_stop(&sc->sc_handshake_co);
        sc->sc_tx_prod = sc->sc_tx_cons = 0;
        sc->sc_peer_state = VIO_DP_STOPPED;
        sc->sc_vio_state = 0;
        vnet_link_state(sc);

        sc->sc_lm->lm_next = 1;
        sc->sc_lm->lm_count = 1;
        for (i = 1; i < sc->sc_lm->lm_nentries; i++)
                sc->sc_lm->lm_slot[i].entry = 0;

        for (i = 0; i < sc->sc_vd->vd_nentries; i++) {
                if (sc->sc_vsd[i].vsd_buf) {
                        pool_put(&sc->sc_pool, sc->sc_vsd[i].vsd_buf);
                        sc->sc_vsd[i].vsd_buf = NULL;
                }
                sc->sc_vd->vd_desc[i].hdr.dstate = VIO_DESC_FREE;
        }
}

void
vnet_ldc_start(struct ldc_conn *lc)
{
        struct vnet_softc *sc = lc->lc_sc;
        callout_stop(&sc->sc_handshake_co);
        vnet_send_ver_info(sc, VNET_MAJOR, VNET_MINOR);
}

void
vnet_sendmsg(struct vnet_softc *sc, void *msg, size_t len)
{
        struct ldc_conn *lc = &sc->sc_lc;
        int err;

        err = ldc_send_unreliable(lc, msg, len);
        if (err)
                printf("%s: ldc_send_unreliable: %d\n", __func__, err);
}
 
void
vnet_send_ver_info(struct vnet_softc *sc, uint16_t major, uint16_t minor)
{
        struct vio_ver_info vi;

        bzero(&vi, sizeof(vi));
        vi.tag.type = VIO_TYPE_CTRL;
        vi.tag.stype = VIO_SUBTYPE_INFO;
        vi.tag.stype_env = VIO_VER_INFO;
        vi.tag.sid = sc->sc_local_sid;
        vi.major = major;
        vi.minor = minor;
        vi.dev_class = VDEV_NETWORK;
        vnet_sendmsg(sc, &vi, sizeof(vi));

        sc->sc_vio_state |= VIO_SND_VER_INFO;
}
 
void
vnet_send_attr_info(struct vnet_softc *sc)
{
        struct vnet_attr_info ai;
        int i;

        bzero(&ai, sizeof(ai));
        ai.tag.type = VIO_TYPE_CTRL;
        ai.tag.stype = VIO_SUBTYPE_INFO;
        ai.tag.stype_env = VIO_ATTR_INFO;
        ai.tag.sid = sc->sc_local_sid;
        ai.xfer_mode = VIO_DRING_MODE;
        ai.addr_type = VNET_ADDR_ETHERMAC;
        ai.ack_freq = 0;
        ai.addr = 0;
        for (i = 0; i < ETHER_ADDR_LEN; i++) {
                ai.addr <<= 8;
                ai.addr |= sc->sc_macaddr[i];
        }
        ai.mtu = ETHER_MAX_LEN - ETHER_CRC_LEN;
        vnet_sendmsg(sc, &ai, sizeof(ai));

        sc->sc_vio_state |= VIO_SND_ATTR_INFO;
}
 
void
vnet_send_dring_reg(struct vnet_softc *sc)
{
        struct vio_dring_reg dr;

        bzero(&dr, sizeof(dr));
        dr.tag.type = VIO_TYPE_CTRL;
        dr.tag.stype = VIO_SUBTYPE_INFO;
        dr.tag.stype_env = VIO_DRING_REG;
        dr.tag.sid = sc->sc_local_sid;
        dr.dring_ident = 0;
        dr.num_descriptors = sc->sc_vd->vd_nentries;
        dr.descriptor_size = sizeof(struct vnet_desc);
        dr.options = VIO_TX_RING;
        dr.ncookies = 1;
        dr.cookie[0].addr = 0;
        dr.cookie[0].size = PAGE_SIZE;
        vnet_sendmsg(sc, &dr, sizeof(dr));

        sc->sc_vio_state |= VIO_SND_DRING_REG;
};
 
void
vio_send_rdx(struct vnet_softc *sc)
{
        struct vio_msg_tag tag;

        tag.type = VIO_TYPE_CTRL;
        tag.stype = VIO_SUBTYPE_INFO;
        tag.stype_env = VIO_RDX;
        tag.sid = sc->sc_local_sid;
        vnet_sendmsg(sc, &tag, sizeof(tag));

        sc->sc_vio_state |= VIO_SND_RDX;
}
 
void
vnet_send_dring_data(struct vnet_softc *sc, uint32_t start_idx)
{
        struct vio_dring_msg dm;
        u_int peer_state;

        peer_state = atomic_swap_uint(&sc->sc_peer_state, VIO_DP_ACTIVE);
        if (peer_state == VIO_DP_ACTIVE) {
                DPRINTF(("%s: peer_state == VIO_DP_ACTIVE\n", __func__));
                return;
        }

        bzero(&dm, sizeof(dm));
        dm.tag.type = VIO_TYPE_DATA;
        dm.tag.stype = VIO_SUBTYPE_INFO;
        dm.tag.stype_env = VIO_DRING_DATA;
        dm.tag.sid = sc->sc_local_sid;
        dm.seq_no = sc->sc_seq_no++;
        dm.dring_ident = sc->sc_dring_ident;
        dm.start_idx = start_idx;
        dm.end_idx = -1;
        vnet_sendmsg(sc, &dm, sizeof(dm));
}
 
void
vnet_start(struct ifnet *ifp)
{
        struct vnet_softc *sc = ifp->if_softc;
        struct ldc_conn *lc = &sc->sc_lc;
        struct ldc_map *map = sc->sc_lm;
        struct mbuf *m;
        paddr_t pa;
        unsigned char *buf;
        uint64_t tx_head, tx_tail, tx_state;
        u_int start, prod, count;
        int err;
        if (!(ifp->if_flags & IFF_RUNNING))
        {
                DPRINTF(("%s: not in RUNNING state\n", __func__));
                return;
        }

        if (IFQ_IS_EMPTY(&ifp->if_snd))
        {
                DPRINTF(("%s: queue is empty\n", __func__));
                return;
        } else {
                DPRINTF(("%s: queue size %d\n", __func__, ifp->if_snd.ifq_len));
        }

        /*
         * We cannot transmit packets until a VIO connection has been
         * established.
         */
        if (!ISSET(sc->sc_vio_state, VIO_RCV_RDX) ||
            !ISSET(sc->sc_vio_state, VIO_ACK_RDX))
        {
                DPRINTF(("%s: vio connection not established yet\n", __func__));
                return;
        }

        /*
         * Make sure there is room in the LDC transmit queue to send a
         * DRING_DATA message.
         */
        err = hv_ldc_tx_get_state(lc->lc_id, &tx_head, &tx_tail, &tx_state);
        if (err != H_EOK) {
                DPRINTF(("%s: no room in ldc transmit queue\n", __func__));
                return;
        }
        tx_tail += sizeof(struct ldc_pkt);
        tx_tail &= ((lc->lc_txq->lq_nentries * sizeof(struct ldc_pkt)) - 1);
        if (tx_tail == tx_head) {
                {
                        DPRINTF(("%s: tail equals head\n", __func__));
                        return;
                }
        }

        if (sc->sc_xfer_mode == VIO_DESC_MODE) {
                DPRINTF(("%s: vio_desc_mode\n", __func__));
                vnet_start_desc(ifp);
                return;
        }

        start = prod = sc->sc_tx_prod & (sc->sc_vd->vd_nentries - 1);
        while (sc->sc_vd->vd_desc[prod].hdr.dstate == VIO_DESC_FREE) {
                count = sc->sc_tx_prod - sc->sc_tx_cons;
                if (count >= (sc->sc_vd->vd_nentries - 1) ||
                    map->lm_count >= map->lm_nentries) {
                        DPRINTF(("%s: count issue\n", __func__));
                        break;
                }

                buf = pool_get(&sc->sc_pool, PR_NOWAIT|PR_ZERO);
                if (buf == NULL) {
                        DPRINTF(("%s: buff is NULL\n", __func__));
                        break;
                }
                IFQ_DEQUEUE(&ifp->if_snd, m);
                if (m == NULL) {
                        pool_put(&sc->sc_pool, buf);
                        break;
                }

                m_copydata(m, 0, m->m_pkthdr.len, buf + VNET_ETHER_ALIGN);
                
#if NBPFILTER > 0
                /*
                 * If BPF is listening on this interface, let it see the
                 * packet before we commit it to the wire.
                 */
                DPRINTF(("%s: before bpf\n", __func__));
                bpf_mtap(ifp, m, BPF_D_OUT);
                DPRINTF(("%s: after bpf\n", __func__));
#endif

                pmap_extract(pmap_kernel(), (vaddr_t)buf, &pa);
                KASSERT((pa & ~PAGE_MASK) == (pa & LDC_MTE_RA_MASK));
                while (map->lm_slot[map->lm_next].entry != 0) {
                        map->lm_next++;
                        map->lm_next &= (map->lm_nentries - 1);
                }
                map->lm_slot[map->lm_next].entry = (pa & LDC_MTE_RA_MASK);
                map->lm_slot[map->lm_next].entry |= LDC_MTE_CPR;
                atomic_inc_32(&map->lm_count);
                sc->sc_vd->vd_desc[prod].nbytes = MAX(m->m_pkthdr.len, 60);
                sc->sc_vd->vd_desc[prod].ncookies = 1;
                sc->sc_vd->vd_desc[prod].cookie[0].addr =
                    map->lm_next << PAGE_SHIFT | (pa & PAGE_MASK);
                sc->sc_vd->vd_desc[prod].cookie[0].size = 2048;
                membar_producer();
                sc->sc_vd->vd_desc[prod].hdr.dstate = VIO_DESC_READY;

                sc->sc_vsd[prod].vsd_map_idx = map->lm_next;
                sc->sc_vsd[prod].vsd_buf = buf;

                sc->sc_tx_prod++;
                prod = sc->sc_tx_prod & (sc->sc_vd->vd_nentries - 1);

                m_freem(m);
        }

        membar_producer();

        if (start != prod && sc->sc_peer_state != VIO_DP_ACTIVE) {
                vnet_send_dring_data(sc, start);
                ifp->if_timer = 5;
        }
                        
}

void
vnet_start_desc(struct ifnet *ifp)
{
        struct vnet_softc *sc = ifp->if_softc;
        struct ldc_map *map = sc->sc_lm;
        struct vnet_desc_msg dm;
        struct mbuf *m;
        paddr_t pa;
        unsigned char *buf;
        u_int prod, count;

        for (;;) {
                count = sc->sc_tx_prod - sc->sc_tx_cons;
                if (count >= (sc->sc_vd->vd_nentries - 1) ||
                    map->lm_count >= map->lm_nentries) {
                        return;
                }

                buf = pool_get(&sc->sc_pool, PR_NOWAIT|PR_ZERO);
                if (buf == NULL) {
                        return;
                }

                IFQ_DEQUEUE(&ifp->if_snd, m);
 
                if (m == NULL) {
                        pool_put(&sc->sc_pool, buf);
                        return;
                }

                m_copydata(m, 0, m->m_pkthdr.len, buf);

#if NBPFILTER > 0
                /*
                 * If BPF is listening on this interface, let it see the
                 * packet before we commit it to the wire.
                 */
                bpf_mtap(ifp, m, BPF_D_OUT);
#endif

                pmap_extract(pmap_kernel(), (vaddr_t)buf, &pa);
                KASSERT((pa & ~PAGE_MASK) == (pa & LDC_MTE_RA_MASK));
                while (map->lm_slot[map->lm_next].entry != 0) {
                        map->lm_next++;
                        map->lm_next &= (map->lm_nentries - 1);
                }
                map->lm_slot[map->lm_next].entry = (pa & LDC_MTE_RA_MASK);
                map->lm_slot[map->lm_next].entry |= LDC_MTE_CPR;
                atomic_inc_32(&map->lm_count);

                prod = sc->sc_tx_prod & (sc->sc_vd->vd_nentries - 1);
                sc->sc_vsd[prod].vsd_map_idx = map->lm_next;
                sc->sc_vsd[prod].vsd_buf = buf;

                bzero(&dm, sizeof(dm));
                dm.tag.type = VIO_TYPE_DATA;
                dm.tag.stype = VIO_SUBTYPE_INFO;
                dm.tag.stype_env = VIO_DESC_DATA;
                dm.tag.sid = sc->sc_local_sid;
                dm.seq_no = sc->sc_seq_no++;
                dm.desc_handle = sc->sc_tx_prod;
                dm.nbytes = MAX(m->m_pkthdr.len, 60);
                dm.ncookies = 1;
                dm.cookie[0].addr =
                        map->lm_next << PAGE_SHIFT | (pa & PAGE_MASK);
                dm.cookie[0].size = 2048;
                vnet_sendmsg(sc, &dm, sizeof(dm));

                sc->sc_tx_prod++;
                sc->sc_tx_prod &= (sc->sc_vd->vd_nentries - 1);

                m_freem(m);
        }
}

int
vnet_ioctl(struct ifnet *ifp, u_long cmd, void* data)
{
        struct vnet_softc *sc = ifp->if_softc;
        struct ifreq *ifr = (struct ifreq *)data;
        int s, error = 0;

        s = splnet();

        switch (cmd) {

                case SIOCSIFADDR:
                        ifp->if_flags |= IFF_UP;
                        /* FALLTHROUGH */
                case SIOCSIFFLAGS:
                        if (ifp->if_flags & IFF_UP) {
                                if ((ifp->if_flags & IFF_RUNNING) == 0)
                                        vnet_init(ifp);
                        } else {
                                if (ifp->if_flags & IFF_RUNNING)
                                        vnet_stop(ifp, 0);
                        }
                break;

                case SIOCGIFMEDIA:
                case SIOCSIFMEDIA:
                        error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
                        break;

                case SIOCADDMULTI:
                case SIOCDELMULTI:
                        /*
                         * XXX Removing all multicast addresses and adding
                         * most of them back, is somewhat retarded.
                         */
                        vnet_setmulti(sc, 0);
                        error = ether_ioctl(ifp, cmd, data);
                        vnet_setmulti(sc, 1);
                        if (error == ENETRESET)
                                error = 0;
                        break;

                default:
                        error = ether_ioctl(ifp, cmd, data);
        }

        splx(s);

        return (error);
}

void
vnet_watchdog(struct ifnet *ifp)
{

        struct vnet_softc *sc = ifp->if_softc;

        printf("%s: watchdog timeout\n", device_xname(sc->sc_dv));
}

int
vnet_media_change(struct ifnet *ifp)
{
        return (0);
}

void
vnet_media_status(struct ifnet *ifp, struct ifmediareq *imr)
{
        imr->ifm_active = IFM_ETHER | IFM_AUTO;
        imr->ifm_status = IFM_AVALID;
        if (ifp->if_link_state == LINK_STATE_UP &&
            ifp->if_flags & IFF_UP)
                imr->ifm_status |= IFM_ACTIVE;
}

void
vnet_link_state(struct vnet_softc *sc)
{
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        int link_state = LINK_STATE_DOWN;

        KERNEL_LOCK(1, curlwp);
        if (ISSET(sc->sc_vio_state, VIO_RCV_RDX) &&
            ISSET(sc->sc_vio_state, VIO_ACK_RDX))
                link_state = LINK_STATE_UP;
        if (ifp->if_link_state != link_state) {
                if_link_state_change(ifp, link_state);
        }
        KERNEL_UNLOCK_ONE(curlwp);
}

void
vnet_setmulti(struct vnet_softc *sc, int set)
{
        struct ethercom *ec = &sc->sc_ethercom;
        struct ether_multi *enm;
        struct ether_multistep step;
        struct vnet_mcast_info mi;
        int count = 0;

        if (!ISSET(sc->sc_vio_state, VIO_RCV_RDX) ||
            !ISSET(sc->sc_vio_state, VIO_ACK_RDX))
                return;

        bzero(&mi, sizeof(mi));
        mi.tag.type = VIO_TYPE_CTRL;
        mi.tag.stype = VIO_SUBTYPE_INFO;
        mi.tag.stype_env = VNET_MCAST_INFO;
        mi.tag.sid = sc->sc_local_sid;
        mi.set = set ? 1 : 0;
        KERNEL_LOCK(1, curlwp);
        ETHER_FIRST_MULTI(step, ec, enm);
        while (enm != NULL) {
                /* XXX What about multicast ranges? */
                bcopy(enm->enm_addrlo, mi.mcast_addr[count], ETHER_ADDR_LEN);
                ETHER_NEXT_MULTI(step, enm);

                count++;
                if (count < VNET_NUM_MCAST)
                        continue;

                mi.count = VNET_NUM_MCAST;
                vnet_sendmsg(sc, &mi, sizeof(mi));
                count = 0;
        }

        if (count > 0) {
                mi.count = count;
                vnet_sendmsg(sc, &mi, sizeof(mi));
        }
        KERNEL_UNLOCK_ONE(curlwp);
}


int
vnet_init(struct ifnet *ifp)
{
        struct vnet_softc *sc = ifp->if_softc;
        struct ldc_conn *lc = &sc->sc_lc;
        int err;
        vaddr_t va;
        paddr_t pa;
        sc->sc_lm = ldc_map_alloc(2048);
        if (sc->sc_lm == NULL)
                return ENOMEM;

        va = (vaddr_t)sc->sc_lm->lm_slot;
        pa = 0;
        if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)
                panic("pmap_extract failed %lx\n", va);
        err = hv_ldc_set_map_table(lc->lc_id, pa, 2048);
        if (err != H_EOK) {
                printf("hv_ldc_set_map_table %d\n", err);
                return EINVAL;
        }

        sc->sc_vd = vnet_dring_alloc(sc->sc_dmatag, VNET_NUM_SOFT_DESC);
        if (sc->sc_vd == NULL)
                return ENOMEM;
        sc->sc_vsd = malloc(VNET_NUM_SOFT_DESC * sizeof(*sc->sc_vsd), M_DEVBUF,
            M_NOWAIT|M_ZERO);
        if (sc->sc_vsd == NULL)
                return ENOMEM;

        va = (vaddr_t)sc->sc_vd->vd_desc;
        pa = 0;
        if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)
                panic("pmap_extract failed %lx\n", va);
        sc->sc_lm->lm_slot[0].entry = pa;
        sc->sc_lm->lm_slot[0].entry &= LDC_MTE_RA_MASK;
        sc->sc_lm->lm_slot[0].entry |= LDC_MTE_CPR | LDC_MTE_CPW;
        sc->sc_lm->lm_next = 1;
        sc->sc_lm->lm_count = 1;
        
        va = lc->lc_txq->lq_va;
        pa = 0;
        if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)
                panic("pmap_extract failed %lx\n", va);
        err = hv_ldc_tx_qconf(lc->lc_id, pa, lc->lc_txq->lq_nentries);
        if (err != H_EOK)
                printf("hv_ldc_tx_qconf %d\n", err);
        
        va = (vaddr_t)lc->lc_rxq->lq_va;
        pa = 0;
        if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)
          panic("pmap_extract failed %lx\n", va);

        err = hv_ldc_rx_qconf(lc->lc_id, pa, lc->lc_rxq->lq_nentries);
        if (err != H_EOK)
                printf("hv_ldc_rx_qconf %d\n", err);

        cbus_intr_setenabled(sc->sc_bustag, sc->sc_tx_ino, INTR_ENABLED);
        cbus_intr_setenabled(sc->sc_bustag, sc->sc_rx_ino, INTR_ENABLED);

        ldc_send_vers(lc);

        ifp->if_flags |= IFF_RUNNING;

        return 0;
}

void
vnet_stop(struct ifnet *ifp, int disable)
                
{
        struct vnet_softc *sc = ifp->if_softc;
        struct ldc_conn *lc = &sc->sc_lc;

        ifp->if_flags &= ~IFF_RUNNING;
        ifp->if_timer = 0;

        cbus_intr_setenabled(sc->sc_bustag, sc->sc_tx_ino, INTR_DISABLED);
        cbus_intr_setenabled(sc->sc_bustag, sc->sc_rx_ino, INTR_DISABLED);

#if 0
openbsd XXX
        intr_barrier(sc->sc_tx_ih);
        intr_barrier(sc->sc_rx_ih);
#else
        printf("vnet_stop() intr_barrier() not available\n");
#endif  

        hv_ldc_tx_qconf(lc->lc_id, 0, 0);
        hv_ldc_rx_qconf(lc->lc_id, 0, 0);
        lc->lc_tx_seqid = 0;
        lc->lc_state = 0;
        lc->lc_tx_state = lc->lc_rx_state = LDC_CHANNEL_DOWN;
        vnet_ldc_reset(lc);

        free(sc->sc_vsd, M_DEVBUF);

        vnet_dring_free(sc->sc_dmatag, sc->sc_vd);

        hv_ldc_set_map_table(lc->lc_id, 0, 0);
        ldc_map_free(sc->sc_lm);
}

struct vnet_dring *
vnet_dring_alloc(bus_dma_tag_t t, int nentries)
{
        struct vnet_dring *vd;
        bus_size_t size;
        vaddr_t va;
        int i;

        vd = kmem_zalloc(sizeof(struct vnet_dring), KM_SLEEP);
        if (vd == NULL)
                return NULL;

        size = roundup(nentries * sizeof(struct vnet_desc), PAGE_SIZE);

        va = (vaddr_t)kmem_zalloc(size, KM_SLEEP);
        vd->vd_desc = (struct vnet_desc *)va;
        vd->vd_nentries = nentries;
        bzero(vd->vd_desc, nentries * sizeof(struct vnet_desc));
        for (i = 0; i < vd->vd_nentries; i++)
                vd->vd_desc[i].hdr.dstate = VIO_DESC_FREE;
        return (vd);

        return (NULL);
}

void
vnet_dring_free(bus_dma_tag_t t, struct vnet_dring *vd)
{

        bus_size_t size;

        size = vd->vd_nentries * sizeof(struct vnet_desc);
        size = roundup(size, PAGE_SIZE);

        kmem_free(vd->vd_desc, size);
        kmem_free(vd, size);
}