 @@ -1,2191 +1,2300 @@
-/*	$NetBSD: vnet.c,v 1.3 2021/03/11 19:34:11 palle Exp $	*/
+/*	$NetBSD: vnet.c,v 1.4 2021/03/13 20:21:37 palle 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.
  */
 #if 0
 FIXME openbsd
 #include "bpfilter.h"
 #endif
 #include <sys/kmem.h>
 #include <sys/param.h>
 #include <sys/atomic.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>
 #if 0
 FIXME openbsd
 #include <sys/timeout.h>
 #else
 #include <sys/callout.h>
 #endif
 #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>
 #if 1
 #define VNET_DEBUG
 #endif
 #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;
 #if 0
 FIXME openbsd
 	caddr_t		vsd_buf;
 #else
 	unsigned char *vsd_buf;
 #endif
 };
 struct vnet_softc {
 	struct device	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
 #if 0
 FIXME openbsd
 	struct timeout	sc_handshake_to;
 #else
 	struct callout	sc_handshake_co;
 #endif
 	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_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);
 #if 0
 FIXME openbsd
 	sc->sc_tx_ih = bus_intr_establish(ca->ca_bustag, sc->sc_tx_ino,
 	    IPL_NET, BUS_INTR_ESTABLISH_MPSAFE, vnet_tx_intr,
 	    sc, sc->sc_dv.dv_xname);
 	sc->sc_rx_ih = bus_intr_establish(ca->ca_bustag, sc->sc_rx_ino,
 	    IPL_NET, BUS_INTR_ESTABLISH_MPSAFE, vnet_rx_intr,
 	    sc, sc->sc_dv.dv_xname);
 	if (sc->sc_tx_ih == NULL || sc->sc_rx_ih == NULL) {
 		printf(", can't establish interrupt\n");
 		return;
+	}
 #else
 	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;
+	}
 #endif
 	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;
 #if 0
 FIXME openbsd
 	timeout_set(&sc->sc_handshake_to, vnet_handshake, sc);
 #else
 	callout_init(&sc->sc_handshake_co, 0);
 /* netbsd callout do silmilar function...*/
 #endif
 	sc->sc_peer_state = VIO_DP_STOPPED;
 #if OPENBSD_BUSDMA
 	lc->lc_txq = ldc_queue_alloc(sc->sc_dmatag, VNET_TX_ENTRIES);
 	if (lc->lc_txq == NULL) {
 		printf(", can't allocate tx queue\n");
 		return;
+	}
 	lc->lc_rxq = ldc_queue_alloc(sc->sc_dmatag, VNET_RX_ENTRIES);
 	if (lc->lc_rxq == NULL) {
 		printf(", can't allocate rx queue\n");
 		goto free_txqueue;
+	}
 #else
 	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;
+	}
 #endif
 	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.
 	 */
 #if 0
 FIXME openbsd
 	pool_init(&sc->sc_pool, 2048, 0, IPL_NET, 0, sc->sc_dv.dv_xname, NULL);
 #else
 	pool_init(&sc->sc_pool, 2048, 0, 0, 0, sc->sc_dv.dv_xname, NULL, IPL_NET);
 #endif
 	ifp = &sc->sc_ethercom.ec_if;
 	ifp->if_softc = sc;
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 #if 0
 	ifp->if_link_state = LINK_STATE_DOWN;
 #endif
 	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);
 #if 0
 FIXME openbsd
 	ifq_set_maxlen(&ifp->if_snd, 31); /* XXX */
 #else
  IFQ_SET_MAXLEN(&ifp->if_snd, 31); /* XXX */
 #endif
 	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 0
 	int error = if_initialize(ifp);
 	if (error != 0) {
 		printf(", if_initialize() failed\n");
 		return;
+	}
 	ether_ifattach(ifp, sc->sc_macaddr);
 	if_register(ifp);
 #else
 	if_attach(ifp);
 	ether_ifattach(ifp, sc->sc_macaddr);
 #endif
 	printf("\n");
 	return;
 free_txqueue:
 #if OPENBSD_BUSDMA
 	ldc_queue_free(sc->sc_dmatag, lc->lc_txq);
 #else
 	ldc_queue_free(lc->lc_txq);
 #endif
+}
 int
 vnet_tx_intr(void *arg)
