 @@ -1,14 +1,14 @@
-/*	$NetBSD: virtio.c,v 1.47 2021/02/05 20:45:38 reinoud Exp $	*/
+/*	$NetBSD: virtio.c,v 1.48 2021/02/07 09:26:17 skrll Exp $	*/
 /*
  * Copyright (c) 2020 The NetBSD Foundation, Inc.
  * Copyright (c) 2012 Stefan Fritsch, Alexander Fiveg.
  * Copyright (c) 2010 Minoura Makoto.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -18,27 +18,27 @@
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: virtio.c,v 1.47 2021/02/05 20:45:38 reinoud Exp $");
+__KERNEL_RCSID(0, "$NetBSD: virtio.c,v 1.48 2021/02/07 09:26:17 skrll Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/atomic.h>
 #include <sys/bus.h>
 #include <sys/device.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #define VIRTIO_PRIVATE
 #include <dev/pci/virtioreg.h> /* XXX: move to non-pci */
 @@ -639,27 +639,27 @@ virtio_init_vq(struct virtio_softc *sc,
 	/* enqueue/dequeue status */
 	vq->vq_avail_idx = 0;
 	vq->vq_used_idx = 0;
 	vq->vq_queued = 0;
 	if (!reinit) {
 		mutex_init(&vq->vq_aring_lock, MUTEX_SPIN, sc->sc_ipl);
 		mutex_init(&vq->vq_uring_lock, MUTEX_SPIN, sc->sc_ipl);
+	}
 	vq_sync_aring(sc, vq, BUS_DMASYNC_PREWRITE);
 	vq_sync_uring(sc, vq, BUS_DMASYNC_PREREAD);
 	vq->vq_queued++;
+}
 /*
  * Allocate/free a vq.
  */
 int
 virtio_alloc_vq(struct virtio_softc *sc, struct virtqueue *vq, int index,
     int maxsegsize, int maxnsegs, const char *name)
+{
 	int vq_size, allocsize1, allocsize2, allocsize3, allocsize = 0;
 	int rsegs, r, hdrlen;
 #define VIRTQUEUE_ALIGN(n)	(((n)+(VIRTIO_PAGE_SIZE-1))&	\
 				 ~(VIRTIO_PAGE_SIZE-1))
 	/* Make sure callers allocate vqs in order */
 @@ -854,27 +854,27 @@ vq_free_entry(struct virtqueue *vq, stru
  * Typical usage:
  *  <queue size> number of followings are stored in arrays
  *  - command blocks (in dmamem) should be pre-allocated and mapped
  *  - dmamaps for command blocks should be pre-allocated and loaded
  *  - dmamaps for payload should be pre-allocated
  *      r = virtio_enqueue_prep(sc, vq, &slot);		// allocate a slot
  *	if (r)		// currently 0 or EAGAIN
  *	  return r;
  *	r = bus_dmamap_load(dmat, dmamap_payload[slot], data, count, ..);
  *	if (r) {
  *	  virtio_enqueue_abort(sc, vq, slot);
  *	  return r;
  *	}
  *	r = virtio_enqueue_reserve(sc, vq, slot,
  *				   dmamap_payload[slot]->dm_nsegs+1);
  *							// ^ +1 for command
  *	if (r) {	// currently 0 or EAGAIN
  *	  bus_dmamap_unload(dmat, dmamap_payload[slot]);
  *	  return r;					// do not call abort()
  *	}
  *	<setup and prepare commands>
  *	bus_dmamap_sync(dmat, dmamap_cmd[slot],... BUS_DMASYNC_PREWRITE);
  *	bus_dmamap_sync(dmat, dmamap_payload[slot],...);
  *	virtio_enqueue(sc, vq, slot, dmamap_cmd[slot], false);
  *	virtio_enqueue(sc, vq, slot, dmamap_payload[slot], iswrite);
  *	virtio_enqueue_commit(sc, vq, slot, true);
  */
 @@ -1149,27 +1149,27 @@ virtio_dequeue_commit(struct virtio_soft
 		s = virtio_rw16(sc, vd[s].next);
 		vq_free_entry(vq, qe);
 		qe = &vq->vq_entries[s];
+	}
 	vq_free_entry(vq, qe);
 	return 0;
+}
 /*
  * Attach a child, fill all the members.
  */
 void
 virtio_child_attach_start(struct virtio_softc *sc, device_t child, int ipl,
 		    struct virtqueue *vqs,
 		    virtio_callback config_change,
 		    virtio_callback intr_hand,
 		    int req_flags, int req_features, const char *feat_bits)
+{
 	char buf[1024];
 	sc->sc_child = child;
 	sc->sc_ipl = ipl;
 	sc->sc_vqs = vqs;
 	sc->sc_config_change = config_change;
 	sc->sc_intrhand = intr_hand;
 	sc->sc_flags = req_flags;
 @@ -1197,27 +1197,27 @@ int
 virtio_child_attach_finish(struct virtio_softc *sc)
+{
 	int r;
 	sc->sc_finished_called = true;
 	r = sc->sc_ops->setup_interrupts(sc);
 	if (r != 0) {
 		aprint_error_dev(sc->sc_dev, "failed to setup interrupts\n");
 		goto fail;
+	}
 	KASSERT(sc->sc_soft_ih == NULL);
 	if (sc->sc_flags & VIRTIO_F_INTR_SOFTINT) {
 		u_int flags = SOFTINT_NET;
 		if (sc->sc_flags & VIRTIO_F_INTR_MPSAFE)
 			flags |= SOFTINT_MPSAFE;
 		sc->sc_soft_ih = softint_establish(flags, virtio_soft_intr, sc);
 		if (sc->sc_soft_ih == NULL) {
 			sc->sc_ops->free_interrupts(sc);
 			aprint_error_dev(sc->sc_dev,
 			    "failed to establish soft interrupt\n");
 			goto fail;
+		}
+	}
 	virtio_set_status(sc, VIRTIO_CONFIG_DEVICE_STATUS_DRIVER_OK);
 @@ -1313,41 +1313,41 @@ virtio_attach_failed(struct virtio_softc
 	return 0;
+}
 void
 virtio_print_device_type(device_t self, int id, int revision)
+{
 	aprint_normal_dev(self, "%s device (rev. 0x%02x)\n",
 		  (id < NDEVNAMES ? virtio_device_name[id] : "Unknown"),
 		  revision);
+}
 MODULE(MODULE_CLASS_DRIVER, virtio, NULL);
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 static int
 virtio_modcmd(modcmd_t cmd, void *opaque)
+{
 	int error = 0;
 #ifdef _MODULE
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		error = config_init_component(cfdriver_ioconf_virtio,
 		    cfattach_ioconf_virtio, cfdata_ioconf_virtio);
 		break;
 	case MODULE_CMD_FINI:
 		error = config_fini_component(cfdriver_ioconf_virtio,
 		    cfattach_ioconf_virtio, cfdata_ioconf_virtio);
 		break;
 	default:
 		error = ENOTTY;
 		break;
+	}
 #endif
 	return error;
+}