+{
 	DPRINTF(("%s: entry\n", __func__));
 	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;
+	}
 	DPRINTF(("%s: exit\n", __func__));
 	return (1);
+}
 int
 vnet_rx_intr(void *arg)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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 0
 	DPRINTF(("%s: rx_state %" PRId64 "  head %" PRId64 "  tail %" PRId64 "\n",
 			 __func__, rx_state, rx_head, rx_tail));
 #endif
 	if (rx_state != lc->lc_rx_state) {
 #if 0
 		DPRINTF(("%s: rx_state %" PRId64 " != lc__rx_state %" PRId64 "\n",
 				 __func__, rx_state, lc->lc_rx_state));
 #endif
 		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:
 #if 0
 			DPRINTF(("%s: Rx link up\n", __func__));
 #endif
 #if 0
 FIXME openbsd
 			timeout_add_msec(&sc->sc_handshake_to, 500);
 #else
 			callout_reset(&sc->sc_handshake_co, hz / 2, vnet_handshake, sc);
 #endif
 			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);
 #if 0
 FIXME openbsd
 			timeout_add_msec(&sc->sc_handshake_to, 500);
 #else
 			callout_reset(&sc->sc_handshake_co, hz / 2, vnet_handshake, sc);
 #endif
 			if (rx_head == rx_tail) {
 #if 0
 				DPRINTF(("%s: rx_head == rx_head\n", __func__));
 #endif
 				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;
 #if 0
 		DPRINTF(("%s: setting rx_state %" PRId64 " = lc__rx_state %" PRId64 "\n",
 				 __func__, rx_state, lc->lc_rx_state));
 #endif
 		return (1);
 	} else {
 #if 0
 		DPRINTF(("%s: rx_state %" PRId64 " == lc__rx_state %" PRId64 "\n",
 				 __func__, rx_state, lc->lc_rx_state));
 #endif
+	}
 	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);
 #if 0
 	DPRINTF(("%s: lp->type %" PRId8 "\n", __func__, lp->type));
 	DPRINTF(("%s: lp->stype %" PRId8 "\n", __func__, lp->stype));
 	DPRINTF(("%s: lp->ctrl %" PRId8 "\n", __func__, lp->ctrl));
 	DPRINTF(("%s: lp->env %" PRId8 "\n", __func__, lp->env));
 	DPRINTF(("%s: lp->seqid %" PRId32 "\n", __func__, lp->seqid));
 	DPRINTF(("%s: lp->major %" PRId16 "\n", __func__, lp->major));
 	DPRINTF(("%s: lp->minor %" PRId16 "\n", __func__, lp->minor));
 #endif
 	switch (lp->type) {
 	case LDC_CTRL:
 #if 0
 		DPRINTF(("%s: LDC_CTRL\n", __func__));
 #endif
 		ldc_rx_ctrl(lc, lp);
 		break;
 	case LDC_DATA:
 #if 0
 		DPRINTF(("%s: LDC_DATA\n", __func__));
 #endif
 		ldc_rx_data(lc, lp);
 		break;
 	default:
 		DPRINTF(("%s: unhandled type %0x02/%0x02/%0x02\n",
 				 __func__, lp->type, lp->stype, lp->ctrl));
 		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);
 #if 0
 	DPRINTF(("%s: exit\n", __func__));
 #endif
 	return (1);
+}
 void
 vnet_handshake(void *arg)
+{
 	DPRINTF(("%s: entry\n", __func__));
 	struct vnet_softc *sc = arg;
 	ldc_send_vers(&sc->sc_lc);
+}
 void
 vio_rx_data(struct ldc_conn *lc, struct ldc_pkt *lp)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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);
 #if 0
 		Debugger();
 #endif
 		break;
+	}
+}
 void
 vnet_rx_vio_ver_info(struct vnet_softc *sc, struct vio_msg_tag *tag)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	struct vio_ver_info *vi = (struct vio_ver_info *)tag;
 	switch (vi->tag.stype) {
 	case VIO_SUBTYPE_INFO:
 #if 0
 		DPRINTF(("CTRL/INFO/VER_INFO\n"));
 #endif
 		/* 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:
 #if 0
 		DPRINTF(("CTRL/ACK/VER_INFO\n"));
 #endif
 		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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	struct vnet_attr_info *ai = (struct vnet_attr_info *)tag;
 	switch (ai->tag.stype) {
 	case VIO_SUBTYPE_INFO:
 #if 0
 		DPRINTF(("CTRL/INFO/ATTR_INFO\n"));
 #endif
 		sc->sc_xfer_mode = ai->xfer_mode;
 #if 0
 		DPRINTF(("sc_xfer_mode %d\n", sc->sc_xfer_mode));
 #endif
 		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:
 #if 0
 		DPRINTF(("CTRL/ACK/ATTR_INFO\n"));
 #endif
 		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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	struct vio_dring_reg *dr = (struct vio_dring_reg *)tag;
 	switch (dr->tag.stype) {
 	case VIO_SUBTYPE_INFO:
 #if 0
 		DPRINTF(("CTRL/INFO/DRING_REG\n"));
 #endif
 		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:
 #if 0
 		DPRINTF(("CTRL/ACK/DRING_REG\n"));
 #endif
 		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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 #if 0
 FIXME openbsd
 	struct ifnet *ifp = &sc->sc_ac.ac_if;
 #else
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 #endif
 	switch(tag->stype) {
 	case VIO_SUBTYPE_INFO:
 #if 0
 		DPRINTF(("CTRL/INFO/RDX\n"));
 #endif
 		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:
 #if 0
 		DPRINTF(("CTRL/ACK/RDX\n"));
 #endif
 		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);
 #if 0
 FIXME openbsd
 		KERNEL_LOCK();
 #else
 	KERNEL_LOCK(1, curlwp);
 #endif
 #if 0
 FIXME openbsd
 		ifq_clr_oactive(&ifp->if_snd);
 #else
 	ifp->if_flags &= ~IFF_OACTIVE;
 #endif
 		vnet_start(ifp);
 #if 0
 FIXME openbsd
 		KERNEL_UNLOCK();
 #else
 	KERNEL_UNLOCK_ONE(curlwp);
 #endif
+	}
+}
 void
 vnet_rx_vio_mcast_info(struct vnet_softc *sc, struct vio_msg_tag *tag)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	switch(tag->stype) {
 		case VIO_SUBTYPE_INFO:
 #if 0
 			DPRINTF(("CTRL/INFO/MCAST_INFO\n"));
 #endif
 			break;
 		case VIO_SUBTYPE_ACK:
 #if 0
 			DPRINTF(("CTRL/ACK/MCAST_INFO\n"));
 #endif
 			break;
 		case VIO_SUBTYPE_NACK:
 #if 0
 			DPRINTF(("CTRL/NACK/MCAST_INFO\n"));
 #endif
 			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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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)
+{
 	DPRINTF(("%s: entry\n", __func__));
 	struct vnet_desc_msg *dm = (struct vnet_desc_msg *)tag;
 	struct ldc_conn *lc = &sc->sc_lc;
 	struct ldc_map *map = sc->sc_lm;
 #if 0
 FIXME openbsd
 	struct ifnet *ifp = &sc->sc_ac.ac_if;
 #else
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 #endif
 #if 0
 FIXME openbsd
 	struct mbuf_list ml = MBUF_LIST_INITIALIZER();
 #endif
 	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 0
 FIXME openbsd
 			ifp->if_ierrors++;
 #else
 			if_statinc(ifp, if_ierrors);
 #endif
 			goto skip;
+		}
 		nbytes = roundup(dm->nbytes, 8);
 		if (dm->nbytes > (ETHER_MAX_LEN - ETHER_CRC_LEN)) {
 #if 0
 FIXME openbsd
 			ifp->if_ierrors++;
 #else
 			if_statinc(ifp, if_ierrors);
 #endif
 			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 0
 FIXME openbsd
 			ifp->if_ierrors++;
 #else
 			if_statinc(ifp, if_ierrors);
 #endif
 			goto skip;
+		}
 		/* Stupid OBP doesn't align properly. */
 #if 0
 FIXME openbsd
                 m = m_devget(buf, dm->nbytes, ETHER_ALIGN);
 #else
 		m = m_devget(buf, dm->nbytes, 0, ifp);
 #endif
 		pool_put(&sc->sc_pool, buf);
 		if (m == NULL) {
 #if 0
 FIXME openbsd
 			ifp->if_ierrors++;
 #else
 			if_statinc(ifp, if_ierrors);
 #endif
 			goto skip;
+		}
 		/* Pass it on. */
 #if 0
 FIXME openbsd
 		ml_enqueue(&ml, m);
 		if_input(ifp, &ml);
 #else
 	if_percpuq_enqueue(ifp->if_percpuq, m);
 #endif
 	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;
 #if 0
 FIXME openbsd
 		atomic_dec_int(&map->lm_count);
 #else
 		map->lm_count--;
 #endif
 		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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	struct vio_dring_msg *dm = (struct vio_dring_msg *)tag;
 	struct ldc_conn *lc = &sc->sc_lc;
 #if 0
 FIXME openbsd
 	struct ifnet *ifp = &sc->sc_ac.ac_if;
 #else
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 #endif
 #if 1
 	struct mbuf *m = NULL;
 #endif
 	paddr_t pa;
 	psize_t nbytes;
 	int err;
 	switch(tag->stype) {
 	case VIO_SUBTYPE_INFO:
+	{
 #if 0
 		DPRINTF(("%s: VIO_SUBTYPE_INFO\n", __func__));
 #endif
 		struct vnet_desc desc;
 		uint64_t cookie;
 		paddr_t desc_pa;
 		int idx, ack_end_idx = -1;
 #if 0
 FIXME openbsd
 		struct mbuf_list ml = MBUF_LIST_INITIALIZER();
 #endif
 		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 0
 FIXME openbsd
 				ifp->if_ierrors++;
 #else
 				if_statinc(ifp, if_ierrors);
 #endif
 				goto skip;
+			}
 #if 0
 FIXME openbsd
 			m = MCLGETI(NULL, M_DONTWAIT, NULL, desc.nbytes);
 			if (!m)
 				break;
 #else
 #if 1
 #if 0
 			DPRINTF(("%s: before MGETHDR\n", __func__));
 #endif
 			MGETHDR(m, M_DONTWAIT, MT_DATA);
 #if 0
 			DPRINTF(("%s: after MGETHDR\n", __func__));
 #endif
 			if (m == NULL) {
 				DPRINTF(("%s: MGETHDR failed\n", __func__));
 				if_statinc(ifp, if_ierrors);
 				goto skip;
+			}
 #if 0
 			DPRINTF(("%s: before MCLGET\n", __func__));
 #endif
 			MCLGET(m, M_DONTWAIT);
 			if ((m->m_flags & M_EXT) == 0)
 				break;
 #if 0
 			DPRINTF(("%s: after MCLGET\n", __func__));
 #endif
 #endif
 #endif
 #if 1
 			m->m_len = m->m_pkthdr.len = desc.nbytes;
 #endif
 			nbytes = roundup(desc.nbytes + VNET_ETHER_ALIGN, 8);
-#if 1
+#if 0
-			DPRINTF(("%s: nbytes %" PRId64 " desc.nbytes %" PRId32 "\n",
+			DPRINTF(("%s: RX frame size %" PRId16 "\n",
-					 __func__, nbytes, desc.nbytes));
+					 __func__, (int)nbytes));
 			uint8_t buf[ETHER_MAX_LEN];
 			pmap_extract(pmap_kernel(), (vaddr_t)buf, &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;
+			}
 			for (int i = 0; i < desc.nbytes; i++) {
 					if (i % 16 == 0) {
-						printf("\n");
+						DPRINTF(("\n"));
+					}
-					printf("%02x ", buf[i]);
+					DPRINTF(("%02x ", buf[i]));
+			}
-			printf("\n");
+			DPRINTF(("\n"));
 			DPRINTF(("\n"));
 #endif
 #if 1
 			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 0
 FIXME openbsd
 			ml_enqueue(&ml, m);
 #else
 #if 0
 			DPRINTF(("%s: before if_percpuq_enqueue\n", __func__));
 #endif
 			if_percpuq_enqueue(ifp->if_percpuq, m);
 #if 0
 			DPRINTF(("%s: after if_percpuq_enqueue\n", __func__));
 #endif
 #endif
 #endif
 		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 0
 FIXME openbd
 		if_input(ifp, &ml);
 #else
 // FIXME??? printf("vnet_rx_vio_dring_data() ignoring if_input - FIXME\n");
 #endif
 		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:
+	{
 #if 0
 		DPRINTF(("%s: VIO_SUBTYPE_ACK\n", __func__));
 #endif
 		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;
 #if 0
 FIXME openbsd
 			atomic_dec_int(&map->lm_count);
 #else
 			map->lm_count--;
 #endif
 			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);
 #if 0
 FIXME openbsd
 		KERNEL_LOCK();
 #else
 		KERNEL_LOCK(1, curlwp);
 #endif
 		if (count < (sc->sc_vd->vd_nentries - 1))
 #if 0
 FIXME openbsd
 			ifq_clr_oactive(&ifp->if_snd);
 #else
 			ifp->if_flags &= ~IFF_OACTIVE;
 #endif
 		if (count == 0)
 			ifp->if_timer = 0;
 		vnet_start(ifp);
 #if 0
 FIXME openbsd
 		KERNEL_UNLOCK();
 #else
 		KERNEL_UNLOCK_ONE(curlwp);
 #endif
 		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)
+{
 	DPRINTF(("%s: entry\n", __func__));
 	struct vnet_softc *sc = lc->lc_sc;
 	int i;
 #if 0
 FIXME openbsd
 	timeout_del(&sc->sc_handshake_to);
 #else
 	callout_stop(&sc->sc_handshake_co);
 #endif
 	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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	struct vnet_softc *sc = lc->lc_sc;
 #if 0
 FIXME openbsd
 	timeout_del(&sc->sc_handshake_to);
 #else
 	callout_stop(&sc->sc_handshake_co);
 #endif
 	vnet_send_ver_info(sc, VNET_MAJOR, VNET_MINOR);
+}
 void
 vnet_sendmsg(struct vnet_softc *sc, void *msg, size_t len)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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;
 #if 0
 	DPRINTF(("%s: ai.addr %" PRIx64 "\n",
 			 __func__, ai.addr));
 	DPRINTF(("%s: ai.mtu %" PRId64 "\n",
 			 __func__, ai.mtu));
 #endif
 	vnet_sendmsg(sc, &ai, sizeof(ai));
 	sc->sc_vio_state |= VIO_SND_ATTR_INFO;
+}
 void
 vnet_send_dring_reg(struct vnet_softc *sc)
+{
-#if 1
+#if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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)
+{
-#if 1
+#if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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)
+	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++;
 #if 0
 	DPRINTF(("%s: dm.seq_no %" PRId64 "\n",
 			 __func__, dm.seq_no));
 #endif
 	dm.dring_ident = sc->sc_dring_ident;
 	dm.start_idx = start_idx;
 	dm.end_idx = -1;
 	vnet_sendmsg(sc, &dm, sizeof(dm));
 #if 0
 	DPRINTF(("%s: exit\n", __func__));
 #endif
+}
 void
 vnet_start(struct ifnet *ifp)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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 0
 FIXME openbsd
 	if (!(ifp->if_flags & IFF_RUNNING) || ifq_is_oactive(&ifp->if_snd))
 		return;
 #else
 	if (!(ifp->if_flags & IFF_RUNNING))
+	{
 		DPRINTF(("%s: not in RUNNING state\n", __func__));
 		return;
+	}
 	if (ifp->if_flags & IFF_OACTIVE)
+	{
 		DPRINTF(("%s: already active\n", __func__));
 		return;
+	}
 #endif
 #if 0
 FIXME openbsd
 	if (ifq_empty(&ifp->if_snd))
 #else
 	if (IFQ_IS_EMPTY(&ifp->if_snd))
 #endif
+	{
 #if 0
 		DPRINTF(("%s: queue is empty\n", __func__));
 #endif
 		return;
 	} else {
 #if 0
 		DPRINTF(("%s: queue size %d\n", __func__, ifp->if_snd.ifq_len));
 #endif
+	}
 	/*
 	 * 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))
+	{
 #if 0
 		DPRINTF(("%s: vio connection not established yet\n", __func__));
 #endif
 		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) {
 #if 0
 FIXME openbsd
 		ifq_set_oactive(&ifp->if_snd);
 #else
 		ifp->if_flags |= IFF_OACTIVE;
 #endif
+		{
 			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 0
 		DPRINTF(("%s: count %d\n", __func__, count));
 #endif
 		if (count >= (sc->sc_vd->vd_nentries - 1) ||
 		    map->lm_count >= map->lm_nentries) {
 			DPRINTF(("%s: count issue\n", __func__));
 #if 0
 FIXME openbsd
 			ifq_set_oactive(&ifp->if_snd);
 #else
 			ifp->if_flags |= IFF_OACTIVE;
 #endif
 			break;
+		}
 		buf = pool_get(&sc->sc_pool, PR_NOWAIT|PR_ZERO);
 		if (buf == NULL) {
 			DPRINTF(("%s: buff is NULL\n", __func__));
 #if 0
 FIXME openbsd
 			ifq_set_oactive(&ifp->if_snd);
 #else
 			ifp->if_flags |= IFF_OACTIVE;
 #endif
 			break;
+		}
 #if 0
 FIXME openbsd
 		m = ifq_dequeue(&ifp->if_snd);
 #else
 		IFQ_DEQUEUE(&ifp->if_snd, m);
 #endif
 		if (m == NULL) {
 #if 0
 			DPRINTF(("%s: m is NULL\n", __func__));
 #endif
 			pool_put(&sc->sc_pool, buf);
 			break;
 		} else {
 #if 0
 			DPRINTF(("%s: m is not NULL\n", __func__));
 #endif
+		}
 #if 1
 		m_copydata(m, 0, m->m_pkthdr.len, buf + VNET_ETHER_ALIGN);
 #if 0
 		DPRINTF(("%s: TX frame size %" PRId16 "\n",
 				 __func__, m->m_pkthdr.len));
 		for (int i = 0; i < m->m_pkthdr.len; i++) {
 			if (i % 16 == 0) {
 				DPRINTF(("\n"));
+			}
 			DPRINTF(("%02x ", buf[VNET_ETHER_ALIGN+i]));
+		}
 		DPRINTF(("\n"));
 #endif
 #else
 		m_copydata(m, 0, m->m_pkthdr.len, buf);
 		DPRINTF(("%s: TX frame size %" PRId16 "\n",
 				 __func__, m->m_pkthdr.len));
 		for (int i = 0; i < m->m_pkthdr.len; i++) {
 			if (i % 16 == 0) {
 				DPRINTF(("\n"));
+			}
 			DPRINTF(("%02x ", buf[i]));
+		}
 		DPRINTF(("\n"));
 #endif
 #if NBPFILTER > 0
 		/*
 		 * If BPF is listening on this interface, let it see the
 		 * packet before we commit it to the wire.
 		 */
 		if (ifp->if_bpf)
+		{
 			DPRINTF(("%s: before bpf\n", __func__));
 			bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_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;
 #if 0
 FIXME openbsd
 		atomic_inc_int(&map->lm_count);
 #else
 		map->lm_count++;
 #endif
 #if 0
 FIXME openbsd
 		sc->sc_vd->vd_desc[prod].nbytes = max(m->m_pkthdr.len, 60);
 #else
 		sc->sc_vd->vd_desc[prod].nbytes = MAX(m->m_pkthdr.len, 60);
 #endif
 		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) {
 #if 0
 		DPRINTF(("%s: before vnet_send_dring_data()\n", __func__));
 #endif
 		vnet_send_dring_data(sc, start);
 		ifp->if_timer = 5;
 	} else {
 		DPRINTF(("%s: no vnet_send_dring_data()\n", __func__));
+	}
 #if 0
 #if 0
 	DPRINTF(("%s: exit\n", __func__));
 #endif
+}
 void
 vnet_start_desc(struct ifnet *ifp)
+{
 	DPRINTF(("%s: entry\n", __func__));
 	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) {
 #if 0
 FIXME openbsd
 			ifq_set_oactive(&ifp->if_snd);
 #else
 			ifp->if_flags |= IFF_OACTIVE;
 #endif
 			return;
+		}
 		buf = pool_get(&sc->sc_pool, PR_NOWAIT|PR_ZERO);
 		if (buf == NULL) {
 #if 0
 FIXME openbsd
 			ifq_set_oactive(&ifp->if_snd);
 #else
 			ifp->if_flags |= IFF_OACTIVE;
 #endif
 			return;
+		}
 #if 0
 FIXME openbsd
 		m = ifq_dequeue(&ifp->if_snd);
 #else
 		IFQ_DEQUEUE(&ifp->if_snd, m);
 #endif
 		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.
 		 */
 		if (ifp->if_bpf)
 			bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_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;
 #if 0
 FIXME openbsd
 		atomic_inc_int(&map->lm_count);
 #else
 		map->lm_count++;
 #endif
 		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;
 #if 0
 FIXME openbsd
 		dm.nbytes = max(m->m_pkthdr.len, 60);
 #else
 		dm.nbytes = MAX(m->m_pkthdr.len, 60);
 #endif
 		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)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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)
+{
 	DPRINTF(("%s: entry\n", __func__));
 	struct vnet_softc *sc = ifp->if_softc;
 	printf("%s: watchdog timeout\n", sc->sc_dv.dv_xname);
+}
 int
 vnet_media_change(struct ifnet *ifp)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	return (0);
+}
 void
 vnet_media_status(struct ifnet *ifp, struct ifmediareq *imr)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	imr->ifm_active = IFM_ETHER | IFM_AUTO;
 	imr->ifm_status = IFM_AVALID;
 #if 0
 FIXME openbsd
 	if (LINK_STATE_IS_UP(ifp->if_link_state) &&
 #else
 	if (ifp->if_link_state == LINK_STATE_UP &&
 #endif
 	    ifp->if_flags & IFF_UP)
 		imr->ifm_status |= IFM_ACTIVE;
+}
 void
 vnet_link_state(struct vnet_softc *sc)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 #if 0
 FIXME openbsd
 	struct ifnet *ifp = &sc->sc_ac.ac_if;
 #else
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 #endif
 	int link_state = LINK_STATE_DOWN;
 #if 0
 FIXME openbsd
 	KERNEL_LOCK();
 #else
 	KERNEL_LOCK(1, curlwp);
 #endif
 	if (ISSET(sc->sc_vio_state, VIO_RCV_RDX) &&
 	    ISSET(sc->sc_vio_state, VIO_ACK_RDX))
 #if 0
 FIXME openbsd
 		link_state = LINK_STATE_FULL_DUPLEX;
 #else
 		link_state = LINK_STATE_UP;
 #endif
 	if (ifp->if_link_state != link_state) {
 #if 0
 FIXME openbsd
 		ifp->if_link_state = link_state;
 		if_link_state_change(ifp);
 #else
 		if_link_state_change(ifp, link_state);
 #endif
+	}
 #if 0
 FIXME openbsd
 	KERNEL_UNLOCK();
 #else
 	KERNEL_UNLOCK_ONE(curlwp);
 #endif
+}
 void
 vnet_setmulti(struct vnet_softc *sc, int set)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	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;
 #if 0
 FIXME openbsd
 	KERNEL_LOCK();
 #else
 	KERNEL_LOCK(1, curlwp);
 #endif
 	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));
+	}
 #if 0
 FIXME openbsd
 	KERNEL_UNLOCK();
 #else
 	KERNEL_UNLOCK_ONE(curlwp);
 #endif
+}
 int
 vnet_init(struct ifnet *ifp)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	struct vnet_softc *sc = ifp->if_softc;
 	struct ldc_conn *lc = &sc->sc_lc;
 	int err;
 	vaddr_t va;
 	paddr_t pa;
 #if OPENBSD_BUSDMA
 	sc->sc_lm = ldc_map_alloc(sc->sc_dmatag, 2048);
 #else
 	sc->sc_lm = ldc_map_alloc(2048);
 #endif
 	if (sc->sc_lm == NULL)
 		return ENOMEM;
 #if OPENBSD_BUSDMA
 	err = hv_ldc_set_map_table(lc->lc_id,
 							   sc->sc_lm->lm_map->dm_segs[0].ds_addr, sc->sc_lm->lm_nentries);
 #else
 	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);
 #endif
 	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;
 #if OPENBSD_BUSDMA
 	sc->sc_lm->lm_slot[0].entry = sc->sc_vd->vd_map->dm_segs[0].ds_addr;
 #else
 	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;
 #endif
 	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);
 #if OPENBSD_BUSDMA
 	err = hv_ldc_tx_qconf(lc->lc_id,
 						  lc->lc_txq->lq_map->dm_segs[0].ds_addr, lc->lc_txq->lq_nentries);
 #else
 	err = hv_ldc_tx_qconf(lc->lc_id, pa, lc->lc_txq->lq_nentries);
 #endif
 	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);
 #if OPENBSD_BUSDMA
 	err = hv_ldc_rx_qconf(lc->lc_id,
 						  lc->lc_rxq->lq_map->dm_segs[0].ds_addr, lc->lc_rxq->lq_nentries);
 #else
 	err = hv_ldc_rx_qconf(lc->lc_id, pa, lc->lc_rxq->lq_nentries);
 #endif
 	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;
 #if 0
 	DPRINTF(("%s: exit\n", __func__));
 #endif
 	return 0;
+}
 void
 vnet_stop(struct ifnet *ifp, int disable)
+{
 	DPRINTF(("%s: entry\n", __func__));
 	struct vnet_softc *sc = ifp->if_softc;
 	struct ldc_conn *lc = &sc->sc_lc;
 	/* FIXME */
 	printf("vnet_stop() disable %d\n", disable);
 	ifp->if_flags &= ~IFF_RUNNING;
 #if 0
 FIXME openbsd
 	ifq_clr_oactive(&ifp->if_snd);
 #else
 	ifp->if_flags &= ~IFF_OACTIVE;
 #endif
 	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
 FIXME openbsd
 	intr_barrier(sc->sc_tx_ih);
 	intr_barrier(sc->sc_rx_ih);
 #else
 	printf("vnet_stop() intr_barrier() FIXME\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);
 #if 0
 FIXME openbsd
 	free(sc->sc_vsd, M_DEVBUF, VNET_NUM_SOFT_DESC * sizeof(*sc->sc_vsd));
 #else
 	free(sc->sc_vsd, M_DEVBUF);
 #endif
 	vnet_dring_free(sc->sc_dmatag, sc->sc_vd);
 	hv_ldc_set_map_table(lc->lc_id, 0, 0);
 #if OPENBSD_BUSDMA
 	ldc_map_free(sc->sc_dmatag, sc->sc_lm);
 #else
 	ldc_map_free(sc->sc_lm);
 #endif
+}
 struct vnet_dring *
 vnet_dring_alloc(bus_dma_tag_t t, int nentries)
+{
 #if 0
 	DPRINTF(("%s: entry\n", __func__));
 #endif
 	struct vnet_dring *vd;
 	bus_size_t size;
 	vaddr_t va;
 #if OPENBSD_BUSDMA
 	int nsegs;
 #endif
 	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);
 #if OPENBSD_BUSDMA
 	if (bus_dmamap_create(t, size, 1, size, 0,
 	    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &vd->vd_map) != 0)
 		return (NULL);
 	if (bus_dmamem_alloc(t, size, PAGE_SIZE, 0, &vd->vd_seg, 1,
 	    &nsegs, BUS_DMA_NOWAIT) != 0)
 		goto destroy;
 	if (bus_dmamem_map(t, &vd->vd_seg, 1, size, &va,
 	    BUS_DMA_NOWAIT) != 0)
 		goto free;
 	if (bus_dmamap_load(t, vd->vd_map, va, size, NULL,
 	    BUS_DMA_NOWAIT) != 0)
 		goto unmap;
 #else
 	va = (vaddr_t)kmem_zalloc(size, KM_SLEEP);
 #endif
 	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);
 #if OPENBSD_BUSDMA
 unmap:
 	bus_dmamem_unmap(t, va, size);
 free:
 	bus_dmamem_free(t, &vd->vd_seg, 1);
 destroy:
 	bus_dmamap_destroy(t, vd->vd_map);
 #endif
 	return (NULL);
+}
 void
 vnet_dring_free(bus_dma_tag_t t, struct vnet_dring *vd)
+{
 	DPRINTF(("%s: entry\n", __func__));
 	bus_size_t size;
 	size = vd->vd_nentries * sizeof(struct vnet_desc);
 	size = roundup(size, PAGE_SIZE);
 #if OPENBSD_BUSDMA
 	bus_dmamap_unload(t, vd->vd_map);
 	bus_dmamem_unmap(t, (caddr_t)vd->vd_desc, size);
 	bus_dmamem_free(t, &vd->vd_seg, 1);
 	bus_dmamap_destroy(t, vd->vd_map);
 #else
 	kmem_free(vd->vd_desc, size);
 #endif
 	kmem_free(vd, size);
+}